@angular/core 17.0.5 → 17.0.7

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

@@ -3997,6 +3997,39 @@ function getInjectFn(target) {
   }
 }
 
+// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/ml_parser/tags.mjs
+var TagContentType;
+(function(TagContentType2) {
+  TagContentType2[TagContentType2["RAW_TEXT"] = 0] = "RAW_TEXT";
+  TagContentType2[TagContentType2["ESCAPABLE_RAW_TEXT"] = 1] = "ESCAPABLE_RAW_TEXT";
+  TagContentType2[TagContentType2["PARSABLE_DATA"] = 2] = "PARSABLE_DATA";
+})(TagContentType || (TagContentType = {}));
+function splitNsName(elementName) {
+  if (elementName[0] != ":") {
+    return [null, elementName];
+  }
+  const colonIndex = elementName.indexOf(":", 1);
+  if (colonIndex === -1) {
+    throw new Error(`Unsupported format "${elementName}" expecting ":namespace:name"`);
+  }
+  return [elementName.slice(1, colonIndex), elementName.slice(colonIndex + 1)];
+}
+function isNgContainer(tagName) {
+  return splitNsName(tagName)[1] === "ng-container";
+}
+function isNgContent(tagName) {
+  return splitNsName(tagName)[1] === "ng-content";
+}
+function isNgTemplate(tagName) {
+  return splitNsName(tagName)[1] === "ng-template";
+}
+function getNsPrefix(fullName) {
+  return fullName === null ? null : splitNsName(fullName)[0];
+}
+function mergeNsAndName(prefix, localName) {
+  return prefix ? `:${prefix}:${localName}` : localName;
+}
+
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/render3/r3_ast.mjs
 var Comment = class {
   constructor(value, sourceSpan) {
@@ -5206,6 +5239,23 @@ var DefinitionMap = class {
     return literalMap(this.values);
   }
 };
+function createCssSelectorFromNode(node) {
+  const elementName = node instanceof Element ? node.name : "ng-template";
+  const attributes = getAttrsForDirectiveMatching(node);
+  const cssSelector = new CssSelector();
+  const elementNameNoNs = splitNsName(elementName)[1];
+  cssSelector.setElement(elementNameNoNs);
+  Object.getOwnPropertyNames(attributes).forEach((name) => {
+    const nameNoNs = splitNsName(name)[1];
+    const value = attributes[name];
+    cssSelector.addAttribute(nameNoNs, value);
+    if (name.toLowerCase() === "class") {
+      const classes = value.trim().split(/\s+/);
+      classes.forEach((className) => cssSelector.addClassName(className));
+    }
+  });
+  return cssSelector;
+}
 function getAttrsForDirectiveMatching(elOrTpl) {
   const attributesMap = {};
   if (elOrTpl instanceof Template && elOrTpl.tagName !== "ng-template") {
@@ -7923,6 +7973,7 @@ var OpKind;
   OpKind2[OpKind2["IcuStart"] = 41] = "IcuStart";
   OpKind2[OpKind2["IcuEnd"] = 42] = "IcuEnd";
   OpKind2[OpKind2["I18nContext"] = 43] = "I18nContext";
+  OpKind2[OpKind2["I18nAttributes"] = 44] = "I18nAttributes";
 })(OpKind || (OpKind = {}));
 var ExpressionKind;
 (function(ExpressionKind2) {
@@ -7947,10 +7998,11 @@ var ExpressionKind;
   ExpressionKind2[ExpressionKind2["AssignTemporaryExpr"] = 18] = "AssignTemporaryExpr";
   ExpressionKind2[ExpressionKind2["ReadTemporaryExpr"] = 19] = "ReadTemporaryExpr";
   ExpressionKind2[ExpressionKind2["SanitizerExpr"] = 20] = "SanitizerExpr";
-  ExpressionKind2[ExpressionKind2["SlotLiteralExpr"] = 21] = "SlotLiteralExpr";
-  ExpressionKind2[ExpressionKind2["ConditionalCase"] = 22] = "ConditionalCase";
-  ExpressionKind2[ExpressionKind2["DerivedRepeaterVar"] = 23] = "DerivedRepeaterVar";
-  ExpressionKind2[ExpressionKind2["ConstCollected"] = 24] = "ConstCollected";
+  ExpressionKind2[ExpressionKind2["TrustedValueFnExpr"] = 21] = "TrustedValueFnExpr";
+  ExpressionKind2[ExpressionKind2["SlotLiteralExpr"] = 22] = "SlotLiteralExpr";
+  ExpressionKind2[ExpressionKind2["ConditionalCase"] = 23] = "ConditionalCase";
+  ExpressionKind2[ExpressionKind2["DerivedRepeaterVar"] = 24] = "DerivedRepeaterVar";
+  ExpressionKind2[ExpressionKind2["ConstCollected"] = 25] = "ConstCollected";
 })(ExpressionKind || (ExpressionKind = {}));
 var VariableFlags;
 (function(VariableFlags2) {
@@ -7969,15 +8021,6 @@ var CompatibilityMode;
   CompatibilityMode2[CompatibilityMode2["Normal"] = 0] = "Normal";
   CompatibilityMode2[CompatibilityMode2["TemplateDefinitionBuilder"] = 1] = "TemplateDefinitionBuilder";
 })(CompatibilityMode || (CompatibilityMode = {}));
-var SanitizerFn;
-(function(SanitizerFn2) {
-  SanitizerFn2[SanitizerFn2["Html"] = 0] = "Html";
-  SanitizerFn2[SanitizerFn2["Script"] = 1] = "Script";
-  SanitizerFn2[SanitizerFn2["Style"] = 2] = "Style";
-  SanitizerFn2[SanitizerFn2["Url"] = 3] = "Url";
-  SanitizerFn2[SanitizerFn2["ResourceUrl"] = 4] = "ResourceUrl";
-  SanitizerFn2[SanitizerFn2["IframeAttribute"] = 5] = "IframeAttribute";
-})(SanitizerFn || (SanitizerFn = {}));
 var DeferSecondaryKind;
 (function(DeferSecondaryKind2) {
   DeferSecondaryKind2[DeferSecondaryKind2["Loading"] = 0] = "Loading";
@@ -7999,6 +8042,11 @@ var I18nParamResolutionTime;
   I18nParamResolutionTime2[I18nParamResolutionTime2["Creation"] = 0] = "Creation";
   I18nParamResolutionTime2[I18nParamResolutionTime2["Postproccessing"] = 1] = "Postproccessing";
 })(I18nParamResolutionTime || (I18nParamResolutionTime = {}));
+var I18nExpressionFor;
+(function(I18nExpressionFor2) {
+  I18nExpressionFor2[I18nExpressionFor2["I18nText"] = 0] = "I18nText";
+  I18nExpressionFor2[I18nExpressionFor2["I18nAttribute"] = 1] = "I18nAttribute";
+})(I18nExpressionFor || (I18nExpressionFor = {}));
 var I18nParamValueFlags;
 (function(I18nParamValueFlags2) {
   I18nParamValueFlags2[I18nParamValueFlags2["None"] = 0] = "None";
@@ -8034,7 +8082,14 @@ var I18nContextKind;
 (function(I18nContextKind2) {
   I18nContextKind2[I18nContextKind2["RootI18n"] = 0] = "RootI18n";
   I18nContextKind2[I18nContextKind2["Icu"] = 1] = "Icu";
+  I18nContextKind2[I18nContextKind2["Attr"] = 2] = "Attr";
 })(I18nContextKind || (I18nContextKind = {}));
+var TemplateKind;
+(function(TemplateKind2) {
+  TemplateKind2[TemplateKind2["NgTemplate"] = 0] = "NgTemplate";
+  TemplateKind2[TemplateKind2["Structural"] = 1] = "Structural";
+  TemplateKind2[TemplateKind2["Block"] = 2] = "Block";
+})(TemplateKind || (TemplateKind = {}));
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/template/pipeline/ir/src/traits.mjs
 var ConsumesSlot = Symbol("ConsumesSlot");
@@ -8091,22 +8146,25 @@ var NEW_OP = {
 };
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/template/pipeline/ir/src/ops/update.mjs
-function createInterpolateTextOp(xref, interpolation, i18nPlaceholders, sourceSpan) {
+function createInterpolateTextOp(xref, interpolation, sourceSpan) {
   return __spreadValues(__spreadValues(__spreadValues({
     kind: OpKind.InterpolateText,
     target: xref,
     interpolation,
-    i18nPlaceholders,
     sourceSpan
   }, TRAIT_DEPENDS_ON_SLOT_CONTEXT), TRAIT_CONSUMES_VARS), NEW_OP);
 }
 var Interpolation2 = class {
-  constructor(strings, expressions) {
+  constructor(strings, expressions, i18nPlaceholders) {
     this.strings = strings;
     this.expressions = expressions;
+    this.i18nPlaceholders = i18nPlaceholders;
+    if (i18nPlaceholders.length !== 0 && i18nPlaceholders.length !== expressions.length) {
+      throw new Error(`Expected ${expressions.length} placeholders to match interpolation expression count, but got ${i18nPlaceholders.length}`);
+    }
   }
 };
-function createBindingOp(target, kind, name, expression, unit, securityContext, isTextAttribute, isTemplate, sourceSpan) {
+function createBindingOp(target, kind, name, expression, unit, securityContext, isTextAttribute, isStructuralTemplateAttribute, templateKind, i18nMessage, sourceSpan) {
   return __spreadValues({
     kind: OpKind.Binding,
     bindingKind: kind,
@@ -8116,11 +8174,14 @@ function createBindingOp(target, kind, name, expression, unit, securityContext,
     unit,
     securityContext,
     isTextAttribute,
-    isTemplate,
+    isStructuralTemplateAttribute,
+    templateKind,
+    i18nContext: null,
+    i18nMessage,
     sourceSpan
   }, NEW_OP);
 }
-function createPropertyOp(target, name, expression, isAnimationTrigger, securityContext, isTemplate, sourceSpan) {
+function createPropertyOp(target, name, expression, isAnimationTrigger, securityContext, isStructuralTemplateAttribute, templateKind, i18nContext, i18nMessage, sourceSpan) {
   return __spreadValues(__spreadValues(__spreadValues({
     kind: OpKind.Property,
     target,
@@ -8129,7 +8190,10 @@ function createPropertyOp(target, name, expression, isAnimationTrigger, security
     isAnimationTrigger,
     securityContext,
     sanitizer: null,
-    isTemplate,
+    isStructuralTemplateAttribute,
+    templateKind,
+    i18nContext,
+    i18nMessage,
     sourceSpan
   }, TRAIT_DEPENDS_ON_SLOT_CONTEXT), TRAIT_CONSUMES_VARS), NEW_OP);
 }
@@ -8168,7 +8232,7 @@ function createClassMapOp(xref, expression, sourceSpan) {
     sourceSpan
   }, TRAIT_DEPENDS_ON_SLOT_CONTEXT), TRAIT_CONSUMES_VARS), NEW_OP);
 }
-function createAttributeOp(target, name, expression, securityContext, isTextAttribute, isTemplate, sourceSpan) {
+function createAttributeOp(target, name, expression, securityContext, isTextAttribute, isStructuralTemplateAttribute, templateKind, i18nMessage, sourceSpan) {
   return __spreadValues(__spreadValues(__spreadValues({
     kind: OpKind.Attribute,
     target,
@@ -8177,7 +8241,10 @@ function createAttributeOp(target, name, expression, securityContext, isTextAttr
     securityContext,
     sanitizer: null,
     isTextAttribute,
-    isTemplate,
+    isStructuralTemplateAttribute,
+    templateKind,
+    i18nContext: null,
+    i18nMessage,
     sourceSpan
   }, TRAIT_DEPENDS_ON_SLOT_CONTEXT), TRAIT_CONSUMES_VARS), NEW_OP);
 }
@@ -8218,22 +8285,25 @@ function createDeferWhenOp(target, expr, prefetch, sourceSpan) {
     sourceSpan
   }, NEW_OP), TRAIT_DEPENDS_ON_SLOT_CONTEXT);
 }
-function createI18nExpressionOp(context, target, handle, expression, i18nPlaceholder, resolutionTime, sourceSpan) {
+function createI18nExpressionOp(context, target, i18nOwner, handle, expression, i18nPlaceholder, resolutionTime, usage, name, sourceSpan) {
   return __spreadValues(__spreadValues(__spreadValues({
     kind: OpKind.I18nExpression,
     context,
     target,
+    i18nOwner,
     handle,
     expression,
     i18nPlaceholder,
     resolutionTime,
+    usage,
+    name,
     sourceSpan
   }, NEW_OP), TRAIT_CONSUMES_VARS), TRAIT_DEPENDS_ON_SLOT_CONTEXT);
 }
-function createI18nApplyOp(target, handle, sourceSpan) {
+function createI18nApplyOp(owner, handle, sourceSpan) {
   return __spreadValues({
     kind: OpKind.I18nApply,
-    target,
+    owner,
     handle,
     sourceSpan
   }, NEW_OP);
@@ -8770,26 +8840,6 @@ var ReadTemporaryExpr = class extends ExpressionBase {
     return r;
   }
 };
-var SanitizerExpr = class extends ExpressionBase {
-  constructor(fn2) {
-    super();
-    this.fn = fn2;
-    this.kind = ExpressionKind.SanitizerExpr;
-  }
-  visitExpression(visitor, context) {
-  }
-  isEquivalent(e) {
-    return e instanceof SanitizerExpr && e.fn === this.fn;
-  }
-  isConstant() {
-    return true;
-  }
-  clone() {
-    return new SanitizerExpr(this.fn);
-  }
-  transformInternalExpressions() {
-  }
-};
 var SlotLiteralExpr = class extends ExpressionBase {
   constructor(slot) {
     super();
@@ -8908,7 +8958,6 @@ function transformExpressionsInOp(op, transform2, flags) {
     case OpKind.ClassProp:
     case OpKind.ClassMap:
     case OpKind.Binding:
-    case OpKind.HostProperty:
       if (op.expression instanceof Interpolation2) {
         transformExpressionsInInterpolation(op.expression, transform2, flags);
       } else {
@@ -8916,6 +8965,7 @@ function transformExpressionsInOp(op, transform2, flags) {
       }
       break;
     case OpKind.Property:
+    case OpKind.HostProperty:
     case OpKind.Attribute:
       if (op.expression instanceof Interpolation2) {
         transformExpressionsInInterpolation(op.expression, transform2, flags);
@@ -8957,6 +9007,7 @@ function transformExpressionsInOp(op, transform2, flags) {
       break;
     case OpKind.ExtractedAttribute:
       op.expression = op.expression && transformExpressionsInExpression(op.expression, transform2, flags);
+      op.trustedValueFn = op.trustedValueFn && transformExpressionsInExpression(op.trustedValueFn, transform2, flags);
       break;
     case OpKind.RepeaterCreate:
       op.track = transformExpressionsInExpression(op.track, transform2, flags);
@@ -9009,6 +9060,7 @@ function transformExpressionsInOp(op, transform2, flags) {
     case OpKind.ProjectionDef:
     case OpKind.Template:
     case OpKind.Text:
+    case OpKind.I18nAttributes:
       break;
     default:
       throw new Error(`AssertionError: transformExpressionsInOp doesn't handle ${OpKind[op.kind]}`);
@@ -9020,6 +9072,8 @@ function transformExpressionsInExpression(expr, transform2, flags) {
   } else if (expr instanceof BinaryOperatorExpr) {
     expr.lhs = transformExpressionsInExpression(expr.lhs, transform2, flags);
     expr.rhs = transformExpressionsInExpression(expr.rhs, transform2, flags);
+  } else if (expr instanceof UnaryOperatorExpr) {
+    expr.expr = transformExpressionsInExpression(expr.expr, transform2, flags);
   } else if (expr instanceof ReadPropExpr) {
     expr.receiver = transformExpressionsInExpression(expr.receiver, transform2, flags);
   } else if (expr instanceof ReadKeyExpr) {
@@ -9059,6 +9113,12 @@ function transformExpressionsInExpression(expr, transform2, flags) {
     for (let i = 0; i < expr.expressions.length; i++) {
       expr.expressions[i] = transformExpressionsInExpression(expr.expressions[i], transform2, flags);
     }
+  } else if (expr instanceof NotExpr) {
+    expr.condition = transformExpressionsInExpression(expr.condition, transform2, flags);
+  } else if (expr instanceof TaggedTemplateExpr) {
+    expr.tag = transformExpressionsInExpression(expr.tag, transform2, flags);
+    expr.template.expressions = expr.template.expressions.map((e) => transformExpressionsInExpression(e, transform2, flags));
+  } else if (expr instanceof WrappedNodeExpr) {
   } else if (expr instanceof ReadVarExpr || expr instanceof ExternalExpr || expr instanceof LiteralExpr) {
   } else {
     throw new Error(`Unhandled expression kind: ${expr.constructor.name}`);
@@ -9314,10 +9374,11 @@ function createElementStartOp(tag, xref, namespace, i18nPlaceholder, sourceSpan)
     sourceSpan
   }, TRAIT_CONSUMES_SLOT), NEW_OP);
 }
-function createTemplateOp(xref, tag, functionNameSuffix, namespace, i18nPlaceholder, sourceSpan) {
+function createTemplateOp(xref, templateKind, tag, functionNameSuffix, namespace, i18nPlaceholder, sourceSpan) {
   return __spreadValues(__spreadValues({
     kind: OpKind.Template,
     xref,
+    templateKind,
     attributes: null,
     tag,
     handle: new SlotHandle(),
@@ -9331,7 +9392,7 @@ function createTemplateOp(xref, tag, functionNameSuffix, namespace, i18nPlacehol
     sourceSpan
   }, TRAIT_CONSUMES_SLOT), NEW_OP);
 }
-function createRepeaterCreateOp(primaryView, emptyView, tag, track, varNames, sourceSpan) {
+function createRepeaterCreateOp(primaryView, emptyView, tag, track, varNames, i18nPlaceholder, emptyI18nPlaceholder, sourceSpan) {
   return __spreadProps(__spreadValues(__spreadValues({
     kind: OpKind.RepeaterCreate,
     attributes: null,
@@ -9349,6 +9410,8 @@ function createRepeaterCreateOp(primaryView, emptyView, tag, track, varNames, so
     vars: null,
     varNames,
     usesComponentInstance: false,
+    i18nPlaceholder,
+    emptyI18nPlaceholder,
     sourceSpan
   }, TRAIT_CONSUMES_SLOT), NEW_OP), {
     numSlotsUsed: emptyView === null ? 2 : 3
@@ -9382,7 +9445,9 @@ function createTextOp(xref, initialValue, sourceSpan) {
     sourceSpan
   }, TRAIT_CONSUMES_SLOT), NEW_OP);
 }
-function createListenerOp(target, targetSlot, name, tag, animationPhase, hostListener, sourceSpan) {
+function createListenerOp(target, targetSlot, name, tag, handlerOps, animationPhase, eventTarget, hostListener, sourceSpan) {
+  const handlerList = new OpList();
+  handlerList.push(handlerOps);
   return __spreadValues({
     kind: OpKind.Listener,
     target,
@@ -9390,11 +9455,12 @@ function createListenerOp(target, targetSlot, name, tag, animationPhase, hostLis
     tag,
     hostListener,
     name,
-    handlerOps: new OpList(),
+    handlerOps: handlerList,
     handlerFnName: null,
     consumesDollarEvent: false,
     isAnimationListener: animationPhase !== null,
     animationPhase,
+    eventTarget,
     sourceSpan
   }, NEW_OP);
 }
@@ -9418,25 +9484,30 @@ function createProjectionDefOp(def) {
     def
   }, NEW_OP);
 }
-function createProjectionOp(xref, selector, sourceSpan) {
+function createProjectionOp(xref, selector, i18nPlaceholder, attributes, sourceSpan) {
   return __spreadValues(__spreadValues({
     kind: OpKind.Projection,
     xref,
     handle: new SlotHandle(),
     selector,
+    i18nPlaceholder,
     projectionSlotIndex: 0,
-    attributes: [],
+    attributes,
     localRefs: [],
     sourceSpan
   }, NEW_OP), TRAIT_CONSUMES_SLOT);
 }
-function createExtractedAttributeOp(target, bindingKind, name, expression) {
+function createExtractedAttributeOp(target, bindingKind, name, expression, i18nContext, i18nMessage, securityContext) {
   return __spreadValues({
     kind: OpKind.ExtractedAttribute,
     target,
     bindingKind,
     name,
-    expression
+    expression,
+    i18nContext,
+    i18nMessage,
+    securityContext,
+    trustedValueFn: null
   }, NEW_OP);
 }
 function createDeferOp(xref, main, mainSlot, metadata, sourceSpan) {
@@ -9473,10 +9544,11 @@ function createDeferOnOp(defer2, trigger, prefetch, sourceSpan) {
     sourceSpan
   }, NEW_OP);
 }
-function createI18nMessageOp(xref, i18nBlock, message, messagePlaceholder, params, postprocessingParams, needsPostprocessing) {
+function createI18nMessageOp(xref, i18nContext, i18nBlock, message, messagePlaceholder, params, postprocessingParams, needsPostprocessing) {
   return __spreadValues({
     kind: OpKind.I18nMessage,
     xref,
+    i18nContext,
     i18nBlock,
     message,
     messagePlaceholder,
@@ -9521,6 +9593,9 @@ function createIcuEndOp(xref) {
   }, NEW_OP);
 }
 function createI18nContextOp(contextKind, xref, i18nBlock, message, sourceSpan) {
+  if (i18nBlock === null && contextKind !== I18nContextKind.Attr) {
+    throw new Error("AssertionError: i18nBlock must be provided for non-attribute contexts.");
+  }
   return __spreadValues({
     kind: OpKind.I18nContext,
     contextKind,
@@ -9532,14 +9607,26 @@ function createI18nContextOp(contextKind, xref, i18nBlock, message, sourceSpan)
     postprocessingParams: /* @__PURE__ */ new Map()
   }, NEW_OP);
 }
+function createI18nAttributesOp(xref, handle, target) {
+  return __spreadValues(__spreadValues({
+    kind: OpKind.I18nAttributes,
+    xref,
+    handle,
+    target,
+    i18nAttributesConfig: null
+  }, NEW_OP), TRAIT_CONSUMES_SLOT);
+}
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/template/pipeline/ir/src/ops/host.mjs
-function createHostPropertyOp(name, expression, isAnimationTrigger, sourceSpan) {
+function createHostPropertyOp(name, expression, isAnimationTrigger, i18nContext, securityContext, sourceSpan) {
   return __spreadValues(__spreadValues({
     kind: OpKind.HostProperty,
     name,
     expression,
     isAnimationTrigger,
+    i18nContext,
+    securityContext,
+    sanitizer: null,
     sourceSpan
   }, TRAIT_CONSUMES_VARS), NEW_OP);
 }
@@ -9685,7 +9772,7 @@ function applyI18nExpressions(job) {
   for (const unit of job.units) {
     for (const op of unit.update) {
       if (op.kind === OpKind.I18nExpression && needsApplication(i18nContexts, op)) {
-        OpList.insertAfter(createI18nApplyOp(op.target, op.handle, null), op);
+        OpList.insertAfter(createI18nApplyOp(op.i18nOwner, op.handle, null), op);
       }
     }
   }
@@ -9697,7 +9784,19 @@ function needsApplication(i18nContexts, op) {
   }
   const context = i18nContexts.get(op.context);
   const nextContext2 = i18nContexts.get(op.next.context);
-  if (context.i18nBlock !== nextContext2.i18nBlock) {
+  if (context === void 0) {
+    throw new Error("AssertionError: expected an I18nContextOp to exist for the I18nExpressionOp's context");
+  }
+  if (nextContext2 === void 0) {
+    throw new Error("AssertionError: expected an I18nContextOp to exist for the next I18nExpressionOp's context");
+  }
+  if (context.i18nBlock !== null) {
+    if (context.i18nBlock !== nextContext2.i18nBlock) {
+      return true;
+    }
+    return false;
+  }
+  if (op.i18nOwner !== op.next.i18nOwner) {
     return true;
   }
   return false;
@@ -9705,27 +9804,44 @@ function needsApplication(i18nContexts, op) {
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/assign_i18n_slot_dependencies.mjs
 function assignI18nSlotDependencies(job) {
-  const i18nLastSlotConsumers = /* @__PURE__ */ new Map();
-  let lastSlotConsumer = null;
-  let currentI18nOp = null;
   for (const unit of job.units) {
-    for (const op of unit.create) {
-      if (hasConsumesSlotTrait(op)) {
-        lastSlotConsumer = op.xref;
-      }
-      switch (op.kind) {
-        case OpKind.I18nStart:
-          currentI18nOp = op;
-          break;
-        case OpKind.I18nEnd:
-          i18nLastSlotConsumers.set(currentI18nOp.xref, lastSlotConsumer);
-          currentI18nOp = null;
-          break;
+    let updateOp = unit.update.head;
+    let i18nExpressionsInProgress = [];
+    let state = null;
+    for (const createOp of unit.create) {
+      if (createOp.kind === OpKind.I18nStart) {
+        state = {
+          blockXref: createOp.xref,
+          lastSlotConsumer: createOp.xref
+        };
+      } else if (createOp.kind === OpKind.I18nEnd) {
+        for (const op of i18nExpressionsInProgress) {
+          op.target = state.lastSlotConsumer;
+          OpList.insertBefore(op, updateOp);
+        }
+        i18nExpressionsInProgress.length = 0;
+        state = null;
       }
-    }
-    for (const op of unit.update) {
-      if (op.kind === OpKind.I18nExpression) {
-        op.target = i18nLastSlotConsumers.get(op.target);
+      if (hasConsumesSlotTrait(createOp)) {
+        if (state !== null) {
+          state.lastSlotConsumer = createOp.xref;
+        }
+        while (true) {
+          if (updateOp.next === null) {
+            break;
+          }
+          if (state !== null && updateOp.kind === OpKind.I18nExpression && updateOp.usage === I18nExpressionFor.I18nText && updateOp.i18nOwner === state.blockXref) {
+            const opToRemove = updateOp;
+            updateOp = updateOp.next;
+            OpList.remove(opToRemove);
+            i18nExpressionsInProgress.push(opToRemove);
+            continue;
+          }
+          if (hasDependsOnSlotContextTrait(updateOp) && updateOp.target !== createOp.xref) {
+            break;
+          }
+          updateOp = updateOp.next;
+        }
       }
     }
   }
@@ -9754,18 +9870,53 @@ function extractAttributes(job) {
           break;
         case OpKind.Property:
           if (!op.isAnimationTrigger) {
-            OpList.insertBefore(createExtractedAttributeOp(op.target, op.isTemplate ? BindingKind.Template : BindingKind.Property, op.name, null), lookupElement(elements, op.target));
+            let bindingKind;
+            if (op.i18nMessage !== null && op.templateKind === null) {
+              bindingKind = BindingKind.I18n;
+            } else if (op.isStructuralTemplateAttribute) {
+              bindingKind = BindingKind.Template;
+            } else {
+              bindingKind = BindingKind.Property;
+            }
+            OpList.insertBefore(
+              createExtractedAttributeOp(
+                op.target,
+                bindingKind,
+                op.name,
+                null,
+                null,
+                null,
+                op.securityContext
+              ),
+              lookupElement(elements, op.target)
+            );
           }
           break;
         case OpKind.StyleProp:
         case OpKind.ClassProp:
           if (unit.job.compatibility === CompatibilityMode.TemplateDefinitionBuilder && op.expression instanceof EmptyExpr2) {
-            OpList.insertBefore(createExtractedAttributeOp(op.target, BindingKind.Property, op.name, null), lookupElement(elements, op.target));
+            OpList.insertBefore(createExtractedAttributeOp(
+              op.target,
+              BindingKind.Property,
+              op.name,
+              null,
+              null,
+              null,
+              SecurityContext.STYLE
+            ), lookupElement(elements, op.target));
           }
           break;
         case OpKind.Listener:
           if (!op.isAnimationListener) {
-            const extractedAttributeOp = createExtractedAttributeOp(op.target, BindingKind.Property, op.name, null);
+            const extractedAttributeOp = createExtractedAttributeOp(
+              op.target,
+              BindingKind.Property,
+              op.name,
+              null,
+              null,
+              null,
+              SecurityContext.NONE
+            );
             if (job.kind === CompilationJobKind.Host) {
               unit.create.push(extractedAttributeOp);
             } else {
@@ -9799,7 +9950,7 @@ function extractAttributeOp(unit, op, elements) {
     }
   }
   if (extractable) {
-    const extractedAttributeOp = createExtractedAttributeOp(op.target, op.isTemplate ? BindingKind.Template : BindingKind.Attribute, op.name, op.expression);
+    const extractedAttributeOp = createExtractedAttributeOp(op.target, op.isStructuralTemplateAttribute ? BindingKind.Template : BindingKind.Attribute, op.name, op.expression, op.i18nContext, op.i18nMessage, op.securityContext);
     if (unit.job.kind === CompilationJobKind.Host) {
       unit.create.push(extractedAttributeOp);
     } else {
@@ -9840,15 +9991,15 @@ function specializeBindings(job) {
             const target = lookupElement2(elements, op.target);
             target.nonBindable = true;
           } else {
-            OpList.replace(op, createAttributeOp(op.target, op.name, op.expression, op.securityContext, op.isTextAttribute, op.isTemplate, op.sourceSpan));
+            OpList.replace(op, createAttributeOp(op.target, op.name, op.expression, op.securityContext, op.isTextAttribute, op.isStructuralTemplateAttribute, op.templateKind, op.i18nMessage, op.sourceSpan));
           }
           break;
         case BindingKind.Property:
         case BindingKind.Animation:
           if (job.kind === CompilationJobKind.Host) {
-            OpList.replace(op, createHostPropertyOp(op.name, op.expression, op.bindingKind === BindingKind.Animation, op.sourceSpan));
+            OpList.replace(op, createHostPropertyOp(op.name, op.expression, op.bindingKind === BindingKind.Animation, op.i18nContext, op.securityContext, op.sourceSpan));
           } else {
-            OpList.replace(op, createPropertyOp(op.target, op.name, op.expression, op.bindingKind === BindingKind.Animation, op.securityContext, op.isTemplate, op.sourceSpan));
+            OpList.replace(op, createPropertyOp(op.target, op.name, op.expression, op.bindingKind === BindingKind.Animation, op.securityContext, op.isStructuralTemplateAttribute, op.templateKind, op.i18nContext, op.i18nMessage, op.sourceSpan));
           }
           break;
         case BindingKind.I18n:
@@ -9975,39 +10126,6 @@ function generateConditionalExpressions(job) {
   }
 }
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/ml_parser/tags.mjs
-var TagContentType;
-(function(TagContentType2) {
-  TagContentType2[TagContentType2["RAW_TEXT"] = 0] = "RAW_TEXT";
-  TagContentType2[TagContentType2["ESCAPABLE_RAW_TEXT"] = 1] = "ESCAPABLE_RAW_TEXT";
-  TagContentType2[TagContentType2["PARSABLE_DATA"] = 2] = "PARSABLE_DATA";
-})(TagContentType || (TagContentType = {}));
-function splitNsName(elementName) {
-  if (elementName[0] != ":") {
-    return [null, elementName];
-  }
-  const colonIndex = elementName.indexOf(":", 1);
-  if (colonIndex === -1) {
-    throw new Error(`Unsupported format "${elementName}" expecting ":namespace:name"`);
-  }
-  return [elementName.slice(1, colonIndex), elementName.slice(colonIndex + 1)];
-}
-function isNgContainer(tagName) {
-  return splitNsName(tagName)[1] === "ng-container";
-}
-function isNgContent(tagName) {
-  return splitNsName(tagName)[1] === "ng-content";
-}
-function isNgTemplate(tagName) {
-  return splitNsName(tagName)[1] === "ng-template";
-}
-function getNsPrefix(fullName) {
-  return fullName === null ? null : splitNsName(fullName)[0];
-}
-function mergeNsAndName(prefix, localName) {
-  return prefix ? `:${prefix}:${localName}` : localName;
-}
-
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/template/pipeline/src/conversion.mjs
 var BINARY_OPERATORS = /* @__PURE__ */ new Map([
   ["&&", BinaryOperator.And],
@@ -10066,7 +10184,7 @@ function collectElementConsts(job) {
       if (op.kind === OpKind.ExtractedAttribute) {
         const attributes = allElementAttributes.get(op.target) || new ElementAttributes();
         allElementAttributes.set(op.target, attributes);
-        attributes.add(op.bindingKind, op.name, op.expression);
+        attributes.add(op.bindingKind, op.name, op.expression, op.trustedValueFn);
         OpList.remove(op);
       }
     }
@@ -10128,7 +10246,7 @@ var ElementAttributes = class {
     var _a2;
     return (_a2 = this.byKind.get(BindingKind.I18n)) != null ? _a2 : FLYWEIGHT_ARRAY;
   }
-  add(kind, name, value) {
+  add(kind, name, value, trustedValueFn) {
     var _a2;
     if (this.known.has(name)) {
       return;
@@ -10144,9 +10262,16 @@ var ElementAttributes = class {
     array.push(...getAttributeNameLiterals(name));
     if (kind === BindingKind.Attribute || kind === BindingKind.StyleProperty) {
       if (value === null) {
-        throw Error("Attribute & style element attributes must have a value");
+        throw Error("Attribute, i18n attribute, & style element attributes must have a value");
+      }
+      if (trustedValueFn !== null) {
+        if (!isStringLiteral(value)) {
+          throw Error("AssertionError: extracted attribute value should be string literal");
+        }
+        array.push(taggedTemplate(trustedValueFn, new TemplateLiteral([new TemplateLiteralElement(value.value)], []), void 0, value.sourceSpan));
+      } else {
+        array.push(value);
       }
-      array.push(value);
     }
   }
   arrayFor(kind) {
@@ -10192,6 +10317,47 @@ function serializeAttributes({ attributes, bindings, classes, i18n: i18n2, proje
   return literalArr(attrArray);
 }
 
+// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/convert_i18n_bindings.mjs
+function convertI18nBindings(job) {
+  const i18nAttributesByElem = /* @__PURE__ */ new Map();
+  for (const unit of job.units) {
+    for (const op of unit.create) {
+      if (op.kind === OpKind.I18nAttributes) {
+        i18nAttributesByElem.set(op.target, op);
+      }
+    }
+    for (const op of unit.update) {
+      switch (op.kind) {
+        case OpKind.Property:
+        case OpKind.Attribute:
+          if (op.i18nContext === null) {
+            continue;
+          }
+          if (!(op.expression instanceof Interpolation2)) {
+            continue;
+          }
+          const i18nAttributesForElem = i18nAttributesByElem.get(op.target);
+          if (i18nAttributesForElem === void 0) {
+            throw new Error("AssertionError: An i18n attribute binding instruction requires the owning element to have an I18nAttributes create instruction");
+          }
+          if (i18nAttributesForElem.target !== op.target) {
+            throw new Error("AssertionError: Expected i18nAttributes target element to match binding target element");
+          }
+          const ops = [];
+          for (let i = 0; i < op.expression.expressions.length; i++) {
+            const expr = op.expression.expressions[i];
+            if (op.expression.i18nPlaceholders.length !== op.expression.expressions.length) {
+              throw new Error(`AssertionError: An i18n attribute binding instruction requires the same number of expressions and placeholders, but found ${op.expression.i18nPlaceholders.length} placeholders and ${op.expression.expressions.length} expressions`);
+            }
+            ops.push(createI18nExpressionOp(op.i18nContext, i18nAttributesForElem.target, i18nAttributesForElem.xref, i18nAttributesForElem.handle, expr, op.expression.i18nPlaceholders[i], I18nParamResolutionTime.Creation, I18nExpressionFor.I18nAttribute, op.name, op.sourceSpan));
+          }
+          OpList.replaceWithMany(op, ops);
+          break;
+      }
+    }
+  }
+}
+
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/create_defer_deps_fns.mjs
 function createDeferDepsFns(job) {
   for (const unit of job.units) {
@@ -10225,6 +10391,7 @@ function createI18nContexts(job) {
   const rootContexts = /* @__PURE__ */ new Map();
   let currentI18nOp = null;
   let xref;
+  const messageToContext = /* @__PURE__ */ new Map();
   for (const unit of job.units) {
     for (const op of unit.create) {
       switch (op.kind) {
@@ -10254,6 +10421,24 @@ function createI18nContexts(job) {
           break;
       }
     }
+    for (const op of unit.ops()) {
+      switch (op.kind) {
+        case OpKind.Binding:
+        case OpKind.Property:
+        case OpKind.Attribute:
+        case OpKind.ExtractedAttribute:
+          if (!op.i18nMessage) {
+            continue;
+          }
+          if (!messageToContext.has(op.i18nMessage)) {
+            const i18nContext = job.allocateXrefId();
+            unit.create.push(createI18nContextOp(I18nContextKind.Attr, i18nContext, null, op.i18nMessage, null));
+            messageToContext.set(op.i18nMessage, i18nContext);
+          }
+          op.i18nContext = messageToContext.get(op.i18nMessage);
+          break;
+      }
+    }
   }
   for (const unit of job.units) {
     for (const op of unit.create) {
@@ -10562,6 +10747,15 @@ function extractI18nMessages(job) {
       }
     }
   }
+  for (const unit of job.units) {
+    for (const op of unit.create) {
+      if (op.kind !== OpKind.I18nContext || op.contextKind !== I18nContextKind.Attr) {
+        continue;
+      }
+      const i18nMessageOp = createI18nMessage(job, op);
+      unit.create.push(i18nMessageOp);
+    }
+  }
   const i18nBlockMessages = /* @__PURE__ */ new Map();
   for (const unit of job.units) {
     for (const op of unit.create) {
@@ -10584,6 +10778,9 @@ function extractI18nMessages(job) {
           }
           const i18nContext = i18nContexts.get(op.context);
           if (i18nContext.contextKind === I18nContextKind.Icu) {
+            if (i18nContext.i18nBlock === null) {
+              throw Error("ICU context should have its i18n block set.");
+            }
             const subMessage = createI18nMessage(job, i18nContext, op.messagePlaceholder);
             unit.create.push(subMessage);
             const rootI18nId = i18nBlocks.get(i18nContext.i18nBlock).root;
@@ -10600,69 +10797,54 @@ function extractI18nMessages(job) {
   }
 }
 function createI18nMessage(job, context, messagePlaceholder) {
-  let [formattedParams, needsPostprocessing] = formatParams(context.params);
-  const [formattedPostprocessingParams] = formatParams(context.postprocessingParams);
-  needsPostprocessing || (needsPostprocessing = formattedPostprocessingParams.size > 0);
-  return createI18nMessageOp(job.allocateXrefId(), context.i18nBlock, context.message, messagePlaceholder != null ? messagePlaceholder : null, formattedParams, formattedPostprocessingParams, needsPostprocessing);
+  let formattedParams = formatParams(context.params);
+  const formattedPostprocessingParams = formatParams(context.postprocessingParams);
+  let needsPostprocessing = formattedPostprocessingParams.size > 0;
+  for (const values of context.params.values()) {
+    if (values.length > 1) {
+      needsPostprocessing = true;
+    }
+  }
+  return createI18nMessageOp(job.allocateXrefId(), context.xref, context.i18nBlock, context.message, messagePlaceholder != null ? messagePlaceholder : null, formattedParams, formattedPostprocessingParams, needsPostprocessing);
 }
 function formatParams(params) {
   const formattedParams = /* @__PURE__ */ new Map();
-  let needsPostprocessing = false;
   for (const [placeholder, placeholderValues] of params) {
-    const [serializedValues, paramNeedsPostprocessing] = formatParamValues(placeholderValues);
-    needsPostprocessing || (needsPostprocessing = paramNeedsPostprocessing);
+    const serializedValues = formatParamValues(placeholderValues);
     if (serializedValues !== null) {
       formattedParams.set(placeholder, literal(serializedValues));
     }
   }
-  return [formattedParams, needsPostprocessing];
+  return formattedParams;
 }
 function formatParamValues(values) {
   if (values.length === 0) {
-    return [null, false];
+    return null;
   }
-  collapseElementTemplatePairs(values);
   const serializedValues = values.map((value) => formatValue(value));
-  return serializedValues.length === 1 ? [serializedValues[0], false] : [`${LIST_START_MARKER}${serializedValues.join(LIST_DELIMITER)}${LIST_END_MARKER}`, true];
+  return serializedValues.length === 1 ? serializedValues[0] : `${LIST_START_MARKER}${serializedValues.join(LIST_DELIMITER)}${LIST_END_MARKER}`;
 }
-function collapseElementTemplatePairs(values) {
-  var _a2;
-  const valueIndiciesBySubTemplateIndex = /* @__PURE__ */ new Map();
-  for (let i = 0; i < values.length; i++) {
-    const value = values[i];
-    if (value.subTemplateIndex !== null && value.flags & (I18nParamValueFlags.ElementTag | I18nParamValueFlags.TemplateTag)) {
-      const valueIndicies = (_a2 = valueIndiciesBySubTemplateIndex.get(value.subTemplateIndex)) != null ? _a2 : [];
-      valueIndicies.push(i);
-      valueIndiciesBySubTemplateIndex.set(value.subTemplateIndex, valueIndicies);
-    }
-  }
-  for (const [subTemplateIndex, valueIndicies] of valueIndiciesBySubTemplateIndex) {
-    if (valueIndicies.length > 1) {
-      const elementIndex = valueIndicies.find((index) => values[index].flags & I18nParamValueFlags.ElementTag);
-      const templateIndex = valueIndicies.find((index) => values[index].flags & I18nParamValueFlags.TemplateTag);
-      if (elementIndex !== void 0 && templateIndex !== void 0) {
-        const elementValue = values[elementIndex];
-        const templateValue = values[templateIndex];
-        let compundValue;
-        if (elementValue.flags & I18nParamValueFlags.OpenTag && elementValue.flags & I18nParamValueFlags.CloseTag) {
-          compundValue = `${formatValue(templateValue)}${formatValue(elementValue)}${formatValue(templateValue)}`;
-        } else if (elementValue.flags & I18nParamValueFlags.OpenTag) {
-          compundValue = `${formatValue(templateValue)}${formatValue(elementValue)}`;
-        } else {
-          compundValue = `${formatValue(elementValue)}${formatValue(templateValue)}`;
-        }
-        values.splice(elementIndex, 1, { value: compundValue, subTemplateIndex, flags: I18nParamValueFlags.None });
-        values.splice(templateIndex, 1, null);
-      }
+function formatValue(value) {
+  if (value.flags & I18nParamValueFlags.ElementTag && value.flags & I18nParamValueFlags.TemplateTag) {
+    if (typeof value.value !== "object") {
+      throw Error("AssertionError: Expected i18n param value to have an element and template slot");
     }
-  }
-  for (let i = values.length - 1; i >= 0; i--) {
-    if (values[i] === null) {
-      values.splice(i, 1);
+    const elementValue = formatValue(__spreadProps(__spreadValues({}, value), {
+      value: value.value.element,
+      flags: value.flags & ~I18nParamValueFlags.TemplateTag
+    }));
+    const templateValue = formatValue(__spreadProps(__spreadValues({}, value), {
+      value: value.value.template,
+      flags: value.flags & ~I18nParamValueFlags.ElementTag
+    }));
+    if (value.flags & I18nParamValueFlags.OpenTag && value.flags & I18nParamValueFlags.CloseTag) {
+      return `${templateValue}${elementValue}${templateValue}`;
     }
+    return value.flags & I18nParamValueFlags.CloseTag ? `${elementValue}${templateValue}` : `${templateValue}${elementValue}`;
+  }
+  if (value.flags & I18nParamValueFlags.OpenTag && value.flags & I18nParamValueFlags.CloseTag) {
+    return `${formatValue(__spreadProps(__spreadValues({}, value), { flags: value.flags & ~I18nParamValueFlags.CloseTag }))}${formatValue(__spreadProps(__spreadValues({}, value), { flags: value.flags & ~I18nParamValueFlags.OpenTag }))}`;
   }
-}
-function formatValue(value) {
   if (value.flags === I18nParamValueFlags.None) {
     return `${value.value}`;
   }
@@ -10677,9 +10859,6 @@ function formatValue(value) {
     closeMarker = value.flags & I18nParamValueFlags.CloseTag ? TAG_CLOSE_MARKER : "";
   }
   const context = value.subTemplateIndex === null ? "" : `${CONTEXT_MARKER}${value.subTemplateIndex}`;
-  if (value.flags & I18nParamValueFlags.OpenTag && value.flags & I18nParamValueFlags.CloseTag) {
-    return `${ESCAPE}${tagMarker}${value.value}${context}${ESCAPE}${ESCAPE}${closeMarker}${tagMarker}${value.value}${context}${ESCAPE}`;
-  }
   return `${ESCAPE}${closeMarker}${tagMarker}${value.value}${context}${ESCAPE}`;
 }
 
@@ -10700,7 +10879,7 @@ function generateAdvance(job) {
       if (!hasDependsOnSlotContextTrait(op)) {
         continue;
       } else if (!slotMap.has(op.target)) {
-        throw new Error(`AssertionError: reference to unknown slot for var ${op.target}`);
+        throw new Error(`AssertionError: reference to unknown slot for target ${op.target}`);
       }
       const slot = slotMap.get(op.target);
       if (slotContext !== slot) {
@@ -10748,8 +10927,13 @@ function recursivelyProcessView(view, parentScope) {
   for (const op of view.create) {
     switch (op.kind) {
       case OpKind.Template:
+        recursivelyProcessView(view.job.views.get(op.xref), scope);
+        break;
       case OpKind.RepeaterCreate:
         recursivelyProcessView(view.job.views.get(op.xref), scope);
+        if (op.emptyView) {
+          recursivelyProcessView(view.job.views.get(op.emptyView), scope);
+        }
         break;
       case OpKind.Listener:
         op.handlerOps.prepend(generateVariablesInScopeForView(view, scope));
@@ -16842,56 +17026,137 @@ function createEmptyMessagePart(location) {
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/i18n_const_collection.mjs
 var NG_I18N_CLOSURE_MODE = "ngI18nClosureMode";
 var TRANSLATION_VAR_PREFIX2 = "i18n_";
+var I18N_ICU_MAPPING_PREFIX2 = "I18N_EXP_";
+var ESCAPE2 = "\uFFFD";
 function collectI18nConsts(job) {
+  var _a2, _b2;
   const fileBasedI18nSuffix = job.relativeContextFilePath.replace(/[^A-Za-z0-9]/g, "_").toUpperCase() + "_";
-  const messageConstIndices = /* @__PURE__ */ new Map();
+  const extractedAttributesByI18nContext = /* @__PURE__ */ new Map();
+  const i18nAttributesByElement = /* @__PURE__ */ new Map();
+  const i18nExpressionsByElement = /* @__PURE__ */ new Map();
   const messages = /* @__PURE__ */ new Map();
+  for (const unit of job.units) {
+    for (const op of unit.ops()) {
+      if (op.kind === OpKind.ExtractedAttribute && op.i18nContext !== null) {
+        const attributes = (_a2 = extractedAttributesByI18nContext.get(op.i18nContext)) != null ? _a2 : [];
+        attributes.push(op);
+        extractedAttributesByI18nContext.set(op.i18nContext, attributes);
+      } else if (op.kind === OpKind.I18nAttributes) {
+        i18nAttributesByElement.set(op.target, op);
+      } else if (op.kind === OpKind.I18nExpression && op.usage === I18nExpressionFor.I18nAttribute) {
+        const expressions = (_b2 = i18nExpressionsByElement.get(op.target)) != null ? _b2 : [];
+        expressions.push(op);
+        i18nExpressionsByElement.set(op.target, expressions);
+      } else if (op.kind === OpKind.I18nMessage) {
+        messages.set(op.xref, op);
+      }
+    }
+  }
+  const i18nValuesByContext = /* @__PURE__ */ new Map();
+  const messageConstIndices = /* @__PURE__ */ new Map();
   for (const unit of job.units) {
     for (const op of unit.create) {
       if (op.kind === OpKind.I18nMessage) {
-        messages.set(op.xref, op);
+        if (op.messagePlaceholder === null) {
+          const { mainVar, statements } = collectMessage(job, fileBasedI18nSuffix, messages, op);
+          if (op.i18nBlock !== null) {
+            const i18nConst = job.addConst(mainVar, statements);
+            messageConstIndices.set(op.i18nBlock, i18nConst);
+          } else {
+            job.constsInitializers.push(...statements);
+            i18nValuesByContext.set(op.i18nContext, mainVar);
+            const attributesForMessage = extractedAttributesByI18nContext.get(op.i18nContext);
+            if (attributesForMessage !== void 0) {
+              for (const attr of attributesForMessage) {
+                attr.expression = mainVar.clone();
+              }
+            }
+          }
+        }
         OpList.remove(op);
       }
     }
   }
-  for (const op of messages.values()) {
-    if (op.kind === OpKind.I18nMessage && op.messagePlaceholder === null) {
-      const { mainVar, statements } = collectMessage(job, fileBasedI18nSuffix, messages, op);
-      messageConstIndices.set(op.i18nBlock, job.addConst(mainVar, statements));
+  for (const unit of job.units) {
+    for (const elem of unit.create) {
+      if (isElementOrContainerOp(elem)) {
+        const i18nAttributes2 = i18nAttributesByElement.get(elem.xref);
+        if (i18nAttributes2 === void 0) {
+          continue;
+        }
+        let i18nExpressions = i18nExpressionsByElement.get(elem.xref);
+        if (i18nExpressions === void 0) {
+          throw new Error("AssertionError: Could not find any i18n expressions associated with an I18nAttributes instruction");
+        }
+        const seenPropertyNames = /* @__PURE__ */ new Set();
+        i18nExpressions = i18nExpressions.filter((i18nExpr) => {
+          const seen = seenPropertyNames.has(i18nExpr.name);
+          seenPropertyNames.add(i18nExpr.name);
+          return !seen;
+        });
+        const i18nAttributeConfig = i18nExpressions.flatMap((i18nExpr) => {
+          const i18nExprValue = i18nValuesByContext.get(i18nExpr.context);
+          if (i18nExprValue === void 0) {
+            throw new Error("AssertionError: Could not find i18n expression's value");
+          }
+          return [literal(i18nExpr.name), i18nExprValue];
+        });
+        i18nAttributes2.i18nAttributesConfig = job.addConst(new LiteralArrayExpr(i18nAttributeConfig));
+      }
     }
   }
   for (const unit of job.units) {
     for (const op of unit.create) {
       if (op.kind === OpKind.I18nStart) {
-        op.messageIndex = messageConstIndices.get(op.root);
+        const msgIndex = messageConstIndices.get(op.root);
+        if (msgIndex === void 0) {
+          throw new Error("AssertionError: Could not find corresponding i18n block index for an i18n message op; was an i18n message incorrectly assumed to correspond to an attribute?");
+        }
+        op.messageIndex = msgIndex;
       }
     }
   }
 }
 function collectMessage(job, fileBasedI18nSuffix, messages, messageOp) {
+  var _a2;
   const statements = [];
+  const subMessagePlaceholders = /* @__PURE__ */ new Map();
   for (const subMessageId of messageOp.subMessages) {
     const subMessage = messages.get(subMessageId);
     const { mainVar: subMessageVar, statements: subMessageStatements } = collectMessage(job, fileBasedI18nSuffix, messages, subMessage);
     statements.push(...subMessageStatements);
-    messageOp.params.set(subMessage.messagePlaceholder, subMessageVar);
+    const subMessages = (_a2 = subMessagePlaceholders.get(subMessage.messagePlaceholder)) != null ? _a2 : [];
+    subMessages.push(subMessageVar);
+    subMessagePlaceholders.set(subMessage.messagePlaceholder, subMessages);
   }
+  addSubMessageParams(messageOp, subMessagePlaceholders);
   messageOp.params = new Map([...messageOp.params.entries()].sort());
-  assertAllParamsResolved(messageOp);
   const mainVar = variable(job.pool.uniqueName(TRANSLATION_VAR_PREFIX2));
   const closureVar = i18nGenerateClosureVar(job.pool, messageOp.message.id, fileBasedI18nSuffix, job.i18nUseExternalIds);
   let transformFn = void 0;
   if (messageOp.needsPostprocessing) {
-    messageOp.postprocessingParams = new Map([...messageOp.postprocessingParams.entries()].sort());
+    const postprocessingParams = Object.fromEntries([...messageOp.postprocessingParams.entries()].sort());
+    const formattedPostprocessingParams = formatI18nPlaceholderNamesInMap(postprocessingParams, false);
     const extraTransformFnParams = [];
     if (messageOp.postprocessingParams.size > 0) {
-      extraTransformFnParams.push(literalMap([...messageOp.postprocessingParams].map(([key, value]) => ({ key, value, quoted: true }))));
+      extraTransformFnParams.push(mapLiteral(formattedPostprocessingParams, true));
     }
     transformFn = (expr) => importExpr(Identifiers.i18nPostprocess).callFn([expr, ...extraTransformFnParams]);
   }
   statements.push(...getTranslationDeclStmts(messageOp.message, mainVar, closureVar, messageOp.params, transformFn));
   return { mainVar, statements };
 }
+function addSubMessageParams(messageOp, subMessagePlaceholders) {
+  for (const [placeholder, subMessages] of subMessagePlaceholders) {
+    if (subMessages.length === 1) {
+      messageOp.params.set(placeholder, subMessages[0]);
+    } else {
+      messageOp.params.set(placeholder, literal(`${ESCAPE2}${I18N_ICU_MAPPING_PREFIX2}${placeholder}${ESCAPE2}`));
+      messageOp.postprocessingParams.set(placeholder, literalArr(subMessages));
+      messageOp.needsPostprocessing = true;
+    }
+  }
+}
 function getTranslationDeclStmts(message, variable2, closureVar, params, transformFn) {
   const paramsObject = Object.fromEntries(params);
   const statements = [
@@ -16919,23 +17184,9 @@ function i18nGenerateClosureVar(pool, messageId, fileBasedI18nSuffix, useExterna
   }
   return variable(name);
 }
-function assertAllParamsResolved(op) {
-  for (let placeholder in op.message.placeholders) {
-    placeholder = placeholder.trimEnd();
-    if (!op.params.has(placeholder) && !op.postprocessingParams.has(placeholder)) {
-      throw Error(`Failed to resolve i18n placeholder: ${placeholder}`);
-    }
-  }
-  for (let placeholder in op.message.placeholderToMessage) {
-    placeholder = placeholder.trimEnd();
-    if (!op.params.has(placeholder) && !op.postprocessingParams.has(placeholder)) {
-      throw Error(`Failed to resolve i18n message placeholder: ${placeholder}`);
-    }
-  }
-}
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/i18n_text_extraction.mjs
-function extractI18nText(job) {
+function convertI18nText(job) {
   var _a2;
   for (const unit of job.units) {
     let currentI18n = null;
@@ -16984,7 +17235,7 @@ function extractI18nText(job) {
           const ops = [];
           for (let i = 0; i < op.interpolation.expressions.length; i++) {
             const expr = op.interpolation.expressions[i];
-            ops.push(createI18nExpressionOp(contextId, i18nOp.xref, i18nOp.handle, expr, op.i18nPlaceholders[i], resolutionTime, (_a2 = expr.sourceSpan) != null ? _a2 : op.sourceSpan));
+            ops.push(createI18nExpressionOp(contextId, i18nOp.xref, i18nOp.xref, i18nOp.handle, expr, op.interpolation.i18nPlaceholders[i], resolutionTime, I18nExpressionFor.I18nText, "", (_a2 = expr.sourceSpan) != null ? _a2 : op.sourceSpan));
           }
           OpList.replaceWithMany(op, ops);
           break;
@@ -17406,13 +17657,13 @@ function parseExtractedStyles(job) {
         if (op.name === "style") {
           const parsedStyles = parse(op.expression.value);
           for (let i = 0; i < parsedStyles.length - 1; i += 2) {
-            OpList.insertBefore(createExtractedAttributeOp(op.target, BindingKind.StyleProperty, parsedStyles[i], literal(parsedStyles[i + 1])), op);
+            OpList.insertBefore(createExtractedAttributeOp(op.target, BindingKind.StyleProperty, parsedStyles[i], literal(parsedStyles[i + 1]), null, null, SecurityContext.STYLE), op);
           }
           OpList.remove(op);
         } else if (op.name === "class") {
           const parsedClasses = op.expression.value.trim().split(/\s+/g);
           for (const parsedClass of parsedClasses) {
-            OpList.insertBefore(createExtractedAttributeOp(op.target, BindingKind.ClassName, parsedClass, null), op);
+            OpList.insertBefore(createExtractedAttributeOp(op.target, BindingKind.ClassName, parsedClass, null, null, null, SecurityContext.NONE), op);
           }
           OpList.remove(op);
         }
@@ -17425,18 +17676,28 @@ function parseExtractedStyles(job) {
 function removeContentSelectors(job) {
   for (const unit of job.units) {
     const elements = createOpXrefMap(unit);
-    for (const op of unit.update) {
+    for (const op of unit.ops()) {
       switch (op.kind) {
         case OpKind.Binding:
           const target = lookupInXrefMap(elements, op.target);
-          if (op.name.toLowerCase() === "select" && target.kind === OpKind.Projection) {
+          if (isSelectAttribute(op.name) && target.kind === OpKind.Projection) {
             OpList.remove(op);
           }
           break;
+        case OpKind.Projection:
+          for (let i = op.attributes.length - 2; i >= 0; i -= 2) {
+            if (isSelectAttribute(op.attributes[i])) {
+              op.attributes.splice(i, 2);
+            }
+          }
+          break;
       }
     }
   }
 }
+function isSelectAttribute(name) {
+  return name.toLowerCase() === "select";
+}
 function lookupInXrefMap(map, xref) {
   const el = map.get(xref);
   if (el === void 0) {
@@ -17523,22 +17784,35 @@ function propagateI18nBlocksToTemplates(unit, subTemplateIndex) {
         i18nBlock = op;
         break;
       case OpKind.I18nEnd:
+        if (i18nBlock.subTemplateIndex === null) {
+          subTemplateIndex = 0;
+        }
         i18nBlock = null;
         break;
       case OpKind.Template:
-        const templateView = unit.job.views.get(op.xref);
-        if (op.i18nPlaceholder !== void 0) {
-          if (i18nBlock === null) {
-            throw Error("Expected template with i18n placeholder to be in an i18n block.");
-          }
-          subTemplateIndex++;
-          wrapTemplateWithI18n(templateView, i18nBlock);
+        subTemplateIndex = propagateI18nBlocksForView(unit.job.views.get(op.xref), i18nBlock, op.i18nPlaceholder, subTemplateIndex);
+        break;
+      case OpKind.RepeaterCreate:
+        const forView = unit.job.views.get(op.xref);
+        subTemplateIndex = propagateI18nBlocksForView(unit.job.views.get(op.xref), i18nBlock, op.i18nPlaceholder, subTemplateIndex);
+        if (op.emptyView !== null) {
+          subTemplateIndex = propagateI18nBlocksForView(unit.job.views.get(op.emptyView), i18nBlock, op.emptyI18nPlaceholder, subTemplateIndex);
         }
-        subTemplateIndex = propagateI18nBlocksToTemplates(templateView, subTemplateIndex);
+        break;
     }
   }
   return subTemplateIndex;
 }
+function propagateI18nBlocksForView(view, i18nBlock, i18nPlaceholder, subTemplateIndex) {
+  if (i18nPlaceholder !== void 0) {
+    if (i18nBlock === null) {
+      throw Error("Expected template with i18n placeholder to be in an i18n block.");
+    }
+    subTemplateIndex++;
+    wrapTemplateWithI18n(view, i18nBlock);
+  }
+  return propagateI18nBlocksToTemplates(view, subTemplateIndex);
+}
 function wrapTemplateWithI18n(unit, parentI18n) {
   var _a2;
   if (((_a2 = unit.create.head.next) == null ? void 0 : _a2.kind) !== OpKind.I18nStart) {
@@ -17695,17 +17969,13 @@ function disableBindings2() {
 function enableBindings() {
   return call(Identifiers.enableBindings, [], null);
 }
-function listener(name, handlerFn, sourceSpan) {
-  return call(Identifiers.listener, [
-    literal(name),
-    handlerFn
-  ], sourceSpan);
-}
-function syntheticHostListener(name, handlerFn, sourceSpan) {
-  return call(Identifiers.syntheticHostListener, [
-    literal(name),
-    handlerFn
-  ], sourceSpan);
+function listener(name, handlerFn, eventTargetResolver, syntheticHost, sourceSpan) {
+  const args = [literal(name), handlerFn];
+  if (eventTargetResolver !== null) {
+    args.push(literal(false));
+    args.push(importExpr(eventTargetResolver));
+  }
+  return call(syntheticHost ? Identifiers.syntheticHostListener : Identifiers.listener, args, sourceSpan);
 }
 function pipe(slot, name) {
   return call(Identifiers.pipe, [
@@ -17852,6 +18122,10 @@ function i18n(slot, constIndex, subTemplateIndex) {
 function i18nEnd() {
   return call(Identifiers.i18nEnd, [], null);
 }
+function i18nAttributes(slot, i18nAttributesConfig) {
+  const args = [literal(slot), literal(i18nAttributesConfig)];
+  return call(Identifiers.i18nAttributes, args, null);
+}
 function property(name, expression, sanitizer, sourceSpan) {
   const args = [literal(name), expression];
   if (sanitizer !== null) {
@@ -17960,8 +18234,12 @@ function classMapInterpolate(strings, expressions, sourceSpan) {
   const interpolationArgs = collateInterpolationArgs(strings, expressions);
   return callVariadicInstruction(CLASS_MAP_INTERPOLATE_CONFIG, [], interpolationArgs, [], sourceSpan);
 }
-function hostProperty(name, expression, sourceSpan) {
-  return call(Identifiers.hostProperty, [literal(name), expression], sourceSpan);
+function hostProperty(name, expression, sanitizer, sourceSpan) {
+  const args = [literal(name), expression];
+  if (sanitizer !== null) {
+    args.push(sanitizer);
+  }
+  return call(Identifiers.hostProperty, args, sourceSpan);
 }
 function syntheticHostProperty(name, expression, sourceSpan) {
   return call(Identifiers.syntheticHostProperty, [literal(name), expression], sourceSpan);
@@ -18149,13 +18427,10 @@ function callVariadicInstruction(config, baseArgs, interpolationArgs, extraArgs,
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/reify.mjs
-var sanitizerIdentifierMap = /* @__PURE__ */ new Map([
-  [SanitizerFn.Html, Identifiers.sanitizeHtml],
-  [SanitizerFn.IframeAttribute, Identifiers.validateIframeAttribute],
-  [SanitizerFn.ResourceUrl, Identifiers.sanitizeResourceUrl],
-  [SanitizerFn.Script, Identifiers.sanitizeScript],
-  [SanitizerFn.Style, Identifiers.sanitizeStyle],
-  [SanitizerFn.Url, Identifiers.sanitizeUrl]
+var GLOBAL_TARGET_RESOLVERS = /* @__PURE__ */ new Map([
+  ["window", Identifiers.resolveWindow],
+  ["document", Identifiers.resolveDocument],
+  ["body", Identifiers.resolveBody]
 ]);
 function reify(job) {
   for (const unit of job.units) {
@@ -18198,6 +18473,12 @@ function reifyCreateOperations(unit, ops) {
       case OpKind.I18n:
         OpList.replace(op, i18n(op.handle.slot, op.messageIndex, op.subTemplateIndex));
         break;
+      case OpKind.I18nAttributes:
+        if (op.i18nAttributesConfig === null) {
+          throw new Error(`AssertionError: i18nAttributesConfig was not set`);
+        }
+        OpList.replace(op, i18nAttributes(op.handle.slot, op.i18nAttributesConfig));
+        break;
       case OpKind.Template:
         if (!(unit instanceof ViewCompilationUnit)) {
           throw new Error(`AssertionError: must be compiling a component`);
@@ -18219,8 +18500,11 @@ function reifyCreateOperations(unit, ops) {
         break;
       case OpKind.Listener:
         const listenerFn = reifyListenerHandler(unit, op.handlerFnName, op.handlerOps, op.consumesDollarEvent);
-        const reified = op.hostListener && op.isAnimationListener ? syntheticHostListener(op.name, listenerFn, op.sourceSpan) : listener(op.name, listenerFn, op.sourceSpan);
-        OpList.replace(op, reified);
+        const eventTargetResolver = op.eventTarget ? GLOBAL_TARGET_RESOLVERS.get(op.eventTarget) : null;
+        if (eventTargetResolver === void 0) {
+          throw new Error(`AssertionError: unknown event target ${op.eventTarget}`);
+        }
+        OpList.replace(op, listener(op.name, listenerFn, eventTargetResolver, op.hostListener && op.isAnimationListener, op.sourceSpan));
         break;
       case OpKind.Variable:
         if (op.variable.name === null) {
@@ -18375,7 +18659,7 @@ function reifyUpdateOperations(_unit, ops) {
           if (op.isAnimationTrigger) {
             OpList.replace(op, syntheticHostProperty(op.name, op.expression, op.sourceSpan));
           } else {
-            OpList.replace(op, hostProperty(op.name, op.expression, op.sourceSpan));
+            OpList.replace(op, hostProperty(op.name, op.expression, op.sanitizer, op.sourceSpan));
           }
         }
         break;
@@ -18453,8 +18737,6 @@ function reifyIrExpression(expr) {
       return pipeBind(expr.targetSlot.slot, expr.varOffset, expr.args);
     case ExpressionKind.PipeBindingVariadic:
       return pipeBindV(expr.targetSlot.slot, expr.varOffset, expr.args);
-    case ExpressionKind.SanitizerExpr:
-      return importExpr(sanitizerIdentifierMap.get(expr.fn));
     case ExpressionKind.SlotLiteralExpr:
       return literal(expr.slot.slot);
     default:
@@ -18514,6 +18796,28 @@ function removeI18nContexts(job) {
   }
 }
 
+// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/remove_unused_i18n_attrs.mjs
+function removeUnusedI18nAttributesOps(job) {
+  for (const unit of job.units) {
+    const ownersWithI18nExpressions = /* @__PURE__ */ new Set();
+    for (const op of unit.update) {
+      switch (op.kind) {
+        case OpKind.I18nExpression:
+          ownersWithI18nExpressions.add(op.i18nOwner);
+      }
+    }
+    for (const op of unit.create) {
+      switch (op.kind) {
+        case OpKind.I18nAttributes:
+          if (ownersWithI18nExpressions.has(op.xref)) {
+            continue;
+          }
+          OpList.remove(op);
+      }
+    }
+  }
+}
+
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/repeater_derived_vars.mjs
 function generateRepeaterDerivedVars(job) {
   const repeaters = /* @__PURE__ */ new Map();
@@ -18626,8 +18930,9 @@ function resolveI18nElementPlaceholders(job) {
   }
   resolvePlaceholdersForView(job, job.root, i18nContexts, elements);
 }
-function resolvePlaceholdersForView(job, unit, i18nContexts, elements) {
+function resolvePlaceholdersForView(job, unit, i18nContexts, elements, pendingStructuralDirective) {
   let currentOps = null;
+  let pendingStructuralDirectiveCloses = /* @__PURE__ */ new Map();
   for (const op of unit.create) {
     switch (op.kind) {
       case OpKind.I18nStart:
@@ -18644,52 +18949,135 @@ function resolvePlaceholdersForView(job, unit, i18nContexts, elements) {
           if (currentOps === null) {
             throw Error("i18n tag placeholder should only occur inside an i18n block");
           }
-          const { startName, closeName } = op.i18nPlaceholder;
-          let flags = I18nParamValueFlags.ElementTag | I18nParamValueFlags.OpenTag;
-          if (closeName === "") {
-            flags |= I18nParamValueFlags.CloseTag;
+          recordElementStart(op, currentOps.i18nContext, currentOps.i18nBlock, pendingStructuralDirective);
+          if (pendingStructuralDirective && op.i18nPlaceholder.closeName) {
+            pendingStructuralDirectiveCloses.set(op.xref, pendingStructuralDirective);
           }
-          addParam(currentOps.i18nContext.params, startName, op.handle.slot, currentOps.i18nBlock.subTemplateIndex, flags);
+          pendingStructuralDirective = void 0;
         }
         break;
       case OpKind.ElementEnd:
         const startOp = elements.get(op.xref);
         if (startOp && startOp.i18nPlaceholder !== void 0) {
           if (currentOps === null) {
-            throw Error("i18n tag placeholder should only occur inside an i18n block");
-          }
-          const { closeName } = startOp.i18nPlaceholder;
-          if (closeName !== "") {
-            addParam(currentOps.i18nContext.params, closeName, startOp.handle.slot, currentOps.i18nBlock.subTemplateIndex, I18nParamValueFlags.ElementTag | I18nParamValueFlags.CloseTag);
+            throw Error("AssertionError: i18n tag placeholder should only occur inside an i18n block");
           }
+          recordElementClose(startOp, currentOps.i18nContext, currentOps.i18nBlock, pendingStructuralDirectiveCloses.get(op.xref));
+          pendingStructuralDirectiveCloses.delete(op.xref);
         }
         break;
-      case OpKind.Template:
+      case OpKind.Projection:
         if (op.i18nPlaceholder !== void 0) {
           if (currentOps === null) {
             throw Error("i18n tag placeholder should only occur inside an i18n block");
           }
-          let startFlags = I18nParamValueFlags.TemplateTag | I18nParamValueFlags.OpenTag;
-          const subTemplateIndex = getSubTemplateIndexForTemplateTag(job, currentOps.i18nBlock, op);
-          const { startName, closeName } = op.i18nPlaceholder;
-          const isSelfClosing = closeName === "";
-          if (isSelfClosing) {
-            startFlags |= I18nParamValueFlags.CloseTag;
+          recordElementStart(op, currentOps.i18nContext, currentOps.i18nBlock, pendingStructuralDirective);
+          recordElementClose(op, currentOps.i18nContext, currentOps.i18nBlock, pendingStructuralDirective);
+          pendingStructuralDirective = void 0;
+        }
+        break;
+      case OpKind.Template:
+        const view = job.views.get(op.xref);
+        if (op.i18nPlaceholder === void 0) {
+          resolvePlaceholdersForView(job, view, i18nContexts, elements);
+        } else {
+          if (currentOps === null) {
+            throw Error("i18n tag placeholder should only occur inside an i18n block");
           }
-          addParam(currentOps.i18nContext.params, startName, op.handle.slot, subTemplateIndex, startFlags);
-          resolvePlaceholdersForView(job, job.views.get(op.xref), i18nContexts, elements);
-          if (!isSelfClosing) {
-            addParam(currentOps.i18nContext.params, closeName, op.handle.slot, subTemplateIndex, I18nParamValueFlags.TemplateTag | I18nParamValueFlags.CloseTag);
+          if (op.templateKind === TemplateKind.Structural) {
+            resolvePlaceholdersForView(job, view, i18nContexts, elements, op);
+          } else {
+            recordTemplateStart(job, view, op.handle.slot, op.i18nPlaceholder, currentOps.i18nContext, currentOps.i18nBlock, pendingStructuralDirective);
+            resolvePlaceholdersForView(job, view, i18nContexts, elements);
+            recordTemplateClose(job, view, op.handle.slot, op.i18nPlaceholder, currentOps.i18nContext, currentOps.i18nBlock, pendingStructuralDirective);
+            pendingStructuralDirective = void 0;
           }
+        }
+        break;
+      case OpKind.RepeaterCreate:
+        if (pendingStructuralDirective !== void 0) {
+          throw Error("AssertionError: Unexpected structural directive associated with @for block");
+        }
+        const forSlot = op.handle.slot + 1;
+        const forView = job.views.get(op.xref);
+        if (op.i18nPlaceholder === void 0) {
+          resolvePlaceholdersForView(job, forView, i18nContexts, elements);
         } else {
-          resolvePlaceholdersForView(job, job.views.get(op.xref), i18nContexts, elements);
+          if (currentOps === null) {
+            throw Error("i18n tag placeholder should only occur inside an i18n block");
+          }
+          recordTemplateStart(job, forView, forSlot, op.i18nPlaceholder, currentOps.i18nContext, currentOps.i18nBlock, pendingStructuralDirective);
+          resolvePlaceholdersForView(job, forView, i18nContexts, elements);
+          recordTemplateClose(job, forView, forSlot, op.i18nPlaceholder, currentOps.i18nContext, currentOps.i18nBlock, pendingStructuralDirective);
+          pendingStructuralDirective = void 0;
+        }
+        if (op.emptyView !== null) {
+          const emptySlot = op.handle.slot + 2;
+          const emptyView = job.views.get(op.emptyView);
+          if (op.emptyI18nPlaceholder === void 0) {
+            resolvePlaceholdersForView(job, emptyView, i18nContexts, elements);
+          } else {
+            if (currentOps === null) {
+              throw Error("i18n tag placeholder should only occur inside an i18n block");
+            }
+            recordTemplateStart(job, emptyView, emptySlot, op.emptyI18nPlaceholder, currentOps.i18nContext, currentOps.i18nBlock, pendingStructuralDirective);
+            resolvePlaceholdersForView(job, emptyView, i18nContexts, elements);
+            recordTemplateClose(job, emptyView, emptySlot, op.emptyI18nPlaceholder, currentOps.i18nContext, currentOps.i18nBlock, pendingStructuralDirective);
+            pendingStructuralDirective = void 0;
+          }
         }
         break;
     }
   }
 }
-function getSubTemplateIndexForTemplateTag(job, i18nOp, op) {
-  for (const childOp of job.views.get(op.xref).create) {
+function recordElementStart(op, i18nContext, i18nBlock, structuralDirective) {
+  const { startName, closeName } = op.i18nPlaceholder;
+  let flags = I18nParamValueFlags.ElementTag | I18nParamValueFlags.OpenTag;
+  let value = op.handle.slot;
+  if (structuralDirective !== void 0) {
+    flags |= I18nParamValueFlags.TemplateTag;
+    value = { element: value, template: structuralDirective.handle.slot };
+  }
+  if (!closeName) {
+    flags |= I18nParamValueFlags.CloseTag;
+  }
+  addParam(i18nContext.params, startName, value, i18nBlock.subTemplateIndex, flags);
+}
+function recordElementClose(op, i18nContext, i18nBlock, structuralDirective) {
+  const { closeName } = op.i18nPlaceholder;
+  if (closeName) {
+    let flags = I18nParamValueFlags.ElementTag | I18nParamValueFlags.CloseTag;
+    let value = op.handle.slot;
+    if (structuralDirective !== void 0) {
+      flags |= I18nParamValueFlags.TemplateTag;
+      value = { element: value, template: structuralDirective.handle.slot };
+    }
+    addParam(i18nContext.params, closeName, value, i18nBlock.subTemplateIndex, flags);
+  }
+}
+function recordTemplateStart(job, view, slot, i18nPlaceholder, i18nContext, i18nBlock, structuralDirective) {
+  let { startName, closeName } = i18nPlaceholder;
+  let flags = I18nParamValueFlags.TemplateTag | I18nParamValueFlags.OpenTag;
+  if (!closeName) {
+    flags |= I18nParamValueFlags.CloseTag;
+  }
+  if (structuralDirective !== void 0) {
+    addParam(i18nContext.params, startName, structuralDirective.handle.slot, i18nBlock.subTemplateIndex, flags);
+  }
+  addParam(i18nContext.params, startName, slot, getSubTemplateIndexForTemplateTag(job, i18nBlock, view), flags);
+}
+function recordTemplateClose(job, view, slot, i18nPlaceholder, i18nContext, i18nBlock, structuralDirective) {
+  const { startName, closeName } = i18nPlaceholder;
+  const flags = I18nParamValueFlags.TemplateTag | I18nParamValueFlags.CloseTag;
+  if (closeName) {
+    addParam(i18nContext.params, closeName, slot, getSubTemplateIndexForTemplateTag(job, i18nBlock, view), flags);
+    if (structuralDirective !== void 0) {
+      addParam(i18nContext.params, closeName, structuralDirective.handle.slot, i18nBlock.subTemplateIndex, flags);
+    }
+  }
+}
+function getSubTemplateIndexForTemplateTag(job, i18nOp, view) {
+  for (const childOp of view.create) {
     if (childOp.kind === OpKind.I18nStart) {
       return childOp.subTemplateIndex;
     }
@@ -18705,6 +19093,7 @@ function addParam(params, placeholder, value, subTemplateIndex, flags) {
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/resolve_i18n_expression_placeholders.mjs
 function resolveI18nExpressionPlaceholders(job) {
+  var _a2;
   const subTemplateIndicies = /* @__PURE__ */ new Map();
   const i18nContexts = /* @__PURE__ */ new Map();
   for (const unit of job.units) {
@@ -18720,12 +19109,13 @@ function resolveI18nExpressionPlaceholders(job) {
     }
   }
   const expressionIndices = /* @__PURE__ */ new Map();
+  const referenceIndex = (op) => op.usage === I18nExpressionFor.I18nText ? op.i18nOwner : op.context;
   for (const unit of job.units) {
     for (const op of unit.update) {
       if (op.kind === OpKind.I18nExpression) {
         const i18nContext = i18nContexts.get(op.context);
-        const index = expressionIndices.get(op.target) || 0;
-        const subTemplateIndex = subTemplateIndicies.get(op.target);
+        const index = expressionIndices.get(referenceIndex(op)) || 0;
+        const subTemplateIndex = (_a2 = subTemplateIndicies.get(op.i18nOwner)) != null ? _a2 : null;
         const params = op.resolutionTime === I18nParamResolutionTime.Creation ? i18nContext.params : i18nContext.postprocessingParams;
         const values = params.get(op.i18nPlaceholder) || [];
         values.push({
@@ -18734,7 +19124,7 @@ function resolveI18nExpressionPlaceholders(job) {
           flags: I18nParamValueFlags.ExpressionIndex
         });
         params.set(op.i18nPlaceholder, values);
-        expressionIndices.set(op.target, index + 1);
+        expressionIndices.set(referenceIndex(op), index + 1);
       }
     }
   }
@@ -18849,30 +19239,54 @@ function processLexicalScope2(unit, ops, savedView) {
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/resolve_sanitizers.mjs
-var sanitizers = /* @__PURE__ */ new Map([
-  [SecurityContext.HTML, SanitizerFn.Html],
-  [SecurityContext.SCRIPT, SanitizerFn.Script],
-  [SecurityContext.STYLE, SanitizerFn.Style],
-  [SecurityContext.URL, SanitizerFn.Url],
-  [SecurityContext.RESOURCE_URL, SanitizerFn.ResourceUrl]
+var sanitizerFns = /* @__PURE__ */ new Map([
+  [SecurityContext.HTML, Identifiers.sanitizeHtml],
+  [SecurityContext.RESOURCE_URL, Identifiers.sanitizeResourceUrl],
+  [SecurityContext.SCRIPT, Identifiers.sanitizeScript],
+  [SecurityContext.STYLE, Identifiers.sanitizeStyle],
+  [SecurityContext.URL, Identifiers.sanitizeUrl]
+]);
+var trustedValueFns = /* @__PURE__ */ new Map([
+  [SecurityContext.HTML, Identifiers.trustConstantHtml],
+  [SecurityContext.RESOURCE_URL, Identifiers.trustConstantResourceUrl]
 ]);
 function resolveSanitizers(job) {
+  var _a2, _b2;
   for (const unit of job.units) {
     const elements = createOpXrefMap(unit);
-    let sanitizerFn;
+    if (job.kind !== CompilationJobKind.Host) {
+      for (const op of unit.create) {
+        if (op.kind === OpKind.ExtractedAttribute) {
+          const trustedValueFn = (_a2 = trustedValueFns.get(getOnlySecurityContext(op.securityContext))) != null ? _a2 : null;
+          op.trustedValueFn = trustedValueFn !== null ? importExpr(trustedValueFn) : null;
+        }
+      }
+    }
     for (const op of unit.update) {
       switch (op.kind) {
         case OpKind.Property:
         case OpKind.Attribute:
-          sanitizerFn = sanitizers.get(op.securityContext) || null;
-          op.sanitizer = sanitizerFn ? new SanitizerExpr(sanitizerFn) : null;
+        case OpKind.HostProperty:
+          let sanitizerFn = null;
+          if (Array.isArray(op.securityContext) && op.securityContext.length === 2 && op.securityContext.indexOf(SecurityContext.URL) > -1 && op.securityContext.indexOf(SecurityContext.RESOURCE_URL) > -1) {
+            sanitizerFn = Identifiers.sanitizeUrlOrResourceUrl;
+          } else {
+            sanitizerFn = (_b2 = sanitizerFns.get(getOnlySecurityContext(op.securityContext))) != null ? _b2 : null;
+          }
+          op.sanitizer = sanitizerFn !== null ? importExpr(sanitizerFn) : null;
           if (op.sanitizer === null) {
-            const ownerOp = elements.get(op.target);
-            if (ownerOp === void 0 || !isElementOrContainerOp(ownerOp)) {
-              throw Error("Property should have an element-like owner");
+            let isIframe = false;
+            if (job.kind === CompilationJobKind.Host || op.kind === OpKind.HostProperty) {
+              isIframe = true;
+            } else {
+              const ownerOp = elements.get(op.target);
+              if (ownerOp === void 0 || !isElementOrContainerOp(ownerOp)) {
+                throw Error("Property should have an element-like owner");
+              }
+              isIframe = isIframeElement(ownerOp);
             }
-            if (isIframeElement(ownerOp) && isIframeSecuritySensitiveAttr(op.name)) {
-              op.sanitizer = new SanitizerExpr(SanitizerFn.IframeAttribute);
+            if (isIframe && isIframeSecuritySensitiveAttr(op.name)) {
+              op.sanitizer = importExpr(Identifiers.validateIframeAttribute);
             }
           }
           break;
@@ -18884,6 +19298,15 @@ function isIframeElement(op) {
   var _a2;
   return op.kind === OpKind.ElementStart && ((_a2 = op.tag) == null ? void 0 : _a2.toLowerCase()) === "iframe";
 }
+function getOnlySecurityContext(securityContext) {
+  if (Array.isArray(securityContext)) {
+    if (securityContext.length > 1) {
+      throw Error(`AssertionError: Ambiguous security context`);
+    }
+    return securityContext[0] || SecurityContext.NONE;
+  }
+  return securityContext;
+}
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/save_restore_view.mjs
 function saveAndRestoreView(job) {
@@ -19531,12 +19954,12 @@ var phases = [
   { kind: CompilationJobKind.Tmpl, fn: removeContentSelectors },
   { kind: CompilationJobKind.Host, fn: parseHostStyleProperties },
   { kind: CompilationJobKind.Tmpl, fn: emitNamespaceChanges },
-  { kind: CompilationJobKind.Both, fn: specializeStyleBindings },
-  { kind: CompilationJobKind.Both, fn: specializeBindings },
   { kind: CompilationJobKind.Tmpl, fn: propagateI18nBlocks },
   { kind: CompilationJobKind.Tmpl, fn: wrapI18nIcus },
-  { kind: CompilationJobKind.Tmpl, fn: createI18nContexts },
+  { kind: CompilationJobKind.Both, fn: specializeStyleBindings },
+  { kind: CompilationJobKind.Both, fn: specializeBindings },
   { kind: CompilationJobKind.Both, fn: extractAttributes },
+  { kind: CompilationJobKind.Tmpl, fn: createI18nContexts },
   { kind: CompilationJobKind.Both, fn: parseExtractedStyles },
   { kind: CompilationJobKind.Tmpl, fn: removeEmptyBindings },
   { kind: CompilationJobKind.Both, fn: collapseSingletonInterpolations },
@@ -19544,14 +19967,17 @@ var phases = [
   { kind: CompilationJobKind.Tmpl, fn: generateConditionalExpressions },
   { kind: CompilationJobKind.Tmpl, fn: createPipes },
   { kind: CompilationJobKind.Tmpl, fn: configureDeferInstructions },
-  { kind: CompilationJobKind.Tmpl, fn: extractI18nText },
+  { kind: CompilationJobKind.Tmpl, fn: convertI18nText },
+  { kind: CompilationJobKind.Tmpl, fn: convertI18nBindings },
+  { kind: CompilationJobKind.Tmpl, fn: removeUnusedI18nAttributesOps },
+  { kind: CompilationJobKind.Tmpl, fn: assignI18nSlotDependencies },
   { kind: CompilationJobKind.Tmpl, fn: applyI18nExpressions },
   { kind: CompilationJobKind.Tmpl, fn: createVariadicPipes },
   { kind: CompilationJobKind.Both, fn: generatePureLiteralStructures },
   { kind: CompilationJobKind.Tmpl, fn: generateProjectionDefs },
   { kind: CompilationJobKind.Tmpl, fn: generateVariables },
   { kind: CompilationJobKind.Tmpl, fn: saveAndRestoreView },
-  { kind: CompilationJobKind.Tmpl, fn: deleteAnyCasts },
+  { kind: CompilationJobKind.Both, fn: deleteAnyCasts },
   { kind: CompilationJobKind.Both, fn: resolveDollarEvent },
   { kind: CompilationJobKind.Tmpl, fn: generateRepeaterDerivedVars },
   { kind: CompilationJobKind.Tmpl, fn: generateTrackVariables },
@@ -19559,7 +19985,7 @@ var phases = [
   { kind: CompilationJobKind.Tmpl, fn: resolveDeferTargetNames },
   { kind: CompilationJobKind.Tmpl, fn: optimizeTrackFns },
   { kind: CompilationJobKind.Both, fn: resolveContexts },
-  { kind: CompilationJobKind.Tmpl, fn: resolveSanitizers },
+  { kind: CompilationJobKind.Both, fn: resolveSanitizers },
   { kind: CompilationJobKind.Tmpl, fn: liftLocalRefs },
   { kind: CompilationJobKind.Both, fn: generateNullishCoalesceExpressions },
   { kind: CompilationJobKind.Both, fn: expandSafeReads },
@@ -19574,7 +20000,6 @@ var phases = [
   { kind: CompilationJobKind.Tmpl, fn: collectI18nConsts },
   { kind: CompilationJobKind.Tmpl, fn: collectConstExpressions },
   { kind: CompilationJobKind.Both, fn: collectElementConsts },
-  { kind: CompilationJobKind.Tmpl, fn: assignI18nSlotDependencies },
   { kind: CompilationJobKind.Tmpl, fn: removeI18nContexts },
   { kind: CompilationJobKind.Both, fn: countVariables },
   { kind: CompilationJobKind.Tmpl, fn: generateAdvance },
@@ -19692,6 +20117,8 @@ function emitHostBindingFunction(job) {
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/template/pipeline/src/ingest.mjs
 var compatibilityMode = CompatibilityMode.TemplateDefinitionBuilder;
+var domSchema = new DomElementSchemaRegistry();
+var NG_TEMPLATE_TAG_NAME = "ng-template";
 function ingestComponent(componentName, template2, constantPool, relativeContextFilePath, i18nUseExternalIds, deferBlocksMeta) {
   const job = new ComponentCompilationJob(componentName, constantPool, compatibilityMode, relativeContextFilePath, i18nUseExternalIds, deferBlocksMeta);
   ingestNodes(job.root, template2);
@@ -19701,50 +20128,55 @@ function ingestHostBinding(input, bindingParser, constantPool) {
   var _a2, _b2, _c2;
   const job = new HostBindingCompilationJob(input.componentName, constantPool, compatibilityMode);
   for (const property2 of (_a2 = input.properties) != null ? _a2 : []) {
-    ingestHostProperty(job, property2, false);
+    let bindingKind = BindingKind.Property;
+    if (property2.name.startsWith("attr.")) {
+      property2.name = property2.name.substring("attr.".length);
+      bindingKind = BindingKind.Attribute;
+    }
+    if (property2.isAnimation) {
+      bindingKind = BindingKind.Animation;
+    }
+    const securityContexts = bindingParser.calcPossibleSecurityContexts(input.componentSelector, property2.name, bindingKind === BindingKind.Attribute).filter((context) => context !== SecurityContext.NONE);
+    ingestHostProperty(job, property2, bindingKind, false, securityContexts);
   }
   for (const [name, expr] of (_b2 = Object.entries(input.attributes)) != null ? _b2 : []) {
-    ingestHostAttribute(job, name, expr);
+    const securityContexts = bindingParser.calcPossibleSecurityContexts(input.componentSelector, name, true).filter((context) => context !== SecurityContext.NONE);
+    ingestHostAttribute(job, name, expr, securityContexts);
   }
   for (const event of (_c2 = input.events) != null ? _c2 : []) {
     ingestHostEvent(job, event);
   }
   return job;
 }
-function ingestHostProperty(job, property2, isTextAttribute) {
+function ingestHostProperty(job, property2, bindingKind, isTextAttribute, securityContexts) {
   let expression;
   const ast = property2.expression.ast;
   if (ast instanceof Interpolation) {
-    expression = new Interpolation2(ast.strings, ast.expressions.map((expr) => convertAst(expr, job, property2.sourceSpan)));
+    expression = new Interpolation2(ast.strings, ast.expressions.map((expr) => convertAst(expr, job, property2.sourceSpan)), []);
   } else {
     expression = convertAst(ast, job, property2.sourceSpan);
   }
-  let bindingKind = BindingKind.Property;
-  if (property2.name.startsWith("attr.")) {
-    property2.name = property2.name.substring("attr.".length);
-    bindingKind = BindingKind.Attribute;
-  }
-  if (property2.isAnimation) {
-    bindingKind = BindingKind.Animation;
-  }
-  job.root.update.push(createBindingOp(job.root.xref, bindingKind, property2.name, expression, null, SecurityContext.NONE, isTextAttribute, false, property2.sourceSpan));
+  job.root.update.push(createBindingOp(job.root.xref, bindingKind, property2.name, expression, null, securityContexts, isTextAttribute, false, null, null, property2.sourceSpan));
 }
-function ingestHostAttribute(job, name, value) {
+function ingestHostAttribute(job, name, value, securityContexts) {
   const attrBinding = createBindingOp(
     job.root.xref,
     BindingKind.Attribute,
     name,
     value,
     null,
-    SecurityContext.NONE,
+    securityContexts,
     true,
     false,
+    null,
+    null,
     null
   );
   job.root.update.push(attrBinding);
 }
 function ingestHostEvent(job, event) {
-  const eventBinding = createListenerOp(job.root.xref, new SlotHandle(), event.name, null, event.targetOrPhase, true, event.sourceSpan);
+  const [phase, target] = event.type === 0 ? [null, event.targetOrPhase] : [event.targetOrPhase, null];
+  const eventBinding = createListenerOp(job.root.xref, new SlotHandle(), event.name, null, [], phase, target, true, event.sourceSpan);
   eventBinding.handlerOps.push(createStatementOp(new ReturnStatement(convertAst(event.handler.ast, job, event.sourceSpan), event.handlerSpan)));
   job.root.create.push(eventBinding);
 }
@@ -19784,14 +20216,17 @@ function ingestElement(unit, element2) {
   const [namespaceKey, elementName] = splitNsName(element2.name);
   const startOp = createElementStartOp(elementName, id, namespaceForKey(namespaceKey), element2.i18n instanceof TagPlaceholder ? element2.i18n : void 0, element2.startSourceSpan);
   unit.create.push(startOp);
-  ingestBindings(unit, startOp, element2);
+  ingestElementBindings(unit, startOp, element2);
   ingestReferences(startOp, element2);
+  let i18nBlockId = null;
+  if (element2.i18n instanceof Message) {
+    i18nBlockId = unit.job.allocateXrefId();
+    unit.create.push(createI18nStartOp(i18nBlockId, element2.i18n));
+  }
   ingestNodes(unit, element2.children);
   const endOp = createElementEndOp(id, (_a2 = element2.endSourceSpan) != null ? _a2 : element2.startSourceSpan);
   unit.create.push(endOp);
-  if (element2.i18n instanceof Message) {
-    const i18nBlockId = unit.job.allocateXrefId();
-    OpList.insertAfter(createI18nStartOp(i18nBlockId, element2.i18n), startOp);
+  if (i18nBlockId !== null) {
     OpList.insertBefore(createI18nEndOp(i18nBlockId), endOp);
   }
 }
@@ -19808,24 +20243,30 @@ function ingestTemplate(unit, tmpl) {
   const i18nPlaceholder = tmpl.i18n instanceof TagPlaceholder ? tmpl.i18n : void 0;
   const namespace = namespaceForKey(namespacePrefix);
   const functionNameSuffix = tagNameWithoutNamespace === null ? "" : prefixWithNamespace(tagNameWithoutNamespace, namespace);
-  const tplOp = createTemplateOp(childView.xref, tagNameWithoutNamespace, functionNameSuffix, namespace, i18nPlaceholder, tmpl.startSourceSpan);
-  unit.create.push(tplOp);
-  ingestBindings(unit, tplOp, tmpl);
-  ingestReferences(tplOp, tmpl);
+  const templateKind = isPlainTemplate(tmpl) ? TemplateKind.NgTemplate : TemplateKind.Structural;
+  const templateOp = createTemplateOp(childView.xref, templateKind, tagNameWithoutNamespace, functionNameSuffix, namespace, i18nPlaceholder, tmpl.startSourceSpan);
+  unit.create.push(templateOp);
+  ingestTemplateBindings(unit, templateOp, tmpl, templateKind);
+  ingestReferences(templateOp, tmpl);
   ingestNodes(childView, tmpl.children);
   for (const { name, value } of tmpl.variables) {
     childView.contextVariables.set(name, value !== "" ? value : "$implicit");
   }
-  if (isPlainTemplate(tmpl) && tmpl.i18n instanceof Message) {
+  if (templateKind === TemplateKind.NgTemplate && tmpl.i18n instanceof Message) {
     const id = unit.job.allocateXrefId();
     OpList.insertAfter(createI18nStartOp(id, tmpl.i18n), childView.create.head);
     OpList.insertBefore(createI18nEndOp(id), childView.create.tail);
   }
 }
 function ingestContent(unit, content) {
-  const op = createProjectionOp(unit.job.allocateXrefId(), content.selector, content.sourceSpan);
+  if (content.i18n !== void 0 && !(content.i18n instanceof TagPlaceholder)) {
+    throw Error(`Unhandled i18n metadata type for element: ${content.i18n.constructor.name}`);
+  }
+  const attrs = content.attributes.flatMap((a) => [a.name, a.value]);
+  const op = createProjectionOp(unit.job.allocateXrefId(), content.selector, content.i18n, attrs, content.sourceSpan);
   for (const attr of content.attributes) {
-    ingestBinding(unit, op.xref, attr.name, literal(attr.value), 1, null, SecurityContext.NONE, attr.sourceSpan, BindingFlags.TextValue);
+    const securityContext = domSchema.securityContext(content.name, attr.name, true);
+    unit.update.push(createBindingOp(op.xref, BindingKind.Attribute, attr.name, literal(attr.value), null, securityContext, true, false, null, asMessage(attr.i18n), attr.sourceSpan));
   }
   unit.create.push(op);
 }
@@ -19853,9 +20294,10 @@ function ingestBoundText(unit, text2, i18nPlaceholders) {
   const textXref = unit.job.allocateXrefId();
   unit.create.push(createTextOp(textXref, "", text2.sourceSpan));
   const baseSourceSpan = unit.job.compatibility ? null : text2.sourceSpan;
-  unit.update.push(createInterpolateTextOp(textXref, new Interpolation2(value.strings, value.expressions.map((expr) => convertAst(expr, unit.job, baseSourceSpan))), i18nPlaceholders, text2.sourceSpan));
+  unit.update.push(createInterpolateTextOp(textXref, new Interpolation2(value.strings, value.expressions.map((expr) => convertAst(expr, unit.job, baseSourceSpan)), i18nPlaceholders), text2.sourceSpan));
 }
 function ingestIfBlock(unit, ifBlock) {
+  var _a2;
   let firstXref = null;
   let firstSlotHandle = null;
   let conditions = [];
@@ -19869,14 +20311,21 @@ function ingestIfBlock(unit, ifBlock) {
     if (ifCase.expressionAlias !== null) {
       cView.contextVariables.set(ifCase.expressionAlias.name, CTX_REF);
     }
-    const tmplOp = createTemplateOp(cView.xref, tagName, "Conditional", Namespace.HTML, void 0, ifCase.sourceSpan);
-    unit.create.push(tmplOp);
+    let ifCaseI18nMeta = void 0;
+    if (ifCase.i18n !== void 0) {
+      if (!(ifCase.i18n instanceof BlockPlaceholder)) {
+        throw Error(`Unhandled i18n metadata type for if block: ${(_a2 = ifCase.i18n) == null ? void 0 : _a2.constructor.name}`);
+      }
+      ifCaseI18nMeta = ifCase.i18n;
+    }
+    const templateOp = createTemplateOp(cView.xref, TemplateKind.Block, tagName, "Conditional", Namespace.HTML, ifCaseI18nMeta, ifCase.sourceSpan);
+    unit.create.push(templateOp);
     if (firstXref === null) {
       firstXref = cView.xref;
-      firstSlotHandle = tmplOp.handle;
+      firstSlotHandle = templateOp.handle;
     }
     const caseExpr = ifCase.expression ? convertAst(ifCase.expression, unit.job, null) : null;
-    const conditionalCaseExpr = new ConditionalCaseExpr(caseExpr, tmplOp.xref, tmplOp.handle, ifCase.expressionAlias);
+    const conditionalCaseExpr = new ConditionalCaseExpr(caseExpr, templateOp.xref, templateOp.handle, ifCase.expressionAlias);
     conditions.push(conditionalCaseExpr);
     ingestNodes(cView, ifCase.children);
   }
@@ -19884,54 +20333,65 @@ function ingestIfBlock(unit, ifBlock) {
   unit.update.push(conditional2);
 }
 function ingestSwitchBlock(unit, switchBlock) {
+  var _a2;
   let firstXref = null;
   let firstSlotHandle = null;
   let conditions = [];
   for (const switchCase of switchBlock.cases) {
     const cView = unit.job.allocateView(unit.xref);
-    const tmplOp = createTemplateOp(cView.xref, null, "Case", Namespace.HTML, void 0, switchCase.sourceSpan);
-    unit.create.push(tmplOp);
+    let switchCaseI18nMeta = void 0;
+    if (switchCase.i18n !== void 0) {
+      if (!(switchCase.i18n instanceof BlockPlaceholder)) {
+        throw Error(`Unhandled i18n metadata type for switch block: ${(_a2 = switchCase.i18n) == null ? void 0 : _a2.constructor.name}`);
+      }
+      switchCaseI18nMeta = switchCase.i18n;
+    }
+    const templateOp = createTemplateOp(cView.xref, TemplateKind.Block, null, "Case", Namespace.HTML, switchCaseI18nMeta, switchCase.sourceSpan);
+    unit.create.push(templateOp);
     if (firstXref === null) {
       firstXref = cView.xref;
-      firstSlotHandle = tmplOp.handle;
+      firstSlotHandle = templateOp.handle;
     }
     const caseExpr = switchCase.expression ? convertAst(switchCase.expression, unit.job, switchBlock.startSourceSpan) : null;
-    const conditionalCaseExpr = new ConditionalCaseExpr(caseExpr, tmplOp.xref, tmplOp.handle);
+    const conditionalCaseExpr = new ConditionalCaseExpr(caseExpr, templateOp.xref, templateOp.handle);
     conditions.push(conditionalCaseExpr);
     ingestNodes(cView, switchCase.children);
   }
   const conditional2 = createConditionalOp(firstXref, firstSlotHandle, convertAst(switchBlock.expression, unit.job, null), conditions, switchBlock.sourceSpan);
   unit.update.push(conditional2);
 }
-function ingestDeferView(unit, suffix, children, sourceSpan) {
+function ingestDeferView(unit, suffix, i18nMeta, children, sourceSpan) {
+  if (i18nMeta !== void 0 && !(i18nMeta instanceof BlockPlaceholder)) {
+    throw Error("Unhandled i18n metadata type for defer block");
+  }
   if (children === void 0) {
     return null;
   }
   const secondaryView = unit.job.allocateView(unit.xref);
   ingestNodes(secondaryView, children);
-  const templateOp = createTemplateOp(secondaryView.xref, null, `Defer${suffix}`, Namespace.HTML, void 0, sourceSpan);
+  const templateOp = createTemplateOp(secondaryView.xref, TemplateKind.Block, null, `Defer${suffix}`, Namespace.HTML, i18nMeta, sourceSpan);
   unit.create.push(templateOp);
   return templateOp;
 }
 function ingestDeferBlock(unit, deferBlock) {
-  var _a2, _b2, _c2, _d2, _e2, _f2, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
+  var _a2, _b2, _c2, _d2, _e2, _f2, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s;
   const blockMeta = unit.job.deferBlocksMeta.get(deferBlock);
   if (blockMeta === void 0) {
     throw new Error(`AssertionError: unable to find metadata for deferred block`);
   }
-  const main = ingestDeferView(unit, "", deferBlock.children, deferBlock.sourceSpan);
-  const loading = ingestDeferView(unit, "Loading", (_a2 = deferBlock.loading) == null ? void 0 : _a2.children, (_b2 = deferBlock.loading) == null ? void 0 : _b2.sourceSpan);
-  const placeholder = ingestDeferView(unit, "Placeholder", (_c2 = deferBlock.placeholder) == null ? void 0 : _c2.children, (_d2 = deferBlock.placeholder) == null ? void 0 : _d2.sourceSpan);
-  const error2 = ingestDeferView(unit, "Error", (_e2 = deferBlock.error) == null ? void 0 : _e2.children, (_f2 = deferBlock.error) == null ? void 0 : _f2.sourceSpan);
+  const main = ingestDeferView(unit, "", deferBlock.i18n, deferBlock.children, deferBlock.sourceSpan);
+  const loading = ingestDeferView(unit, "Loading", (_a2 = deferBlock.loading) == null ? void 0 : _a2.i18n, (_b2 = deferBlock.loading) == null ? void 0 : _b2.children, (_c2 = deferBlock.loading) == null ? void 0 : _c2.sourceSpan);
+  const placeholder = ingestDeferView(unit, "Placeholder", (_d2 = deferBlock.placeholder) == null ? void 0 : _d2.i18n, (_e2 = deferBlock.placeholder) == null ? void 0 : _e2.children, (_f2 = deferBlock.placeholder) == null ? void 0 : _f2.sourceSpan);
+  const error2 = ingestDeferView(unit, "Error", (_g = deferBlock.error) == null ? void 0 : _g.i18n, (_h = deferBlock.error) == null ? void 0 : _h.children, (_i = deferBlock.error) == null ? void 0 : _i.sourceSpan);
   const deferXref = unit.job.allocateXrefId();
   const deferOp = createDeferOp(deferXref, main.xref, main.handle, blockMeta, deferBlock.sourceSpan);
-  deferOp.placeholderView = (_g = placeholder == null ? void 0 : placeholder.xref) != null ? _g : null;
-  deferOp.placeholderSlot = (_h = placeholder == null ? void 0 : placeholder.handle) != null ? _h : null;
-  deferOp.loadingSlot = (_i = loading == null ? void 0 : loading.handle) != null ? _i : null;
-  deferOp.errorSlot = (_j = error2 == null ? void 0 : error2.handle) != null ? _j : null;
-  deferOp.placeholderMinimumTime = (_l = (_k = deferBlock.placeholder) == null ? void 0 : _k.minimumTime) != null ? _l : null;
-  deferOp.loadingMinimumTime = (_n = (_m = deferBlock.loading) == null ? void 0 : _m.minimumTime) != null ? _n : null;
-  deferOp.loadingAfterTime = (_p = (_o = deferBlock.loading) == null ? void 0 : _o.afterTime) != null ? _p : null;
+  deferOp.placeholderView = (_j = placeholder == null ? void 0 : placeholder.xref) != null ? _j : null;
+  deferOp.placeholderSlot = (_k = placeholder == null ? void 0 : placeholder.handle) != null ? _k : null;
+  deferOp.loadingSlot = (_l = loading == null ? void 0 : loading.handle) != null ? _l : null;
+  deferOp.errorSlot = (_m = error2 == null ? void 0 : error2.handle) != null ? _m : null;
+  deferOp.placeholderMinimumTime = (_o = (_n = deferBlock.placeholder) == null ? void 0 : _n.minimumTime) != null ? _o : null;
+  deferOp.loadingMinimumTime = (_q = (_p = deferBlock.loading) == null ? void 0 : _p.minimumTime) != null ? _q : null;
+  deferOp.loadingAfterTime = (_s = (_r = deferBlock.loading) == null ? void 0 : _r.afterTime) != null ? _s : null;
   unit.create.push(deferOp);
   let prefetch = false;
   let deferOnOps = [];
@@ -19995,17 +20455,12 @@ function ingestDeferBlock(unit, deferBlock) {
   unit.update.push(deferWhenOps);
 }
 function ingestIcu(unit, icu) {
-  var _a2, _b2;
+  var _a2;
   if (icu.i18n instanceof Message && isSingleI18nIcu(icu.i18n)) {
     const xref = unit.job.allocateXrefId();
     const icuNode = icu.i18n.nodes[0];
     unit.create.push(createIcuStartOp(xref, icu.i18n, icuFromI18nMessage(icu.i18n).name, null));
-    const expressionPlaceholder = (_a2 = icuNode.expressionPlaceholder) == null ? void 0 : _a2.trimEnd();
-    if (expressionPlaceholder === void 0 || icu.vars[expressionPlaceholder] === void 0) {
-      throw Error("ICU should have a text binding");
-    }
-    ingestBoundText(unit, icu.vars[expressionPlaceholder], [expressionPlaceholder]);
-    for (const [placeholder, text2] of Object.entries(icu.placeholders)) {
+    for (const [placeholder, text2] of Object.entries(__spreadValues(__spreadValues({}, icu.vars), icu.placeholders))) {
       if (text2 instanceof BoundText) {
         ingestBoundText(unit, text2, [placeholder]);
       } else {
@@ -20014,11 +20469,11 @@ function ingestIcu(unit, icu) {
     }
     unit.create.push(createIcuEndOp(xref));
   } else {
-    throw Error(`Unhandled i18n metadata type for ICU: ${(_b2 = icu.i18n) == null ? void 0 : _b2.constructor.name}`);
+    throw Error(`Unhandled i18n metadata type for ICU: ${(_a2 = icu.i18n) == null ? void 0 : _a2.constructor.name}`);
   }
 }
 function ingestForBlock(unit, forBlock) {
-  var _a2;
+  var _a2, _b2, _c2;
   const repeaterView = unit.job.allocateView(unit.xref);
   const createRepeaterAlias = (ident, repeaterVar) => {
     repeaterView.aliases.add({
@@ -20052,8 +20507,16 @@ function ingestForBlock(unit, forBlock) {
     $odd: forBlock.contextVariables.$odd.name,
     $implicit: forBlock.item.name
   };
+  if (forBlock.i18n !== void 0 && !(forBlock.i18n instanceof BlockPlaceholder)) {
+    throw Error("AssertionError: Unhandled i18n metadata type or @for");
+  }
+  if (((_a2 = forBlock.empty) == null ? void 0 : _a2.i18n) !== void 0 && !(forBlock.empty.i18n instanceof BlockPlaceholder)) {
+    throw Error("AssertionError: Unhandled i18n metadata type or @empty");
+  }
+  const i18nPlaceholder = forBlock.i18n;
+  const emptyI18nPlaceholder = (_b2 = forBlock.empty) == null ? void 0 : _b2.i18n;
   const tagName = ingestControlFlowInsertionPoint(unit, repeaterView.xref, forBlock);
-  const repeaterCreate2 = createRepeaterCreateOp(repeaterView.xref, (_a2 = emptyView == null ? void 0 : emptyView.xref) != null ? _a2 : null, tagName, track, varNames, forBlock.sourceSpan);
+  const repeaterCreate2 = createRepeaterCreateOp(repeaterView.xref, (_c2 = emptyView == null ? void 0 : emptyView.xref) != null ? _c2 : null, tagName, track, varNames, i18nPlaceholder, emptyI18nPlaceholder, forBlock.sourceSpan);
   unit.create.push(repeaterCreate2);
   const expression = convertAst(forBlock.expression, unit.job, convertSourceSpan(forBlock.expression.span, forBlock.sourceSpan));
   const repeater2 = createRepeaterOp(repeaterCreate2.xref, repeaterCreate2.handle, expression, forBlock.sourceSpan);
@@ -20089,6 +20552,15 @@ function convertAst(ast, job, baseSourceSpan) {
     }
   } else if (ast instanceof LiteralPrimitive) {
     return literal(ast.value, void 0, convertSourceSpan(ast.span, baseSourceSpan));
+  } else if (ast instanceof Unary) {
+    switch (ast.operator) {
+      case "+":
+        return new UnaryOperatorExpr(UnaryOperator.Plus, convertAst(ast.expr, job, baseSourceSpan), void 0, convertSourceSpan(ast.span, baseSourceSpan));
+      case "-":
+        return new UnaryOperatorExpr(UnaryOperator.Minus, convertAst(ast.expr, job, baseSourceSpan), void 0, convertSourceSpan(ast.span, baseSourceSpan));
+      default:
+        throw new Error(`AssertionError: unknown unary operator ${ast.operator}`);
+    }
   } else if (ast instanceof Binary) {
     const operator = BINARY_OPERATORS.get(ast.operation);
     if (operator === void 0) {
@@ -20126,104 +20598,134 @@ function convertAst(ast, job, baseSourceSpan) {
     return new SafeInvokeFunctionExpr(convertAst(ast.receiver, job, baseSourceSpan), ast.args.map((a) => convertAst(a, job, baseSourceSpan)));
   } else if (ast instanceof EmptyExpr) {
     return new EmptyExpr2(convertSourceSpan(ast.span, baseSourceSpan));
+  } else if (ast instanceof PrefixNot) {
+    return not(convertAst(ast.expression, job, baseSourceSpan), convertSourceSpan(ast.span, baseSourceSpan));
   } else {
     throw new Error(`Unhandled expression type "${ast.constructor.name}" in file "${baseSourceSpan == null ? void 0 : baseSourceSpan.start.file.url}"`);
   }
 }
+function convertAstWithInterpolation(job, value, i18nMeta) {
+  var _a2, _b2;
+  let expression;
+  if (value instanceof Interpolation) {
+    expression = new Interpolation2(value.strings, value.expressions.map((e) => convertAst(e, job, null)), Object.keys((_b2 = (_a2 = asMessage(i18nMeta)) == null ? void 0 : _a2.placeholders) != null ? _b2 : {}));
+  } else if (value instanceof AST) {
+    expression = convertAst(value, job, null);
+  } else {
+    expression = literal(value);
+  }
+  return expression;
+}
+var BINDING_KINDS = /* @__PURE__ */ new Map([
+  [0, BindingKind.Property],
+  [1, BindingKind.Attribute],
+  [2, BindingKind.ClassName],
+  [3, BindingKind.StyleProperty],
+  [4, BindingKind.Animation]
+]);
 function isPlainTemplate(tmpl) {
   var _a2;
-  return splitNsName((_a2 = tmpl.tagName) != null ? _a2 : "")[1] === "ng-template";
-}
-function ingestBindings(unit, op, element2) {
-  let flags = BindingFlags.None;
-  if (element2 instanceof Template) {
-    flags |= BindingFlags.OnNgTemplateElement;
-    if (element2 instanceof Template && isPlainTemplate(element2)) {
-      flags |= BindingFlags.BindingTargetsTemplate;
-    }
-    const templateAttrFlags = flags | BindingFlags.BindingTargetsTemplate | BindingFlags.IsStructuralTemplateAttribute;
-    for (const attr of element2.templateAttrs) {
-      if (attr instanceof TextAttribute) {
-        ingestBinding(unit, op.xref, attr.name, literal(attr.value), 1, null, SecurityContext.NONE, attr.sourceSpan, templateAttrFlags | BindingFlags.TextValue);
-      } else {
-        ingestBinding(unit, op.xref, attr.name, attr.value, attr.type, attr.unit, attr.securityContext, attr.sourceSpan, templateAttrFlags);
-      }
-    }
+  return splitNsName((_a2 = tmpl.tagName) != null ? _a2 : "")[1] === NG_TEMPLATE_TAG_NAME;
+}
+function asMessage(i18nMeta) {
+  if (i18nMeta == null) {
+    return null;
   }
+  if (!(i18nMeta instanceof Message)) {
+    throw Error(`Expected i18n meta to be a Message, but got: ${i18nMeta.constructor.name}`);
+  }
+  return i18nMeta;
+}
+function ingestElementBindings(unit, op, element2) {
+  var _a2;
+  let bindings = new Array();
   for (const attr of element2.attributes) {
-    ingestBinding(unit, op.xref, attr.name, literal(attr.value), 1, null, SecurityContext.NONE, attr.sourceSpan, flags | BindingFlags.TextValue);
+    const securityContext = domSchema.securityContext(element2.name, attr.name, true);
+    bindings.push(createBindingOp(op.xref, BindingKind.Attribute, attr.name, convertAstWithInterpolation(unit.job, attr.value, attr.i18n), null, securityContext, true, false, null, asMessage(attr.i18n), attr.sourceSpan));
   }
   for (const input of element2.inputs) {
-    ingestBinding(unit, op.xref, input.name, input.value, input.type, input.unit, input.securityContext, input.sourceSpan, flags);
+    bindings.push(createBindingOp(op.xref, BINDING_KINDS.get(input.type), input.name, convertAstWithInterpolation(unit.job, astOf(input.value), input.i18n), input.unit, input.securityContext, false, false, null, (_a2 = asMessage(input.i18n)) != null ? _a2 : null, input.sourceSpan));
   }
+  unit.create.push(bindings.filter((b) => (b == null ? void 0 : b.kind) === OpKind.ExtractedAttribute));
+  unit.update.push(bindings.filter((b) => (b == null ? void 0 : b.kind) === OpKind.Binding));
   for (const output of element2.outputs) {
-    let listenerOp;
-    if (output.type === 1) {
-      if (output.phase === null) {
-        throw Error("Animation listener should have a phase");
-      }
+    if (output.type === 1 && output.phase === null) {
+      throw Error("Animation listener should have a phase");
     }
-    if (element2 instanceof Template && !isPlainTemplate(element2)) {
-      unit.create.push(createExtractedAttributeOp(op.xref, BindingKind.Property, output.name, null));
-      continue;
-    }
-    listenerOp = createListenerOp(op.xref, op.handle, output.name, op.tag, output.phase, false, output.sourceSpan);
-    let handlerExprs;
-    let handler = output.handler;
-    if (handler instanceof ASTWithSource) {
-      handler = handler.ast;
-    }
-    if (handler instanceof Chain) {
-      handlerExprs = handler.expressions;
+    unit.create.push(createListenerOp(op.xref, op.handle, output.name, op.tag, makeListenerHandlerOps(unit, output.handler, output.handlerSpan), output.phase, output.target, false, output.sourceSpan));
+  }
+  if (bindings.some((b) => b == null ? void 0 : b.i18nMessage) !== null) {
+    unit.create.push(createI18nAttributesOp(unit.job.allocateXrefId(), new SlotHandle(), op.xref));
+  }
+}
+function ingestTemplateBindings(unit, op, template2, templateKind) {
+  let bindings = new Array();
+  for (const attr of template2.templateAttrs) {
+    if (attr instanceof TextAttribute) {
+      const securityContext = domSchema.securityContext(NG_TEMPLATE_TAG_NAME, attr.name, true);
+      bindings.push(createTemplateBinding(unit, op.xref, 1, attr.name, attr.value, null, securityContext, true, templateKind, asMessage(attr.i18n), attr.sourceSpan));
     } else {
-      handlerExprs = [handler];
+      bindings.push(createTemplateBinding(unit, op.xref, attr.type, attr.name, astOf(attr.value), attr.unit, attr.securityContext, true, templateKind, asMessage(attr.i18n), attr.sourceSpan));
+    }
+  }
+  for (const attr of template2.attributes) {
+    const securityContext = domSchema.securityContext(NG_TEMPLATE_TAG_NAME, attr.name, true);
+    bindings.push(createTemplateBinding(unit, op.xref, 1, attr.name, attr.value, null, securityContext, false, templateKind, asMessage(attr.i18n), attr.sourceSpan));
+  }
+  for (const input of template2.inputs) {
+    bindings.push(createTemplateBinding(unit, op.xref, input.type, input.name, astOf(input.value), input.unit, input.securityContext, false, templateKind, asMessage(input.i18n), input.sourceSpan));
+  }
+  unit.create.push(bindings.filter((b) => (b == null ? void 0 : b.kind) === OpKind.ExtractedAttribute));
+  unit.update.push(bindings.filter((b) => (b == null ? void 0 : b.kind) === OpKind.Binding));
+  for (const output of template2.outputs) {
+    if (output.type === 1 && output.phase === null) {
+      throw Error("Animation listener should have a phase");
     }
-    if (handlerExprs.length === 0) {
-      throw new Error("Expected listener to have non-empty expression list.");
+    if (templateKind === TemplateKind.NgTemplate) {
+      unit.create.push(createListenerOp(op.xref, op.handle, output.name, op.tag, makeListenerHandlerOps(unit, output.handler, output.handlerSpan), output.phase, output.target, false, output.sourceSpan));
     }
-    const expressions = handlerExprs.map((expr) => convertAst(expr, unit.job, output.handlerSpan));
-    const returnExpr = expressions.pop();
-    for (const expr of expressions) {
-      const stmtOp = createStatementOp(new ExpressionStatement(expr, expr.sourceSpan));
-      listenerOp.handlerOps.push(stmtOp);
+    if (templateKind === TemplateKind.Structural && output.type !== 1) {
+      const securityContext = domSchema.securityContext(NG_TEMPLATE_TAG_NAME, output.name, false);
+      unit.create.push(createExtractedAttributeOp(op.xref, BindingKind.Property, output.name, null, null, null, securityContext));
     }
-    listenerOp.handlerOps.push(createStatementOp(new ReturnStatement(returnExpr, returnExpr.sourceSpan)));
-    unit.create.push(listenerOp);
+  }
+  if (bindings.some((b) => b == null ? void 0 : b.i18nMessage) !== null) {
+    unit.create.push(createI18nAttributesOp(unit.job.allocateXrefId(), new SlotHandle(), op.xref));
   }
 }
-var BINDING_KINDS = /* @__PURE__ */ new Map([
-  [0, BindingKind.Property],
-  [1, BindingKind.Attribute],
-  [2, BindingKind.ClassName],
-  [3, BindingKind.StyleProperty],
-  [4, BindingKind.Animation]
-]);
-var BindingFlags;
-(function(BindingFlags2) {
-  BindingFlags2[BindingFlags2["None"] = 0] = "None";
-  BindingFlags2[BindingFlags2["TextValue"] = 1] = "TextValue";
-  BindingFlags2[BindingFlags2["BindingTargetsTemplate"] = 2] = "BindingTargetsTemplate";
-  BindingFlags2[BindingFlags2["IsStructuralTemplateAttribute"] = 4] = "IsStructuralTemplateAttribute";
-  BindingFlags2[BindingFlags2["OnNgTemplateElement"] = 8] = "OnNgTemplateElement";
-})(BindingFlags || (BindingFlags = {}));
-function ingestBinding(view, xref, name, value, type, unit, securityContext, sourceSpan, flags) {
-  if (value instanceof ASTWithSource) {
-    value = value.ast;
+function createTemplateBinding(view, xref, type, name, value, unit, securityContext, isStructuralTemplateAttribute, templateKind, i18nMessage, sourceSpan) {
+  const isTextBinding = typeof value === "string";
+  if (templateKind === TemplateKind.Structural) {
+    if (!isStructuralTemplateAttribute && (type === 0 || type === 2 || type === 3)) {
+      return createExtractedAttributeOp(xref, BindingKind.Property, name, null, null, i18nMessage, securityContext);
+    }
+    if (!isTextBinding && (type === 1 || type === 4)) {
+      return null;
+    }
   }
-  if (flags & BindingFlags.OnNgTemplateElement && !(flags & BindingFlags.BindingTargetsTemplate) && type === 0) {
-    view.create.push(createExtractedAttributeOp(xref, BindingKind.Property, name, null));
-    return;
+  let bindingType = BINDING_KINDS.get(type);
+  if (templateKind === TemplateKind.NgTemplate) {
+    if (type === 2 || type === 3 || type === 1 && !isTextBinding) {
+      bindingType = BindingKind.Property;
+    }
   }
-  let expression;
-  if (value instanceof Interpolation) {
-    expression = new Interpolation2(value.strings, value.expressions.map((expr) => convertAst(expr, view.job, null)));
-  } else if (value instanceof AST) {
-    expression = convertAst(value, view.job, null);
-  } else {
-    expression = value;
+  return createBindingOp(xref, bindingType, name, convertAstWithInterpolation(view.job, value, i18nMessage), unit, securityContext, isTextBinding, isStructuralTemplateAttribute, templateKind, i18nMessage, sourceSpan);
+}
+function makeListenerHandlerOps(unit, handler, handlerSpan) {
+  handler = astOf(handler);
+  const handlerOps = new Array();
+  let handlerExprs = handler instanceof Chain ? handler.expressions : [handler];
+  if (handlerExprs.length === 0) {
+    throw new Error("Expected listener to have non-empty expression list.");
   }
-  const kind = BINDING_KINDS.get(type);
-  view.update.push(createBindingOp(xref, kind, name, expression, unit, securityContext, !!(flags & BindingFlags.TextValue), !!(flags & BindingFlags.IsStructuralTemplateAttribute), sourceSpan));
+  const expressions = handlerExprs.map((expr) => convertAst(expr, unit.job, handlerSpan));
+  const returnExpr = expressions.pop();
+  handlerOps.push(...expressions.map((e) => createStatementOp(new ExpressionStatement(e, e.sourceSpan))));
+  handlerOps.push(createStatementOp(new ReturnStatement(returnExpr, returnExpr.sourceSpan)));
+  return handlerOps;
+}
+function astOf(ast) {
+  return ast instanceof ASTWithSource ? ast.ast : ast;
 }
 function ingestReferences(op, element2) {
   assertIsArray(op.localRefs);
@@ -20263,10 +20765,11 @@ function ingestControlFlowInsertionPoint(unit, xref, node) {
   }
   if (root !== null) {
     for (const attr of root.attributes) {
-      ingestBinding(unit, xref, attr.name, literal(attr.value), 1, null, SecurityContext.NONE, attr.sourceSpan, BindingFlags.TextValue);
+      const securityContext = domSchema.securityContext(NG_TEMPLATE_TAG_NAME, attr.name, true);
+      unit.update.push(createBindingOp(xref, BindingKind.Attribute, attr.name, literal(attr.value), null, securityContext, true, false, null, asMessage(attr.i18n), attr.sourceSpan));
     }
     const tagName = root instanceof Element ? root.name : root.tagName;
-    return tagName === "ng-template" ? null : tagName;
+    return tagName === NG_TEMPLATE_TAG_NAME ? null : tagName;
   }
   return null;
 }
@@ -22352,17 +22855,17 @@ function serializePlaceholderValue(value) {
 var NG_CONTENT_SELECT_ATTR2 = "select";
 var NG_PROJECT_AS_ATTR_NAME = "ngProjectAs";
 var EVENT_BINDING_SCOPE_GLOBALS = /* @__PURE__ */ new Set(["$event"]);
-var NG_TEMPLATE_TAG_NAME = "ng-template";
-var GLOBAL_TARGET_RESOLVERS = /* @__PURE__ */ new Map([["window", Identifiers.resolveWindow], ["document", Identifiers.resolveDocument], ["body", Identifiers.resolveBody]]);
+var NG_TEMPLATE_TAG_NAME2 = "ng-template";
+var GLOBAL_TARGET_RESOLVERS2 = /* @__PURE__ */ new Map([["window", Identifiers.resolveWindow], ["document", Identifiers.resolveDocument], ["body", Identifiers.resolveBody]]);
 var LEADING_TRIVIA_CHARS = [" ", "\n", "\r", "	"];
 function renderFlagCheckIfStmt(flags, statements) {
   return ifStmt(variable(RENDER_FLAGS).bitwiseAnd(literal(flags), null, false), statements);
 }
 function prepareEventListenerParameters(eventAst, handlerName = null, scope = null) {
   const { type, name, target, phase, handler } = eventAst;
-  if (target && !GLOBAL_TARGET_RESOLVERS.has(target)) {
+  if (target && !GLOBAL_TARGET_RESOLVERS2.has(target)) {
     throw new Error(`Unexpected global target '${target}' defined for '${name}' event.
-        Supported list of global targets: ${Array.from(GLOBAL_TARGET_RESOLVERS.keys())}.`);
+        Supported list of global targets: ${Array.from(GLOBAL_TARGET_RESOLVERS2.keys())}.`);
   }
   const eventArgumentName = "$event";
   const implicitReceiverAccesses = /* @__PURE__ */ new Set();
@@ -22395,7 +22898,7 @@ function prepareEventListenerParameters(eventAst, handlerName = null, scope = nu
   if (target) {
     params.push(
       literal(false),
-      importExpr(GLOBAL_TARGET_RESOLVERS.get(target))
+      importExpr(GLOBAL_TARGET_RESOLVERS2.get(target))
     );
   }
   return params;
@@ -22941,10 +23444,10 @@ var TemplateDefinitionBuilder = class {
     var _a2;
     const tagNameWithoutNamespace = template2.tagName ? splitNsName(template2.tagName)[1] : template2.tagName;
     const contextNameSuffix = template2.tagName ? "_" + sanitizeIdentifier(template2.tagName) : "";
-    const attrsExprs = this.getAttributeExpressions(NG_TEMPLATE_TAG_NAME, template2.attributes, template2.inputs, template2.outputs, void 0, template2.templateAttrs);
+    const attrsExprs = this.getAttributeExpressions(NG_TEMPLATE_TAG_NAME2, template2.attributes, template2.inputs, template2.outputs, void 0, template2.templateAttrs);
     const templateIndex = this.createEmbeddedTemplateFn(tagNameWithoutNamespace, template2.children, contextNameSuffix, template2.sourceSpan, template2.variables, attrsExprs, template2.references, template2.i18n);
     this.templatePropertyBindings(templateIndex, template2.templateAttrs);
-    if (tagNameWithoutNamespace === NG_TEMPLATE_TAG_NAME) {
+    if (tagNameWithoutNamespace === NG_TEMPLATE_TAG_NAME2) {
       const [i18nInputs, inputs] = partitionArray(template2.inputs, hasI18nMeta);
       if (i18nInputs.length > 0) {
         this.i18nAttributesInstruction(templateIndex, i18nInputs, (_a2 = template2.startSourceSpan) != null ? _a2 : template2.sourceSpan);
@@ -23185,8 +23688,8 @@ var TemplateDefinitionBuilder = class {
     }
     if (root !== null) {
       const name = root instanceof Element ? root.name : root.tagName;
-      tagName = name === NG_TEMPLATE_TAG_NAME ? null : name;
-      attrsExprs = this.getAttributeExpressions(NG_TEMPLATE_TAG_NAME, root.attributes, root.inputs, []);
+      tagName = name === NG_TEMPLATE_TAG_NAME2 ? null : name;
+      attrsExprs = this.getAttributeExpressions(NG_TEMPLATE_TAG_NAME2, root.attributes, root.inputs, []);
     }
     return { tagName, attrsExprs };
   }
@@ -23808,21 +24311,6 @@ var TrackByBindingScope = class extends BindingScope {
     return this.componentAccessCount;
   }
 };
-function createCssSelector(elementName, attributes) {
-  const cssSelector = new CssSelector();
-  const elementNameNoNs = splitNsName(elementName)[1];
-  cssSelector.setElement(elementNameNoNs);
-  Object.getOwnPropertyNames(attributes).forEach((name) => {
-    const nameNoNs = splitNsName(name)[1];
-    const value = attributes[name];
-    cssSelector.addAttribute(nameNoNs, value);
-    if (name.toLowerCase() === "class") {
-      const classes = value.trim().split(/\s+/);
-      classes.forEach((className) => cssSelector.addClassName(className));
-    }
-  });
-  return cssSelector;
-}
 function getNgProjectAsLiteral(attribute2) {
   const parsedR3Selector = parseSelectorToR3Selector(attribute2.value)[0];
   return [literal(5), asLiteral(parsedR3Selector)];
@@ -24361,6 +24849,7 @@ function createHostBindingsFunction(hostBindingsMetadata, typeSourceSpan, bindin
     }
     const hostJob = ingestHostBinding({
       componentName: name,
+      componentSelector: selector,
       properties: bindings,
       events: eventBindings,
       attributes: hostBindingsMetadata.attributes
@@ -24373,6 +24862,8 @@ function createHostBindingsFunction(hostBindingsMetadata, typeSourceSpan, bindin
     }
     return emitHostBindingFunction(hostJob);
   }
+  let bindingId = 0;
+  const getNextBindingId = () => `${bindingId++}`;
   const bindingContext = variable(CONTEXT_NAME);
   const styleBuilder = new StylingBuilder(bindingContext);
   const { styleAttr, classAttr } = hostBindingsMetadata.specialAttributes;
@@ -24422,7 +24913,7 @@ function createHostBindingsFunction(hostBindingsMetadata, typeSourceSpan, bindin
   const syntheticHostBindings = [];
   for (const binding of allOtherBindings) {
     const value = binding.expression.visit(getValueConverter());
-    const bindingExpr = bindingFn(bindingContext, value);
+    const bindingExpr = bindingFn(bindingContext, value, getNextBindingId);
     const { bindingName, instruction, isAttribute } = getBindingNameAndInstruction(binding);
     const securityContexts = bindingParser.calcPossibleSecurityContexts(selector, bindingName, isAttribute).filter((context) => context !== SecurityContext.NONE);
     let sanitizerFn = null;
@@ -24467,9 +24958,11 @@ function createHostBindingsFunction(hostBindingsMetadata, typeSourceSpan, bindin
     styleBuilder.buildUpdateLevelInstructions(getValueConverter()).forEach((instruction) => {
       for (const call2 of instruction.calls) {
         totalHostVarsCount += Math.max(call2.allocateBindingSlots - MIN_STYLING_BINDING_SLOTS_REQUIRED, 0);
+        const { params, stmts } = convertStylingCall(call2, bindingContext, bindingFn, getNextBindingId);
+        updateVariables.push(...stmts);
         updateInstructions.push({
           reference: instruction.reference,
-          paramsOrFn: convertStylingCall(call2, bindingContext, bindingFn),
+          paramsOrFn: params,
           span: null
         });
       }
@@ -24491,11 +24984,19 @@ function createHostBindingsFunction(hostBindingsMetadata, typeSourceSpan, bindin
   }
   return null;
 }
-function bindingFn(implicit, value) {
-  return convertPropertyBinding(null, implicit, value, "b");
+function bindingFn(implicit, value, getNextBindingIdFn) {
+  return convertPropertyBinding(null, implicit, value, getNextBindingIdFn());
 }
-function convertStylingCall(call2, bindingContext, bindingFn2) {
-  return call2.params((value) => bindingFn2(bindingContext, value).currValExpr);
+function convertStylingCall(call2, bindingContext, bindingFn2, getNextBindingIdFn) {
+  const stmts = [];
+  const params = call2.params((value) => {
+    const result = bindingFn2(bindingContext, value, getNextBindingIdFn);
+    if (Array.isArray(result.stmts) && result.stmts.length > 0) {
+      stmts.push(...result.stmts);
+    }
+    return result.currValExpr;
+  });
+  return { params, stmts };
 }
 function getBindingNameAndInstruction(binding) {
   let bindingName = binding.name;
@@ -24810,13 +25311,13 @@ var DirectiveBinder = class {
     template2.forEach((node) => node.visit(this));
   }
   visitElement(element2) {
-    this.visitElementOrTemplate(element2.name, element2);
+    this.visitElementOrTemplate(element2);
   }
   visitTemplate(template2) {
-    this.visitElementOrTemplate("ng-template", template2);
+    this.visitElementOrTemplate(template2);
   }
-  visitElementOrTemplate(elementName, node) {
-    const cssSelector = createCssSelector(elementName, getAttrsForDirectiveMatching(node));
+  visitElementOrTemplate(node) {
+    const cssSelector = createCssSelectorFromNode(node);
     const directives = [];
     this.matcher.match(cssSelector, (_selector, results) => directives.push(...results));
     if (directives.length > 0) {
@@ -25804,7 +26305,7 @@ function publishFacade(global) {
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/version.mjs
-var VERSION2 = new Version("17.0.5");
+var VERSION2 = new Version("17.0.7");
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/i18n/extractor_merger.mjs
 var _I18N_ATTR = "i18n";
@@ -26870,7 +27371,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("17.0.5"));
+  definitionMap.set("version", literal("17.0.7"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", metadata.type);
   definitionMap.set("decorators", metadata.decorators);
@@ -26941,7 +27442,7 @@ function createDirectiveDefinitionMap(meta) {
   const hasTransformFunctions = Object.values(meta.inputs).some((input) => input.transformFunction !== null);
   const minVersion = hasTransformFunctions ? MINIMUM_PARTIAL_LINKER_VERSION2 : "14.0.0";
   definitionMap.set("minVersion", literal(minVersion));
-  definitionMap.set("version", literal("17.0.5"));
+  definitionMap.set("version", literal("17.0.7"));
   definitionMap.set("type", meta.type.value);
   if (meta.isStandalone) {
     definitionMap.set("isStandalone", literal(meta.isStandalone));
@@ -27173,7 +27674,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("17.0.5"));
+  definitionMap.set("version", literal("17.0.7"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   definitionMap.set("deps", compileDependencies(meta.deps));
@@ -27196,7 +27697,7 @@ function compileDeclareInjectableFromMetadata(meta) {
 function createInjectableDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION4));
-  definitionMap.set("version", literal("17.0.5"));
+  definitionMap.set("version", literal("17.0.7"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   if (meta.providedIn !== void 0) {
@@ -27234,7 +27735,7 @@ function compileDeclareInjectorFromMetadata(meta) {
 function createInjectorDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION5));
-  definitionMap.set("version", literal("17.0.5"));
+  definitionMap.set("version", literal("17.0.7"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   definitionMap.set("providers", meta.providers);
@@ -27258,7 +27759,7 @@ function createNgModuleDefinitionMap(meta) {
     throw new Error("Invalid path! Local compilation mode should not get into the partial compilation path");
   }
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION6));
-  definitionMap.set("version", literal("17.0.5"));
+  definitionMap.set("version", literal("17.0.7"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   if (meta.bootstrap.length > 0) {
@@ -27293,7 +27794,7 @@ function compileDeclarePipeFromMetadata(meta) {
 function createPipeDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION7));
-  definitionMap.set("version", literal("17.0.5"));
+  definitionMap.set("version", literal("17.0.7"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   if (meta.isStandalone) {
@@ -27310,7 +27811,7 @@ function createPipeDefinitionMap(meta) {
 publishFacade(_global);
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/version.mjs
-var VERSION3 = new Version("17.0.5");
+var VERSION3 = new Version("17.0.7");
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/transformers/api.mjs
 var EmitFlags;
@@ -27498,6 +27999,7 @@ var ErrorCode;
   ErrorCode2[ErrorCode2["MISSING_REQUIRED_INPUTS"] = 8008] = "MISSING_REQUIRED_INPUTS";
   ErrorCode2[ErrorCode2["ILLEGAL_FOR_LOOP_TRACK_ACCESS"] = 8009] = "ILLEGAL_FOR_LOOP_TRACK_ACCESS";
   ErrorCode2[ErrorCode2["INACCESSIBLE_DEFERRED_TRIGGER_ELEMENT"] = 8010] = "INACCESSIBLE_DEFERRED_TRIGGER_ELEMENT";
+  ErrorCode2[ErrorCode2["CONTROL_FLOW_PREVENTING_CONTENT_PROJECTION"] = 8011] = "CONTROL_FLOW_PREVENTING_CONTENT_PROJECTION";
   ErrorCode2[ErrorCode2["INVALID_BANANA_IN_BOX"] = 8101] = "INVALID_BANANA_IN_BOX";
   ErrorCode2[ErrorCode2["NULLISH_COALESCING_NOT_NULLABLE"] = 8102] = "NULLISH_COALESCING_NOT_NULLABLE";
   ErrorCode2[ErrorCode2["MISSING_CONTROL_FLOW_DIRECTIVE"] = 8103] = "MISSING_CONTROL_FLOW_DIRECTIVE";
@@ -27607,6 +28109,7 @@ var ExtendedTemplateDiagnosticName;
   ExtendedTemplateDiagnosticName2["SUFFIX_NOT_SUPPORTED"] = "suffixNotSupported";
   ExtendedTemplateDiagnosticName2["SKIP_HYDRATION_NOT_STATIC"] = "skipHydrationNotStatic";
   ExtendedTemplateDiagnosticName2["INTERPOLATED_SIGNAL_NOT_INVOKED"] = "interpolatedSignalNotInvoked";
+  ExtendedTemplateDiagnosticName2["CONTROL_FLOW_PREVENTING_CONTENT_PROJECTION"] = "controlFlowPreventingContentProjection";
 })(ExtendedTemplateDiagnosticName || (ExtendedTemplateDiagnosticName = {}));
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/transform/src/api.mjs
@@ -27850,6 +28353,7 @@ var ClassMemberKind;
   ClassMemberKind2[ClassMemberKind2["Property"] = 3] = "Property";
   ClassMemberKind2[ClassMemberKind2["Method"] = 4] = "Method";
 })(ClassMemberKind || (ClassMemberKind = {}));
+var AmbientImport = {};
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/reflection/src/type_to_value.mjs
 var import_typescript7 = __toESM(require("typescript"), 1);
@@ -28238,19 +28742,18 @@ var TypeScriptReflectionHost = class {
       return this.getDeclarationOfSymbol(targetSymbol, originalId);
     }
     const importInfo = originalId && this.getImportOfIdentifier(originalId);
-    const viaModule = importInfo !== null && importInfo.from !== null && !importInfo.from.startsWith(".") ? importInfo.from : null;
     while (symbol.flags & import_typescript9.default.SymbolFlags.Alias) {
       symbol = this.checker.getAliasedSymbol(symbol);
     }
     if (symbol.valueDeclaration !== void 0) {
       return {
         node: symbol.valueDeclaration,
-        viaModule
+        viaModule: this._viaModule(symbol.valueDeclaration, originalId, importInfo)
       };
     } else if (symbol.declarations !== void 0 && symbol.declarations.length > 0) {
       return {
         node: symbol.declarations[0],
-        viaModule
+        viaModule: this._viaModule(symbol.declarations[0], originalId, importInfo)
       };
     } else {
       return null;
@@ -28346,6 +28849,12 @@ var TypeScriptReflectionHost = class {
     }
     return exportSet;
   }
+  _viaModule(declaration, originalId, importInfo) {
+    if (importInfo === null && originalId !== null && declaration.getSourceFile() !== originalId.getSourceFile()) {
+      return AmbientImport;
+    }
+    return importInfo !== null && importInfo.from !== null && !importInfo.from.startsWith(".") ? importInfo.from : null;
+  }
 };
 function reflectTypeEntityToDeclaration(type, checker) {
   let realSymbol = checker.getSymbolAtLocation(type);
@@ -29119,6 +29628,7 @@ var ImportFlags;
   ImportFlags2[ImportFlags2["NoAliasing"] = 2] = "NoAliasing";
   ImportFlags2[ImportFlags2["AllowTypeImports"] = 4] = "AllowTypeImports";
   ImportFlags2[ImportFlags2["AllowRelativeDtsImports"] = 8] = "AllowRelativeDtsImports";
+  ImportFlags2[ImportFlags2["AllowAmbientReferences"] = 16] = "AllowAmbientReferences";
 })(ImportFlags || (ImportFlags = {}));
 function assertSuccessfulReferenceEmit(result, origin, typeKind) {
   if (result.kind === 0) {
@@ -29159,6 +29669,18 @@ var LocalIdentifierStrategy = class {
         importedFile: null
       };
     }
+    if (ref.isAmbient && importFlags & ImportFlags.AllowAmbientReferences) {
+      const identifier2 = identifierOfNode(ref.node);
+      if (identifier2 !== null) {
+        return {
+          kind: 0,
+          expression: new WrappedNodeExpr(identifier2),
+          importedFile: null
+        };
+      } else {
+        return null;
+      }
+    }
     const identifier = ref.getIdentityIn(context);
     if (identifier !== null) {
       return {
@@ -29643,7 +30165,13 @@ var Reference2 = class {
     this.identifiers = [];
     this.synthetic = false;
     this._alias = null;
-    this.bestGuessOwningModule = bestGuessOwningModule;
+    if (bestGuessOwningModule === AmbientImport) {
+      this.isAmbient = true;
+      this.bestGuessOwningModule = null;
+    } else {
+      this.isAmbient = false;
+      this.bestGuessOwningModule = bestGuessOwningModule;
+    }
     const id = identifierOfNode(node);
     if (id !== null) {
       this.identifiers.push(id);
@@ -29686,13 +30214,13 @@ var Reference2 = class {
     return id !== null ? id : fallback;
   }
   cloneWithAlias(alias) {
-    const ref = new Reference2(this.node, this.bestGuessOwningModule);
+    const ref = new Reference2(this.node, this.isAmbient ? AmbientImport : this.bestGuessOwningModule);
     ref.identifiers = [...this.identifiers];
     ref._alias = alias;
     return ref;
   }
   cloneWithNoIdentifiers() {
-    const ref = new Reference2(this.node, this.bestGuessOwningModule);
+    const ref = new Reference2(this.node, this.isAmbient ? AmbientImport : this.bestGuessOwningModule);
     ref._alias = this._alias;
     ref.identifiers = [];
     return ref;
@@ -30261,14 +30789,14 @@ var TypeTranslatorVisitor = class {
       throw new Error(`Unable to statically determine the declaration file of type node ${target.text}`);
     }
     let owningModule2 = viaModule;
-    if (declaration.viaModule !== null) {
+    if (typeof declaration.viaModule === "string") {
       owningModule2 = {
         specifier: declaration.viaModule,
         resolutionContext: type.getSourceFile().fileName
       };
     }
-    const reference2 = new Reference2(declaration.node, owningModule2);
-    const emittedType = this.refEmitter.emit(reference2, this.contextFile, ImportFlags.NoAliasing | ImportFlags.AllowTypeImports);
+    const reference2 = new Reference2(declaration.node, declaration.viaModule === AmbientImport ? AmbientImport : owningModule2);
+    const emittedType = this.refEmitter.emit(reference2, this.contextFile, ImportFlags.NoAliasing | ImportFlags.AllowTypeImports | ImportFlags.AllowAmbientReferences);
     assertSuccessfulReferenceEmit(emittedType, target, "type");
     const typeNode = this.translateExpression(emittedType.expression, context);
     if (!import_typescript25.default.isTypeReferenceNode(typeNode)) {
@@ -31677,6 +32205,7 @@ var DtsMetadataReader = class {
     const isStructural = !isComponent && ctorParams !== null && ctorParams.some((param) => {
       return param.typeValueReference.kind === 1 && param.typeValueReference.moduleName === "@angular/core" && param.typeValueReference.importedName === "TemplateRef";
     });
+    const ngContentSelectors = def.type.typeArguments.length > 6 ? readStringArrayType(def.type.typeArguments[6]) : null;
     const isStandalone = def.type.typeArguments.length > 7 && ((_a2 = readBooleanType(def.type.typeArguments[7])) != null ? _a2 : false);
     const inputs = ClassPropertyMapping.fromMappedObject(readInputsType(def.type.typeArguments[3]));
     const outputs = ClassPropertyMapping.fromMappedObject(readMapType(def.type.typeArguments[4], readStringType));
@@ -31699,12 +32228,14 @@ var DtsMetadataReader = class {
       isPoisoned: false,
       isStructural,
       animationTriggerNames: null,
+      ngContentSelectors,
       isStandalone,
       isSignal,
       imports: null,
       schemas: null,
       decorator: null,
-      assumedToExportProviders: isComponent && isStandalone
+      assumedToExportProviders: isComponent && isStandalone,
+      preserveWhitespaces: false
     });
   }
   getPipeMetadata(ref) {
@@ -32964,7 +33495,7 @@ function isVariableDeclarationDeclared(node) {
 }
 var EMPTY = {};
 function joinModuleContext(existing, node, decl) {
-  if (decl.viaModule !== null && decl.viaModule !== existing.absoluteModuleName) {
+  if (typeof decl.viaModule === "string" && decl.viaModule !== existing.absoluteModuleName) {
     return {
       absoluteModuleName: decl.viaModule,
       resolutionContext: node.getSourceFile().fileName
@@ -34725,7 +35256,7 @@ function assertEmittableInputType(type, contextFile, reflector, refEmitter) {
       const declaration = reflector.getDeclarationOfIdentifier(node.typeName);
       if (declaration !== null) {
         if (declaration.node.getSourceFile() !== contextFile) {
-          const emittedType = refEmitter.emit(new Reference2(declaration.node), contextFile, ImportFlags.NoAliasing | ImportFlags.AllowTypeImports | ImportFlags.AllowRelativeDtsImports);
+          const emittedType = refEmitter.emit(new Reference2(declaration.node, declaration.viaModule === AmbientImport ? AmbientImport : null), contextFile, ImportFlags.NoAliasing | ImportFlags.AllowTypeImports | ImportFlags.AllowRelativeDtsImports | ImportFlags.AllowAmbientReferences);
           assertSuccessfulReferenceEmit(emittedType, node, "type");
         } else if (!reflector.isStaticallyExported(declaration.node)) {
           throw new FatalDiagnosticError(ErrorCode.SYMBOL_NOT_EXPORTED, type, `Symbol must be exported in order to be used as the type of an Input transform function`, [makeRelatedInformation(declaration.node, `The symbol is declared here.`)]);
@@ -35022,7 +35553,9 @@ var DirectiveDecoratorHandler = class {
       isSignal: analysis.meta.isSignal,
       imports: null,
       schemas: null,
+      ngContentSelectors: null,
       decorator: analysis.decorator,
+      preserveWhitespaces: false,
       assumedToExportProviders: false
     }));
     this.injectableRegistry.registerInjectable(node, {
@@ -36481,10 +37014,7 @@ var ComponentDecoratorHandler = class {
         hostDirectives,
         rawHostDirectives,
         meta: __spreadProps(__spreadValues({}, metadata), {
-          template: {
-            nodes: template2.nodes,
-            ngContentSelectors: template2.ngContentSelectors
-          },
+          template: template2,
           encapsulation,
           changeDetection,
           interpolation: (_c2 = template2.interpolationConfig) != null ? _c2 : DEFAULT_INTERPOLATION_CONFIG,
@@ -36528,6 +37058,7 @@ var ComponentDecoratorHandler = class {
     return new ComponentSymbol(node, analysis.meta.selector, analysis.inputs, analysis.outputs, analysis.meta.exportAs, analysis.typeCheckMeta, typeParameters);
   }
   register(node, analysis) {
+    var _a2;
     const ref = new Reference2(node);
     this.metaRegistry.registerDirectiveMetadata(__spreadProps(__spreadValues({
       kind: MetaKind.Directive,
@@ -36551,7 +37082,9 @@ var ComponentDecoratorHandler = class {
       animationTriggerNames: analysis.animationTriggerNames,
       schemas: analysis.schemas,
       decorator: analysis.decorator,
-      assumedToExportProviders: false
+      assumedToExportProviders: false,
+      ngContentSelectors: analysis.template.ngContentSelectors,
+      preserveWhitespaces: (_a2 = analysis.template.preserveWhitespaces) != null ? _a2 : false
     }));
     this.resourceRegistry.registerResources(analysis.resources, node);
     this.injectableRegistry.registerInjectable(node, {
@@ -36590,6 +37123,7 @@ var ComponentDecoratorHandler = class {
     return null;
   }
   typeCheck(ctx, node, meta) {
+    var _a2;
     if (this.typeCheckScopeRegistry === null || !import_typescript54.default.isClassDeclaration(node)) {
       return;
     }
@@ -36601,7 +37135,7 @@ var ComponentDecoratorHandler = class {
       return;
     }
     const binder = new R3TargetBinder(scope.matcher);
-    ctx.addTemplate(new Reference2(node), binder, meta.template.diagNodes, scope.pipes, scope.schemas, meta.template.sourceMapping, meta.template.file, meta.template.errors, meta.meta.isStandalone);
+    ctx.addTemplate(new Reference2(node), binder, meta.template.diagNodes, scope.pipes, scope.schemas, meta.template.sourceMapping, meta.template.file, meta.template.errors, meta.meta.isStandalone, (_a2 = meta.meta.template.preserveWhitespaces) != null ? _a2 : false);
   }
   extendedTemplateCheck(component, extendedTemplateChecker) {
     return extendedTemplateChecker.getDiagnosticsForComponent(component);
@@ -40253,13 +40787,13 @@ var TypeParameterEmitter = class {
       return type;
     }
     let owningModule2 = null;
-    if (declaration.viaModule !== null) {
+    if (typeof declaration.viaModule === "string") {
       owningModule2 = {
         specifier: declaration.viaModule,
         resolutionContext: type.getSourceFile().fileName
       };
     }
-    return new Reference2(declaration.node, owningModule2);
+    return new Reference2(declaration.node, declaration.viaModule === AmbientImport ? AmbientImport : owningModule2);
   }
   translateTypeReference(type, emitReference) {
     const reference2 = this.resolveTypeReference(type);
@@ -40537,12 +41071,12 @@ var Environment = class {
     assertSuccessfulReferenceEmit(ngExpr, this.contextFile, "class");
     return translateExpression(ngExpr.expression, this.importManager);
   }
-  canReferenceType(ref) {
-    const result = this.refEmitter.emit(ref, this.contextFile, ImportFlags.NoAliasing | ImportFlags.AllowTypeImports | ImportFlags.AllowRelativeDtsImports);
+  canReferenceType(ref, flags = ImportFlags.NoAliasing | ImportFlags.AllowTypeImports | ImportFlags.AllowRelativeDtsImports) {
+    const result = this.refEmitter.emit(ref, this.contextFile, flags);
     return result.kind === 0;
   }
-  referenceType(ref) {
-    const ngExpr = this.refEmitter.emit(ref, this.contextFile, ImportFlags.NoAliasing | ImportFlags.AllowTypeImports | ImportFlags.AllowRelativeDtsImports);
+  referenceType(ref, flags = ImportFlags.NoAliasing | ImportFlags.AllowTypeImports | ImportFlags.AllowRelativeDtsImports) {
+    const ngExpr = this.refEmitter.emit(ref, this.contextFile, flags);
     assertSuccessfulReferenceEmit(ngExpr, this.contextFile, "symbol");
     return translateType(new ExpressionType(ngExpr.expression), this.contextFile, this.reflector, this.refEmitter, this.importManager);
   }
@@ -40711,6 +41245,21 @@ Deferred blocks can only access triggers in same view, a parent embedded view or
     }
     this._diagnostics.push(makeTemplateDiagnostic(templateId, this.resolver.getSourceMapping(templateId), trigger.sourceSpan, import_typescript85.default.DiagnosticCategory.Error, ngErrorCode(ErrorCode.INACCESSIBLE_DEFERRED_TRIGGER_ELEMENT), message));
   }
+  controlFlowPreventingContentProjection(templateId, category, projectionNode, componentName, slotSelector, controlFlowNode, preservesWhitespaces) {
+    const blockName = controlFlowNode instanceof IfBlockBranch ? "@if" : "@for";
+    const lines = [
+      `Node matches the "${slotSelector}" slot of the "${componentName}" component, but will not be projected into the specific slot because the surrounding ${blockName} has more than one node at its root. To project the node in the right slot, you can:
+`,
+      `1. Wrap the content of the ${blockName} block in an <ng-container/> that matches the "${slotSelector}" selector.`,
+      `2. Split the content of the ${blockName} block across multiple ${blockName} blocks such that each one only has a single projectable node at its root.`,
+      `3. Remove all content from the ${blockName} block, except for the node being projected.`
+    ];
+    if (preservesWhitespaces) {
+      lines.push("Note: the host component has `preserveWhitespaces: true` which may cause whitespace to affect content projection.");
+    }
+    lines.push("", 'This check can be disabled using the `extendedDiagnostics.checks.controlFlowPreventingContentProjection = "suppress" compiler option.`');
+    this._diagnostics.push(makeTemplateDiagnostic(templateId, this.resolver.getSourceMapping(templateId), projectionNode.startSourceSpan, category, ngErrorCode(ErrorCode.CONTROL_FLOW_PREVENTING_CONTENT_PROJECTION), lines.join("\n")));
+  }
 };
 function makeInlineDiagnostic(templateId, code, node, messageText, relatedInformation) {
   return __spreadProps(__spreadValues({}, makeDiagnostic(code, node, messageText, relatedInformation)), {
@@ -41148,7 +41697,7 @@ var TcbGenericContextBehavior;
   TcbGenericContextBehavior2[TcbGenericContextBehavior2["FallbackToAny"] = 2] = "FallbackToAny";
 })(TcbGenericContextBehavior || (TcbGenericContextBehavior = {}));
 function generateTypeCheckBlock(env, ref, name, meta, domSchemaChecker, oobRecorder, genericContextBehavior) {
-  const tcb = new Context2(env, domSchemaChecker, oobRecorder, meta.id, meta.boundTarget, meta.pipes, meta.schemas, meta.isStandalone);
+  const tcb = new Context2(env, domSchemaChecker, oobRecorder, meta.id, meta.boundTarget, meta.pipes, meta.schemas, meta.isStandalone, meta.preserveWhitespaces);
   const scope = Scope3.forNodes(tcb, null, null, tcb.boundTarget.target.template, null);
   const ctxRawType = env.referenceType(ref);
   if (!import_typescript89.default.isTypeReferenceNode(ctxRawType)) {
@@ -41604,6 +42153,62 @@ var TcbDomSchemaCheckerOp = class extends TcbOp {
     return null;
   }
 };
+var TcbControlFlowContentProjectionOp = class extends TcbOp {
+  constructor(tcb, element2, ngContentSelectors, componentName) {
+    super();
+    this.tcb = tcb;
+    this.element = element2;
+    this.ngContentSelectors = ngContentSelectors;
+    this.componentName = componentName;
+    this.optional = false;
+    this.category = tcb.env.config.controlFlowPreventingContentProjection === "error" ? import_typescript89.default.DiagnosticCategory.Error : import_typescript89.default.DiagnosticCategory.Warning;
+  }
+  execute() {
+    const controlFlowToCheck = this.findPotentialControlFlowNodes();
+    if (controlFlowToCheck.length > 0) {
+      const matcher = new SelectorMatcher();
+      for (const selector of this.ngContentSelectors) {
+        if (selector !== "*") {
+          matcher.addSelectables(CssSelector.parse(selector), selector);
+        }
+      }
+      for (const root of controlFlowToCheck) {
+        for (const child of root.children) {
+          if (child instanceof Element || child instanceof Template) {
+            matcher.match(createCssSelectorFromNode(child), (_, originalSelector) => {
+              this.tcb.oobRecorder.controlFlowPreventingContentProjection(this.tcb.id, this.category, child, this.componentName, originalSelector, root, this.tcb.hostPreserveWhitespaces);
+            });
+          }
+        }
+      }
+    }
+    return null;
+  }
+  findPotentialControlFlowNodes() {
+    const result = [];
+    for (const child of this.element.children) {
+      let eligibleNode = null;
+      if (child instanceof ForLoopBlock) {
+        eligibleNode = child;
+      } else if (child instanceof IfBlock) {
+        eligibleNode = child.branches[0];
+      }
+      if (eligibleNode === null || eligibleNode.children.length < 2) {
+        continue;
+      }
+      const rootNodeCount = eligibleNode.children.reduce((count, node) => {
+        if (!(node instanceof Text) || this.tcb.hostPreserveWhitespaces || node.value.trim().length > 0) {
+          count++;
+        }
+        return count;
+      }, 0);
+      if (rootNodeCount > 1) {
+        result.push(eligibleNode);
+      }
+    }
+    return result;
+  }
+};
 var ATTR_TO_PROP = new Map(Object.entries({
   "class": "className",
   "for": "htmlFor",
@@ -41785,9 +42390,7 @@ var TcbBlockImplicitVariableOp = class extends TcbOp {
     this.scope = scope;
     this.type = type;
     this.variable = variable2;
-  }
-  get optional() {
-    return false;
+    this.optional = true;
   }
   execute() {
     const id = this.tcb.allocateId();
@@ -41923,7 +42526,11 @@ var TcbForOfOp = class extends TcbOp {
   }
   execute() {
     const loopScope = Scope3.forNodes(this.tcb, this.scope, this.block, this.block.children, null);
-    const initializer = import_typescript89.default.factory.createVariableDeclarationList([import_typescript89.default.factory.createVariableDeclaration(this.block.item.name)], import_typescript89.default.NodeFlags.Const);
+    const initializerId = loopScope.resolve(this.block.item);
+    if (!import_typescript89.default.isIdentifier(initializerId)) {
+      throw new Error(`Could not resolve for loop variable ${this.block.item.name} to an identifier`);
+    }
+    const initializer = import_typescript89.default.factory.createVariableDeclarationList([import_typescript89.default.factory.createVariableDeclaration(initializerId)], import_typescript89.default.NodeFlags.Const);
     const expression = import_typescript89.default.factory.createNonNullExpression(tcbExpression(this.block.expression, this.tcb, loopScope));
     const trackTranslator = new TcbForLoopTrackTranslator(this.tcb, loopScope, this.block);
     const trackExpression = trackTranslator.translate(this.block.trackBy);
@@ -41937,7 +42544,7 @@ var TcbForOfOp = class extends TcbOp {
 };
 var INFER_TYPE_FOR_CIRCULAR_OP_EXPR = import_typescript89.default.factory.createNonNullExpression(import_typescript89.default.factory.createNull());
 var Context2 = class {
-  constructor(env, domSchemaChecker, oobRecorder, id, boundTarget, pipes, schemas, hostIsStandalone) {
+  constructor(env, domSchemaChecker, oobRecorder, id, boundTarget, pipes, schemas, hostIsStandalone, hostPreserveWhitespaces) {
     this.env = env;
     this.domSchemaChecker = domSchemaChecker;
     this.oobRecorder = oobRecorder;
@@ -41946,6 +42553,7 @@ var Context2 = class {
     this.pipes = pipes;
     this.schemas = schemas;
     this.hostIsStandalone = hostIsStandalone;
+    this.hostPreserveWhitespaces = hostPreserveWhitespaces;
     this.nextId = 1;
   }
   allocateId() {
@@ -41993,7 +42601,9 @@ var _Scope = class {
         this.registerVariable(scope, expressionAlias, new TcbBlockVariableOp(tcb, scope, tcbExpression(expression, tcb, scope), expressionAlias));
       }
     } else if (scopedNode instanceof ForLoopBlock) {
-      this.registerVariable(scope, scopedNode.item, new TcbBlockVariableOp(tcb, scope, import_typescript89.default.factory.createIdentifier(scopedNode.item.name), scopedNode.item));
+      const loopInitializer = tcb.allocateId();
+      addParseSpanInfo(loopInitializer, scopedNode.item.sourceSpan);
+      scope.varMap.set(scopedNode.item, loopInitializer);
       for (const [name, variable2] of Object.entries(scopedNode.contextVariables)) {
         if (!this.forLoopContextVariableTypes.has(name)) {
           throw new Error(`Unrecognized for loop context variable ${name}`);
@@ -42058,7 +42668,8 @@ var _Scope = class {
     if (ref instanceof Reference && this.referenceOpMap.has(ref)) {
       return this.resolveOp(this.referenceOpMap.get(ref));
     } else if (ref instanceof Variable && this.varMap.has(ref)) {
-      return this.resolveOp(this.varMap.get(ref));
+      const opIndexOrNode = this.varMap.get(ref);
+      return typeof opIndexOrNode === "number" ? this.resolveOp(opIndexOrNode) : opIndexOrNode;
     } else if (ref instanceof Template && directive === void 0 && this.templateCtxOpMap.has(ref)) {
       return this.resolveOp(this.templateCtxOpMap.get(ref));
     } else if ((ref instanceof Element || ref instanceof Template) && directive !== void 0 && this.directiveOpMap.has(ref)) {
@@ -42098,6 +42709,9 @@ var _Scope = class {
     if (node instanceof Element) {
       const opIndex = this.opQueue.push(new TcbElementOp(this.tcb, this, node)) - 1;
       this.elementOpMap.set(node, opIndex);
+      if (this.tcb.env.config.controlFlowPreventingContentProjection !== "suppress") {
+        this.appendContentProjectionCheckOp(node);
+      }
       this.appendDirectivesAndInputsOfNode(node);
       this.appendOutputsOfNode(node);
       this.appendChildren(node);
@@ -42241,6 +42855,16 @@ var _Scope = class {
       }
     }
   }
+  appendContentProjectionCheckOp(root) {
+    var _a2;
+    const meta = ((_a2 = this.tcb.boundTarget.getDirectivesOfNode(root)) == null ? void 0 : _a2.find((meta2) => meta2.isComponent)) || null;
+    if (meta !== null && meta.ngContentSelectors !== null && meta.ngContentSelectors.length > 0) {
+      const selectors = meta.ngContentSelectors;
+      if (selectors.length > 1 || selectors.length === 1 && selectors[0] !== "*") {
+        this.opQueue.push(new TcbControlFlowContentProjectionOp(this.tcb, root, selectors, meta.name));
+      }
+    }
+  }
   appendDeferredBlock(block) {
     this.appendDeferredTriggers(block, block.triggers);
     this.appendDeferredTriggers(block, block.prefetchTriggers);
@@ -42584,7 +43208,7 @@ var TypeCheckContextImpl = class {
       throw new Error(`AssertionError: invalid inlining configuration.`);
     }
   }
-  addTemplate(ref, binder, template2, pipes, schemas, sourceMapping, file, parseErrors, isStandalone) {
+  addTemplate(ref, binder, template2, pipes, schemas, sourceMapping, file, parseErrors, isStandalone, preserveWhitespaces) {
     if (!this.host.shouldCheckComponent(ref.node)) {
       return;
     }
@@ -42637,7 +43261,8 @@ var TypeCheckContextImpl = class {
       boundTarget,
       pipes,
       schemas,
-      isStandalone
+      isStandalone,
+      preserveWhitespaces
     };
     this.perf.eventCount(PerfEvent.GenerateTcb);
     if (inliningRequirement !== TcbInliningRequirement.None && this.inlining === InliningMode.InlineOps) {
@@ -44547,6 +45172,10 @@ var ALL_DIAGNOSTIC_FACTORIES = [
   factory7,
   factory
 ];
+var SUPPORTED_DIAGNOSTIC_NAMES = /* @__PURE__ */ new Set([
+  ExtendedTemplateDiagnosticName.CONTROL_FLOW_PREVENTING_CONTENT_PROJECTION,
+  ...ALL_DIAGNOSTIC_FACTORIES.map((factory9) => factory9.name)
+]);
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler-cli/src/ngtsc/core/src/compiler.mjs
 var CompilationTicketKind;
@@ -44866,6 +45495,7 @@ var NgCompiler = class {
     return strictTemplates || !!this.options.fullTemplateTypeCheck;
   }
   getTypeCheckingConfig() {
+    var _a2, _b2, _c2, _d2;
     const strictTemplates = !!this.options.strictTemplates;
     const useInlineTypeConstructors = this.programDriver.supportsInlineOperations;
     let typeCheckingConfig;
@@ -44891,7 +45521,8 @@ var NgCompiler = class {
         strictLiteralTypes: true,
         enableTemplateTypeChecker: this.enableTemplateTypeChecker,
         useInlineTypeConstructors,
-        suggestionsForSuboptimalTypeInference: this.enableTemplateTypeChecker && !strictTemplates
+        suggestionsForSuboptimalTypeInference: this.enableTemplateTypeChecker && !strictTemplates,
+        controlFlowPreventingContentProjection: ((_a2 = this.options.extendedDiagnostics) == null ? void 0 : _a2.defaultCategory) || DiagnosticCategoryLabel.Warning
       };
     } else {
       typeCheckingConfig = {
@@ -44915,7 +45546,8 @@ var NgCompiler = class {
         strictLiteralTypes: false,
         enableTemplateTypeChecker: this.enableTemplateTypeChecker,
         useInlineTypeConstructors,
-        suggestionsForSuboptimalTypeInference: false
+        suggestionsForSuboptimalTypeInference: false,
+        controlFlowPreventingContentProjection: ((_b2 = this.options.extendedDiagnostics) == null ? void 0 : _b2.defaultCategory) || DiagnosticCategoryLabel.Warning
       };
     }
     if (this.options.strictInputTypes !== void 0) {
@@ -44950,6 +45582,9 @@ var NgCompiler = class {
     if (this.options.strictLiteralTypes !== void 0) {
       typeCheckingConfig.strictLiteralTypes = this.options.strictLiteralTypes;
     }
+    if (((_d2 = (_c2 = this.options.extendedDiagnostics) == null ? void 0 : _c2.checks) == null ? void 0 : _d2.controlFlowPreventingContentProjection) !== void 0) {
+      typeCheckingConfig.controlFlowPreventingContentProjection = this.options.extendedDiagnostics.checks.controlFlowPreventingContentProjection;
+    }
     return typeCheckingConfig;
   }
   getTemplateDiagnostics() {
@@ -45208,9 +45843,8 @@ ${allowedCategoryLabels.join("\n")}
       `.trim()
     });
   }
-  const allExtendedDiagnosticNames = ALL_DIAGNOSTIC_FACTORIES.map((factory9) => factory9.name);
   for (const [checkName, category] of Object.entries((_c2 = (_b2 = options.extendedDiagnostics) == null ? void 0 : _b2.checks) != null ? _c2 : {})) {
-    if (!allExtendedDiagnosticNames.includes(checkName)) {
+    if (!SUPPORTED_DIAGNOSTIC_NAMES.has(checkName)) {
       yield makeConfigDiagnostic({
         category: import_typescript98.default.DiagnosticCategory.Error,
         code: ErrorCode.CONFIG_EXTENDED_DIAGNOSTICS_UNKNOWN_CHECK,
@@ -45218,7 +45852,7 @@ ${allowedCategoryLabels.join("\n")}
 Angular compiler option "extendedDiagnostics.checks" has an unknown check: "${checkName}".
 
 Allowed check names are:
-${allExtendedDiagnosticNames.join("\n")}
+${Array.from(SUPPORTED_DIAGNOSTIC_NAMES).join("\n")}
         `.trim()
       });
     }
@@ -45948,7 +46582,7 @@ function normalizePath(path4) {
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/core/schematics/utils/project_tsconfig_paths.mjs
-var import_core16 = require("@angular-devkit/core");
+var import_core18 = require("@angular-devkit/core");
 function getProjectTsConfigPaths(tree) {
   return __async(this, null, function* () {
     const buildPaths = /* @__PURE__ */ new Set();
@@ -45965,9 +46599,9 @@ function getProjectTsConfigPaths(tree) {
             continue;
           }
           if (name === "build") {
-            buildPaths.add((0, import_core16.normalize)(tsConfig));
+            buildPaths.add((0, import_core18.normalize)(tsConfig));
           } else {
-            testPaths.add((0, import_core16.normalize)(tsConfig));
+            testPaths.add((0, import_core18.normalize)(tsConfig));
           }
         }
       }
@@ -45999,7 +46633,7 @@ function createHost(tree) {
         if (!data) {
           throw new Error("File not found.");
         }
-        return import_core16.virtualFs.fileBufferToString(data);
+        return import_core18.virtualFs.fileBufferToString(data);
       });
     },
     writeFile(path4, data) {
@@ -46022,7 +46656,7 @@ function createHost(tree) {
 function getWorkspace(tree) {
   return __async(this, null, function* () {
     const host = createHost(tree);
-    const { workspace } = yield import_core16.workspaces.readWorkspace("/", host);
+    const { workspace } = yield import_core18.workspaces.readWorkspace("/", host);
     return workspace;
   });
 }