@angular/core 16.1.2 → 16.2.0-next.0

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

@@ -1401,6 +1401,9 @@ var ReadVarExpr = class extends Expression {
   visitExpression(visitor, context) {
     return visitor.visitReadVarExpr(this, context);
   }
+  clone() {
+    return new ReadVarExpr(this.name, this.type, this.sourceSpan);
+  }
   set(value) {
     return new WriteVarExpr(this.name, value, null, this.sourceSpan);
   }
@@ -1419,6 +1422,9 @@ var TypeofExpr = class extends Expression {
   isConstant() {
     return this.expr.isConstant();
   }
+  clone() {
+    return new TypeofExpr(this.expr.clone());
+  }
 };
 var WrappedNodeExpr = class extends Expression {
   constructor(node, type, sourceSpan) {
@@ -1434,6 +1440,9 @@ var WrappedNodeExpr = class extends Expression {
   visitExpression(visitor, context) {
     return visitor.visitWrappedNodeExpr(this, context);
   }
+  clone() {
+    return new WrappedNodeExpr(this.node, this.type, this.sourceSpan);
+  }
 };
 var WriteVarExpr = class extends Expression {
   constructor(name, value, type, sourceSpan) {
@@ -1450,6 +1459,9 @@ var WriteVarExpr = class extends Expression {
   visitExpression(visitor, context) {
     return visitor.visitWriteVarExpr(this, context);
   }
+  clone() {
+    return new WriteVarExpr(this.name, this.value.clone(), this.type, this.sourceSpan);
+  }
   toDeclStmt(type, modifiers) {
     return new DeclareVarStmt(this.name, this.value, type, modifiers, this.sourceSpan);
   }
@@ -1473,6 +1485,9 @@ var WriteKeyExpr = class extends Expression {
   visitExpression(visitor, context) {
     return visitor.visitWriteKeyExpr(this, context);
   }
+  clone() {
+    return new WriteKeyExpr(this.receiver.clone(), this.index.clone(), this.value.clone(), this.type, this.sourceSpan);
+  }
 };
 var WritePropExpr = class extends Expression {
   constructor(receiver, name, value, type, sourceSpan) {
@@ -1490,6 +1505,9 @@ var WritePropExpr = class extends Expression {
   visitExpression(visitor, context) {
     return visitor.visitWritePropExpr(this, context);
   }
+  clone() {
+    return new WritePropExpr(this.receiver.clone(), this.name, this.value.clone(), this.type, this.sourceSpan);
+  }
 };
 var InvokeFunctionExpr = class extends Expression {
   constructor(fn2, args, type, sourceSpan, pure = false) {
@@ -1507,6 +1525,9 @@ var InvokeFunctionExpr = class extends Expression {
   visitExpression(visitor, context) {
     return visitor.visitInvokeFunctionExpr(this, context);
   }
+  clone() {
+    return new InvokeFunctionExpr(this.fn.clone(), this.args.map((arg) => arg.clone()), this.type, this.sourceSpan, this.pure);
+  }
 };
 var TaggedTemplateExpr = class extends Expression {
   constructor(tag, template2, type, sourceSpan) {
@@ -1523,6 +1544,9 @@ var TaggedTemplateExpr = class extends Expression {
   visitExpression(visitor, context) {
     return visitor.visitTaggedTemplateExpr(this, context);
   }
+  clone() {
+    return new TaggedTemplateExpr(this.tag.clone(), this.template.clone(), this.type, this.sourceSpan);
+  }
 };
 var InstantiateExpr = class extends Expression {
   constructor(classExpr, args, type, sourceSpan) {
@@ -1539,6 +1563,9 @@ var InstantiateExpr = class extends Expression {
   visitExpression(visitor, context) {
     return visitor.visitInstantiateExpr(this, context);
   }
+  clone() {
+    return new InstantiateExpr(this.classExpr.clone(), this.args.map((arg) => arg.clone()), this.type, this.sourceSpan);
+  }
 };
 var LiteralExpr = class extends Expression {
   constructor(value, type, sourceSpan) {
@@ -1554,12 +1581,18 @@ var LiteralExpr = class extends Expression {
   visitExpression(visitor, context) {
     return visitor.visitLiteralExpr(this, context);
   }
+  clone() {
+    return new LiteralExpr(this.value, this.type, this.sourceSpan);
+  }
 };
 var TemplateLiteral = class {
   constructor(elements, expressions) {
     this.elements = elements;
     this.expressions = expressions;
   }
+  clone() {
+    return new TemplateLiteral(this.elements.map((el) => el.clone()), this.expressions.map((expr) => expr.clone()));
+  }
 };
 var TemplateLiteralElement = class {
   constructor(text2, sourceSpan, rawText) {
@@ -1568,6 +1601,9 @@ var TemplateLiteralElement = class {
     this.sourceSpan = sourceSpan;
     this.rawText = (_a2 = rawText != null ? rawText : sourceSpan == null ? void 0 : sourceSpan.toString()) != null ? _a2 : escapeForTemplateLiteral(escapeSlashes(text2));
   }
+  clone() {
+    return new TemplateLiteralElement(this.text, this.sourceSpan, this.rawText);
+  }
 };
 var LiteralPiece = class {
   constructor(text2, sourceSpan) {
@@ -1602,6 +1638,9 @@ var LocalizedString = class extends Expression {
   visitExpression(visitor, context) {
     return visitor.visitLocalizedString(this, context);
   }
+  clone() {
+    return new LocalizedString(this.metaBlock, this.messageParts, this.placeHolderNames, this.expressions.map((expr) => expr.clone()), this.sourceSpan);
+  }
   serializeI18nHead() {
     let metaBlock = this.metaBlock.description || "";
     if (this.metaBlock.meaning) {
@@ -1670,6 +1709,9 @@ var ExternalExpr = class extends Expression {
   visitExpression(visitor, context) {
     return visitor.visitExternalExpr(this, context);
   }
+  clone() {
+    return new ExternalExpr(this.value, this.type, this.typeParams, this.sourceSpan);
+  }
 };
 var ExternalReference = class {
   constructor(moduleName, name, runtime) {
@@ -1694,6 +1736,10 @@ var ConditionalExpr = class extends Expression {
   visitExpression(visitor, context) {
     return visitor.visitConditionalExpr(this, context);
   }
+  clone() {
+    var _a2;
+    return new ConditionalExpr(this.condition.clone(), this.trueCase.clone(), (_a2 = this.falseCase) == null ? void 0 : _a2.clone(), this.type, this.sourceSpan);
+  }
 };
 var NotExpr = class extends Expression {
   constructor(condition, sourceSpan) {
@@ -1709,6 +1755,9 @@ var NotExpr = class extends Expression {
   visitExpression(visitor, context) {
     return visitor.visitNotExpr(this, context);
   }
+  clone() {
+    return new NotExpr(this.condition.clone(), this.sourceSpan);
+  }
 };
 var FnParam = class {
   constructor(name, type = null) {
@@ -1718,6 +1767,9 @@ var FnParam = class {
   isEquivalent(param) {
     return this.name === param.name;
   }
+  clone() {
+    return new FnParam(this.name, this.type);
+  }
 };
 var FunctionExpr = class extends Expression {
   constructor(params, statements, type, sourceSpan, name) {
@@ -1738,6 +1790,9 @@ var FunctionExpr = class extends Expression {
   toDeclStmt(name, modifiers) {
     return new DeclareFunctionStmt(name, this.params, this.statements, this.type, modifiers, this.sourceSpan);
   }
+  clone() {
+    return new FunctionExpr(this.params.map((p2) => p2.clone()), this.statements, this.type, this.sourceSpan, this.name);
+  }
 };
 var UnaryOperatorExpr = class extends Expression {
   constructor(operator, expr, type, sourceSpan, parens = true) {
@@ -1755,6 +1810,9 @@ var UnaryOperatorExpr = class extends Expression {
   visitExpression(visitor, context) {
     return visitor.visitUnaryOperatorExpr(this, context);
   }
+  clone() {
+    return new UnaryOperatorExpr(this.operator, this.expr.clone(), this.type, this.sourceSpan, this.parens);
+  }
 };
 var BinaryOperatorExpr = class extends Expression {
   constructor(operator, lhs, rhs, type, sourceSpan, parens = true) {
@@ -1773,6 +1831,9 @@ var BinaryOperatorExpr = class extends Expression {
   visitExpression(visitor, context) {
     return visitor.visitBinaryOperatorExpr(this, context);
   }
+  clone() {
+    return new BinaryOperatorExpr(this.operator, this.lhs.clone(), this.rhs.clone(), this.type, this.sourceSpan, this.parens);
+  }
 };
 var ReadPropExpr = class extends Expression {
   constructor(receiver, name, type, sourceSpan) {
@@ -1792,6 +1853,9 @@ var ReadPropExpr = class extends Expression {
   set(value) {
     return new WritePropExpr(this.receiver, this.name, value, null, this.sourceSpan);
   }
+  clone() {
+    return new ReadPropExpr(this.receiver.clone(), this.name, this.type, this.sourceSpan);
+  }
 };
 var ReadKeyExpr = class extends Expression {
   constructor(receiver, index, type, sourceSpan) {
@@ -1811,6 +1875,9 @@ var ReadKeyExpr = class extends Expression {
   set(value) {
     return new WriteKeyExpr(this.receiver, this.index, value, null, this.sourceSpan);
   }
+  clone() {
+    return new ReadKeyExpr(this.receiver, this.index.clone(), this.type, this.sourceSpan);
+  }
 };
 var LiteralArrayExpr = class extends Expression {
   constructor(entries, type, sourceSpan) {
@@ -1826,6 +1893,9 @@ var LiteralArrayExpr = class extends Expression {
   visitExpression(visitor, context) {
     return visitor.visitLiteralArrayExpr(this, context);
   }
+  clone() {
+    return new LiteralArrayExpr(this.entries.map((e) => e.clone()), this.type, this.sourceSpan);
+  }
 };
 var LiteralMapEntry = class {
   constructor(key, value, quoted) {
@@ -1836,6 +1906,9 @@ var LiteralMapEntry = class {
   isEquivalent(e) {
     return this.key === e.key && this.value.isEquivalent(e.value);
   }
+  clone() {
+    return new LiteralMapEntry(this.key, this.value.clone(), this.quoted);
+  }
 };
 var LiteralMapExpr = class extends Expression {
   constructor(entries, type, sourceSpan) {
@@ -1855,6 +1928,10 @@ var LiteralMapExpr = class extends Expression {
   visitExpression(visitor, context) {
     return visitor.visitLiteralMapExpr(this, context);
   }
+  clone() {
+    const entriesClone = this.entries.map((entry) => entry.clone());
+    return new LiteralMapExpr(entriesClone, this.type, this.sourceSpan);
+  }
 };
 var CommaExpr = class extends Expression {
   constructor(parts, sourceSpan) {
@@ -1870,6 +1947,9 @@ var CommaExpr = class extends Expression {
   visitExpression(visitor, context) {
     return visitor.visitCommaExpr(this, context);
   }
+  clone() {
+    return new CommaExpr(this.parts.map((p2) => p2.clone()));
+  }
 };
 var NULL_EXPR = new LiteralExpr(null, null, null);
 var TYPED_NULL_EXPR = new LiteralExpr(null, INFERRED_TYPE, null);
@@ -2251,6 +2331,9 @@ var FixupExpression = class extends Expression {
   isConstant() {
     return true;
   }
+  clone() {
+    throw new Error(`Not supported.`);
+  }
   fixup(expression) {
     this.resolved = expression;
     this.shared = true;
@@ -6831,6 +6914,7 @@ var InterpolationExpression = class extends Expression {
     this.isConstant = unsupported;
     this.isEquivalent = unsupported;
     this.visitExpression = unsupported;
+    this.clone = unsupported;
   }
 };
 var DefaultLocalResolver = class {
@@ -7461,7 +7545,10 @@ var ElementAttributes = class {
     this.known.add(name);
     const array = this.arrayFor(kind);
     array.push(...getAttributeNameLiterals(name));
-    if (value !== null) {
+    if (kind === ElementAttributeKind.Attribute || kind === ElementAttributeKind.Style) {
+      if (value === null) {
+        throw Error("Attribute & style element attributes must have a value");
+      }
       array.push(value);
     }
   }
@@ -7510,6 +7597,7 @@ var OpKind;
   OpKind2[OpKind2["InterpolateProperty"] = 14] = "InterpolateProperty";
   OpKind2[OpKind2["Advance"] = 15] = "Advance";
   OpKind2[OpKind2["Pipe"] = 16] = "Pipe";
+  OpKind2[OpKind2["Attribute"] = 17] = "Attribute";
 })(OpKind || (OpKind = {}));
 var ExpressionKind;
 (function(ExpressionKind2) {
@@ -7525,6 +7613,10 @@ var ExpressionKind;
   ExpressionKind2[ExpressionKind2["PureFunctionParameterExpr"] = 9] = "PureFunctionParameterExpr";
   ExpressionKind2[ExpressionKind2["PipeBinding"] = 10] = "PipeBinding";
   ExpressionKind2[ExpressionKind2["PipeBindingVariadic"] = 11] = "PipeBindingVariadic";
+  ExpressionKind2[ExpressionKind2["SafePropertyRead"] = 12] = "SafePropertyRead";
+  ExpressionKind2[ExpressionKind2["SafeKeyedRead"] = 13] = "SafeKeyedRead";
+  ExpressionKind2[ExpressionKind2["SafeInvokeFunction"] = 14] = "SafeInvokeFunction";
+  ExpressionKind2[ExpressionKind2["SafeTernaryExpr"] = 15] = "SafeTernaryExpr";
 })(ExpressionKind || (ExpressionKind = {}));
 var SemanticVariableKind;
 (function(SemanticVariableKind2) {
@@ -7608,6 +7700,9 @@ var LexicalReadExpr = class extends ExpressionBase {
   }
   transformInternalExpressions() {
   }
+  clone() {
+    return new LexicalReadExpr(this.name);
+  }
 };
 var _ReferenceExpr = class extends ExpressionBase {
   constructor(target, offset) {
@@ -7628,6 +7723,11 @@ var _ReferenceExpr = class extends ExpressionBase {
   }
   transformInternalExpressions() {
   }
+  clone() {
+    const expr = new _ReferenceExpr(this.target, this.offset);
+    expr.slot = this.slot;
+    return expr;
+  }
 };
 var ReferenceExpr = _ReferenceExpr;
 (() => {
@@ -7649,6 +7749,9 @@ var ContextExpr = class extends ExpressionBase {
   }
   transformInternalExpressions() {
   }
+  clone() {
+    return new ContextExpr(this.view);
+  }
 };
 var NextContextExpr = class extends ExpressionBase {
   constructor() {
@@ -7666,6 +7769,11 @@ var NextContextExpr = class extends ExpressionBase {
   }
   transformInternalExpressions() {
   }
+  clone() {
+    const expr = new NextContextExpr();
+    expr.steps = this.steps;
+    return expr;
+  }
 };
 var GetCurrentViewExpr = class extends ExpressionBase {
   constructor() {
@@ -7682,6 +7790,9 @@ var GetCurrentViewExpr = class extends ExpressionBase {
   }
   transformInternalExpressions() {
   }
+  clone() {
+    return new GetCurrentViewExpr();
+  }
 };
 var RestoreViewExpr = class extends ExpressionBase {
   constructor(view) {
@@ -7712,6 +7823,9 @@ var RestoreViewExpr = class extends ExpressionBase {
       this.view = transformExpressionsInExpression(this.view, transform, flags);
     }
   }
+  clone() {
+    return new RestoreViewExpr(this.view instanceof Expression ? this.view.clone() : this.view);
+  }
 };
 var ResetViewExpr = class extends ExpressionBase {
   constructor(expr) {
@@ -7731,6 +7845,9 @@ var ResetViewExpr = class extends ExpressionBase {
   transformInternalExpressions(transform, flags) {
     this.expr = transformExpressionsInExpression(this.expr, transform, flags);
   }
+  clone() {
+    return new ResetViewExpr(this.expr.clone());
+  }
 };
 var ReadVariableExpr = class extends ExpressionBase {
   constructor(xref) {
@@ -7749,6 +7866,11 @@ var ReadVariableExpr = class extends ExpressionBase {
   }
   transformInternalExpressions() {
   }
+  clone() {
+    const expr = new ReadVariableExpr(this.xref);
+    expr.name = this.name;
+    return expr;
+  }
 };
 var _PureFunctionExpr = class extends ExpressionBase {
   constructor(expression, args) {
@@ -7787,6 +7909,13 @@ var _PureFunctionExpr = class extends ExpressionBase {
       this.args[i] = transformExpressionsInExpression(this.args[i], transform, flags);
     }
   }
+  clone() {
+    var _a2, _b2, _c2, _d2;
+    const expr = new _PureFunctionExpr((_b2 = (_a2 = this.body) == null ? void 0 : _a2.clone()) != null ? _b2 : null, this.args.map((arg) => arg.clone()));
+    expr.fn = (_d2 = (_c2 = this.fn) == null ? void 0 : _c2.clone()) != null ? _d2 : null;
+    expr.varOffset = this.varOffset;
+    return expr;
+  }
 };
 var PureFunctionExpr = _PureFunctionExpr;
 (() => {
@@ -7808,8 +7937,11 @@ var PureFunctionParameterExpr = class extends ExpressionBase {
   }
   transformInternalExpressions() {
   }
+  clone() {
+    return new PureFunctionParameterExpr(this.index);
+  }
 };
-var PipeBindingExpr = class extends ExpressionBase {
+var _PipeBindingExpr = class extends ExpressionBase {
   constructor(target, name, args) {
     super();
     this.target = target;
@@ -7838,11 +7970,18 @@ var PipeBindingExpr = class extends ExpressionBase {
       this.args[idx] = transformExpressionsInExpression(this.args[idx], transform, flags);
     }
   }
+  clone() {
+    const r = new _PipeBindingExpr(this.target, this.name, this.args.map((a) => a.clone()));
+    r.slot = this.slot;
+    r.varOffset = this.varOffset;
+    return r;
+  }
 };
+var PipeBindingExpr = _PipeBindingExpr;
 (() => {
   _d = UsesSlotIndex, _e = ConsumesVarsTrait, _f = UsesVarOffset;
 })();
-var PipeBindingVariadicExpr = class extends ExpressionBase {
+var _PipeBindingVariadicExpr = class extends ExpressionBase {
   constructor(target, name, args, numArgs) {
     super();
     this.target = target;
@@ -7868,10 +8007,110 @@ var PipeBindingVariadicExpr = class extends ExpressionBase {
   transformInternalExpressions(transform, flags) {
     this.args = transformExpressionsInExpression(this.args, transform, flags);
   }
+  clone() {
+    const r = new _PipeBindingVariadicExpr(this.target, this.name, this.args.clone(), this.numArgs);
+    r.slot = this.slot;
+    r.varOffset = this.varOffset;
+    return r;
+  }
 };
+var PipeBindingVariadicExpr = _PipeBindingVariadicExpr;
 (() => {
   _g = UsesSlotIndex, _h = ConsumesVarsTrait, _j = UsesVarOffset;
 })();
+var SafePropertyReadExpr = class extends ExpressionBase {
+  constructor(receiver, name) {
+    super();
+    this.receiver = receiver;
+    this.name = name;
+    this.kind = ExpressionKind.SafePropertyRead;
+  }
+  visitExpression(visitor, context) {
+  }
+  isEquivalent() {
+    return false;
+  }
+  isConstant() {
+    return false;
+  }
+  transformInternalExpressions(transform, flags) {
+    this.receiver = transformExpressionsInExpression(this.receiver, transform, flags);
+  }
+  clone() {
+    return new SafePropertyReadExpr(this.receiver.clone(), this.name);
+  }
+};
+var SafeKeyedReadExpr = class extends ExpressionBase {
+  constructor(receiver, index) {
+    super();
+    this.receiver = receiver;
+    this.index = index;
+    this.kind = ExpressionKind.SafeKeyedRead;
+  }
+  visitExpression(visitor, context) {
+  }
+  isEquivalent() {
+    return false;
+  }
+  isConstant() {
+    return false;
+  }
+  transformInternalExpressions(transform, flags) {
+    this.receiver = transformExpressionsInExpression(this.receiver, transform, flags);
+    this.index = transformExpressionsInExpression(this.index, transform, flags);
+  }
+  clone() {
+    return new SafeKeyedReadExpr(this.receiver.clone(), this.index.clone());
+  }
+};
+var SafeInvokeFunctionExpr = class extends ExpressionBase {
+  constructor(receiver, args) {
+    super();
+    this.receiver = receiver;
+    this.args = args;
+    this.kind = ExpressionKind.SafeInvokeFunction;
+  }
+  visitExpression(visitor, context) {
+  }
+  isEquivalent() {
+    return false;
+  }
+  isConstant() {
+    return false;
+  }
+  transformInternalExpressions(transform, flags) {
+    this.receiver = transformExpressionsInExpression(this.receiver, transform, flags);
+    for (let i = 0; i < this.args.length; i++) {
+      this.args[i] = transformExpressionsInExpression(this.args[i], transform, flags);
+    }
+  }
+  clone() {
+    return new SafeInvokeFunctionExpr(this.receiver.clone(), this.args.map((a) => a.clone()));
+  }
+};
+var SafeTernaryExpr = class extends ExpressionBase {
+  constructor(guard, expr) {
+    super();
+    this.guard = guard;
+    this.expr = expr;
+    this.kind = ExpressionKind.SafeTernaryExpr;
+  }
+  visitExpression(visitor, context) {
+  }
+  isEquivalent() {
+    return false;
+  }
+  isConstant() {
+    return false;
+  }
+  transformInternalExpressions(transform, flags) {
+    this.guard = transformExpressionsInExpression(this.guard, transform, flags);
+    this.expr = transformExpressionsInExpression(this.expr, transform, flags);
+  }
+  clone() {
+    return new SafeTernaryExpr(this.guard.clone(), this.expr.clone());
+  }
+};
 function visitExpressionsInOp(op, visitor) {
   transformExpressionsInOp(op, (expr, flags) => {
     visitor(expr, flags);
@@ -7896,6 +8135,11 @@ function transformExpressionsInOp(op, transform, flags) {
     case OpKind.Statement:
       transformExpressionsInStatement(op.statement, transform, flags);
       break;
+    case OpKind.Attribute:
+      if (op.value) {
+        transformExpressionsInExpression(op.value, transform, flags);
+      }
+      break;
     case OpKind.Variable:
       op.initializer = transformExpressionsInExpression(op.initializer, transform, flags);
       break;
@@ -8165,6 +8409,16 @@ var NEW_OP = {
 };
 
 // bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/ir/src/ops/create.mjs
+var elementContainerOpKinds = /* @__PURE__ */ new Set([
+  OpKind.Element,
+  OpKind.ElementStart,
+  OpKind.Container,
+  OpKind.ContainerStart,
+  OpKind.Template
+]);
+function isElementOrContainerOp(op) {
+  return elementContainerOpKinds.has(op.kind);
+}
 function createElementStartOp(tag, xref) {
   return __spreadValues(__spreadValues({
     kind: OpKind.ElementStart,
@@ -8225,18 +8479,29 @@ function createInterpolateTextOp(xref, strings, expressions) {
     expressions
   }, TRAIT_DEPENDS_ON_SLOT_CONTEXT), TRAIT_CONSUMES_VARS), NEW_OP);
 }
-function createPropertyOp(xref, name, expression) {
+function createPropertyOp(xref, bindingKind, name, expression) {
   return __spreadValues(__spreadValues(__spreadValues({
     kind: OpKind.Property,
     target: xref,
+    bindingKind,
     name,
     expression
   }, TRAIT_DEPENDS_ON_SLOT_CONTEXT), TRAIT_CONSUMES_VARS), NEW_OP);
 }
-function createInterpolatePropertyOp(xref, name, strings, expressions) {
+function createAttributeOp(target, attributeKind, name, value) {
+  return __spreadValues({
+    kind: OpKind.Attribute,
+    target,
+    attributeKind,
+    name,
+    value
+  }, NEW_OP);
+}
+function createInterpolatePropertyOp(xref, bindingKind, name, strings, expressions) {
   return __spreadValues(__spreadValues(__spreadValues({
     kind: OpKind.InterpolateProperty,
     target: xref,
+    bindingKind,
     name,
     strings,
     expressions
@@ -8249,6 +8514,181 @@ function createAdvanceOp(delta) {
   }, NEW_OP);
 }
 
+// bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/var_counting.mjs
+function phaseVarCounting(cpl) {
+  for (const [_, view] of cpl.views) {
+    let varCount = 0;
+    for (const op of view.ops()) {
+      if (hasConsumesVarsTrait(op)) {
+        varCount += varsUsedByOp(op);
+      }
+      visitExpressionsInOp(op, (expr) => {
+        if (!isIrExpression(expr)) {
+          return;
+        }
+        if (hasUsesVarOffsetTrait(expr)) {
+          expr.varOffset = varCount;
+        }
+        if (hasConsumesVarsTrait(expr)) {
+          varCount += varsUsedByIrExpression(expr);
+        }
+      });
+    }
+    view.vars = varCount;
+  }
+  for (const [_, view] of cpl.views) {
+    for (const op of view.create) {
+      if (op.kind !== OpKind.Template) {
+        continue;
+      }
+      const childView = cpl.views.get(op.xref);
+      op.vars = childView.vars;
+    }
+  }
+}
+function varsUsedByOp(op) {
+  switch (op.kind) {
+    case OpKind.Property:
+      return 1;
+    case OpKind.InterpolateText:
+      return op.expressions.length;
+    case OpKind.InterpolateProperty:
+      return 1 + op.expressions.length;
+    default:
+      throw new Error(`Unhandled op: ${OpKind[op.kind]}`);
+  }
+}
+function varsUsedByIrExpression(expr) {
+  switch (expr.kind) {
+    case ExpressionKind.PureFunctionExpr:
+      return 1 + expr.args.length;
+    case ExpressionKind.PipeBinding:
+      return 1 + expr.args.length;
+    case ExpressionKind.PipeBindingVariadic:
+      return 1 + expr.numArgs;
+    default:
+      throw new Error(`AssertionError: unhandled ConsumesVarsTrait expression ${expr.constructor.name}`);
+  }
+}
+
+// bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/align_pipe_variadic_var_offset.mjs
+function phaseAlignPipeVariadicVarOffset(cpl) {
+  for (const view of cpl.views.values()) {
+    for (const op of view.update) {
+      visitExpressionsInOp(op, (expr) => {
+        if (!(expr instanceof PipeBindingVariadicExpr)) {
+          return expr;
+        }
+        if (!(expr.args instanceof PureFunctionExpr)) {
+          return expr;
+        }
+        if (expr.varOffset === null || expr.args.varOffset === null) {
+          throw new Error(`Must run after variable counting`);
+        }
+        expr.varOffset = expr.args.varOffset;
+        expr.args.varOffset = expr.varOffset + varsUsedByIrExpression(expr);
+      });
+    }
+  }
+}
+
+// bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/attribute_extraction.mjs
+function lookupElement(elements, xref) {
+  const el = elements.get(xref);
+  if (el === void 0) {
+    throw new Error("All attributes should have an element-like target.");
+  }
+  return el;
+}
+function phaseAttributeExtraction(cpl, compatibility) {
+  for (const [_, view] of cpl.views) {
+    populateElementAttributes(view, compatibility);
+  }
+}
+function populateElementAttributes(view, compatibility) {
+  const elements = /* @__PURE__ */ new Map();
+  for (const op of view.create) {
+    if (!isElementOrContainerOp(op)) {
+      continue;
+    }
+    elements.set(op.xref, op);
+  }
+  for (const op of view.ops()) {
+    let ownerOp;
+    switch (op.kind) {
+      case OpKind.Attribute:
+        ownerOp = lookupElement(elements, op.target);
+        assertIsElementAttributes(ownerOp.attributes);
+        let extractable = compatibility ? op.value instanceof LiteralExpr && typeof op.value.value === "string" : op.value.isConstant();
+        if (extractable) {
+          ownerOp.attributes.add(op.attributeKind, op.name, op.value);
+          OpList.remove(op);
+        }
+        break;
+      case OpKind.Property:
+      case OpKind.InterpolateProperty:
+        ownerOp = lookupElement(elements, op.target);
+        assertIsElementAttributes(ownerOp.attributes);
+        ownerOp.attributes.add(op.bindingKind, op.name, null);
+        break;
+      case OpKind.Listener:
+        ownerOp = lookupElement(elements, op.target);
+        assertIsElementAttributes(ownerOp.attributes);
+        ownerOp.attributes.add(ElementAttributeKind.Binding, op.name, null);
+        if (ownerOp.kind === OpKind.Template) {
+          OpList.remove(op);
+        }
+        break;
+    }
+  }
+}
+
+// bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/chaining.mjs
+var CHAINABLE = /* @__PURE__ */ new Set([
+  Identifiers.elementStart,
+  Identifiers.elementEnd,
+  Identifiers.property,
+  Identifiers.elementContainerStart,
+  Identifiers.elementContainerEnd,
+  Identifiers.elementContainer
+]);
+function phaseChaining(cpl) {
+  for (const [_, view] of cpl.views) {
+    chainOperationsInList(view.create);
+    chainOperationsInList(view.update);
+  }
+}
+function chainOperationsInList(opList) {
+  let chain = null;
+  for (const op of opList) {
+    if (op.kind !== OpKind.Statement || !(op.statement instanceof ExpressionStatement)) {
+      chain = null;
+      continue;
+    }
+    if (!(op.statement.expr instanceof InvokeFunctionExpr) || !(op.statement.expr.fn instanceof ExternalExpr)) {
+      chain = null;
+      continue;
+    }
+    const instruction = op.statement.expr.fn.value;
+    if (!CHAINABLE.has(instruction)) {
+      chain = null;
+      continue;
+    }
+    if (chain !== null && chain.instruction === instruction) {
+      const expression = chain.expression.callFn(op.statement.expr.args, op.statement.expr.sourceSpan, op.statement.expr.pure);
+      chain.expression = expression;
+      chain.op.statement = expression.toStmt();
+      OpList.remove(op);
+    } else {
+      chain = {
+        op,
+        instruction,
+        expression: op.statement.expr
+      };
+    }
+  }
+}
+
 // bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/const_collection.mjs
 function phaseConstCollection(cpl) {
   for (const [_, view] of cpl.views) {
@@ -8343,6 +8783,402 @@ function phaseGenerateAdvance(cpl) {
   }
 }
 
+// bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/nullish_coalescing.mjs
+function phaseNullishCoalescing(cpl) {
+  for (const view of cpl.views.values()) {
+    for (const op of view.ops()) {
+      transformExpressionsInOp(op, (expr) => {
+        if (!(expr instanceof BinaryOperatorExpr) || expr.operator !== BinaryOperator.NullishCoalesce) {
+          return expr;
+        }
+        return new ConditionalExpr(new BinaryOperatorExpr(BinaryOperator.And, new BinaryOperatorExpr(BinaryOperator.NotIdentical, expr.lhs, NULL_EXPR), new BinaryOperatorExpr(BinaryOperator.NotIdentical, expr.lhs, new LiteralExpr(void 0))), expr.lhs, expr.rhs);
+      }, VisitorContextFlag.None);
+    }
+  }
+}
+
+// bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/generate_variables.mjs
+function phaseGenerateVariables(cpl) {
+  recursivelyProcessView(cpl.root, null);
+}
+function recursivelyProcessView(view, parentScope) {
+  const scope = getScopeForView(view, parentScope);
+  if (view.parent !== null) {
+  }
+  for (const op of view.create) {
+    switch (op.kind) {
+      case OpKind.Template:
+        recursivelyProcessView(view.tpl.views.get(op.xref), scope);
+        break;
+      case OpKind.Listener:
+        op.handlerOps.prepend(generateVariablesInScopeForView(view, scope));
+        break;
+    }
+  }
+  const preambleOps = generateVariablesInScopeForView(view, scope);
+  view.update.prepend(preambleOps);
+}
+function getScopeForView(view, parent) {
+  const scope = {
+    view: view.xref,
+    viewContextVariable: {
+      kind: SemanticVariableKind.Context,
+      name: null,
+      view: view.xref
+    },
+    contextVariables: /* @__PURE__ */ new Map(),
+    references: [],
+    parent
+  };
+  for (const identifier of view.contextVariables.keys()) {
+    scope.contextVariables.set(identifier, {
+      kind: SemanticVariableKind.Identifier,
+      name: null,
+      identifier
+    });
+  }
+  for (const op of view.create) {
+    switch (op.kind) {
+      case OpKind.Element:
+      case OpKind.ElementStart:
+      case OpKind.Template:
+        if (!Array.isArray(op.localRefs)) {
+          throw new Error(`AssertionError: expected localRefs to be an array`);
+        }
+        for (let offset = 0; offset < op.localRefs.length; offset++) {
+          scope.references.push({
+            name: op.localRefs[offset].name,
+            targetId: op.xref,
+            offset,
+            variable: {
+              kind: SemanticVariableKind.Identifier,
+              name: null,
+              identifier: op.localRefs[offset].name
+            }
+          });
+        }
+        break;
+    }
+  }
+  return scope;
+}
+function generateVariablesInScopeForView(view, scope) {
+  const newOps = [];
+  if (scope.view !== view.xref) {
+    newOps.push(createVariableOp(view.tpl.allocateXrefId(), scope.viewContextVariable, new NextContextExpr()));
+  }
+  for (const [name, value] of view.tpl.views.get(scope.view).contextVariables) {
+    newOps.push(createVariableOp(view.tpl.allocateXrefId(), scope.contextVariables.get(name), new ReadPropExpr(new ContextExpr(scope.view), value)));
+  }
+  for (const ref of scope.references) {
+    newOps.push(createVariableOp(view.tpl.allocateXrefId(), ref.variable, new ReferenceExpr(ref.targetId, ref.offset)));
+  }
+  if (scope.parent !== null) {
+    newOps.push(...generateVariablesInScopeForView(view, scope.parent));
+  }
+  return newOps;
+}
+
+// bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/local_refs.mjs
+function phaseLocalRefs(cpl) {
+  for (const view of cpl.views.values()) {
+    for (const op of view.create) {
+      switch (op.kind) {
+        case OpKind.ElementStart:
+        case OpKind.Element:
+        case OpKind.Template:
+          if (!Array.isArray(op.localRefs)) {
+            throw new Error(`AssertionError: expected localRefs to be an array still`);
+          }
+          op.numSlotsUsed += op.localRefs.length;
+          if (op.localRefs.length > 0) {
+            const localRefs = serializeLocalRefs(op.localRefs);
+            op.localRefs = cpl.addConst(localRefs);
+          } else {
+            op.localRefs = null;
+          }
+          break;
+      }
+    }
+  }
+}
+function serializeLocalRefs(refs) {
+  const constRefs = [];
+  for (const ref of refs) {
+    constRefs.push(literal(ref.name), literal(ref.target));
+  }
+  return literalArr(constRefs);
+}
+
+// bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/naming.mjs
+function phaseNaming(cpl) {
+  addNamesToView(cpl.root, cpl.componentName, { index: 0 });
+}
+function addNamesToView(view, baseName, state) {
+  if (view.fnName === null) {
+    view.fnName = `${baseName}_Template`;
+  }
+  const varNames = /* @__PURE__ */ new Map();
+  for (const op of view.ops()) {
+    switch (op.kind) {
+      case OpKind.Listener:
+        if (op.handlerFnName === null) {
+          if (op.slot === null) {
+            throw new Error(`Expected a slot to be assigned`);
+          }
+          op.handlerFnName = `${view.fnName}_${op.tag}_${op.name}_${op.slot}_listener`;
+        }
+        break;
+      case OpKind.Variable:
+        varNames.set(op.xref, getVariableName(op.variable, state));
+        break;
+      case OpKind.Template:
+        const childView = view.tpl.views.get(op.xref);
+        if (op.slot === null) {
+          throw new Error(`Expected slot to be assigned`);
+        }
+        const safeTagName = op.tag.replace("-", "_");
+        addNamesToView(childView, `${baseName}_${safeTagName}_${op.slot}`, state);
+        break;
+    }
+  }
+  for (const op of view.ops()) {
+    visitExpressionsInOp(op, (expr) => {
+      if (!(expr instanceof ReadVariableExpr) || expr.name !== null) {
+        return;
+      }
+      if (!varNames.has(expr.xref)) {
+        throw new Error(`Variable ${expr.xref} not yet named`);
+      }
+      expr.name = varNames.get(expr.xref);
+    });
+  }
+}
+function getVariableName(variable2, state) {
+  if (variable2.name === null) {
+    switch (variable2.kind) {
+      case SemanticVariableKind.Identifier:
+        variable2.name = `${variable2.identifier}_${state.index++}`;
+        break;
+      default:
+        variable2.name = `_r${state.index++}`;
+        break;
+    }
+  }
+  return variable2.name;
+}
+
+// bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/next_context_merging.mjs
+function phaseMergeNextContext(cpl) {
+  for (const view of cpl.views.values()) {
+    for (const op of view.create) {
+      if (op.kind === OpKind.Listener) {
+        mergeNextContextsInOps(op.handlerOps);
+      }
+    }
+    mergeNextContextsInOps(view.update);
+  }
+}
+function mergeNextContextsInOps(ops) {
+  for (const op of ops) {
+    if (op.kind !== OpKind.Statement || !(op.statement instanceof ExpressionStatement) || !(op.statement.expr instanceof NextContextExpr)) {
+      continue;
+    }
+    const mergeSteps = op.statement.expr.steps;
+    let tryToMerge = true;
+    for (let candidate = op.next; candidate.kind !== OpKind.ListEnd && tryToMerge; candidate = candidate.next) {
+      visitExpressionsInOp(candidate, (expr, flags) => {
+        if (!isIrExpression(expr)) {
+          return expr;
+        }
+        if (!tryToMerge) {
+          return;
+        }
+        if (flags & VisitorContextFlag.InChildOperation) {
+          return;
+        }
+        switch (expr.kind) {
+          case ExpressionKind.NextContext:
+            expr.steps += mergeSteps;
+            OpList.remove(op);
+            tryToMerge = false;
+            break;
+          case ExpressionKind.GetCurrentView:
+          case ExpressionKind.Reference:
+            tryToMerge = false;
+            break;
+        }
+      });
+    }
+  }
+}
+
+// bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/ng_container.mjs
+var CONTAINER_TAG = "ng-container";
+function phaseNgContainer(cpl) {
+  for (const [_, view] of cpl.views) {
+    const updatedElementXrefs = /* @__PURE__ */ new Set();
+    for (const op of view.create) {
+      if (op.kind === OpKind.ElementStart && op.tag === CONTAINER_TAG) {
+        op.kind = OpKind.ContainerStart;
+        updatedElementXrefs.add(op.xref);
+      }
+      if (op.kind === OpKind.ElementEnd && updatedElementXrefs.has(op.xref)) {
+        op.kind = OpKind.ContainerEnd;
+      }
+    }
+  }
+}
+
+// bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/pipe_creation.mjs
+function phasePipeCreation(cpl) {
+  for (const view of cpl.views.values()) {
+    processPipeBindingsInView(view);
+  }
+}
+function processPipeBindingsInView(view) {
+  for (const updateOp of view.update) {
+    visitExpressionsInOp(updateOp, (expr, flags) => {
+      if (!isIrExpression(expr)) {
+        return;
+      }
+      if (expr.kind !== ExpressionKind.PipeBinding) {
+        return;
+      }
+      if (flags & VisitorContextFlag.InChildOperation) {
+        throw new Error(`AssertionError: pipe bindings should not appear in child expressions`);
+      }
+      if (!hasDependsOnSlotContextTrait(updateOp)) {
+        throw new Error(`AssertionError: pipe binding associated with non-slot operation ${OpKind[updateOp.kind]}`);
+      }
+      addPipeToCreationBlock(view, updateOp.target, expr);
+    });
+  }
+}
+function addPipeToCreationBlock(view, afterTargetXref, binding) {
+  for (let op = view.create.head.next; op.kind !== OpKind.ListEnd; op = op.next) {
+    if (!hasConsumesSlotTrait(op)) {
+      continue;
+    }
+    if (op.xref !== afterTargetXref) {
+      continue;
+    }
+    while (op.next.kind === OpKind.Pipe) {
+      op = op.next;
+    }
+    const pipe2 = createPipeOp(binding.target, binding.name);
+    OpList.insertBefore(pipe2, op.next);
+    return;
+  }
+  throw new Error(`AssertionError: unable to find insertion point for pipe ${binding.name}`);
+}
+
+// bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/pipe_variadic.mjs
+function phasePipeVariadic(cpl) {
+  for (const view of cpl.views.values()) {
+    for (const op of view.update) {
+      transformExpressionsInOp(op, (expr) => {
+        if (!(expr instanceof PipeBindingExpr)) {
+          return expr;
+        }
+        if (expr.args.length <= 4) {
+          return expr;
+        }
+        return new PipeBindingVariadicExpr(expr.target, expr.name, literalArr(expr.args), expr.args.length);
+      }, VisitorContextFlag.None);
+    }
+  }
+}
+
+// bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/pure_function_extraction.mjs
+function phasePureFunctionExtraction(cpl) {
+  for (const view of cpl.views.values()) {
+    for (const op of view.ops()) {
+      visitExpressionsInOp(op, (expr) => {
+        if (!(expr instanceof PureFunctionExpr) || expr.body === null) {
+          return;
+        }
+        const constantDef = new PureFunctionConstant(expr.args.length);
+        expr.fn = cpl.pool.getSharedConstant(constantDef, expr.body);
+        expr.body = null;
+      });
+    }
+  }
+}
+var PureFunctionConstant = class extends GenericKeyFn {
+  constructor(numArgs) {
+    super();
+    this.numArgs = numArgs;
+  }
+  keyOf(expr) {
+    if (expr instanceof PureFunctionParameterExpr) {
+      return `param(${expr.index})`;
+    } else {
+      return super.keyOf(expr);
+    }
+  }
+  toSharedConstantDeclaration(declName, keyExpr) {
+    const fnParams = [];
+    for (let idx = 0; idx < this.numArgs; idx++) {
+      fnParams.push(new FnParam("_p" + idx));
+    }
+    const returnExpr = transformExpressionsInExpression(keyExpr, (expr) => {
+      if (!(expr instanceof PureFunctionParameterExpr)) {
+        return expr;
+      }
+      return variable("_p" + expr.index);
+    }, VisitorContextFlag.None);
+    return new DeclareFunctionStmt(declName, fnParams, [new ReturnStatement(returnExpr)]);
+  }
+};
+
+// bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/pure_literal_structures.mjs
+function phasePureLiteralStructures(cpl) {
+  for (const view of cpl.views.values()) {
+    for (const op of view.update) {
+      transformExpressionsInOp(op, (expr, flags) => {
+        if (flags & VisitorContextFlag.InChildOperation) {
+          return expr;
+        }
+        if (expr instanceof LiteralArrayExpr) {
+          return transformLiteralArray(expr);
+        } else if (expr instanceof LiteralMapExpr) {
+          return transformLiteralMap(expr);
+        }
+        return expr;
+      }, VisitorContextFlag.None);
+    }
+  }
+}
+function transformLiteralArray(expr) {
+  const derivedEntries = [];
+  const nonConstantArgs = [];
+  for (const entry of expr.entries) {
+    if (entry.isConstant()) {
+      derivedEntries.push(entry);
+    } else {
+      const idx = nonConstantArgs.length;
+      nonConstantArgs.push(entry);
+      derivedEntries.push(new PureFunctionParameterExpr(idx));
+    }
+  }
+  return new PureFunctionExpr(literalArr(derivedEntries), nonConstantArgs);
+}
+function transformLiteralMap(expr) {
+  let derivedEntries = [];
+  const nonConstantArgs = [];
+  for (const entry of expr.entries) {
+    if (entry.value.isConstant()) {
+      derivedEntries.push(entry);
+    } else {
+      const idx = nonConstantArgs.length;
+      nonConstantArgs.push(entry.value);
+      derivedEntries.push(new LiteralMapEntry(entry.key, new PureFunctionParameterExpr(idx), entry.quoted));
+    }
+  }
+  return new PureFunctionExpr(literalMap(derivedEntries), nonConstantArgs);
+}
+
 // bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/instruction.mjs
 function element(slot, tag, constIndex, localRefIndex) {
   return elementOrContainerBase(Identifiers.element, slot, tag, constIndex, localRefIndex);
@@ -8712,299 +9548,66 @@ function reifyListenerHandler(view, name, handlerOps) {
   if (lookForEvent.seenEventRead) {
     params.push(new FnParam("$event"));
   }
-  return fn(params, handlerStmts, void 0, void 0, name);
-}
-var LookForEventVisitor = class extends RecursiveAstVisitor {
-  constructor() {
-    super(...arguments);
-    this.seenEventRead = false;
-  }
-  visitReadVarExpr(ast, context) {
-    if (ast.name === "$event") {
-      this.seenEventRead = true;
-    }
-  }
-};
-
-// bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/slot_allocation.mjs
-function phaseSlotAllocation(cpl) {
-  const slotMap = /* @__PURE__ */ new Map();
-  for (const [_, view] of cpl.views) {
-    let slotCount = 0;
-    for (const op of view.create) {
-      if (!hasConsumesSlotTrait(op)) {
-        continue;
-      }
-      op.slot = slotCount;
-      slotMap.set(op.xref, op.slot);
-      slotCount += op.numSlotsUsed;
-    }
-    view.decls = slotCount;
-  }
-  for (const [_, view] of cpl.views) {
-    for (const op of view.ops()) {
-      if (op.kind === OpKind.Template) {
-        const childView = cpl.views.get(op.xref);
-        op.decls = childView.decls;
-      }
-      if (hasUsesSlotIndexTrait(op) && op.slot === null) {
-        if (!slotMap.has(op.target)) {
-          throw new Error(`AssertionError: no slot allocated for ${OpKind[op.kind]} target ${op.target}`);
-        }
-        op.slot = slotMap.get(op.target);
-      }
-      visitExpressionsInOp(op, (expr) => {
-        if (!isIrExpression(expr)) {
-          return;
-        }
-        if (!hasUsesSlotIndexTrait(expr) || expr.slot !== null) {
-          return;
-        }
-        if (!slotMap.has(expr.target)) {
-          throw new Error(`AssertionError: no slot allocated for ${expr.constructor.name} target ${expr.target}`);
-        }
-        expr.slot = slotMap.get(expr.target);
-      });
-    }
-  }
-}
-
-// bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/var_counting.mjs
-function phaseVarCounting(cpl) {
-  for (const [_, view] of cpl.views) {
-    let varCount = 0;
-    for (const op of view.ops()) {
-      if (hasConsumesVarsTrait(op)) {
-        varCount += varsUsedByOp(op);
-      }
-      visitExpressionsInOp(op, (expr) => {
-        if (!isIrExpression(expr)) {
-          return;
-        }
-        if (hasUsesVarOffsetTrait(expr)) {
-          expr.varOffset = varCount;
-        }
-        if (hasConsumesVarsTrait(expr)) {
-          varCount += varsUsedByIrExpression(expr);
-        }
-      });
-    }
-    view.vars = varCount;
-  }
-  for (const [_, view] of cpl.views) {
-    for (const op of view.create) {
-      if (op.kind !== OpKind.Template) {
-        continue;
-      }
-      const childView = cpl.views.get(op.xref);
-      op.vars = childView.vars;
-    }
-  }
-}
-function varsUsedByOp(op) {
-  switch (op.kind) {
-    case OpKind.Property:
-      return 1;
-    case OpKind.InterpolateText:
-      return op.expressions.length;
-    case OpKind.InterpolateProperty:
-      return 1 + op.expressions.length;
-    default:
-      throw new Error(`Unhandled op: ${OpKind[op.kind]}`);
-  }
-}
-function varsUsedByIrExpression(expr) {
-  switch (expr.kind) {
-    case ExpressionKind.PureFunctionExpr:
-      return 1 + expr.args.length;
-    case ExpressionKind.PipeBinding:
-      return 1 + expr.args.length;
-    case ExpressionKind.PipeBindingVariadic:
-      return 1 + expr.numArgs;
-    default:
-      throw new Error(`AssertionError: unhandled ConsumesVarsTrait expression ${expr.constructor.name}`);
-  }
-}
-
-// bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/naming.mjs
-function phaseNaming(cpl) {
-  addNamesToView(cpl.root, cpl.componentName, { index: 0 });
-}
-function addNamesToView(view, baseName, state) {
-  if (view.fnName === null) {
-    view.fnName = `${baseName}_Template`;
-  }
-  const varNames = /* @__PURE__ */ new Map();
-  for (const op of view.ops()) {
-    switch (op.kind) {
-      case OpKind.Listener:
-        if (op.handlerFnName === null) {
-          if (op.slot === null) {
-            throw new Error(`Expected a slot to be assigned`);
-          }
-          op.handlerFnName = `${view.fnName}_${op.tag}_${op.name}_${op.slot}_listener`;
-        }
-        break;
-      case OpKind.Variable:
-        varNames.set(op.xref, getVariableName(op.variable, state));
-        break;
-      case OpKind.Template:
-        const childView = view.tpl.views.get(op.xref);
-        if (op.slot === null) {
-          throw new Error(`Expected slot to be assigned`);
-        }
-        const safeTagName = op.tag.replace("-", "_");
-        addNamesToView(childView, `${baseName}_${safeTagName}_${op.slot}`, state);
-        break;
-    }
-  }
-  for (const op of view.ops()) {
-    visitExpressionsInOp(op, (expr) => {
-      if (!(expr instanceof ReadVariableExpr) || expr.name !== null) {
-        return;
-      }
-      if (!varNames.has(expr.xref)) {
-        throw new Error(`Variable ${expr.xref} not yet named`);
-      }
-      expr.name = varNames.get(expr.xref);
-    });
-  }
-}
-function getVariableName(variable2, state) {
-  if (variable2.name === null) {
-    switch (variable2.kind) {
-      case SemanticVariableKind.Identifier:
-        variable2.name = `${variable2.identifier}_${state.index++}`;
-        break;
-      default:
-        variable2.name = `_r${state.index++}`;
-        break;
-    }
-  }
-  return variable2.name;
-}
-
-// bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/local_refs.mjs
-function phaseLocalRefs(cpl) {
-  for (const view of cpl.views.values()) {
-    for (const op of view.create) {
-      switch (op.kind) {
-        case OpKind.ElementStart:
-        case OpKind.Element:
-        case OpKind.Template:
-          if (!Array.isArray(op.localRefs)) {
-            throw new Error(`AssertionError: expected localRefs to be an array still`);
-          }
-          op.numSlotsUsed += op.localRefs.length;
-          if (op.localRefs.length > 0) {
-            const localRefs = serializeLocalRefs(op.localRefs);
-            op.localRefs = cpl.addConst(localRefs);
-          } else {
-            op.localRefs = null;
-          }
-          break;
-      }
-    }
-  }
-}
-function serializeLocalRefs(refs) {
-  const constRefs = [];
-  for (const ref of refs) {
-    constRefs.push(literal(ref.name), literal(ref.target));
-  }
-  return literalArr(constRefs);
-}
-
-// bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/generate_variables.mjs
-function phaseGenerateVariables(cpl) {
-  recursivelyProcessView(cpl.root, null);
+  return fn(params, handlerStmts, void 0, void 0, name);
 }
-function recursivelyProcessView(view, parentScope) {
-  const scope = getScopeForView(view, parentScope);
-  if (view.parent !== null) {
+var LookForEventVisitor = class extends RecursiveAstVisitor {
+  constructor() {
+    super(...arguments);
+    this.seenEventRead = false;
   }
-  for (const op of view.create) {
-    switch (op.kind) {
-      case OpKind.Template:
-        recursivelyProcessView(view.tpl.views.get(op.xref), scope);
-        break;
-      case OpKind.Listener:
-        op.handlerOps.prepend(generateVariablesInScopeForView(view, scope));
-        break;
+  visitReadVarExpr(ast, context) {
+    if (ast.name === "$event") {
+      this.seenEventRead = true;
     }
   }
-  const preambleOps = generateVariablesInScopeForView(view, scope);
-  view.update.prepend(preambleOps);
-}
-function getScopeForView(view, parent) {
-  const scope = {
-    view: view.xref,
-    viewContextVariable: {
-      kind: SemanticVariableKind.Context,
-      name: null,
-      view: view.xref
-    },
-    contextVariables: /* @__PURE__ */ new Map(),
-    references: [],
-    parent
-  };
-  for (const identifier of view.contextVariables.keys()) {
-    scope.contextVariables.set(identifier, {
-      kind: SemanticVariableKind.Identifier,
-      name: null,
-      identifier
-    });
+};
+
+// bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/resolve_contexts.mjs
+function phaseResolveContexts(cpl) {
+  for (const view of cpl.views.values()) {
+    processLexicalScope(view, view.create);
+    processLexicalScope(view, view.update);
   }
-  for (const op of view.create) {
+}
+function processLexicalScope(view, ops) {
+  const scope = /* @__PURE__ */ new Map();
+  scope.set(view.xref, variable("ctx"));
+  for (const op of ops) {
     switch (op.kind) {
-      case OpKind.Element:
-      case OpKind.ElementStart:
-      case OpKind.Template:
-        if (!Array.isArray(op.localRefs)) {
-          throw new Error(`AssertionError: expected localRefs to be an array`);
-        }
-        for (let offset = 0; offset < op.localRefs.length; offset++) {
-          scope.references.push({
-            name: op.localRefs[offset].name,
-            targetId: op.xref,
-            offset,
-            variable: {
-              kind: SemanticVariableKind.Identifier,
-              name: null,
-              identifier: op.localRefs[offset].name
-            }
-          });
+      case OpKind.Variable:
+        switch (op.variable.kind) {
+          case SemanticVariableKind.Context:
+            scope.set(op.variable.view, new ReadVariableExpr(op.xref));
+            break;
         }
         break;
+      case OpKind.Listener:
+        processLexicalScope(view, op.handlerOps);
+        break;
     }
   }
-  return scope;
-}
-function generateVariablesInScopeForView(view, scope) {
-  const newOps = [];
-  if (scope.view !== view.xref) {
-    newOps.push(createVariableOp(view.tpl.allocateXrefId(), scope.viewContextVariable, new NextContextExpr()));
-  }
-  for (const [name, value] of view.tpl.views.get(scope.view).contextVariables) {
-    newOps.push(createVariableOp(view.tpl.allocateXrefId(), scope.contextVariables.get(name), new ReadPropExpr(new ContextExpr(scope.view), value)));
-  }
-  for (const ref of scope.references) {
-    newOps.push(createVariableOp(view.tpl.allocateXrefId(), ref.variable, new ReferenceExpr(ref.targetId, ref.offset)));
-  }
-  if (scope.parent !== null) {
-    newOps.push(...generateVariablesInScopeForView(view, scope.parent));
+  for (const op of ops) {
+    transformExpressionsInOp(op, (expr) => {
+      if (expr instanceof ContextExpr) {
+        if (!scope.has(expr.view)) {
+          throw new Error(`No context found for reference to view ${expr.view} from view ${view.xref}`);
+        }
+        return scope.get(expr.view);
+      } else {
+        return expr;
+      }
+    }, VisitorContextFlag.None);
   }
-  return newOps;
 }
 
 // bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/resolve_names.mjs
 function phaseResolveNames(cpl) {
   for (const [_, view] of cpl.views) {
-    processLexicalScope(view, view.create, null);
-    processLexicalScope(view, view.update, null);
+    processLexicalScope2(view, view.create, null);
+    processLexicalScope2(view, view.update, null);
   }
 }
-function processLexicalScope(view, ops, savedView) {
+function processLexicalScope2(view, ops, savedView) {
   const scope = /* @__PURE__ */ new Map();
   for (const op of ops) {
     switch (op.kind) {
@@ -9025,7 +9628,7 @@ function processLexicalScope(view, ops, savedView) {
         }
         break;
       case OpKind.Listener:
-        processLexicalScope(view, op.handlerOps, savedView);
+        processLexicalScope2(view, op.handlerOps, savedView);
         break;
     }
   }
@@ -9050,41 +9653,79 @@ function processLexicalScope(view, ops, savedView) {
   }
 }
 
-// bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/resolve_contexts.mjs
-function phaseResolveContexts(cpl) {
+// bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/save_restore_view.mjs
+function phaseSaveRestoreView(cpl) {
   for (const view of cpl.views.values()) {
-    processLexicalScope2(view, view.create);
-    processLexicalScope2(view, view.update);
+    if (view === cpl.root) {
+      continue;
+    }
+    view.create.prepend([
+      createVariableOp(view.tpl.allocateXrefId(), {
+        kind: SemanticVariableKind.SavedView,
+        name: null,
+        view: view.xref
+      }, new GetCurrentViewExpr())
+    ]);
+    for (const op of view.create) {
+      if (op.kind !== OpKind.Listener) {
+        continue;
+      }
+      op.handlerOps.prepend([
+        createVariableOp(view.tpl.allocateXrefId(), {
+          kind: SemanticVariableKind.Context,
+          name: null,
+          view: view.xref
+        }, new RestoreViewExpr(view.xref))
+      ]);
+      for (const handlerOp of op.handlerOps) {
+        if (handlerOp.kind === OpKind.Statement && handlerOp.statement instanceof ReturnStatement) {
+          handlerOp.statement.value = new ResetViewExpr(handlerOp.statement.value);
+        }
+      }
+    }
   }
 }
-function processLexicalScope2(view, ops) {
-  const scope = /* @__PURE__ */ new Map();
-  scope.set(view.xref, variable("ctx"));
-  for (const op of ops) {
-    switch (op.kind) {
-      case OpKind.Variable:
-        switch (op.variable.kind) {
-          case SemanticVariableKind.Context:
-            scope.set(op.variable.view, new ReadVariableExpr(op.xref));
-            break;
-        }
-        break;
-      case OpKind.Listener:
-        processLexicalScope2(view, op.handlerOps);
-        break;
+
+// bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/slot_allocation.mjs
+function phaseSlotAllocation(cpl) {
+  const slotMap = /* @__PURE__ */ new Map();
+  for (const [_, view] of cpl.views) {
+    let slotCount = 0;
+    for (const op of view.create) {
+      if (!hasConsumesSlotTrait(op)) {
+        continue;
+      }
+      op.slot = slotCount;
+      slotMap.set(op.xref, op.slot);
+      slotCount += op.numSlotsUsed;
     }
+    view.decls = slotCount;
   }
-  for (const op of ops) {
-    transformExpressionsInOp(op, (expr) => {
-      if (expr instanceof ContextExpr) {
-        if (!scope.has(expr.view)) {
-          throw new Error(`No context found for reference to view ${expr.view} from view ${view.xref}`);
+  for (const [_, view] of cpl.views) {
+    for (const op of view.ops()) {
+      if (op.kind === OpKind.Template) {
+        const childView = cpl.views.get(op.xref);
+        op.decls = childView.decls;
+      }
+      if (hasUsesSlotIndexTrait(op) && op.slot === null) {
+        if (!slotMap.has(op.target)) {
+          throw new Error(`AssertionError: no slot allocated for ${OpKind[op.kind]} target ${op.target}`);
         }
-        return scope.get(expr.view);
-      } else {
-        return expr;
+        op.slot = slotMap.get(op.target);
       }
-    }, VisitorContextFlag.None);
+      visitExpressionsInOp(op, (expr) => {
+        if (!isIrExpression(expr)) {
+          return;
+        }
+        if (!hasUsesSlotIndexTrait(expr) || expr.slot !== null) {
+          return;
+        }
+        if (!slotMap.has(expr.target)) {
+          throw new Error(`AssertionError: no slot allocated for ${expr.constructor.name} target ${expr.target}`);
+        }
+        expr.slot = slotMap.get(expr.target);
+      });
+    }
   }
 }
 
@@ -9298,319 +9939,79 @@ function allowConservativeInlining(decl, target) {
   }
 }
 
-// bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/chaining.mjs
-var CHAINABLE = /* @__PURE__ */ new Set([
-  Identifiers.elementStart,
-  Identifiers.elementEnd,
-  Identifiers.property,
-  Identifiers.elementContainerStart,
-  Identifiers.elementContainerEnd,
-  Identifiers.elementContainer
-]);
-function phaseChaining(cpl) {
+// bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/expand_safe_reads.mjs
+function phaseExpandSafeReads(cpl) {
   for (const [_, view] of cpl.views) {
-    chainOperationsInList(view.create);
-    chainOperationsInList(view.update);
-  }
-}
-function chainOperationsInList(opList) {
-  let chain = null;
-  for (const op of opList) {
-    if (op.kind !== OpKind.Statement || !(op.statement instanceof ExpressionStatement)) {
-      chain = null;
-      continue;
-    }
-    if (!(op.statement.expr instanceof InvokeFunctionExpr) || !(op.statement.expr.fn instanceof ExternalExpr)) {
-      chain = null;
-      continue;
-    }
-    const instruction = op.statement.expr.fn.value;
-    if (!CHAINABLE.has(instruction)) {
-      chain = null;
-      continue;
-    }
-    if (chain !== null && chain.instruction === instruction) {
-      const expression = chain.expression.callFn(op.statement.expr.args, op.statement.expr.sourceSpan, op.statement.expr.pure);
-      chain.expression = expression;
-      chain.op.statement = expression.toStmt();
-      OpList.remove(op);
-    } else {
-      chain = {
-        op,
-        instruction,
-        expression: op.statement.expr
-      };
-    }
-  }
-}
-
-// bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/next_context_merging.mjs
-function phaseMergeNextContext(cpl) {
-  for (const view of cpl.views.values()) {
-    for (const op of view.create) {
-      if (op.kind === OpKind.Listener) {
-        mergeNextContextsInOps(op.handlerOps);
-      }
+    for (const op of view.ops()) {
+      transformExpressionsInOp(op, safeTransform, VisitorContextFlag.None);
+      transformExpressionsInOp(op, ternaryTransform, VisitorContextFlag.None);
     }
-    mergeNextContextsInOps(view.update);
   }
 }
-function mergeNextContextsInOps(ops) {
-  for (const op of ops) {
-    if (op.kind !== OpKind.Statement || !(op.statement instanceof ExpressionStatement) || !(op.statement.expr instanceof NextContextExpr)) {
-      continue;
-    }
-    const mergeSteps = op.statement.expr.steps;
-    let tryToMerge = true;
-    for (let candidate = op.next; candidate.kind !== OpKind.ListEnd && tryToMerge; candidate = candidate.next) {
-      visitExpressionsInOp(candidate, (expr, flags) => {
-        if (!isIrExpression(expr)) {
-          return expr;
-        }
-        if (!tryToMerge) {
-          return;
-        }
-        if (flags & VisitorContextFlag.InChildOperation) {
-          return;
-        }
-        switch (expr.kind) {
-          case ExpressionKind.NextContext:
-            expr.steps += mergeSteps;
-            OpList.remove(op);
-            tryToMerge = false;
-            break;
-          case ExpressionKind.GetCurrentView:
-          case ExpressionKind.Reference:
-            tryToMerge = false;
-            break;
-        }
-      });
-    }
-  }
+function isSafeAccessExpression(e) {
+  return e instanceof SafePropertyReadExpr || e instanceof SafeKeyedReadExpr;
 }
-
-// bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/ng_container.mjs
-var CONTAINER_TAG = "ng-container";
-function phaseNgContainer(cpl) {
-  for (const [_, view] of cpl.views) {
-    const updatedElementXrefs = /* @__PURE__ */ new Set();
-    for (const op of view.create) {
-      if (op.kind === OpKind.ElementStart && op.tag === CONTAINER_TAG) {
-        op.kind = OpKind.ContainerStart;
-        updatedElementXrefs.add(op.xref);
-      }
-      if (op.kind === OpKind.ElementEnd && updatedElementXrefs.has(op.xref)) {
-        op.kind = OpKind.ContainerEnd;
-      }
-    }
-  }
+function isUnsafeAccessExpression(e) {
+  return e instanceof ReadPropExpr || e instanceof ReadKeyExpr;
 }
-
-// bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/save_restore_view.mjs
-function phaseSaveRestoreView(cpl) {
-  for (const view of cpl.views.values()) {
-    if (view === cpl.root) {
-      continue;
-    }
-    view.create.prepend([
-      createVariableOp(view.tpl.allocateXrefId(), {
-        kind: SemanticVariableKind.SavedView,
-        name: null,
-        view: view.xref
-      }, new GetCurrentViewExpr())
-    ]);
-    for (const op of view.create) {
-      if (op.kind !== OpKind.Listener) {
-        continue;
-      }
-      op.handlerOps.prepend([
-        createVariableOp(view.tpl.allocateXrefId(), {
-          kind: SemanticVariableKind.Context,
-          name: null,
-          view: view.xref
-        }, new RestoreViewExpr(view.xref))
-      ]);
-      for (const handlerOp of op.handlerOps) {
-        if (handlerOp.kind === OpKind.Statement && handlerOp.statement instanceof ReturnStatement) {
-          handlerOp.statement.value = new ResetViewExpr(handlerOp.statement.value);
-        }
-      }
-    }
-  }
+function isAccessExpression(e) {
+  return isSafeAccessExpression(e) || isUnsafeAccessExpression(e);
 }
-
-// bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/pure_function_extraction.mjs
-function phasePureFunctionExtraction(cpl) {
-  for (const view of cpl.views.values()) {
-    for (const op of view.ops()) {
-      visitExpressionsInOp(op, (expr) => {
-        if (!(expr instanceof PureFunctionExpr) || expr.body === null) {
-          return;
-        }
-        const constantDef = new PureFunctionConstant(expr.args.length);
-        expr.fn = cpl.pool.getSharedConstant(constantDef, expr.body);
-        expr.body = null;
-      });
+function deepestSafeTernary(e) {
+  if (isAccessExpression(e) && e.receiver instanceof SafeTernaryExpr) {
+    let st = e.receiver;
+    while (st.expr instanceof SafeTernaryExpr) {
+      st = st.expr;
     }
+    return st;
   }
+  return null;
 }
-var PureFunctionConstant = class extends GenericKeyFn {
-  constructor(numArgs) {
-    super();
-    this.numArgs = numArgs;
-  }
-  keyOf(expr) {
-    if (expr instanceof PureFunctionParameterExpr) {
-      return `param(${expr.index})`;
-    } else {
-      return super.keyOf(expr);
-    }
-  }
-  toSharedConstantDeclaration(declName, keyExpr) {
-    const fnParams = [];
-    for (let idx = 0; idx < this.numArgs; idx++) {
-      fnParams.push(new FnParam("_p" + idx));
-    }
-    const returnExpr = transformExpressionsInExpression(keyExpr, (expr) => {
-      if (!(expr instanceof PureFunctionParameterExpr)) {
-        return expr;
-      }
-      return variable("_p" + expr.index);
-    }, VisitorContextFlag.None);
-    return new DeclareFunctionStmt(declName, fnParams, [new ReturnStatement(returnExpr)]);
-  }
-};
-
-// bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/pipe_creation.mjs
-function phasePipeCreation(cpl) {
-  for (const view of cpl.views.values()) {
-    processPipeBindingsInView(view);
+function safeTransform(e) {
+  if (e instanceof SafeInvokeFunctionExpr) {
+    return new InvokeFunctionExpr(e.receiver, e.args);
   }
-}
-function processPipeBindingsInView(view) {
-  for (const updateOp of view.update) {
-    visitExpressionsInOp(updateOp, (expr, flags) => {
-      if (!isIrExpression(expr)) {
-        return;
-      }
-      if (expr.kind !== ExpressionKind.PipeBinding) {
-        return;
-      }
-      if (flags & VisitorContextFlag.InChildOperation) {
-        throw new Error(`AssertionError: pipe bindings should not appear in child expressions`);
-      }
-      if (!hasDependsOnSlotContextTrait(updateOp)) {
-        throw new Error(`AssertionError: pipe binding associated with non-slot operation ${OpKind[updateOp.kind]}`);
-      }
-      addPipeToCreationBlock(view, updateOp.target, expr);
-    });
+  if (!isAccessExpression(e)) {
+    return e;
   }
-}
-function addPipeToCreationBlock(view, afterTargetXref, binding) {
-  for (let op = view.create.head.next; op.kind !== OpKind.ListEnd; op = op.next) {
-    if (!hasConsumesSlotTrait(op)) {
-      continue;
-    }
-    if (op.xref !== afterTargetXref) {
-      continue;
+  const dst = deepestSafeTernary(e);
+  if (dst) {
+    if (e instanceof ReadPropExpr) {
+      dst.expr = dst.expr.prop(e.name);
+      return e.receiver;
     }
-    while (op.next.kind === OpKind.Pipe) {
-      op = op.next;
+    if (e instanceof ReadKeyExpr) {
+      dst.expr = dst.expr.key(e.index);
+      return e.receiver;
     }
-    const pipe2 = createPipeOp(binding.target, binding.name);
-    OpList.insertBefore(pipe2, op.next);
-    return;
-  }
-  throw new Error(`AssertionError: unable to find insertion point for pipe ${binding.name}`);
-}
-
-// bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/pipe_variadic.mjs
-function phasePipeVariadic(cpl) {
-  for (const view of cpl.views.values()) {
-    for (const op of view.update) {
-      transformExpressionsInOp(op, (expr) => {
-        if (!(expr instanceof PipeBindingExpr)) {
-          return expr;
-        }
-        if (expr.args.length <= 4) {
-          return expr;
-        }
-        return new PipeBindingVariadicExpr(expr.target, expr.name, literalArr(expr.args), expr.args.length);
-      }, VisitorContextFlag.None);
+    if (e instanceof SafePropertyReadExpr) {
+      dst.expr = new SafeTernaryExpr(dst.expr.clone(), dst.expr.prop(e.name));
+      return e.receiver;
     }
-  }
-}
-
-// bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/pure_literal_structures.mjs
-function phasePureLiteralStructures(cpl) {
-  for (const view of cpl.views.values()) {
-    for (const op of view.update) {
-      transformExpressionsInOp(op, (expr, flags) => {
-        if (flags & VisitorContextFlag.InChildOperation) {
-          return expr;
-        }
-        if (expr instanceof LiteralArrayExpr) {
-          return transformLiteralArray(expr);
-        } else if (expr instanceof LiteralMapExpr) {
-          return transformLiteralMap(expr);
-        }
-        return expr;
-      }, VisitorContextFlag.None);
+    if (e instanceof SafeKeyedReadExpr) {
+      dst.expr = new SafeTernaryExpr(dst.expr.clone(), dst.expr.key(e.index));
+      return e.receiver;
     }
-  }
-}
-function transformLiteralArray(expr) {
-  const derivedEntries = [];
-  const nonConstantArgs = [];
-  for (const entry of expr.entries) {
-    if (entry.isConstant()) {
-      derivedEntries.push(entry);
-    } else {
-      const idx = nonConstantArgs.length;
-      nonConstantArgs.push(entry);
-      derivedEntries.push(new PureFunctionParameterExpr(idx));
+  } else {
+    if (e instanceof SafePropertyReadExpr) {
+      return new SafeTernaryExpr(e.receiver.clone(), e.receiver.prop(e.name));
     }
-  }
-  return new PureFunctionExpr(literalArr(derivedEntries), nonConstantArgs);
-}
-function transformLiteralMap(expr) {
-  let derivedEntries = [];
-  const nonConstantArgs = [];
-  for (const entry of expr.entries) {
-    if (entry.value.isConstant()) {
-      derivedEntries.push(entry);
-    } else {
-      const idx = nonConstantArgs.length;
-      nonConstantArgs.push(entry.value);
-      derivedEntries.push(new LiteralMapEntry(entry.key, new PureFunctionParameterExpr(idx), entry.quoted));
+    if (e instanceof SafeKeyedReadExpr) {
+      return new SafeTernaryExpr(e.receiver.clone(), e.receiver.key(e.index));
     }
   }
-  return new PureFunctionExpr(literalMap(derivedEntries), nonConstantArgs);
+  return e;
 }
-
-// bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/align_pipe_variadic_var_offset.mjs
-function phaseAlignPipeVariadicVarOffset(cpl) {
-  for (const view of cpl.views.values()) {
-    for (const op of view.update) {
-      visitExpressionsInOp(op, (expr) => {
-        if (!(expr instanceof PipeBindingVariadicExpr)) {
-          return expr;
-        }
-        if (!(expr.args instanceof PureFunctionExpr)) {
-          return expr;
-        }
-        if (expr.varOffset === null || expr.args.varOffset === null) {
-          throw new Error(`Must run after variable counting`);
-        }
-        expr.varOffset = expr.args.varOffset;
-        expr.args.varOffset = expr.varOffset + varsUsedByIrExpression(expr);
-      });
-    }
+function ternaryTransform(e) {
+  if (!(e instanceof SafeTernaryExpr)) {
+    return e;
   }
+  return new ConditionalExpr(new BinaryOperatorExpr(BinaryOperator.Equals, e.guard, NULL_EXPR), NULL_EXPR, e.expr);
 }
 
 // bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/emit.mjs
 function transformTemplate(cpl) {
+  phaseAttributeExtraction(cpl, true);
   phasePipeCreation(cpl);
   phasePipeVariadic(cpl);
   phasePureLiteralStructures(cpl);
@@ -9620,6 +10021,8 @@ function transformTemplate(cpl) {
   phaseResolveContexts(cpl);
   phaseLocalRefs(cpl);
   phaseConstCollection(cpl);
+  phaseNullishCoalescing(cpl);
+  phaseExpandSafeReads(cpl);
   phaseSlotAllocation(cpl);
   phaseVarCounting(cpl);
   phaseGenerateAdvance(cpl);
@@ -9799,7 +10202,6 @@ function ingestElement(view, element2) {
   const id = view.tpl.allocateXrefId();
   const startOp = createElementStartOp(element2.name, id);
   view.create.push(startOp);
-  ingestAttributes(startOp, element2);
   ingestBindings(view, startOp, element2);
   ingestReferences(startOp, element2);
   ingestNodes(view, element2.children);
@@ -9810,7 +10212,6 @@ function ingestTemplate(view, tmpl) {
   const childView = view.tpl.allocateView(view.xref);
   const tplOp = createTemplateOp(childView.xref, (_a2 = tmpl.tagName) != null ? _a2 : "ng-template");
   view.create.push(tplOp);
-  ingestAttributes(tplOp, tmpl);
   ingestBindings(view, tplOp, tmpl);
   ingestReferences(tplOp, tmpl);
   ingestNodes(childView, tmpl.children);
@@ -9876,78 +10277,84 @@ function convertAst(ast, cpl) {
     return new LiteralArrayExpr(ast.expressions.map((expr) => convertAst(expr, cpl)));
   } else if (ast instanceof Conditional) {
     return new ConditionalExpr(convertAst(ast.condition, cpl), convertAst(ast.trueExp, cpl), convertAst(ast.falseExp, cpl));
+  } else if (ast instanceof NonNullAssert) {
+    return convertAst(ast.expression, cpl);
   } else if (ast instanceof BindingPipe) {
     return new PipeBindingExpr(cpl.allocateXrefId(), ast.name, [
       convertAst(ast.exp, cpl),
       ...ast.args.map((arg) => convertAst(arg, cpl))
     ]);
+  } else if (ast instanceof SafeKeyedRead) {
+    return new SafeKeyedReadExpr(convertAst(ast.receiver, cpl), convertAst(ast.key, cpl));
+  } else if (ast instanceof SafePropertyRead) {
+    return new SafePropertyReadExpr(convertAst(ast.receiver, cpl), ast.name);
+  } else if (ast instanceof SafeCall) {
+    return new SafeInvokeFunctionExpr(convertAst(ast.receiver, cpl), ast.args.map((a) => convertAst(a, cpl)));
   } else {
     throw new Error(`Unhandled expression type: ${ast.constructor.name}`);
   }
 }
-function ingestAttributes(op, element2) {
-  assertIsElementAttributes(op.attributes);
+function ingestBindings(view, op, element2) {
+  if (element2 instanceof Template) {
+    for (const attr of element2.templateAttrs) {
+      if (attr instanceof TextAttribute) {
+        view.update.push(createAttributeOp(op.xref, ElementAttributeKind.Template, attr.name, literal(attr.value)));
+      } else {
+        ingestPropertyBinding(view, op.xref, ElementAttributeKind.Template, attr);
+      }
+    }
+  }
   for (const attr of element2.attributes) {
-    op.attributes.add(ElementAttributeKind.Attribute, attr.name, literal(attr.value));
+    view.update.push(createAttributeOp(op.xref, ElementAttributeKind.Attribute, attr.name, literal(attr.value)));
   }
   for (const input of element2.inputs) {
-    op.attributes.add(ElementAttributeKind.Binding, input.name, null);
+    ingestPropertyBinding(view, op.xref, ElementAttributeKind.Binding, input);
   }
   for (const output of element2.outputs) {
-    op.attributes.add(ElementAttributeKind.Binding, output.name, null);
-  }
-  if (element2 instanceof Template) {
-    for (const attr of element2.templateAttrs) {
-      op.attributes.add(ElementAttributeKind.Template, attr.name, null);
+    const listenerOp = createListenerOp(op.xref, output.name, op.tag);
+    let inputExprs;
+    let handler = output.handler;
+    if (handler instanceof ASTWithSource) {
+      handler = handler.ast;
+    }
+    if (handler instanceof Chain) {
+      inputExprs = handler.expressions;
+    } else {
+      inputExprs = [handler];
     }
-  }
-}
-function ingestBindings(view, op, element2) {
-  if (element2 instanceof Template) {
-    for (const attr of [...element2.templateAttrs, ...element2.inputs]) {
-      if (!(attr instanceof BoundAttribute)) {
-        continue;
-      }
-      ingestPropertyBinding(view, op.xref, attr.name, attr.value);
+    if (inputExprs.length === 0) {
+      throw new Error("Expected listener to have non-empty expression list.");
     }
-  } else {
-    for (const input of element2.inputs) {
-      ingestPropertyBinding(view, op.xref, input.name, input.value);
-    }
-    for (const output of element2.outputs) {
-      const listenerOp = createListenerOp(op.xref, output.name, op.tag);
-      let inputExprs;
-      let handler = output.handler;
-      if (handler instanceof ASTWithSource) {
-        handler = handler.ast;
-      }
-      if (handler instanceof Chain) {
-        inputExprs = handler.expressions;
-      } else {
-        inputExprs = [handler];
-      }
-      if (inputExprs.length === 0) {
-        throw new Error("Expected listener to have non-empty expression list.");
-      }
-      const expressions = inputExprs.map((expr) => convertAst(expr, view.tpl));
-      const returnExpr = expressions.pop();
-      for (const expr of expressions) {
-        const stmtOp = createStatementOp(new ExpressionStatement(expr));
-        listenerOp.handlerOps.push(stmtOp);
-      }
-      listenerOp.handlerOps.push(createStatementOp(new ReturnStatement(returnExpr)));
-      view.create.push(listenerOp);
+    const expressions = inputExprs.map((expr) => convertAst(expr, view.tpl));
+    const returnExpr = expressions.pop();
+    for (const expr of expressions) {
+      const stmtOp = createStatementOp(new ExpressionStatement(expr));
+      listenerOp.handlerOps.push(stmtOp);
     }
+    listenerOp.handlerOps.push(createStatementOp(new ReturnStatement(returnExpr)));
+    view.create.push(listenerOp);
   }
 }
-function ingestPropertyBinding(view, xref, name, value) {
+function ingestPropertyBinding(view, xref, bindingKind, { name, value, type }) {
   if (value instanceof ASTWithSource) {
     value = value.ast;
   }
   if (value instanceof Interpolation) {
-    view.update.push(createInterpolatePropertyOp(xref, name, value.strings, value.expressions.map((expr) => convertAst(expr, view.tpl))));
+    switch (type) {
+      case 0:
+        view.update.push(createInterpolatePropertyOp(xref, bindingKind, name, value.strings, value.expressions.map((expr) => convertAst(expr, view.tpl))));
+        break;
+      default:
+        throw Error(`Interpolated property binding type not handled: ${type}`);
+    }
   } else {
-    view.update.push(createPropertyOp(xref, name, convertAst(value, view.tpl)));
+    switch (type) {
+      case 0:
+        view.update.push(createPropertyOp(xref, bindingKind, name, convertAst(value, view.tpl)));
+        break;
+      default:
+        throw Error(`Property binding type not handled: ${type}`);
+    }
   }
 }
 function ingestReferences(op, element2) {
@@ -19406,7 +19813,7 @@ function publishFacade(global2) {
 }
 
 // bazel-out/k8-fastbuild/bin/packages/compiler/src/version.mjs
-var VERSION2 = new Version("16.1.2");
+var VERSION2 = new Version("16.2.0-next.0");
 
 // bazel-out/k8-fastbuild/bin/packages/compiler/src/i18n/extractor_merger.mjs
 var _I18N_ATTR = "i18n";
@@ -20725,7 +21132,7 @@ var MINIMUM_PARTIAL_LINKER_VERSION = "12.0.0";
 function compileDeclareClassMetadata(metadata) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION));
-  definitionMap.set("version", literal("16.1.2"));
+  definitionMap.set("version", literal("16.2.0-next.0"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", metadata.type);
   definitionMap.set("decorators", metadata.decorators);
@@ -20794,7 +21201,7 @@ function createDirectiveDefinitionMap(meta) {
   var _a2;
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION2));
-  definitionMap.set("version", literal("16.1.2"));
+  definitionMap.set("version", literal("16.2.0-next.0"));
   definitionMap.set("type", meta.type.value);
   if (meta.isStandalone) {
     definitionMap.set("isStandalone", literal(meta.isStandalone));
@@ -20979,7 +21386,7 @@ var MINIMUM_PARTIAL_LINKER_VERSION3 = "12.0.0";
 function compileDeclareFactoryFunction(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION3));
-  definitionMap.set("version", literal("16.1.2"));
+  definitionMap.set("version", literal("16.2.0-next.0"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   definitionMap.set("deps", compileDependencies(meta.deps));
@@ -21002,7 +21409,7 @@ function compileDeclareInjectableFromMetadata(meta) {
 function createInjectableDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION4));
-  definitionMap.set("version", literal("16.1.2"));
+  definitionMap.set("version", literal("16.2.0-next.0"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   if (meta.providedIn !== void 0) {
@@ -21040,7 +21447,7 @@ function compileDeclareInjectorFromMetadata(meta) {
 function createInjectorDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION5));
-  definitionMap.set("version", literal("16.1.2"));
+  definitionMap.set("version", literal("16.2.0-next.0"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   definitionMap.set("providers", meta.providers);
@@ -21061,7 +21468,7 @@ function compileDeclareNgModuleFromMetadata(meta) {
 function createNgModuleDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION6));
-  definitionMap.set("version", literal("16.1.2"));
+  definitionMap.set("version", literal("16.2.0-next.0"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   if (meta.bootstrap.length > 0) {
@@ -21096,7 +21503,7 @@ function compileDeclarePipeFromMetadata(meta) {
 function createPipeDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION7));
-  definitionMap.set("version", literal("16.1.2"));
+  definitionMap.set("version", literal("16.2.0-next.0"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   if (meta.isStandalone) {
@@ -21113,7 +21520,7 @@ function createPipeDefinitionMap(meta) {
 publishFacade(_global);
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/version.mjs
-var VERSION3 = new Version("16.1.2");
+var VERSION3 = new Version("16.2.0-next.0");
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/transformers/api.mjs
 var EmitFlags;
@@ -32747,7 +33154,7 @@ function tsCallMethod(receiver, methodName, args = []) {
     args
   );
 }
-function isAccessExpression(node) {
+function isAccessExpression2(node) {
   return import_typescript70.default.isPropertyAccessExpression(node) || import_typescript70.default.isElementAccessExpression(node);
 }
 
@@ -35410,7 +35817,7 @@ var SymbolBuilder = class {
       expectedAccess = bindingPropertyNames[0].classPropertyName;
     }
     function filter(n) {
-      if (!isAccessExpression(n)) {
+      if (!isAccessExpression2(n)) {
         return false;
       }
       if (import_typescript84.default.isPropertyAccessExpression(n)) {
@@ -35489,7 +35896,7 @@ var SymbolBuilder = class {
     const nodes = findAllMatchingNodes(this.typeCheckBlock, { withSpan: binding.sourceSpan, filter: isAssignment });
     const bindings = [];
     for (const node of nodes) {
-      if (!isAccessExpression(node.left)) {
+      if (!isAccessExpression2(node.left)) {
         continue;
       }
       const symbolInfo = this.getSymbolOfTsNode(node.left);