@angular-eslint/bundled-angular-compiler 21.2.1-alpha.8 → 21.2.1-alpha.9

package/dist/index.js

@@ -26,7 +26,9 @@ __export(index_exports, {
   ASTWithSource: () => ASTWithSource,
   AbsoluteSourceSpan: () => AbsoluteSourceSpan,
   ArrayType: () => ArrayType,
-  ArrowFunctionExpr: () => ArrowFunctionExpr,
+  ArrowFunction: () => ArrowFunction,
+  ArrowFunctionExpr: () => ArrowFunctionExpr$1,
+  ArrowFunctionIdentifierParameter: () => ArrowFunctionIdentifierParameter,
   Attribute: () => Attribute,
   Binary: () => Binary,
   BinaryOperator: () => BinaryOperator,
@@ -194,6 +196,7 @@ __export(index_exports, {
   TmplAstSwitchBlock: () => SwitchBlock,
   TmplAstSwitchBlockCase: () => SwitchBlockCase,
   TmplAstSwitchBlockCaseGroup: () => SwitchBlockCaseGroup,
+  TmplAstSwitchExhaustiveCheck: () => SwitchExhaustiveCheck,
   TmplAstTemplate: () => Template,
   TmplAstText: () => Text$3,
   TmplAstTextAttribute: () => TextAttribute,
@@ -286,7 +289,7 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// ../../node_modules/.pnpm/@angular+compiler@21.1.4/node_modules/@angular/compiler/fesm2022/compiler.mjs
+// ../../node_modules/.pnpm/@angular+compiler@21.2.0/node_modules/@angular/compiler/fesm2022/compiler.mjs
 var _SELECTOR_REGEXP = new RegExp(`(\\:not\\()|(([\\.\\#]?)[-\\w]+)|(?:\\[([-.\\w*\\\\$]+)(?:=(["']?)([^\\]"']*)\\5)?\\])|(\\))|(\\s*,\\s*)`, "g");
 var CssSelector = class _CssSelector {
   static {
@@ -627,6 +630,7 @@ var ChangeDetectionStrategy;
 (function(ChangeDetectionStrategy2) {
   ChangeDetectionStrategy2[ChangeDetectionStrategy2["OnPush"] = 0] = "OnPush";
   ChangeDetectionStrategy2[ChangeDetectionStrategy2["Default"] = 1] = "Default";
+  ChangeDetectionStrategy2[ChangeDetectionStrategy2["Eager"] = 1] = "Eager";
 })(ChangeDetectionStrategy || (ChangeDetectionStrategy = {}));
 var InputFlags;
 (function(InputFlags2) {
@@ -1124,15 +1128,16 @@ var BinaryOperator;
   BinaryOperator2[BinaryOperator2["NullishCoalesce"] = 18] = "NullishCoalesce";
   BinaryOperator2[BinaryOperator2["Exponentiation"] = 19] = "Exponentiation";
   BinaryOperator2[BinaryOperator2["In"] = 20] = "In";
-  BinaryOperator2[BinaryOperator2["AdditionAssignment"] = 21] = "AdditionAssignment";
-  BinaryOperator2[BinaryOperator2["SubtractionAssignment"] = 22] = "SubtractionAssignment";
-  BinaryOperator2[BinaryOperator2["MultiplicationAssignment"] = 23] = "MultiplicationAssignment";
-  BinaryOperator2[BinaryOperator2["DivisionAssignment"] = 24] = "DivisionAssignment";
-  BinaryOperator2[BinaryOperator2["RemainderAssignment"] = 25] = "RemainderAssignment";
-  BinaryOperator2[BinaryOperator2["ExponentiationAssignment"] = 26] = "ExponentiationAssignment";
-  BinaryOperator2[BinaryOperator2["AndAssignment"] = 27] = "AndAssignment";
-  BinaryOperator2[BinaryOperator2["OrAssignment"] = 28] = "OrAssignment";
-  BinaryOperator2[BinaryOperator2["NullishCoalesceAssignment"] = 29] = "NullishCoalesceAssignment";
+  BinaryOperator2[BinaryOperator2["InstanceOf"] = 21] = "InstanceOf";
+  BinaryOperator2[BinaryOperator2["AdditionAssignment"] = 22] = "AdditionAssignment";
+  BinaryOperator2[BinaryOperator2["SubtractionAssignment"] = 23] = "SubtractionAssignment";
+  BinaryOperator2[BinaryOperator2["MultiplicationAssignment"] = 24] = "MultiplicationAssignment";
+  BinaryOperator2[BinaryOperator2["DivisionAssignment"] = 25] = "DivisionAssignment";
+  BinaryOperator2[BinaryOperator2["RemainderAssignment"] = 26] = "RemainderAssignment";
+  BinaryOperator2[BinaryOperator2["ExponentiationAssignment"] = 27] = "ExponentiationAssignment";
+  BinaryOperator2[BinaryOperator2["AndAssignment"] = 28] = "AndAssignment";
+  BinaryOperator2[BinaryOperator2["OrAssignment"] = 29] = "OrAssignment";
+  BinaryOperator2[BinaryOperator2["NullishCoalesceAssignment"] = 30] = "NullishCoalesceAssignment";
 })(BinaryOperator || (BinaryOperator = {}));
 function nullSafeIsEquivalent(base, other) {
   if (base == null || other == null) {
@@ -1767,7 +1772,7 @@ var FunctionExpr = class _FunctionExpr extends Expression {
     return new _FunctionExpr(this.params.map((p) => p.clone()), this.statements, this.type, this.sourceSpan, this.name);
   }
 };
-var ArrowFunctionExpr = class _ArrowFunctionExpr extends Expression {
+var ArrowFunctionExpr$1 = class ArrowFunctionExpr extends Expression {
   static {
     __name(this, "ArrowFunctionExpr");
   }
@@ -1779,7 +1784,7 @@ var ArrowFunctionExpr = class _ArrowFunctionExpr extends Expression {
     this.body = body;
   }
   isEquivalent(e) {
-    if (!(e instanceof _ArrowFunctionExpr) || !areAllEquivalent(this.params, e.params)) {
+    if (!(e instanceof ArrowFunctionExpr) || !areAllEquivalent(this.params, e.params)) {
       return false;
     }
     if (this.body instanceof Expression && e.body instanceof Expression) {
@@ -1797,7 +1802,7 @@ var ArrowFunctionExpr = class _ArrowFunctionExpr extends Expression {
     return visitor.visitArrowFunctionExpr(this, context);
   }
   clone() {
-    return new _ArrowFunctionExpr(this.params.map((p) => p.clone()), Array.isArray(this.body) ? this.body : this.body.clone(), this.type, this.sourceSpan);
+    return new ArrowFunctionExpr(this.params.map((p) => p.clone()), Array.isArray(this.body) ? this.body : this.body.clone(), this.type, this.sourceSpan);
   }
   toDeclStmt(name, modifiers) {
     return new DeclareVarStmt(name, this, INFERRED_TYPE, modifiers, this.sourceSpan);
@@ -2467,7 +2472,7 @@ function fn(params, body, type, sourceSpan, name) {
 }
 __name(fn, "fn");
 function arrowFn(params, body, type, sourceSpan) {
-  return new ArrowFunctionExpr(params, body, type, sourceSpan);
+  return new ArrowFunctionExpr$1(params, body, type, sourceSpan);
 }
 __name(arrowFn, "arrowFn");
 function ifStmt(condition, thenClause, elseClause, sourceSpan, leadingComments) {
@@ -2522,7 +2527,7 @@ __name(serializeTags, "serializeTags");
 var output_ast = /* @__PURE__ */ Object.freeze({
   __proto__: null,
   ArrayType,
-  ArrowFunctionExpr,
+  ArrowFunctionExpr: ArrowFunctionExpr$1,
   BOOL_TYPE,
   get BinaryOperator() {
     return BinaryOperator;
@@ -2705,7 +2710,7 @@ var ConstantPool = class {
     return this.sharedConstants.get(key);
   }
   getSharedFunctionReference(fn2, prefix, useUniqueName = true) {
-    const isArrow = fn2 instanceof ArrowFunctionExpr;
+    const isArrow = fn2 instanceof ArrowFunctionExpr$1;
     for (const current of this.statements) {
       if (isArrow && current instanceof DeclareVarStmt && current.value?.isEquivalent(fn2)) {
         return variable(current.name);
@@ -3506,6 +3511,10 @@ var Identifiers = class {
     name: "\u0275\u0275readContextLet",
     moduleName: CORE
   };
+  static arrowFunction = {
+    name: "\u0275\u0275arrowFunction",
+    moduleName: CORE
+  };
   static attachSourceLocations = {
     name: "\u0275\u0275attachSourceLocations",
     moduleName: CORE
@@ -3514,6 +3523,10 @@ var Identifiers = class {
     name: "\u0275\u0275NgOnChangesFeature",
     moduleName: CORE
   };
+  static ControlFeature = {
+    name: "\u0275\u0275ControlFeature",
+    moduleName: CORE
+  };
   static InheritDefinitionFeature = {
     name: "\u0275\u0275InheritDefinitionFeature",
     moduleName: CORE
@@ -3873,7 +3886,7 @@ var _EmittedLine = class {
     this.indent = indent;
   }
 };
-var BINARY_OPERATORS$1 = /* @__PURE__ */ new Map([[BinaryOperator.And, "&&"], [BinaryOperator.Bigger, ">"], [BinaryOperator.BiggerEquals, ">="], [BinaryOperator.BitwiseOr, "|"], [BinaryOperator.BitwiseAnd, "&"], [BinaryOperator.Divide, "/"], [BinaryOperator.Assign, "="], [BinaryOperator.Equals, "=="], [BinaryOperator.Identical, "==="], [BinaryOperator.Lower, "<"], [BinaryOperator.LowerEquals, "<="], [BinaryOperator.Minus, "-"], [BinaryOperator.Modulo, "%"], [BinaryOperator.Exponentiation, "**"], [BinaryOperator.Multiply, "*"], [BinaryOperator.NotEquals, "!="], [BinaryOperator.NotIdentical, "!=="], [BinaryOperator.NullishCoalesce, "??"], [BinaryOperator.Or, "||"], [BinaryOperator.Plus, "+"], [BinaryOperator.In, "in"], [BinaryOperator.AdditionAssignment, "+="], [BinaryOperator.SubtractionAssignment, "-="], [BinaryOperator.MultiplicationAssignment, "*="], [BinaryOperator.DivisionAssignment, "/="], [BinaryOperator.RemainderAssignment, "%="], [BinaryOperator.ExponentiationAssignment, "**="], [BinaryOperator.AndAssignment, "&&="], [BinaryOperator.OrAssignment, "||="], [BinaryOperator.NullishCoalesceAssignment, "??="]]);
+var BINARY_OPERATORS$1 = /* @__PURE__ */ new Map([[BinaryOperator.And, "&&"], [BinaryOperator.Bigger, ">"], [BinaryOperator.BiggerEquals, ">="], [BinaryOperator.BitwiseOr, "|"], [BinaryOperator.BitwiseAnd, "&"], [BinaryOperator.Divide, "/"], [BinaryOperator.Assign, "="], [BinaryOperator.Equals, "=="], [BinaryOperator.Identical, "==="], [BinaryOperator.Lower, "<"], [BinaryOperator.LowerEquals, "<="], [BinaryOperator.Minus, "-"], [BinaryOperator.Modulo, "%"], [BinaryOperator.Exponentiation, "**"], [BinaryOperator.Multiply, "*"], [BinaryOperator.NotEquals, "!="], [BinaryOperator.NotIdentical, "!=="], [BinaryOperator.NullishCoalesce, "??"], [BinaryOperator.Or, "||"], [BinaryOperator.Plus, "+"], [BinaryOperator.In, "in"], [BinaryOperator.InstanceOf, "instanceof"], [BinaryOperator.AdditionAssignment, "+="], [BinaryOperator.SubtractionAssignment, "-="], [BinaryOperator.MultiplicationAssignment, "*="], [BinaryOperator.DivisionAssignment, "/="], [BinaryOperator.RemainderAssignment, "%="], [BinaryOperator.ExponentiationAssignment, "**="], [BinaryOperator.AndAssignment, "&&="], [BinaryOperator.OrAssignment, "||="], [BinaryOperator.NullishCoalesceAssignment, "??="]]);
 var EmitterVisitorContext = class _EmitterVisitorContext {
   static {
     __name(this, "EmitterVisitorContext");
@@ -4063,7 +4076,7 @@ var AbstractEmitterVisitor = class {
     return null;
   }
   visitInvokeFunctionExpr(expr, ctx) {
-    const shouldParenthesize = expr.fn instanceof ArrowFunctionExpr;
+    const shouldParenthesize = expr.fn instanceof ArrowFunctionExpr$1;
     if (shouldParenthesize) {
       ctx.print(expr.fn, "(");
     }
@@ -4572,6 +4585,7 @@ var EmptyExpr$1 = class EmptyExpr extends AST {
     __name(this, "EmptyExpr");
   }
   visit(visitor, context = null) {
+    return visitor.visitEmptyExpr?.(this, context);
   }
 };
 var ImplicitReceiver = class extends AST {
@@ -4962,6 +4976,34 @@ var ParenthesizedExpression = class extends AST {
     return visitor.visitParenthesizedExpression(this, context);
   }
 };
+var ArrowFunctionIdentifierParameter = class {
+  static {
+    __name(this, "ArrowFunctionIdentifierParameter");
+  }
+  name;
+  span;
+  sourceSpan;
+  constructor(name, span, sourceSpan) {
+    this.name = name;
+    this.span = span;
+    this.sourceSpan = sourceSpan;
+  }
+};
+var ArrowFunction = class extends AST {
+  static {
+    __name(this, "ArrowFunction");
+  }
+  parameters;
+  body;
+  constructor(span, sourceSpan, parameters, body) {
+    super(span, sourceSpan);
+    this.parameters = parameters;
+    this.body = body;
+  }
+  visit(visitor, context) {
+    return visitor.visitArrowFunction(this, context);
+  }
+};
 var RegularExpressionLiteral = class extends AST {
   static {
     __name(this, "RegularExpressionLiteral");
@@ -5132,11 +5174,16 @@ var RecursiveAstVisitor2 = class {
   visitParenthesizedExpression(ast, context) {
     this.visit(ast.expression, context);
   }
+  visitArrowFunction(ast, context) {
+    this.visit(ast.body, context);
+  }
   visitRegularExpressionLiteral(ast, context) {
   }
   visitSpreadElement(ast, context) {
     this.visit(ast.expression, context);
   }
+  visitEmptyExpr(ast, context) {
+  }
   visitAll(asts, context) {
     for (const ast of asts) {
       this.visit(ast, context);
@@ -5671,11 +5718,13 @@ var SwitchBlock = class extends BlockNode {
   expression;
   groups;
   unknownBlocks;
-  constructor(expression, groups, unknownBlocks, sourceSpan, startSourceSpan, endSourceSpan, nameSpan) {
+  exhaustiveCheck;
+  constructor(expression, groups, unknownBlocks, exhaustiveCheck, sourceSpan, startSourceSpan, endSourceSpan, nameSpan) {
     super(nameSpan, sourceSpan, startSourceSpan, endSourceSpan);
     this.expression = expression;
     this.groups = groups;
     this.unknownBlocks = unknownBlocks;
+    this.exhaustiveCheck = exhaustiveCheck;
   }
   visit(visitor) {
     return visitor.visitSwitchBlock(this);
@@ -5711,6 +5760,17 @@ var SwitchBlockCaseGroup = class extends BlockNode {
     return visitor.visitSwitchBlockCaseGroup(this);
   }
 };
+var SwitchExhaustiveCheck = class extends BlockNode {
+  static {
+    __name(this, "SwitchExhaustiveCheck");
+  }
+  constructor(sourceSpan, startSourceSpan, endSourceSpan, nameSpan) {
+    super(nameSpan, sourceSpan, startSourceSpan, endSourceSpan);
+  }
+  visit(visitor) {
+    return visitor.visitSwitchExhaustiveCheck(this);
+  }
+};
 var ForLoopBlock = class extends BlockNode {
   static {
     __name(this, "ForLoopBlock");
@@ -6075,6 +6135,8 @@ var RecursiveVisitor$1 = class RecursiveVisitor {
     visitAll$1(this, block.cases);
     visitAll$1(this, block.children);
   }
+  visitSwitchExhaustiveCheck(block) {
+  }
   visitForLoopBlock(block) {
     const blockItems = [block.item, ...block.contextVariables, ...block.children];
     block.empty && blockItems.push(block.empty);
@@ -8429,6 +8491,7 @@ var ExpressionKind;
   ExpressionKind2[ExpressionKind2["ConditionalCase"] = 23] = "ConditionalCase";
   ExpressionKind2[ExpressionKind2["ConstCollected"] = 24] = "ConstCollected";
   ExpressionKind2[ExpressionKind2["TwoWayBindingSet"] = 25] = "TwoWayBindingSet";
+  ExpressionKind2[ExpressionKind2["ArrowFunction"] = 26] = "ArrowFunction";
 })(ExpressionKind || (ExpressionKind = {}));
 var VariableFlags;
 (function(VariableFlags2) {
@@ -8442,11 +8505,6 @@ var SemanticVariableKind;
   SemanticVariableKind2[SemanticVariableKind2["SavedView"] = 2] = "SavedView";
   SemanticVariableKind2[SemanticVariableKind2["Alias"] = 3] = "Alias";
 })(SemanticVariableKind || (SemanticVariableKind = {}));
-var CompatibilityMode;
-(function(CompatibilityMode2) {
-  CompatibilityMode2[CompatibilityMode2["Normal"] = 0] = "Normal";
-  CompatibilityMode2[CompatibilityMode2["TemplateDefinitionBuilder"] = 1] = "TemplateDefinitionBuilder";
-})(CompatibilityMode || (CompatibilityMode = {}));
 var BindingKind;
 (function(BindingKind2) {
   BindingKind2[BindingKind2["Attribute"] = 0] = "Attribute";
@@ -8506,6 +8564,222 @@ var TemplateKind;
   TemplateKind2[TemplateKind2["Structural"] = 1] = "Structural";
   TemplateKind2[TemplateKind2["Block"] = 2] = "Block";
 })(TemplateKind || (TemplateKind = {}));
+var OpList = class _OpList {
+  static {
+    __name(this, "OpList");
+  }
+  static nextListId = 0;
+  debugListId = _OpList.nextListId++;
+  head = {
+    kind: OpKind.ListEnd,
+    next: null,
+    prev: null,
+    debugListId: this.debugListId
+  };
+  tail = {
+    kind: OpKind.ListEnd,
+    next: null,
+    prev: null,
+    debugListId: this.debugListId
+  };
+  constructor() {
+    this.head.next = this.tail;
+    this.tail.prev = this.head;
+  }
+  push(op) {
+    if (Array.isArray(op)) {
+      for (const o of op) {
+        this.push(o);
+      }
+      return;
+    }
+    _OpList.assertIsNotEnd(op);
+    _OpList.assertIsUnowned(op);
+    op.debugListId = this.debugListId;
+    const oldLast = this.tail.prev;
+    op.prev = oldLast;
+    oldLast.next = op;
+    op.next = this.tail;
+    this.tail.prev = op;
+  }
+  prepend(ops) {
+    if (ops.length === 0) {
+      return;
+    }
+    for (const op of ops) {
+      _OpList.assertIsNotEnd(op);
+      _OpList.assertIsUnowned(op);
+      op.debugListId = this.debugListId;
+    }
+    const first = this.head.next;
+    let prev = this.head;
+    for (const op of ops) {
+      prev.next = op;
+      op.prev = prev;
+      prev = op;
+    }
+    prev.next = first;
+    first.prev = prev;
+  }
+  *[Symbol.iterator]() {
+    let current = this.head.next;
+    while (current !== this.tail) {
+      _OpList.assertIsOwned(current, this.debugListId);
+      const next = current.next;
+      yield current;
+      current = next;
+    }
+  }
+  *reversed() {
+    let current = this.tail.prev;
+    while (current !== this.head) {
+      _OpList.assertIsOwned(current, this.debugListId);
+      const prev = current.prev;
+      yield current;
+      current = prev;
+    }
+  }
+  static replace(oldOp, newOp) {
+    _OpList.assertIsNotEnd(oldOp);
+    _OpList.assertIsNotEnd(newOp);
+    _OpList.assertIsOwned(oldOp);
+    _OpList.assertIsUnowned(newOp);
+    newOp.debugListId = oldOp.debugListId;
+    if (oldOp.prev !== null) {
+      oldOp.prev.next = newOp;
+      newOp.prev = oldOp.prev;
+    }
+    if (oldOp.next !== null) {
+      oldOp.next.prev = newOp;
+      newOp.next = oldOp.next;
+    }
+    oldOp.debugListId = null;
+    oldOp.prev = null;
+    oldOp.next = null;
+  }
+  static replaceWithMany(oldOp, newOps) {
+    if (newOps.length === 0) {
+      _OpList.remove(oldOp);
+      return;
+    }
+    _OpList.assertIsNotEnd(oldOp);
+    _OpList.assertIsOwned(oldOp);
+    const listId = oldOp.debugListId;
+    oldOp.debugListId = null;
+    for (const newOp of newOps) {
+      _OpList.assertIsNotEnd(newOp);
+      _OpList.assertIsUnowned(newOp);
+    }
+    const {
+      prev: oldPrev,
+      next: oldNext
+    } = oldOp;
+    oldOp.prev = null;
+    oldOp.next = null;
+    let prev = oldPrev;
+    for (const newOp of newOps) {
+      _OpList.assertIsUnowned(newOp);
+      newOp.debugListId = listId;
+      prev.next = newOp;
+      newOp.prev = prev;
+      newOp.next = null;
+      prev = newOp;
+    }
+    const first = newOps[0];
+    const last = prev;
+    if (oldPrev !== null) {
+      oldPrev.next = first;
+      first.prev = oldPrev;
+    }
+    if (oldNext !== null) {
+      oldNext.prev = last;
+      last.next = oldNext;
+    }
+  }
+  static remove(op) {
+    _OpList.assertIsNotEnd(op);
+    _OpList.assertIsOwned(op);
+    op.prev.next = op.next;
+    op.next.prev = op.prev;
+    op.debugListId = null;
+    op.prev = null;
+    op.next = null;
+  }
+  static insertBefore(op, target) {
+    if (Array.isArray(op)) {
+      for (const o of op) {
+        _OpList.insertBefore(o, target);
+      }
+      return;
+    }
+    _OpList.assertIsOwned(target);
+    if (target.prev === null) {
+      throw new Error(`AssertionError: illegal operation on list start`);
+    }
+    _OpList.assertIsNotEnd(op);
+    _OpList.assertIsUnowned(op);
+    op.debugListId = target.debugListId;
+    op.prev = null;
+    target.prev.next = op;
+    op.prev = target.prev;
+    op.next = target;
+    target.prev = op;
+  }
+  static insertAfter(op, target) {
+    _OpList.assertIsOwned(target);
+    if (target.next === null) {
+      throw new Error(`AssertionError: illegal operation on list end`);
+    }
+    _OpList.assertIsNotEnd(op);
+    _OpList.assertIsUnowned(op);
+    op.debugListId = target.debugListId;
+    target.next.prev = op;
+    op.next = target.next;
+    op.prev = target;
+    target.next = op;
+  }
+  static assertIsUnowned(op) {
+    if (op.debugListId !== null) {
+      throw new Error(`AssertionError: illegal operation on owned node: ${OpKind[op.kind]}`);
+    }
+  }
+  static assertIsOwned(op, byList) {
+    if (op.debugListId === null) {
+      throw new Error(`AssertionError: illegal operation on unowned node: ${OpKind[op.kind]}`);
+    } else if (byList !== void 0 && op.debugListId !== byList) {
+      throw new Error(`AssertionError: node belongs to the wrong list (expected ${byList}, actual ${op.debugListId})`);
+    }
+  }
+  static assertIsNotEnd(op) {
+    if (op.kind === OpKind.ListEnd) {
+      throw new Error(`AssertionError: illegal operation on list head or tail`);
+    }
+  }
+};
+function createStatementOp(statement) {
+  return {
+    kind: OpKind.Statement,
+    statement,
+    ...NEW_OP
+  };
+}
+__name(createStatementOp, "createStatementOp");
+function createVariableOp(xref, variable2, initializer, flags) {
+  return {
+    kind: OpKind.Variable,
+    xref,
+    variable: variable2,
+    initializer,
+    flags,
+    ...NEW_OP
+  };
+}
+__name(createVariableOp, "createVariableOp");
+var NEW_OP = {
+  debugListId: null,
+  prev: null,
+  next: null
+};
 var ConsumesSlot = Symbol("ConsumesSlot");
 var DependsOnSlotContext = Symbol("DependsOnSlotContext");
 var ConsumesVarsTrait = Symbol("ConsumesVars");
@@ -8536,31 +8810,7 @@ function hasUsesVarOffsetTrait(expr) {
   return expr[UsesVarOffset] === true;
 }
 __name(hasUsesVarOffsetTrait, "hasUsesVarOffsetTrait");
-function createStatementOp(statement) {
-  return {
-    kind: OpKind.Statement,
-    statement,
-    ...NEW_OP
-  };
-}
-__name(createStatementOp, "createStatementOp");
-function createVariableOp(xref, variable2, initializer, flags) {
-  return {
-    kind: OpKind.Variable,
-    xref,
-    variable: variable2,
-    initializer,
-    flags,
-    ...NEW_OP
-  };
-}
-__name(createVariableOp, "createVariableOp");
-var NEW_OP = {
-  debugListId: null,
-  prev: null,
-  next: null
-};
-function createInterpolateTextOp(xref, interpolation, sourceSpan) {
+function createInterpolateTextOp(xref, interpolation, sourceSpan) {
   return {
     kind: OpKind.InterpolateText,
     target: xref,
@@ -8826,22 +9076,12 @@ function createStoreLetOp(target, declaredName, value, sourceSpan) {
   };
 }
 __name(createStoreLetOp, "createStoreLetOp");
-function createControlOp(op) {
+function createControlOp(target, sourceSpan) {
   return {
     kind: OpKind.Control,
-    target: op.target,
-    name: op.name,
-    expression: op.expression,
-    bindingKind: op.bindingKind,
-    securityContext: op.securityContext,
-    sanitizer: null,
-    isStructuralTemplateAttribute: op.isStructuralTemplateAttribute,
-    templateKind: op.templateKind,
-    i18nContext: op.i18nContext,
-    i18nMessage: op.i18nMessage,
-    sourceSpan: op.sourceSpan,
+    sourceSpan,
+    target,
     ...TRAIT_DEPENDS_ON_SLOT_CONTEXT,
-    ...TRAIT_CONSUMES_VARS,
     ...NEW_OP
   };
 }
@@ -9021,9 +9261,6 @@ var NextContextExpr = class _NextContextExpr extends ExpressionBase {
   }
   kind = ExpressionKind.NextContext;
   steps = 1;
-  constructor() {
-    super();
-  }
   visitExpression() {
   }
   isEquivalent(e) {
@@ -9625,6 +9862,51 @@ var ConstCollectedExpr = class _ConstCollectedExpr extends ExpressionBase {
     return new _ConstCollectedExpr(this.expr);
   }
 };
+var ArrowFunctionExpr2 = class _ArrowFunctionExpr extends ExpressionBase {
+  static {
+    __name(this, "ArrowFunctionExpr");
+  }
+  parameters;
+  body;
+  kind = ExpressionKind.ArrowFunction;
+  [ConsumesVarsTrait] = true;
+  [UsesVarOffset] = true;
+  contextName = CONTEXT_NAME;
+  currentViewName = "view";
+  varOffset = null;
+  ops;
+  constructor(parameters, body) {
+    super();
+    this.parameters = parameters;
+    this.body = body;
+    this.ops = new OpList();
+    this.ops.push([createStatementOp(new ReturnStatement(body, body.sourceSpan))]);
+  }
+  visitExpression(visitor, context) {
+    for (const op of this.ops) {
+      visitExpressionsInOp(op, (expr) => {
+        expr.visitExpression(visitor, context);
+      });
+    }
+  }
+  isEquivalent(e) {
+    return e instanceof _ArrowFunctionExpr && e.parameters.length === this.parameters.length && e.parameters.every((param, index) => param.isEquivalent(this.parameters[index])) && e.body.isEquivalent(this.body);
+  }
+  isConstant() {
+    return false;
+  }
+  transformInternalExpressions(transform2, flags) {
+    for (const op of this.ops) {
+      transformExpressionsInOp(op, transform2, flags | (VisitorContextFlag.InChildOperation | VisitorContextFlag.InArrowFunctionOperation));
+    }
+  }
+  clone() {
+    const expr = new _ArrowFunctionExpr(this.parameters, this.body);
+    expr.varOffset = this.varOffset;
+    expr.ops = this.ops;
+    return expr;
+  }
+};
 function visitExpressionsInOp(op, visitor) {
   transformExpressionsInOp(op, (expr, flags) => {
     visitor(expr, flags);
@@ -9636,6 +9918,7 @@ var VisitorContextFlag;
 (function(VisitorContextFlag2) {
   VisitorContextFlag2[VisitorContextFlag2["None"] = 0] = "None";
   VisitorContextFlag2[VisitorContextFlag2["InChildOperation"] = 1] = "InChildOperation";
+  VisitorContextFlag2[VisitorContextFlag2["InArrowFunctionOperation"] = 2] = "InArrowFunctionOperation";
 })(VisitorContextFlag || (VisitorContextFlag = {}));
 function transformExpressionsInInterpolation(interpolation, transform2, flags) {
   for (let i = 0; i < interpolation.expressions.length; i++) {
@@ -9661,7 +9944,6 @@ function transformExpressionsInOp(op, transform2, flags) {
     case OpKind.Property:
     case OpKind.DomProperty:
     case OpKind.Attribute:
-    case OpKind.Control:
       if (op.expression instanceof Interpolation2) {
         transformExpressionsInInterpolation(op.expression, transform2, flags);
       } else {
@@ -9780,6 +10062,7 @@ function transformExpressionsInOp(op, transform2, flags) {
     case OpKind.SourceLocation:
     case OpKind.ConditionalCreate:
     case OpKind.ConditionalBranchCreate:
+    case OpKind.Control:
     case OpKind.ControlCreate:
       break;
     default:
@@ -9836,248 +10119,56 @@ function transformExpressionsInExpression(expr, transform2, flags) {
   } else if (expr instanceof TaggedTemplateLiteralExpr) {
     expr.tag = transformExpressionsInExpression(expr.tag, transform2, flags);
     expr.template.expressions = expr.template.expressions.map((e) => transformExpressionsInExpression(e, transform2, flags));
-  } else if (expr instanceof ArrowFunctionExpr) {
+  } else if (expr instanceof ArrowFunctionExpr$1) {
     if (Array.isArray(expr.body)) {
       for (let i = 0; i < expr.body.length; i++) {
-        transformExpressionsInStatement(expr.body[i], transform2, flags);
-      }
-    } else {
-      expr.body = transformExpressionsInExpression(expr.body, transform2, flags);
-    }
-  } else if (expr instanceof WrappedNodeExpr) ;
-  else if (expr instanceof TemplateLiteralExpr) {
-    for (let i = 0; i < expr.expressions.length; i++) {
-      expr.expressions[i] = transformExpressionsInExpression(expr.expressions[i], transform2, flags);
-    }
-  } else if (expr instanceof ParenthesizedExpr) {
-    expr.expr = transformExpressionsInExpression(expr.expr, transform2, flags);
-  } else if (expr instanceof SpreadElementExpr) {
-    expr.expression = transformExpressionsInExpression(expr.expression, transform2, flags);
-  } else if (expr instanceof ReadVarExpr || expr instanceof ExternalExpr || expr instanceof LiteralExpr || expr instanceof RegularExpressionLiteralExpr) ;
-  else {
-    throw new Error(`Unhandled expression kind: ${expr.constructor.name}`);
-  }
-  return transform2(expr, flags);
-}
-__name(transformExpressionsInExpression, "transformExpressionsInExpression");
-function transformExpressionsInStatement(stmt, transform2, flags) {
-  if (stmt instanceof ExpressionStatement) {
-    stmt.expr = transformExpressionsInExpression(stmt.expr, transform2, flags);
-  } else if (stmt instanceof ReturnStatement) {
-    stmt.value = transformExpressionsInExpression(stmt.value, transform2, flags);
-  } else if (stmt instanceof DeclareVarStmt) {
-    if (stmt.value !== void 0) {
-      stmt.value = transformExpressionsInExpression(stmt.value, transform2, flags);
-    }
-  } else if (stmt instanceof IfStmt) {
-    stmt.condition = transformExpressionsInExpression(stmt.condition, transform2, flags);
-    for (const caseStatement of stmt.trueCase) {
-      transformExpressionsInStatement(caseStatement, transform2, flags);
-    }
-    for (const caseStatement of stmt.falseCase) {
-      transformExpressionsInStatement(caseStatement, transform2, flags);
-    }
-  } else {
-    throw new Error(`Unhandled statement kind: ${stmt.constructor.name}`);
-  }
-}
-__name(transformExpressionsInStatement, "transformExpressionsInStatement");
-function isStringLiteral(expr) {
-  return expr instanceof LiteralExpr && typeof expr.value === "string";
-}
-__name(isStringLiteral, "isStringLiteral");
-var OpList = class _OpList {
-  static {
-    __name(this, "OpList");
-  }
-  static nextListId = 0;
-  debugListId = _OpList.nextListId++;
-  head = {
-    kind: OpKind.ListEnd,
-    next: null,
-    prev: null,
-    debugListId: this.debugListId
-  };
-  tail = {
-    kind: OpKind.ListEnd,
-    next: null,
-    prev: null,
-    debugListId: this.debugListId
-  };
-  constructor() {
-    this.head.next = this.tail;
-    this.tail.prev = this.head;
-  }
-  push(op) {
-    if (Array.isArray(op)) {
-      for (const o of op) {
-        this.push(o);
-      }
-      return;
-    }
-    _OpList.assertIsNotEnd(op);
-    _OpList.assertIsUnowned(op);
-    op.debugListId = this.debugListId;
-    const oldLast = this.tail.prev;
-    op.prev = oldLast;
-    oldLast.next = op;
-    op.next = this.tail;
-    this.tail.prev = op;
-  }
-  prepend(ops) {
-    if (ops.length === 0) {
-      return;
-    }
-    for (const op of ops) {
-      _OpList.assertIsNotEnd(op);
-      _OpList.assertIsUnowned(op);
-      op.debugListId = this.debugListId;
-    }
-    const first = this.head.next;
-    let prev = this.head;
-    for (const op of ops) {
-      prev.next = op;
-      op.prev = prev;
-      prev = op;
-    }
-    prev.next = first;
-    first.prev = prev;
-  }
-  *[Symbol.iterator]() {
-    let current = this.head.next;
-    while (current !== this.tail) {
-      _OpList.assertIsOwned(current, this.debugListId);
-      const next = current.next;
-      yield current;
-      current = next;
-    }
-  }
-  *reversed() {
-    let current = this.tail.prev;
-    while (current !== this.head) {
-      _OpList.assertIsOwned(current, this.debugListId);
-      const prev = current.prev;
-      yield current;
-      current = prev;
-    }
-  }
-  static replace(oldOp, newOp) {
-    _OpList.assertIsNotEnd(oldOp);
-    _OpList.assertIsNotEnd(newOp);
-    _OpList.assertIsOwned(oldOp);
-    _OpList.assertIsUnowned(newOp);
-    newOp.debugListId = oldOp.debugListId;
-    if (oldOp.prev !== null) {
-      oldOp.prev.next = newOp;
-      newOp.prev = oldOp.prev;
-    }
-    if (oldOp.next !== null) {
-      oldOp.next.prev = newOp;
-      newOp.next = oldOp.next;
-    }
-    oldOp.debugListId = null;
-    oldOp.prev = null;
-    oldOp.next = null;
-  }
-  static replaceWithMany(oldOp, newOps) {
-    if (newOps.length === 0) {
-      _OpList.remove(oldOp);
-      return;
-    }
-    _OpList.assertIsNotEnd(oldOp);
-    _OpList.assertIsOwned(oldOp);
-    const listId = oldOp.debugListId;
-    oldOp.debugListId = null;
-    for (const newOp of newOps) {
-      _OpList.assertIsNotEnd(newOp);
-      _OpList.assertIsUnowned(newOp);
-    }
-    const {
-      prev: oldPrev,
-      next: oldNext
-    } = oldOp;
-    oldOp.prev = null;
-    oldOp.next = null;
-    let prev = oldPrev;
-    for (const newOp of newOps) {
-      _OpList.assertIsUnowned(newOp);
-      newOp.debugListId = listId;
-      prev.next = newOp;
-      newOp.prev = prev;
-      newOp.next = null;
-      prev = newOp;
-    }
-    const first = newOps[0];
-    const last = prev;
-    if (oldPrev !== null) {
-      oldPrev.next = first;
-      first.prev = oldPrev;
-    }
-    if (oldNext !== null) {
-      oldNext.prev = last;
-      last.next = oldNext;
-    }
-  }
-  static remove(op) {
-    _OpList.assertIsNotEnd(op);
-    _OpList.assertIsOwned(op);
-    op.prev.next = op.next;
-    op.next.prev = op.prev;
-    op.debugListId = null;
-    op.prev = null;
-    op.next = null;
-  }
-  static insertBefore(op, target) {
-    if (Array.isArray(op)) {
-      for (const o of op) {
-        _OpList.insertBefore(o, target);
+        transformExpressionsInStatement(expr.body[i], transform2, flags | VisitorContextFlag.InChildOperation);
       }
-      return;
-    }
-    _OpList.assertIsOwned(target);
-    if (target.prev === null) {
-      throw new Error(`AssertionError: illegal operation on list start`);
-    }
-    _OpList.assertIsNotEnd(op);
-    _OpList.assertIsUnowned(op);
-    op.debugListId = target.debugListId;
-    op.prev = null;
-    target.prev.next = op;
-    op.prev = target.prev;
-    op.next = target;
-    target.prev = op;
-  }
-  static insertAfter(op, target) {
-    _OpList.assertIsOwned(target);
-    if (target.next === null) {
-      throw new Error(`AssertionError: illegal operation on list end`);
-    }
-    _OpList.assertIsNotEnd(op);
-    _OpList.assertIsUnowned(op);
-    op.debugListId = target.debugListId;
-    target.next.prev = op;
-    op.next = target.next;
-    op.prev = target;
-    target.next = op;
-  }
-  static assertIsUnowned(op) {
-    if (op.debugListId !== null) {
-      throw new Error(`AssertionError: illegal operation on owned node: ${OpKind[op.kind]}`);
+    } else {
+      expr.body = transformExpressionsInExpression(expr.body, transform2, flags | VisitorContextFlag.InChildOperation);
     }
-  }
-  static assertIsOwned(op, byList) {
-    if (op.debugListId === null) {
-      throw new Error(`AssertionError: illegal operation on unowned node: ${OpKind[op.kind]}`);
-    } else if (byList !== void 0 && op.debugListId !== byList) {
-      throw new Error(`AssertionError: node belongs to the wrong list (expected ${byList}, actual ${op.debugListId})`);
+  } else if (expr instanceof WrappedNodeExpr) ;
+  else if (expr instanceof TemplateLiteralExpr) {
+    for (let i = 0; i < expr.expressions.length; i++) {
+      expr.expressions[i] = transformExpressionsInExpression(expr.expressions[i], transform2, flags);
     }
+  } else if (expr instanceof ParenthesizedExpr) {
+    expr.expr = transformExpressionsInExpression(expr.expr, transform2, flags);
+  } else if (expr instanceof SpreadElementExpr) {
+    expr.expression = transformExpressionsInExpression(expr.expression, transform2, flags);
+  } else if (expr instanceof ReadVarExpr || expr instanceof ExternalExpr || expr instanceof LiteralExpr || expr instanceof RegularExpressionLiteralExpr) ;
+  else {
+    throw new Error(`Unhandled expression kind: ${expr.constructor.name}`);
   }
-  static assertIsNotEnd(op) {
-    if (op.kind === OpKind.ListEnd) {
-      throw new Error(`AssertionError: illegal operation on list head or tail`);
+  return transform2(expr, flags);
+}
+__name(transformExpressionsInExpression, "transformExpressionsInExpression");
+function transformExpressionsInStatement(stmt, transform2, flags) {
+  if (stmt instanceof ExpressionStatement) {
+    stmt.expr = transformExpressionsInExpression(stmt.expr, transform2, flags);
+  } else if (stmt instanceof ReturnStatement) {
+    stmt.value = transformExpressionsInExpression(stmt.value, transform2, flags);
+  } else if (stmt instanceof DeclareVarStmt) {
+    if (stmt.value !== void 0) {
+      stmt.value = transformExpressionsInExpression(stmt.value, transform2, flags);
     }
+  } else if (stmt instanceof IfStmt) {
+    stmt.condition = transformExpressionsInExpression(stmt.condition, transform2, flags);
+    for (const caseStatement of stmt.trueCase) {
+      transformExpressionsInStatement(caseStatement, transform2, flags);
+    }
+    for (const caseStatement of stmt.falseCase) {
+      transformExpressionsInStatement(caseStatement, transform2, flags);
+    }
+  } else {
+    throw new Error(`Unhandled statement kind: ${stmt.constructor.name}`);
   }
-};
+}
+__name(transformExpressionsInStatement, "transformExpressionsInStatement");
+function isStringLiteral(expr) {
+  return expr instanceof LiteralExpr && typeof expr.value === "string";
+}
+__name(isStringLiteral, "isStringLiteral");
 var SlotHandle = class {
   static {
     __name(this, "SlotHandle");
@@ -10596,12 +10687,10 @@ var CompilationJob = class {
   }
   componentName;
   pool;
-  compatibility;
   mode;
-  constructor(componentName, pool, compatibility, mode) {
+  constructor(componentName, pool, mode) {
     this.componentName = componentName;
     this.pool = pool;
-    this.compatibility = compatibility;
     this.mode = mode;
   }
   kind = CompilationJobKind.Both;
@@ -10620,8 +10709,8 @@ var ComponentCompilationJob = class extends CompilationJob {
   allDeferrableDepsFn;
   relativeTemplatePath;
   enableDebugLocations;
-  constructor(componentName, pool, compatibility, mode, relativeContextFilePath, i18nUseExternalIds, deferMeta, allDeferrableDepsFn, relativeTemplatePath, enableDebugLocations) {
-    super(componentName, pool, compatibility, mode);
+  constructor(componentName, pool, mode, relativeContextFilePath, i18nUseExternalIds, deferMeta, allDeferrableDepsFn, relativeTemplatePath, enableDebugLocations) {
+    super(componentName, pool, mode);
     this.relativeContextFilePath = relativeContextFilePath;
     this.i18nUseExternalIds = i18nUseExternalIds;
     this.deferMeta = deferMeta;
@@ -10670,9 +10759,15 @@ var CompilationUnit = class {
   }
   create = new OpList();
   update = new OpList();
+  functions = /* @__PURE__ */ new Set();
   fnName = null;
   vars = null;
   *ops() {
+    for (const expr of this.functions) {
+      for (const op of expr.ops) {
+        yield op;
+      }
+    }
     for (const op of this.create) {
       yield op;
       if (op.kind === OpKind.Listener || op.kind === OpKind.Animation || op.kind === OpKind.AnimationListener || op.kind === OpKind.TwoWayListener) {
@@ -10709,8 +10804,8 @@ var HostBindingCompilationJob = class extends CompilationJob {
   static {
     __name(this, "HostBindingCompilationJob");
   }
-  constructor(componentName, pool, compatibility, mode) {
-    super(componentName, pool, compatibility, mode);
+  constructor(componentName, pool, mode) {
+    super(componentName, pool, mode);
     this.root = new HostBindingCompilationUnit(this);
   }
   kind = CompilationJobKind.Host;
@@ -10903,15 +10998,12 @@ function extractAttributes(job) {
             OpList.insertBefore(createExtractedAttributeOp(op.target, bindingKind, null, op.name, null, null, null, op.securityContext), lookupElement$3(elements, op.target));
           }
           break;
-        case OpKind.Control:
-          OpList.insertBefore(createExtractedAttributeOp(op.target, BindingKind.Property, null, op.name, null, null, null, op.securityContext), lookupElement$3(elements, op.target));
-          break;
         case OpKind.TwoWayProperty:
           OpList.insertBefore(createExtractedAttributeOp(op.target, BindingKind.TwoWayProperty, null, op.name, null, null, null, op.securityContext), lookupElement$3(elements, op.target));
           break;
         case OpKind.StyleProp:
         case OpKind.ClassProp:
-          if (unit.job.compatibility === CompatibilityMode.TemplateDefinitionBuilder && op.expression instanceof EmptyExpr2) {
+          if (op.expression instanceof EmptyExpr2) {
             OpList.insertBefore(createExtractedAttributeOp(op.target, BindingKind.Property, null, op.name, null, null, null, SecurityContext.STYLE), lookupElement$3(elements, op.target));
           }
           break;
@@ -10919,10 +11011,7 @@ function extractAttributes(job) {
           if (!op.isLegacyAnimationListener) {
             const extractedAttributeOp = createExtractedAttributeOp(op.target, BindingKind.Property, null, op.name, null, null, null, SecurityContext.NONE);
             if (job.kind === CompilationJobKind.Host) {
-              if (job.compatibility) {
-                break;
-              }
-              unit.create.push(extractedAttributeOp);
+              break;
             } else {
               OpList.insertBefore(extractedAttributeOp, lookupElement$3(elements, op.target));
             }
@@ -10951,11 +11040,7 @@ function extractAttributeOp(unit, op, elements) {
   if (op.expression instanceof Interpolation2) {
     return;
   }
-  let extractable = op.isTextAttribute || op.expression.isConstant();
-  if (unit.job.compatibility === CompatibilityMode.TemplateDefinitionBuilder) {
-    extractable &&= op.isTextAttribute;
-  }
-  if (extractable) {
+  if (op.isTextAttribute) {
     const extractedAttributeOp = createExtractedAttributeOp(op.target, op.isStructuralTemplateAttribute ? BindingKind.Template : BindingKind.Attribute, op.namespace, op.name, op.expression, op.i18nContext, op.i18nMessage, op.securityContext);
     if (unit.job.kind === CompilationJobKind.Host) {
       unit.create.push(extractedAttributeOp);
@@ -11017,8 +11102,6 @@ function specializeBindings(job) {
             OpList.replace(op, createAttributeOp(op.target, null, op.name, op.expression, op.securityContext, false, op.isStructuralTemplateAttribute, op.templateKind, op.i18nMessage, op.sourceSpan));
           } else if (job.kind === CompilationJobKind.Host) {
             OpList.replace(op, createDomPropertyOp(op.name, op.expression, op.bindingKind, op.i18nContext, op.securityContext, op.sourceSpan));
-          } else if (op.name === "formField") {
-            OpList.replace(op, createControlOp(op));
           } else {
             OpList.replace(op, createPropertyOp(op.target, op.name, op.expression, op.bindingKind, op.securityContext, op.isStructuralTemplateAttribute, op.templateKind, op.i18nContext, op.i18nMessage, op.sourceSpan));
           }
@@ -11128,7 +11211,7 @@ function generateConditionalExpressions(job) {
   }
 }
 __name(generateConditionalExpressions, "generateConditionalExpressions");
-var BINARY_OPERATORS = /* @__PURE__ */ new Map([["&&", BinaryOperator.And], [">", BinaryOperator.Bigger], [">=", BinaryOperator.BiggerEquals], ["|", BinaryOperator.BitwiseOr], ["&", BinaryOperator.BitwiseAnd], ["/", BinaryOperator.Divide], ["=", BinaryOperator.Assign], ["==", BinaryOperator.Equals], ["===", BinaryOperator.Identical], ["<", BinaryOperator.Lower], ["<=", BinaryOperator.LowerEquals], ["-", BinaryOperator.Minus], ["%", BinaryOperator.Modulo], ["**", BinaryOperator.Exponentiation], ["*", BinaryOperator.Multiply], ["!=", BinaryOperator.NotEquals], ["!==", BinaryOperator.NotIdentical], ["??", BinaryOperator.NullishCoalesce], ["||", BinaryOperator.Or], ["+", BinaryOperator.Plus], ["in", BinaryOperator.In], ["+=", BinaryOperator.AdditionAssignment], ["-=", BinaryOperator.SubtractionAssignment], ["*=", BinaryOperator.MultiplicationAssignment], ["/=", BinaryOperator.DivisionAssignment], ["%=", BinaryOperator.RemainderAssignment], ["**=", BinaryOperator.ExponentiationAssignment], ["&&=", BinaryOperator.AndAssignment], ["||=", BinaryOperator.OrAssignment], ["??=", BinaryOperator.NullishCoalesceAssignment]]);
+var BINARY_OPERATORS = /* @__PURE__ */ new Map([["&&", BinaryOperator.And], [">", BinaryOperator.Bigger], [">=", BinaryOperator.BiggerEquals], ["|", BinaryOperator.BitwiseOr], ["&", BinaryOperator.BitwiseAnd], ["/", BinaryOperator.Divide], ["=", BinaryOperator.Assign], ["==", BinaryOperator.Equals], ["===", BinaryOperator.Identical], ["<", BinaryOperator.Lower], ["<=", BinaryOperator.LowerEquals], ["-", BinaryOperator.Minus], ["%", BinaryOperator.Modulo], ["**", BinaryOperator.Exponentiation], ["*", BinaryOperator.Multiply], ["!=", BinaryOperator.NotEquals], ["!==", BinaryOperator.NotIdentical], ["??", BinaryOperator.NullishCoalesce], ["||", BinaryOperator.Or], ["+", BinaryOperator.Plus], ["in", BinaryOperator.In], ["instanceof", BinaryOperator.InstanceOf], ["+=", BinaryOperator.AdditionAssignment], ["-=", BinaryOperator.SubtractionAssignment], ["*=", BinaryOperator.MultiplicationAssignment], ["/=", BinaryOperator.DivisionAssignment], ["%=", BinaryOperator.RemainderAssignment], ["**=", BinaryOperator.ExponentiationAssignment], ["&&=", BinaryOperator.AndAssignment], ["||=", BinaryOperator.OrAssignment], ["??=", BinaryOperator.NullishCoalesceAssignment]]);
 function namespaceForKey(namespacePrefixKey) {
   const NAMESPACES = /* @__PURE__ */ new Map([["svg", Namespace.SVG], ["math", Namespace.Math]]);
   if (namespacePrefixKey === null) {
@@ -11166,7 +11249,7 @@ function collectElementConsts(job) {
   for (const unit of job.units) {
     for (const op of unit.create) {
       if (op.kind === OpKind.ExtractedAttribute) {
-        const attributes = allElementAttributes.get(op.target) || new ElementAttributes(job.compatibility);
+        const attributes = allElementAttributes.get(op.target) || new ElementAttributes();
         allElementAttributes.set(op.target, attributes);
         attributes.add(op.bindingKind, op.name, op.expression, op.namespace, op.trustedValueFn);
         OpList.remove(op);
@@ -11221,7 +11304,6 @@ var ElementAttributes = class {
   static {
     __name(this, "ElementAttributes");
   }
-  compatibility;
   known = /* @__PURE__ */ new Map();
   byKind = /* @__PURE__ */ new Map();
   propertyBindings = null;
@@ -11244,9 +11326,6 @@ var ElementAttributes = class {
   get i18n() {
     return this.byKind.get(BindingKind.I18n) ?? FLYWEIGHT_ARRAY;
   }
-  constructor(compatibility) {
-    this.compatibility = compatibility;
-  }
   isKnown(kind, name) {
     const nameToValue = this.known.get(kind) ?? /* @__PURE__ */ new Set();
     this.known.set(kind, nameToValue);
@@ -11257,7 +11336,7 @@ var ElementAttributes = class {
     return false;
   }
   add(kind, name, value, namespace, trustedValueFn) {
-    const allowDuplicates = this.compatibility === CompatibilityMode.TemplateDefinitionBuilder && (kind === BindingKind.Attribute || kind === BindingKind.ClassName || kind === BindingKind.StyleProperty);
+    const allowDuplicates = kind === BindingKind.Attribute || kind === BindingKind.ClassName || kind === BindingKind.StyleProperty;
     if (!allowDuplicates && this.isKnown(kind, name)) {
       return;
     }
@@ -11500,12 +11579,8 @@ function deduplicateTextBindings(job) {
     for (const op of unit.update.reversed()) {
       if (op.kind === OpKind.Binding && op.isTextAttribute) {
         const seenForElement = seen.get(op.target) || /* @__PURE__ */ new Set();
-        if (seenForElement.has(op.name)) {
-          if (job.compatibility === CompatibilityMode.TemplateDefinitionBuilder) {
-            if (op.name === "style" || op.name === "class") {
-              OpList.remove(op);
-            }
-          }
+        if (seenForElement.has(op.name) && (op.name === "style" || op.name === "class")) {
+          OpList.remove(op);
         }
         seenForElement.add(op.name);
         seen.set(op.target, seenForElement);
@@ -11703,7 +11778,7 @@ function eliminateTemporaryAssignments(e, tmps, ctx) {
   transformExpressionsInExpression(e, (e2) => {
     if (e2 instanceof AssignTemporaryExpr && tmps.has(e2.xref)) {
       const read = new ReadTemporaryExpr(e2.xref);
-      return ctx.job.compatibility === CompatibilityMode.TemplateDefinitionBuilder ? new AssignTemporaryExpr(read, read.xref) : read;
+      return new AssignTemporaryExpr(read, read.xref);
     }
     return e2;
   }, VisitorContextFlag.None);
@@ -11717,7 +11792,7 @@ function safeTernaryWithTemporary(guard, body, ctx) {
     result = [new AssignTemporaryExpr(guard, xref), new ReadTemporaryExpr(xref)];
   } else {
     result = [guard, guard.clone()];
-    eliminateTemporaryAssignments(result[1], temporariesIn(result[0]), ctx);
+    eliminateTemporaryAssignments(result[1], temporariesIn(result[0]));
   }
   return new SafeTernaryExpr(result[0], body(result[1]));
 }
@@ -12004,7 +12079,7 @@ function generateLocalLetReferences(job) {
 }
 __name(generateLocalLetReferences, "generateLocalLetReferences");
 function generateProjectionDefs(job) {
-  const share = job.compatibility === CompatibilityMode.TemplateDefinitionBuilder;
+  const share = true;
   const selectors = [];
   let projectionSlotIndex = 0;
   for (const unit of job.units) {
@@ -12062,6 +12137,9 @@ function recursivelyProcessView(view, parentScope) {
     }
   }
   view.update.prepend(generateVariablesInScopeForView(view, scope, false));
+  for (const expr of view.functions) {
+    expr.ops.prepend(generateVariablesInScopeForView(view, getScopeForView(view, parentScope), true));
+  }
 }
 __name(recursivelyProcessView, "recursivelyProcessView");
 function getScopeForView(view, parent) {
@@ -14855,6 +14933,13 @@ var _Tokenizer = class {
     this._requireCharCode($AT);
     this._beginToken(24, start);
     const startToken = this._endToken([this._getBlockName()]);
+    if (startToken.parts[0] === "default never" && this._attemptCharCode($SEMICOLON)) {
+      this._beginToken(25);
+      this._endToken([]);
+      this._beginToken(26);
+      this._endToken([]);
+      return;
+    }
     if (this._cursor.peek() === $LPAREN) {
       this._cursor.advance();
       this._consumeBlockParameters();
@@ -16341,8 +16426,15 @@ var _TreeBuilder = class __TreeBuilder {
     this._pushContainer(block, false);
   }
   _consumeBlockClose(token) {
+    const initialStackLength = this._containerStack.length;
+    const topNode = this._containerStack[initialStackLength - 1];
     if (!this._popContainer(null, Block, token.sourceSpan)) {
-      this.errors.push(TreeError.create(null, token.sourceSpan, `Unexpected closing block. The block may have been closed earlier. If you meant to write the } character, you should use the "&#125;" HTML entity instead.`));
+      if (this._containerStack.length < initialStackLength) {
+        const nodeName = topNode instanceof Component2 ? topNode.fullName : topNode.name;
+        this.errors.push(TreeError.create(null, token.sourceSpan, `Unexpected closing block. The block may have been closed earlier. Did you forget to close the <${nodeName}> element? If you meant to write the \`}\` character, you should use the "&#125;" HTML entity instead.`));
+        return;
+      }
+      this.errors.push(TreeError.create(null, token.sourceSpan, `Unexpected closing block. The block may have been closed earlier. If you meant to write the \`}\` character, you should use the "&#125;" HTML entity instead.`));
     }
   }
   _consumeIncompleteBlock(token) {
@@ -16674,7 +16766,7 @@ var StringTokenKind;
   StringTokenKind2[StringTokenKind2["TemplateLiteralPart"] = 1] = "TemplateLiteralPart";
   StringTokenKind2[StringTokenKind2["TemplateLiteralEnd"] = 2] = "TemplateLiteralEnd";
 })(StringTokenKind || (StringTokenKind = {}));
-var KEYWORDS = ["var", "let", "as", "null", "undefined", "true", "false", "if", "else", "this", "typeof", "void", "in"];
+var KEYWORDS = ["var", "let", "as", "null", "undefined", "true", "false", "if", "else", "this", "typeof", "void", "in", "instanceof"];
 var Lexer = class {
   static {
     __name(this, "Lexer");
@@ -16750,6 +16842,9 @@ var Token = class {
   isKeywordIn() {
     return this.type === TokenType.Keyword && this.strValue === "in";
   }
+  isKeywordInstanceOf() {
+    return this.type === TokenType.Keyword && this.strValue === "instanceof";
+  }
   isError() {
     return this.type === TokenType.Error;
   }
@@ -16941,8 +17036,9 @@ var _Scanner = class {
       case $GT:
         return this.scanComplexOperator(start, String.fromCharCode(peek), $EQ, "=");
       case $BANG:
+        return this.scanComplexOperator(start, "!", $EQ, "=", $EQ, "=");
       case $EQ:
-        return this.scanComplexOperator(start, String.fromCharCode(peek), $EQ, "=", $EQ, "=");
+        return this.scanEquals(start);
       case $AMPERSAND:
         return this.scanComplexOperator(start, "&", $AMPERSAND, "&", $EQ, "=");
       case $BAR:
@@ -16989,6 +17085,23 @@ var _Scanner = class {
     }
     return newOperatorToken(start, this.index, str);
   }
+  scanEquals(start) {
+    this.advance();
+    let str = "=";
+    if (this.peek === $EQ) {
+      this.advance();
+      str += "=";
+    } else if (this.peek === $GT) {
+      this.advance();
+      str += ">";
+      return newOperatorToken(start, this.index, str);
+    }
+    if (this.peek === $EQ) {
+      this.advance();
+      str += "=";
+    }
+    return newOperatorToken(start, this.index, str);
+  }
   scanIdentifier() {
     const start = this.index;
     this.advance();
@@ -17792,7 +17905,7 @@ var _ParseAST = class {
   parseRelational() {
     const start = this.inputIndex;
     let result = this.parseAdditive();
-    while (this.next.type == TokenType.Operator || this.next.isKeywordIn) {
+    while (this.next.type == TokenType.Operator || this.next.isKeywordIn() || this.next.isKeywordInstanceOf()) {
       const operator = this.next.strValue;
       switch (operator) {
         case "<":
@@ -17800,6 +17913,7 @@ var _ParseAST = class {
         case "<=":
         case ">=":
         case "in":
+        case "instanceof":
           this.advance();
           const right = this.parseAdditive();
           result = new Binary(this.span(start), this.sourceSpan(start), operator, result, right);
@@ -17918,7 +18032,9 @@ var _ParseAST = class {
   }
   parsePrimary() {
     const start = this.inputIndex;
-    if (this.consumeOptionalCharacter($LPAREN)) {
+    if (this.isArrowFunction()) {
+      return this.parseArrowFunction(start);
+    } else if (this.consumeOptionalCharacter($LPAREN)) {
       this.rparensExpected++;
       const result = this.parsePipe();
       if (!this.consumeOptionalCharacter($RPAREN)) {
@@ -18293,6 +18409,78 @@ var _ParseAST = class {
     const end = flagsToken ? flagsToken.end : bodyToken.end;
     return new RegularExpressionLiteral(this.span(start, end), this.sourceSpan(start, end), bodyToken.strValue, flagsToken ? flagsToken.strValue : null);
   }
+  parseArrowFunction(start) {
+    let params;
+    if (this.next.isIdentifier()) {
+      const token = this.next;
+      this.advance();
+      params = [this.getArrowFunctionIdentifierArg(token)];
+    } else if (this.next.isCharacter($LPAREN)) {
+      this.rparensExpected++;
+      this.advance();
+      params = this.parseArrowFunctionParameters();
+      this.rparensExpected--;
+    } else {
+      params = [];
+      this.error(`Unexpected token ${this.next}`);
+    }
+    this.expectOperator("=>");
+    let body;
+    if (this.next.isCharacter($LBRACE)) {
+      this.error("Multi-line arrow functions are not supported. If you meant to return an object literal, wrap it with parentheses.");
+      body = new EmptyExpr$1(this.span(start), this.sourceSpan(start));
+    } else {
+      const prevFlags = this.parseFlags;
+      this.parseFlags = 1;
+      body = this.parseExpression();
+      this.parseFlags = prevFlags;
+    }
+    return new ArrowFunction(this.span(start), this.sourceSpan(start), params, body);
+  }
+  parseArrowFunctionParameters() {
+    const params = [];
+    if (!this.consumeOptionalCharacter($RPAREN)) {
+      while (this.next !== EOF) {
+        if (this.next.isIdentifier()) {
+          const token = this.next;
+          this.advance();
+          params.push(this.getArrowFunctionIdentifierArg(token));
+          if (this.consumeOptionalCharacter($RPAREN)) {
+            break;
+          } else {
+            this.expectCharacter($COMMA);
+          }
+        } else {
+          this.error(`Unexpected token ${this.next}`);
+          break;
+        }
+      }
+    }
+    return params;
+  }
+  getArrowFunctionIdentifierArg(token) {
+    return new ArrowFunctionIdentifierParameter(token.strValue, this.span(token.index), this.sourceSpan(token.index));
+  }
+  isArrowFunction() {
+    const start = this.index;
+    const tokens = this.tokens;
+    if (start > tokens.length - 2) {
+      return false;
+    }
+    if (tokens[start].isIdentifier() && tokens[start + 1].isOperator("=>")) {
+      return true;
+    }
+    if (tokens[start].isCharacter($LPAREN)) {
+      let i = start + 1;
+      for (i; i < tokens.length; i++) {
+        if (!tokens[i].isIdentifier() && !tokens[i].isCharacter($COMMA)) {
+          break;
+        }
+      }
+      return i < tokens.length - 1 && tokens[i].isCharacter($RPAREN) && tokens[i + 1].isOperator("=>");
+    }
+    return false;
+  }
   consumeStatementTerminator() {
     this.consumeOptionalCharacter($SEMICOLON) || this.consumeOptionalCharacter($COMMA);
   }
@@ -18455,6 +18643,15 @@ var SerializeExpressionVisitor = class {
   visitRegularExpressionLiteral(ast, context) {
     return `/${ast.body}/${ast.flags || ""}`;
   }
+  visitArrowFunction(ast, context) {
+    let params;
+    if (ast.parameters.length === 1) {
+      params = ast.parameters[0].name;
+    } else {
+      params = `(${ast.parameters.map((e) => e.name).join(", ")})`;
+    }
+    return `${params} => ${ast.body.visit(this, context)}`;
+  }
   visitASTWithSource(ast, context) {
     return ast.ast.visit(this, context);
   }
@@ -20090,10 +20287,10 @@ __name(parseExtractedStyles, "parseExtractedStyles");
 function nameFunctionsAndVariables(job) {
   addNamesToView(job.root, job.componentName, {
     index: 0
-  }, job.compatibility === CompatibilityMode.TemplateDefinitionBuilder);
+  });
 }
 __name(nameFunctionsAndVariables, "nameFunctionsAndVariables");
-function addNamesToView(unit, baseName, state, compatibility) {
+function addNamesToView(unit, baseName, state) {
   if (unit.fnName === null) {
     unit.fnName = unit.job.pool.uniqueName(sanitizeIdentifier(`${baseName}_${unit.job.fnSuffix}`), false);
   }
@@ -20157,7 +20354,7 @@ function addNamesToView(unit, baseName, state, compatibility) {
         op.handlerFnName = sanitizeIdentifier(`${unit.fnName}_${op.tag.replace("-", "_")}_${op.name}_${op.targetSlot.slot}_listener`);
         break;
       case OpKind.Variable:
-        varNames.set(op.xref, getVariableName(unit, op.variable, state));
+        varNames.set(op.xref, getVariableName(op.variable, state));
         break;
       case OpKind.RepeaterCreate:
         if (!(unit instanceof ViewCompilationUnit)) {
@@ -20168,9 +20365,9 @@ function addNamesToView(unit, baseName, state, compatibility) {
         }
         if (op.emptyView !== null) {
           const emptyView = unit.job.views.get(op.emptyView);
-          addNamesToView(emptyView, `${baseName}_${op.functionNameSuffix}Empty_${op.handle.slot + 2}`, state, compatibility);
+          addNamesToView(emptyView, `${baseName}_${op.functionNameSuffix}Empty_${op.handle.slot + 2}`, state);
         }
-        addNamesToView(unit.job.views.get(op.xref), `${baseName}_${op.functionNameSuffix}_${op.handle.slot + 1}`, state, compatibility);
+        addNamesToView(unit.job.views.get(op.xref), `${baseName}_${op.functionNameSuffix}_${op.handle.slot + 1}`, state);
         break;
       case OpKind.Projection:
         if (!(unit instanceof ViewCompilationUnit)) {
@@ -20181,7 +20378,7 @@ function addNamesToView(unit, baseName, state, compatibility) {
         }
         if (op.fallbackView !== null) {
           const fallbackView = unit.job.views.get(op.fallbackView);
-          addNamesToView(fallbackView, `${baseName}_ProjectionFallback_${op.handle.slot}`, state, compatibility);
+          addNamesToView(fallbackView, `${baseName}_ProjectionFallback_${op.handle.slot}`, state);
         }
         break;
       case OpKind.ConditionalCreate:
@@ -20195,18 +20392,13 @@ function addNamesToView(unit, baseName, state, compatibility) {
           throw new Error(`Expected slot to be assigned`);
         }
         const suffix = op.functionNameSuffix.length === 0 ? "" : `_${op.functionNameSuffix}`;
-        addNamesToView(childView, `${baseName}${suffix}_${op.handle.slot}`, state, compatibility);
+        addNamesToView(childView, `${baseName}${suffix}_${op.handle.slot}`, state);
         break;
       case OpKind.StyleProp:
-        op.name = normalizeStylePropName(op.name);
-        if (compatibility) {
-          op.name = stripImportant(op.name);
-        }
+        op.name = stripImportant(normalizeStylePropName(op.name));
         break;
       case OpKind.ClassProp:
-        if (compatibility) {
-          op.name = stripImportant(op.name);
-        }
+        op.name = stripImportant(op.name);
         break;
     }
   }
@@ -20223,19 +20415,15 @@ function addNamesToView(unit, baseName, state, compatibility) {
   }
 }
 __name(addNamesToView, "addNamesToView");
-function getVariableName(unit, variable2, state) {
+function getVariableName(variable2, state) {
   if (variable2.name === null) {
     switch (variable2.kind) {
       case SemanticVariableKind.Context:
         variable2.name = `ctx_r${state.index++}`;
         break;
       case SemanticVariableKind.Identifier:
-        if (unit.job.compatibility === CompatibilityMode.TemplateDefinitionBuilder) {
-          const compatPrefix = variable2.identifier === "ctx" ? "i" : "";
-          variable2.name = `${variable2.identifier}_${compatPrefix}r${++state.index}`;
-        } else {
-          variable2.name = `${variable2.identifier}_i${state.index++}`;
-        }
+        const compatPrefix = variable2.identifier === CONTEXT_NAME ? "i" : "";
+        variable2.name = `${variable2.identifier}_${compatPrefix}r${++state.index}`;
         break;
       default:
         variable2.name = `_r${++state.index}`;
@@ -20259,6 +20447,9 @@ function stripImportant(name) {
 __name(stripImportant, "stripImportant");
 function mergeNextContextExpressions(job) {
   for (const unit of job.units) {
+    for (const expr of unit.functions) {
+      mergeNextContextsInOps(expr.ops);
+    }
     for (const op of unit.create) {
       if (op.kind === OpKind.Listener || op.kind === OpKind.Animation || op.kind === OpKind.AnimationListener || op.kind === OpKind.TwoWayListener) {
         mergeNextContextsInOps(op.handlerOps);
@@ -20501,15 +20692,11 @@ function processPipeBindingsInView(unit) {
       if (flags & VisitorContextFlag.InChildOperation) {
         throw new Error(`AssertionError: pipe bindings should not appear in child expressions`);
       }
-      if (unit.job.compatibility) {
-        const slotHandle = updateOp.target;
-        if (slotHandle == void 0) {
-          throw new Error(`AssertionError: expected slot handle to be assigned for pipe creation`);
-        }
-        addPipeToCreationBlock(unit, updateOp.target, expr);
-      } else {
-        unit.create.push(createPipeOp(expr.target, expr.targetSlot, expr.name));
+      const slotHandle = updateOp.target;
+      if (slotHandle == void 0) {
+        throw new Error(`AssertionError: expected slot handle to be assigned for pipe creation`);
       }
+      addPipeToCreationBlock(unit, updateOp.target, expr);
     });
   }
 }
@@ -20649,7 +20836,7 @@ var PureFunctionConstant = class extends GenericKeyFn {
       }
       return variable("a" + expr.index);
     }, VisitorContextFlag.None);
-    return new DeclareVarStmt(declName, new ArrowFunctionExpr(fnParams, returnExpr), void 0, StmtModifier.Final);
+    return new DeclareVarStmt(declName, new ArrowFunctionExpr$1(fnParams, returnExpr), void 0, StmtModifier.Final);
   }
 };
 function generatePureLiteralStructures(job) {
@@ -21045,18 +21232,8 @@ function property(name, expression, sanitizer, sourceSpan) {
   return propertyBase(Identifiers.property, name, expression, sanitizer, sourceSpan);
 }
 __name(property, "property");
-function control(name, expression, sanitizer, sourceSpan) {
-  const args = [];
-  if (expression instanceof Interpolation2) {
-    args.push(interpolationToExpression(expression, sourceSpan));
-  } else {
-    args.push(expression);
-  }
-  args.push(literal(name));
-  if (sanitizer !== null) {
-    args.push(sanitizer);
-  }
-  return call(Identifiers.control, args, sourceSpan);
+function control(sourceSpan) {
+  return call(Identifiers.control, [], sourceSpan);
 }
 __name(control, "control");
 function controlCreate(sourceSpan) {
@@ -21217,6 +21394,10 @@ function attachSourceLocation(templatePath, locations) {
   return call(Identifiers.attachSourceLocations, [literal(templatePath), locations], null);
 }
 __name(attachSourceLocation, "attachSourceLocation");
+function arrowFunction(slotOffset, factory, contextRef) {
+  return importExpr(Identifiers.arrowFunction).callFn([literal(slotOffset), factory, contextRef]);
+}
+__name(arrowFunction, "arrowFunction");
 function collateInterpolationArgs(strings, expressions) {
   if (strings.length < 1 || expressions.length !== strings.length - 1) {
     throw new Error(`AssertionError: expected specific shape of args for strings/expressions in interpolation`);
@@ -21307,7 +21488,7 @@ function reify(job) {
 __name(reify, "reify");
 function reifyCreateOperations(unit, ops) {
   for (const op of ops) {
-    transformExpressionsInOp(op, reifyIrExpression, VisitorContextFlag.None);
+    transformExpressionsInOp(op, (expr) => reifyIrExpression(unit, expr), VisitorContextFlag.None);
     switch (op.kind) {
       case OpKind.Text:
         OpList.replace(op, text(op.handle.slot, op.initialValue, op.sourceSpan));
@@ -21555,7 +21736,7 @@ function reifyCreateOperations(unit, ops) {
 __name(reifyCreateOperations, "reifyCreateOperations");
 function reifyUpdateOperations(unit, ops) {
   for (const op of ops) {
-    transformExpressionsInOp(op, reifyIrExpression, VisitorContextFlag.None);
+    transformExpressionsInOp(op, (expr) => reifyIrExpression(unit, expr), VisitorContextFlag.None);
     switch (op.kind) {
       case OpKind.Advance:
         OpList.replace(op, advance(op.delta, op.sourceSpan));
@@ -21641,10 +21822,10 @@ function reifyProperty(op) {
 }
 __name(reifyProperty, "reifyProperty");
 function reifyControl(op) {
-  return control(op.name, op.expression, op.sanitizer, op.sourceSpan);
+  return control(op.sourceSpan);
 }
 __name(reifyControl, "reifyControl");
-function reifyIrExpression(expr) {
+function reifyIrExpression(unit, expr) {
   if (!isIrExpression(expr)) {
     return expr;
   }
@@ -21700,6 +21881,11 @@ function reifyIrExpression(expr) {
       return storeLet(expr.value, expr.sourceSpan);
     case ExpressionKind.TrackContext:
       return variable("this");
+    case ExpressionKind.ArrowFunction:
+      if (expr.varOffset === null) {
+        throw new Error(`AssertionError: variable offset was not assigned to arrow function`);
+      }
+      return arrowFunction(expr.varOffset, unit.job.pool.getSharedFunctionReference(getArrowFunctionFactory(unit, expr), "arrowFn"), variable(CONTEXT_NAME));
     default:
       throw new Error(`AssertionError: Unsupported reification of ir.Expression kind: ${ExpressionKind[expr.kind]}`);
   }
@@ -21744,6 +21930,19 @@ function reifyTrackBy(unit, op) {
   return op.trackByFn;
 }
 __name(reifyTrackBy, "reifyTrackBy");
+function getArrowFunctionFactory(unit, expr) {
+  reifyUpdateOperations(unit, expr.ops);
+  const statements = [];
+  for (const op of expr.ops) {
+    if (op.kind !== OpKind.Statement) {
+      throw new Error(`AssertionError: expected reified statements, but found op ${OpKind[op.kind]}`);
+    }
+    statements.push(op.statement);
+  }
+  const body = statements.length === 1 && statements[0] instanceof ReturnStatement ? statements[0].value : statements;
+  return arrowFn([new FnParam(expr.contextName), new FnParam(expr.currentViewName)], arrowFn(expr.parameters, body));
+}
+__name(getArrowFunctionFactory, "getArrowFunctionFactory");
 function removeEmptyBindings(job) {
   for (const unit of job.units) {
     for (const op of unit.update) {
@@ -21818,6 +22017,9 @@ function removeUnusedI18nAttributesOps(job) {
 __name(removeUnusedI18nAttributesOps, "removeUnusedI18nAttributesOps");
 function resolveContexts(job) {
   for (const unit of job.units) {
+    for (const expr of unit.functions) {
+      processLexicalScope$1(unit, expr.ops);
+    }
     processLexicalScope$1(unit, unit.create);
     processLexicalScope$1(unit, unit.update);
   }
@@ -21825,7 +22027,7 @@ function resolveContexts(job) {
 __name(resolveContexts, "resolveContexts");
 function processLexicalScope$1(view, ops) {
   const scope = /* @__PURE__ */ new Map();
-  scope.set(view.xref, variable("ctx"));
+  scope.set(view.xref, variable(CONTEXT_NAME));
   for (const op of ops) {
     switch (op.kind) {
       case OpKind.Variable:
@@ -21849,7 +22051,7 @@ function processLexicalScope$1(view, ops) {
     }
   }
   if (view === view.job.root) {
-    scope.set(view.xref, variable("ctx"));
+    scope.set(view.xref, variable(CONTEXT_NAME));
   }
   for (const op of ops) {
     transformExpressionsInOp(op, (expr) => {
@@ -22184,6 +22386,9 @@ function updatePlaceholder(op, value, i18nContexts, icuPlaceholders) {
 __name(updatePlaceholder, "updatePlaceholder");
 function resolveNames(job) {
   for (const unit of job.units) {
+    for (const expr of unit.functions) {
+      processLexicalScope(unit, expr.ops, null);
+    }
     processLexicalScope(unit, unit.create, null);
     processLexicalScope(unit, unit.update, null);
   }
@@ -22235,7 +22440,7 @@ function processLexicalScope(unit, ops, savedView) {
     }
   }
   for (const op of ops) {
-    if (op.kind == OpKind.Listener || op.kind === OpKind.TwoWayListener || op.kind === OpKind.Animation || op.kind === OpKind.AnimationListener) {
+    if (op.kind === OpKind.Listener || op.kind === OpKind.TwoWayListener || op.kind === OpKind.Animation || op.kind === OpKind.AnimationListener) {
       continue;
     }
     transformExpressionsInOp(op, (expr) => {
@@ -22309,45 +22514,53 @@ function getOnlySecurityContext(securityContext) {
 __name(getOnlySecurityContext, "getOnlySecurityContext");
 function saveAndRestoreView(job) {
   for (const unit of job.units) {
+    for (const expr of unit.functions) {
+      if (needsRestoreView(job, unit, expr.ops)) {
+        addSaveRestoreViewOperation(unit, expr.ops, variable(expr.currentViewName));
+      }
+    }
     unit.create.prepend([createVariableOp(unit.job.allocateXrefId(), {
       kind: SemanticVariableKind.SavedView,
       name: null,
       view: unit.xref
     }, new GetCurrentViewExpr(), VariableFlags.None)]);
     for (const op of unit.create) {
-      if (op.kind !== OpKind.Listener && op.kind !== OpKind.TwoWayListener && op.kind !== OpKind.Animation && op.kind !== OpKind.AnimationListener) {
-        continue;
-      }
-      let needsRestoreView = unit !== job.root;
-      if (!needsRestoreView) {
-        for (const handlerOp of op.handlerOps) {
-          visitExpressionsInOp(handlerOp, (expr) => {
-            if (expr instanceof ReferenceExpr || expr instanceof ContextLetReferenceExpr) {
-              needsRestoreView = true;
-            }
-          });
+      if (op.kind === OpKind.Listener || op.kind === OpKind.TwoWayListener || op.kind === OpKind.Animation || op.kind === OpKind.AnimationListener) {
+        if (needsRestoreView(job, unit, op.handlerOps)) {
+          addSaveRestoreViewOperation(unit, op.handlerOps, unit.xref);
         }
       }
-      if (needsRestoreView) {
-        addSaveRestoreViewOperationToListener(unit, op);
-      }
     }
   }
 }
 __name(saveAndRestoreView, "saveAndRestoreView");
-function addSaveRestoreViewOperationToListener(unit, op) {
-  op.handlerOps.prepend([createVariableOp(unit.job.allocateXrefId(), {
+function needsRestoreView(job, unit, opList) {
+  let result = unit !== job.root;
+  if (!result) {
+    for (const innerOp of opList) {
+      visitExpressionsInOp(innerOp, (expr) => {
+        if (expr instanceof ReferenceExpr || expr instanceof ContextLetReferenceExpr) {
+          result = true;
+        }
+      });
+    }
+  }
+  return result;
+}
+__name(needsRestoreView, "needsRestoreView");
+function addSaveRestoreViewOperation(unit, opList, restoreViewTarget) {
+  opList.prepend([createVariableOp(unit.job.allocateXrefId(), {
     kind: SemanticVariableKind.Context,
     name: null,
     view: unit.xref
-  }, new RestoreViewExpr(unit.xref), VariableFlags.None)]);
-  for (const handlerOp of op.handlerOps) {
+  }, new RestoreViewExpr(restoreViewTarget), VariableFlags.None)]);
+  for (const handlerOp of opList) {
     if (handlerOp.kind === OpKind.Statement && handlerOp.statement instanceof ReturnStatement) {
       handlerOp.statement.value = new ResetViewExpr(handlerOp.statement.value);
     }
   }
 }
-__name(addSaveRestoreViewOperationToListener, "addSaveRestoreViewOperationToListener");
+__name(addSaveRestoreViewOperation, "addSaveRestoreViewOperation");
 function allocateSlots(job) {
   const slotMap = /* @__PURE__ */ new Map();
   for (const unit of job.units) {
@@ -22504,6 +22717,9 @@ function generateTemporaryVariables(job) {
   for (const unit of job.units) {
     unit.create.prepend(generateTemporaries(unit.create));
     unit.update.prepend(generateTemporaries(unit.update));
+    for (const expr of unit.functions) {
+      expr.ops.prepend(generateTemporaries(expr.ops));
+    }
   }
 }
 __name(generateTemporaryVariables, "generateTemporaryVariables");
@@ -22669,36 +22885,42 @@ function countVariables(job) {
         varCount += varsUsedByOp(op);
       }
     }
-    for (const op of unit.ops()) {
-      visitExpressionsInOp(op, (expr) => {
-        if (!isIrExpression(expr)) {
-          return;
-        }
-        if (job.compatibility === CompatibilityMode.TemplateDefinitionBuilder && expr instanceof PureFunctionExpr) {
-          return;
-        }
-        if (hasUsesVarOffsetTrait(expr)) {
-          expr.varOffset = varCount;
-        }
-        if (hasConsumesVarsTrait(expr)) {
-          varCount += varsUsedByIrExpression(expr);
-        }
-      });
-    }
-    if (job.compatibility === CompatibilityMode.TemplateDefinitionBuilder) {
-      for (const op of unit.ops()) {
-        visitExpressionsInOp(op, (expr) => {
-          if (!isIrExpression(expr) || !(expr instanceof PureFunctionExpr)) {
-            return;
-          }
-          if (hasUsesVarOffsetTrait(expr)) {
-            expr.varOffset = varCount;
-          }
-          if (hasConsumesVarsTrait(expr)) {
-            varCount += varsUsedByIrExpression(expr);
-          }
-        });
+    const firstPassCountExpressionVars = /* @__PURE__ */ __name((expr) => {
+      if (!isIrExpression(expr)) {
+        return;
+      }
+      if (expr instanceof PureFunctionExpr) {
+        return;
+      }
+      if (hasUsesVarOffsetTrait(expr)) {
+        expr.varOffset = varCount;
+      }
+      if (hasConsumesVarsTrait(expr)) {
+        varCount += varsUsedByIrExpression(expr);
       }
+    }, "firstPassCountExpressionVars");
+    const secondPassCountExpressionVars = /* @__PURE__ */ __name((expr) => {
+      if (!isIrExpression(expr) || !(expr instanceof PureFunctionExpr)) {
+        return;
+      }
+      if (hasUsesVarOffsetTrait(expr)) {
+        expr.varOffset = varCount;
+      }
+      if (hasConsumesVarsTrait(expr)) {
+        varCount += varsUsedByIrExpression(expr);
+      }
+    }, "secondPassCountExpressionVars");
+    for (const createOp of unit.create) {
+      visitExpressionsInOp(createOp, firstPassCountExpressionVars);
+    }
+    for (const updateOp of unit.update) {
+      visitExpressionsInOp(updateOp, firstPassCountExpressionVars);
+    }
+    for (const createOp of unit.create) {
+      visitExpressionsInOp(createOp, secondPassCountExpressionVars);
+    }
+    for (const updateOp of unit.update) {
+      visitExpressionsInOp(updateOp, secondPassCountExpressionVars);
     }
     unit.vars = varCount;
   }
@@ -22767,6 +22989,7 @@ function varsUsedByIrExpression(expr) {
     case ExpressionKind.PipeBindingVariadic:
       return 1 + expr.numArgs;
     case ExpressionKind.StoreLet:
+    case ExpressionKind.ArrowFunction:
       return 1;
     default:
       throw new Error(`AssertionError: unhandled ConsumesVarsTrait expression ${expr.constructor.name}`);
@@ -22785,6 +23008,9 @@ function isSingletonInterpolation(expr) {
 __name(isSingletonInterpolation, "isSingletonInterpolation");
 function optimizeVariables(job) {
   for (const unit of job.units) {
+    for (const expr of unit.functions) {
+      inlineAlwaysInlineVariables(expr.ops);
+    }
     inlineAlwaysInlineVariables(unit.create);
     inlineAlwaysInlineVariables(unit.update);
     for (const op of unit.create) {
@@ -22794,15 +23020,20 @@ function optimizeVariables(job) {
         inlineAlwaysInlineVariables(op.trackByOps);
       }
     }
-    optimizeVariablesInOpList(unit.create, job.compatibility);
-    optimizeVariablesInOpList(unit.update, job.compatibility);
+    for (const expr of unit.functions) {
+      optimizeVariablesInOpList(expr.ops, null);
+      optimizeSaveRestoreView(expr.ops);
+    }
     for (const op of unit.create) {
       if (op.kind === OpKind.Listener || op.kind === OpKind.Animation || op.kind === OpKind.AnimationListener || op.kind === OpKind.TwoWayListener) {
-        optimizeVariablesInOpList(op.handlerOps, job.compatibility);
+        optimizeVariablesInOpList(op.handlerOps, skipArrowFunctionOps);
+        optimizeSaveRestoreView(op.handlerOps);
       } else if (op.kind === OpKind.RepeaterCreate && op.trackByOps !== null) {
-        optimizeVariablesInOpList(op.trackByOps, job.compatibility);
+        optimizeVariablesInOpList(op.trackByOps, skipArrowFunctionOps);
       }
     }
+    optimizeVariablesInOpList(unit.create, skipArrowFunctionOps);
+    optimizeVariablesInOpList(unit.update, skipArrowFunctionOps);
   }
 }
 __name(optimizeVariables, "optimizeVariables");
@@ -22813,6 +23044,10 @@ var Fence;
   Fence2[Fence2["ViewContextWrite"] = 2] = "ViewContextWrite";
   Fence2[Fence2["SideEffectful"] = 4] = "SideEffectful";
 })(Fence || (Fence = {}));
+function skipArrowFunctionOps(flags) {
+  return !(flags & VisitorContextFlag.InArrowFunctionOperation);
+}
+__name(skipArrowFunctionOps, "skipArrowFunctionOps");
 function inlineAlwaysInlineVariables(ops) {
   const vars = /* @__PURE__ */ new Map();
   for (const op of ops) {
@@ -22837,7 +23072,7 @@ function inlineAlwaysInlineVariables(ops) {
   }
 }
 __name(inlineAlwaysInlineVariables, "inlineAlwaysInlineVariables");
-function optimizeVariablesInOpList(ops, compatibility) {
+function optimizeVariablesInOpList(ops, predicate) {
   const varDecls = /* @__PURE__ */ new Map();
   const varUsages = /* @__PURE__ */ new Map();
   const varRemoteUsages = /* @__PURE__ */ new Set();
@@ -22850,8 +23085,8 @@ function optimizeVariablesInOpList(ops, compatibility) {
       varDecls.set(op.xref, op);
       varUsages.set(op.xref, 0);
     }
-    opMap.set(op, collectOpInfo(op));
-    countVariableUsages(op, varUsages, varRemoteUsages);
+    opMap.set(op, collectOpInfo(op, predicate));
+    countVariableUsages(op, varUsages, varRemoteUsages, predicate);
   }
   let contextIsUsed = false;
   for (const op of ops.reversed()) {
@@ -22897,7 +23132,7 @@ function optimizeVariablesInOpList(ops, compatibility) {
     for (let targetOp = decl.next; targetOp.kind !== OpKind.ListEnd; targetOp = targetOp.next) {
       const opInfo = opMap.get(targetOp);
       if (opInfo.variablesUsed.has(candidate)) {
-        if (compatibility === CompatibilityMode.TemplateDefinitionBuilder && !allowConservativeInlining(decl, targetOp)) {
+        if (!allowConservativeInlining(decl, targetOp)) {
           break;
         }
         if (tryInlineVariableInitializer(candidate, decl.initializer, targetOp, varInfo.fences)) {
@@ -22936,19 +23171,17 @@ function fencesForIrExpression(expr) {
   }
 }
 __name(fencesForIrExpression, "fencesForIrExpression");
-function collectOpInfo(op) {
+function collectOpInfo(op, predicate) {
   let fences = Fence.None;
   const variablesUsed = /* @__PURE__ */ new Set();
-  visitExpressionsInOp(op, (expr) => {
-    if (!isIrExpression(expr)) {
+  visitExpressionsInOp(op, (expr, flags) => {
+    if (!isIrExpression(expr) || predicate !== null && !predicate(flags)) {
       return;
     }
-    switch (expr.kind) {
-      case ExpressionKind.ReadVariable:
-        variablesUsed.add(expr.xref);
-        break;
-      default:
-        fences |= fencesForIrExpression(expr);
+    if (expr.kind === ExpressionKind.ReadVariable) {
+      variablesUsed.add(expr.xref);
+    } else {
+      fences |= fencesForIrExpression(expr);
     }
   });
   return {
@@ -22957,9 +23190,9 @@ function collectOpInfo(op) {
   };
 }
 __name(collectOpInfo, "collectOpInfo");
-function countVariableUsages(op, varUsages, varRemoteUsage) {
+function countVariableUsages(op, varUsages, varRemoteUsage, predicate) {
   visitExpressionsInOp(op, (expr, flags) => {
-    if (!isIrExpression(expr)) {
+    if (!isIrExpression(expr) || predicate !== null && !predicate(flags)) {
       return;
     }
     if (expr.kind !== ExpressionKind.ReadVariable) {
@@ -23039,7 +23272,7 @@ __name(tryInlineVariableInitializer, "tryInlineVariableInitializer");
 function allowConservativeInlining(decl, target) {
   switch (decl.variable.kind) {
     case SemanticVariableKind.Identifier:
-      if (decl.initializer instanceof ReadVarExpr && decl.initializer.name === "ctx") {
+      if (decl.initializer instanceof ReadVarExpr && decl.initializer.name === CONTEXT_NAME) {
         return true;
       }
       return false;
@@ -23050,6 +23283,15 @@ function allowConservativeInlining(decl, target) {
   }
 }
 __name(allowConservativeInlining, "allowConservativeInlining");
+function optimizeSaveRestoreView(ops) {
+  const head = ops.head.next;
+  const tail = ops.tail.prev;
+  if (head !== null && tail !== null && head.next === tail && head.kind === OpKind.Statement && head.statement instanceof ExpressionStatement && head.statement.expr instanceof RestoreViewExpr && tail.kind === OpKind.Statement && tail.statement instanceof ReturnStatement && tail.statement.value instanceof ResetViewExpr) {
+    OpList.remove(head);
+    tail.statement.value = tail.statement.value.expr;
+  }
+}
+__name(optimizeSaveRestoreView, "optimizeSaveRestoreView");
 function wrapI18nIcus(job) {
   for (const unit of job.units) {
     let currentI18nOp = null;
@@ -23079,6 +23321,77 @@ function wrapI18nIcus(job) {
   }
 }
 __name(wrapI18nIcus, "wrapI18nIcus");
+function generateArrowFunctions(job) {
+  for (const unit of job.units) {
+    for (const op of unit.create) {
+      if (op.kind !== OpKind.Animation && op.kind !== OpKind.AnimationListener && op.kind !== OpKind.Listener && op.kind !== OpKind.TwoWayListener) {
+        addArrowFunctions(unit, op);
+      }
+    }
+    for (const op of unit.update) {
+      addArrowFunctions(unit, op);
+    }
+  }
+}
+__name(generateArrowFunctions, "generateArrowFunctions");
+function addArrowFunctions(unit, op) {
+  transformExpressionsInOp(op, (expr, flags) => {
+    if (!(expr instanceof ArrowFunctionExpr$1) || flags & VisitorContextFlag.InChildOperation) {
+      return expr;
+    }
+    if (Array.isArray(expr.body)) {
+      throw new Error("AssertionError: unexpected multi-line arrow function");
+    }
+    const arrowFunction2 = new ArrowFunctionExpr2(expr.params, expr.body);
+    unit.functions.add(arrowFunction2);
+    return arrowFunction2;
+  }, VisitorContextFlag.None);
+}
+__name(addArrowFunctions, "addArrowFunctions");
+var ELIGIBLE_CONTROL_PROPERTIES = /* @__PURE__ */ new Set(["formField"]);
+function specializeControlProperties(job) {
+  for (const unit of job.units) {
+    processView(unit);
+  }
+}
+__name(specializeControlProperties, "specializeControlProperties");
+function processView(view) {
+  for (const op of view.update) {
+    if (op.kind !== OpKind.Property) {
+      continue;
+    }
+    if (ELIGIBLE_CONTROL_PROPERTIES.has(op.name)) {
+      addControlInstruction(view, op);
+    }
+  }
+}
+__name(processView, "processView");
+var CONTROL_OP_CREATE_KINDS = /* @__PURE__ */ new Set([OpKind.Container, OpKind.ContainerStart, OpKind.ContainerEnd, OpKind.Element, OpKind.ElementStart, OpKind.ElementEnd, OpKind.Template]);
+function isRelevantCreateOp(createOp) {
+  return CONTROL_OP_CREATE_KINDS.has(createOp.kind);
+}
+__name(isRelevantCreateOp, "isRelevantCreateOp");
+function findCreateInstruction(view, target) {
+  let lastFoundOp = null;
+  for (const createOp of view.create) {
+    if (!isRelevantCreateOp(createOp) || createOp.xref !== target) {
+      continue;
+    }
+    lastFoundOp = createOp;
+  }
+  return lastFoundOp;
+}
+__name(findCreateInstruction, "findCreateInstruction");
+function addControlInstruction(view, propertyOp) {
+  const targetCreateOp = findCreateInstruction(view, propertyOp.target);
+  if (targetCreateOp === null) {
+    throw new Error(`No create instruction found for control target ${propertyOp.target}`);
+  }
+  const controlCreateOp = createControlCreateOp(propertyOp.sourceSpan);
+  OpList.insertAfter(controlCreateOp, targetCreateOp);
+  OpList.insertAfter(createControlOp(propertyOp.target, propertyOp.sourceSpan), propertyOp);
+}
+__name(addControlInstruction, "addControlInstruction");
 var phases = [{
   kind: CompilationJobKind.Tmpl,
   fn: removeContentSelectors
@@ -23106,6 +23419,9 @@ var phases = [{
 }, {
   kind: CompilationJobKind.Both,
   fn: specializeBindings
+}, {
+  kind: CompilationJobKind.Tmpl,
+  fn: specializeControlProperties
 }, {
   kind: CompilationJobKind.Both,
   fn: convertAnimations
@@ -23139,6 +23455,9 @@ var phases = [{
 }, {
   kind: CompilationJobKind.Tmpl,
   fn: createVariadicPipes
+}, {
+  kind: CompilationJobKind.Both,
+  fn: generateArrowFunctions
 }, {
   kind: CompilationJobKind.Both,
   fn: generatePureLiteralStructures
@@ -23323,14 +23642,14 @@ function emitView(view) {
   }
   const createCond = maybeGenerateRfBlock(1, createStatements);
   const updateCond = maybeGenerateRfBlock(2, updateStatements);
-  return fn([new FnParam("rf"), new FnParam("ctx")], [...createCond, ...updateCond], void 0, void 0, view.fnName);
+  return fn([new FnParam(RENDER_FLAGS), new FnParam(CONTEXT_NAME)], [...createCond, ...updateCond], void 0, void 0, view.fnName);
 }
 __name(emitView, "emitView");
 function maybeGenerateRfBlock(flag, statements) {
   if (statements.length === 0) {
     return [];
   }
-  return [ifStmt(new BinaryOperatorExpr(BinaryOperator.BitwiseAnd, variable("rf"), literal(flag)), statements)];
+  return [ifStmt(new BinaryOperatorExpr(BinaryOperator.BitwiseAnd, variable(RENDER_FLAGS), literal(flag)), statements)];
 }
 __name(maybeGenerateRfBlock, "maybeGenerateRfBlock");
 function emitHostBindingFunction(job) {
@@ -23356,10 +23675,9 @@ function emitHostBindingFunction(job) {
   }
   const createCond = maybeGenerateRfBlock(1, createStatements);
   const updateCond = maybeGenerateRfBlock(2, updateStatements);
-  return fn([new FnParam("rf"), new FnParam("ctx")], [...createCond, ...updateCond], void 0, void 0, job.root.fnName);
+  return fn([new FnParam(RENDER_FLAGS), new FnParam(CONTEXT_NAME)], [...createCond, ...updateCond], void 0, void 0, job.root.fnName);
 }
 __name(emitHostBindingFunction, "emitHostBindingFunction");
-var compatibilityMode = CompatibilityMode.TemplateDefinitionBuilder;
 var domSchema = new DomElementSchemaRegistry();
 var NG_TEMPLATE_TAG_NAME = "ng-template";
 var ANIMATE_PREFIX$1 = "animate.";
@@ -23372,13 +23690,13 @@ function isSingleI18nIcu(meta) {
 }
 __name(isSingleI18nIcu, "isSingleI18nIcu");
 function ingestComponent(componentName, template2, constantPool, compilationMode, relativeContextFilePath, i18nUseExternalIds, deferMeta, allDeferrableDepsFn, relativeTemplatePath, enableDebugLocations) {
-  const job = new ComponentCompilationJob(componentName, constantPool, compatibilityMode, compilationMode, relativeContextFilePath, i18nUseExternalIds, deferMeta, allDeferrableDepsFn, relativeTemplatePath, enableDebugLocations);
+  const job = new ComponentCompilationJob(componentName, constantPool, compilationMode, relativeContextFilePath, i18nUseExternalIds, deferMeta, allDeferrableDepsFn, relativeTemplatePath, enableDebugLocations);
   ingestNodes(job.root, template2);
   return job;
 }
 __name(ingestComponent, "ingestComponent");
 function ingestHostBinding(input, bindingParser, constantPool) {
-  const job = new HostBindingCompilationJob(input.componentName, constantPool, compatibilityMode, TemplateCompilationMode.DomOnly);
+  const job = new HostBindingCompilationJob(input.componentName, constantPool, TemplateCompilationMode.DomOnly);
   for (const property2 of input.properties ?? []) {
     let bindingKind = BindingKind.Property;
     if (property2.name.startsWith("attr.")) {
@@ -23480,10 +23798,6 @@ function ingestElement(unit, element2) {
   ingestNodes(unit, element2.children);
   const endOp = createElementEndOp(id, element2.endSourceSpan ?? element2.startSourceSpan);
   unit.create.push(endOp);
-  const fieldInput = element2.inputs.find((input) => input.name === "formField" && input.type === BindingType.Property);
-  if (fieldInput) {
-    unit.create.push(createControlCreateOp(fieldInput.sourceSpan));
-  }
   if (i18nBlockId !== null) {
     OpList.insertBefore(createI18nEndOp(i18nBlockId, element2.endSourceSpan ?? element2.startSourceSpan), endOp);
   }
@@ -23560,8 +23874,7 @@ function ingestBoundText(unit, text2, icuPlaceholder) {
   }
   const textXref = unit.job.allocateXrefId();
   unit.create.push(createTextOp(textXref, "", icuPlaceholder, 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, null)), i18nPlaceholders), text2.sourceSpan));
 }
 __name(ingestBoundText, "ingestBoundText");
 function ingestIfBlock(unit, ifBlock) {
@@ -23930,6 +24243,8 @@ function convertAst(ast, job, baseSourceSpan) {
     return new RegularExpressionLiteralExpr(ast.body, ast.flags, baseSourceSpan);
   } else if (ast instanceof SpreadElement) {
     return new SpreadElementExpr(convertAst(ast.expression, job, baseSourceSpan));
+  } else if (ast instanceof ArrowFunction) {
+    return updateParameterReferences(arrowFn(ast.parameters.map((arg) => new FnParam(arg.name)), convertAst(ast.body, job, baseSourceSpan)));
   } else {
     throw new Error(`Unhandled expression type "${ast.constructor.name}" in file "${baseSourceSpan?.start.file.url}"`);
   }
@@ -24168,6 +24483,20 @@ function ingestControlFlowInsertionPoint(unit, xref, node) {
   return null;
 }
 __name(ingestControlFlowInsertionPoint, "ingestControlFlowInsertionPoint");
+function updateParameterReferences(root) {
+  const parameterNames = new Set(root.params.map((param) => param.name));
+  return transformExpressionsInExpression(root, (expr) => {
+    if (expr instanceof ArrowFunctionExpr$1) {
+      for (const param of expr.params) {
+        parameterNames.add(param.name);
+      }
+    } else if (expr instanceof LexicalReadExpr && parameterNames.has(expr.name)) {
+      return variable(expr.name);
+    }
+    return expr;
+  }, VisitorContextFlag.None);
+}
+__name(updateParameterReferences, "updateParameterReferences");
 var ENABLE_TEMPLATE_SOURCE_LOCATIONS = false;
 function setEnableTemplateSourceLocations(value) {
   ENABLE_TEMPLATE_SOURCE_LOCATIONS = value;
@@ -24880,18 +25209,31 @@ function createSwitchBlock(ast, visitor, bindingParser) {
   const unknownBlocks = [];
   let collectedCases = [];
   let firstCaseStart = null;
+  let exhaustiveCheck = null;
   for (const node2 of ast.children) {
     if (!(node2 instanceof Block)) {
       continue;
     }
-    if ((node2.name !== "case" || node2.parameters.length === 0) && node2.name !== "default") {
+    if ((node2.name !== "case" || node2.parameters.length === 0) && node2.name !== "default" && node2.name !== "default never") {
       unknownBlocks.push(new UnknownBlock(node2.name, node2.sourceSpan, node2.nameSpan));
       continue;
     }
+    if (exhaustiveCheck !== null) {
+      errors.push(new ParseError(node2.sourceSpan, '@default block with "never" parameter must be the last case in a switch'));
+    }
     const isCase = node2.name === "case";
     let expression = null;
     if (isCase) {
       expression = parseBlockParameterToBinding(node2.parameters[0], bindingParser);
+    } else if (node2.name === "default never") {
+      if (node2.children.length > 0 || node2.endSourceSpan !== null && node2.endSourceSpan.start.offset !== node2.endSourceSpan.end.offset) {
+        errors.push(new ParseError(node2.sourceSpan, '@default block with "never" parameter cannot have a body'));
+      }
+      if (collectedCases.length > 0) {
+        errors.push(new ParseError(node2.sourceSpan, 'A @case block with no body cannot be followed by a @default block with "never" parameter'));
+      }
+      exhaustiveCheck = new SwitchExhaustiveCheck(node2.sourceSpan, node2.startSourceSpan, node2.endSourceSpan, node2.nameSpan);
+      continue;
     }
     const switchCase = new SwitchBlockCase(expression, node2.sourceSpan, node2.startSourceSpan, node2.endSourceSpan, node2.nameSpan);
     collectedCases.push(switchCase);
@@ -24913,7 +25255,7 @@ function createSwitchBlock(ast, visitor, bindingParser) {
     groups.push(group);
     collectedCases = [];
   }
-  const node = new SwitchBlock(primaryExpression, groups, unknownBlocks, ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan, ast.nameSpan);
+  const node = new SwitchBlock(primaryExpression, groups, unknownBlocks, exhaustiveCheck, ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan, ast.nameSpan);
   return {
     node,
     errors
@@ -25045,11 +25387,16 @@ function validateSwitchBlock(ast) {
     if (node instanceof Comment2 || node instanceof Text4 && node.value.trim().length === 0) {
       continue;
     }
-    if (!(node instanceof Block) || node.name !== "case" && node.name !== "default") {
+    if (!(node instanceof Block) || node.name !== "case" && node.name !== "default" && node.name !== "default never") {
       errors.push(new ParseError(node.sourceSpan, "@switch block can only contain @case and @default blocks"));
       continue;
     }
-    if (node.name === "default") {
+    if (node.name === "default never") {
+      if (hasDefault) {
+        errors.push(new ParseError(node.startSourceSpan, "@switch block can only have one @default block"));
+      }
+      hasDefault = true;
+    } else if (node.name === "default") {
       if (hasDefault) {
         errors.push(new ParseError(node.startSourceSpan, "@switch block can only have one @default block"));
       } else if (node.parameters.length > 0) {
@@ -26467,6 +26814,9 @@ function addFeatures(definitionMap, meta) {
   if (meta.lifecycle.usesOnChanges) {
     features.push(importExpr(Identifiers.NgOnChangesFeature));
   }
+  if (meta.controlCreate !== null) {
+    features.push(importExpr(Identifiers.ControlFeature).callFn([literal(meta.controlCreate.passThroughInput)]));
+  }
   if ("externalStyles" in meta && meta.externalStyles?.length) {
     const externalStyleNodes = meta.externalStyles.map((externalStyle) => literal(externalStyle));
     features.push(importExpr(Identifiers.ExternalStylesFeature).callFn([literalArr(externalStyleNodes)]));
@@ -26933,6 +27283,8 @@ var CombinedRecursiveAstVisitor = class extends RecursiveAstVisitor2 {
     this.visitAllTemplateNodes(block.cases);
     this.visitAllTemplateNodes(block.children);
   }
+  visitSwitchExhaustiveCheck(block) {
+  }
   visitForLoopBlock(block) {
     block.item.visit(this);
     this.visitAllTemplateNodes(block.contextVariables);
@@ -27144,6 +27496,8 @@ var Scope2 = class _Scope {
   visitSwitchBlockCaseGroup(block) {
     this.ingestScopedNode(block);
   }
+  visitSwitchExhaustiveCheck(block) {
+  }
   visitForLoopBlock(block) {
     this.ingestScopedNode(block);
     block.empty?.visit(this);
@@ -27276,6 +27630,8 @@ var DirectiveBinder = class _DirectiveBinder {
   visitSwitchBlockCaseGroup(block) {
     block.children.forEach((node) => node.visit(this));
   }
+  visitSwitchExhaustiveCheck(block) {
+  }
   visitForLoopBlock(block) {
     block.item.visit(this);
     block.contextVariables.forEach((v) => v.visit(this));
@@ -27527,6 +27883,8 @@ var TemplateBinder = class _TemplateBinder extends CombinedRecursiveAstVisitor {
     block.cases.forEach((caseNode) => caseNode.visit(this));
     this.ingestScopedNode(block);
   }
+  visitSwitchExhaustiveCheck(block) {
+  }
   visitForLoopBlock(block) {
     block.expression.visit(this);
     this.ingestScopedNode(block);
@@ -28050,6 +28408,7 @@ function convertDeclareDirectiveFacadeToMetadata(declaration, typeSourceSpan) {
     providers: declaration.providers !== void 0 ? new WrappedNodeExpr(declaration.providers) : null,
     exportAs: declaration.exportAs ?? null,
     usesInheritance: declaration.usesInheritance ?? false,
+    controlCreate: declaration.controlCreate ?? null,
     lifecycle: {
       usesOnChanges: declaration.usesOnChanges ?? false
     },
@@ -30084,7 +30443,7 @@ var MINIMUM_PARTIAL_LINKER_DEFER_SUPPORT_VERSION = "18.0.0";
 function compileDeclareClassMetadata(metadata) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION$5));
-  definitionMap.set("version", literal("21.1.4"));
+  definitionMap.set("version", literal("21.2.0"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", metadata.type);
   definitionMap.set("decorators", metadata.decorators);
@@ -30103,7 +30462,7 @@ function compileComponentDeclareClassMetadata(metadata, dependencies) {
   callbackReturnDefinitionMap.set("ctorParameters", metadata.ctorParameters ?? literal(null));
   callbackReturnDefinitionMap.set("propDecorators", metadata.propDecorators ?? literal(null));
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_DEFER_SUPPORT_VERSION));
-  definitionMap.set("version", literal("21.1.4"));
+  definitionMap.set("version", literal("21.2.0"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", metadata.type);
   definitionMap.set("resolveDeferredDeps", compileComponentMetadataAsyncResolver(dependencies));
@@ -30180,7 +30539,7 @@ function createDirectiveDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   const minVersion = getMinimumVersionForPartialOutput(meta);
   definitionMap.set("minVersion", literal(minVersion));
-  definitionMap.set("version", literal("21.1.4"));
+  definitionMap.set("version", literal("21.2.0"));
   definitionMap.set("type", meta.type.value);
   if (meta.isStandalone !== void 0) {
     definitionMap.set("isStandalone", literal(meta.isStandalone));
@@ -30210,6 +30569,13 @@ function createDirectiveDefinitionMap(meta) {
   if (meta.lifecycle.usesOnChanges) {
     definitionMap.set("usesOnChanges", literal(true));
   }
+  if (meta.controlCreate) {
+    definitionMap.set("controlCreate", literalMap([{
+      key: "passThroughInput",
+      value: literal(meta.controlCreate.passThroughInput),
+      quoted: false
+    }]));
+  }
   if (meta.hostDirectives?.length) {
     definitionMap.set("hostDirectives", createHostDirectives(meta.hostDirectives));
   }
@@ -30529,7 +30895,7 @@ var MINIMUM_PARTIAL_LINKER_VERSION$4 = "12.0.0";
 function compileDeclareFactoryFunction(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION$4));
-  definitionMap.set("version", literal("21.1.4"));
+  definitionMap.set("version", literal("21.2.0"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   definitionMap.set("deps", compileDependencies(meta.deps));
@@ -30556,7 +30922,7 @@ __name(compileDeclareInjectableFromMetadata, "compileDeclareInjectableFromMetada
 function createInjectableDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION$3));
-  definitionMap.set("version", literal("21.1.4"));
+  definitionMap.set("version", literal("21.2.0"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   if (meta.providedIn !== void 0) {
@@ -30598,7 +30964,7 @@ __name(compileDeclareInjectorFromMetadata, "compileDeclareInjectorFromMetadata")
 function createInjectorDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION$2));
-  definitionMap.set("version", literal("21.1.4"));
+  definitionMap.set("version", literal("21.2.0"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   definitionMap.set("providers", meta.providers);
@@ -30626,7 +30992,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_VERSION$1));
-  definitionMap.set("version", literal("21.1.4"));
+  definitionMap.set("version", literal("21.2.0"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   if (meta.bootstrap.length > 0) {
@@ -30665,7 +31031,7 @@ __name(compileDeclarePipeFromMetadata, "compileDeclarePipeFromMetadata");
 function createPipeDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION));
-  definitionMap.set("version", literal("21.1.4"));
+  definitionMap.set("version", literal("21.2.0"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   if (meta.isStandalone !== void 0) {
@@ -30740,7 +31106,7 @@ function compileHmrUpdateCallback(definitions, constantStatements, meta) {
   return new DeclareFunctionStmt(`${meta.className}_UpdateMetadata`, params, body, null, StmtModifier.Final);
 }
 __name(compileHmrUpdateCallback, "compileHmrUpdateCallback");
-var VERSION = new Version("21.1.4");
+var VERSION = new Version("21.2.0");
 publishFacade(_global);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -30749,7 +31115,9 @@ publishFacade(_global);
   ASTWithSource,
   AbsoluteSourceSpan,
   ArrayType,
+  ArrowFunction,
   ArrowFunctionExpr,
+  ArrowFunctionIdentifierParameter,
   Attribute,
   Binary,
   BinaryOperator,
@@ -30917,6 +31285,7 @@ publishFacade(_global);
   TmplAstSwitchBlock,
   TmplAstSwitchBlockCase,
   TmplAstSwitchBlockCaseGroup,
+  TmplAstSwitchExhaustiveCheck,
   TmplAstTemplate,
   TmplAstText,
   TmplAstTextAttribute,
@@ -31011,7 +31380,7 @@ publishFacade(_global);
 
 @angular/compiler/fesm2022/compiler.mjs:
   (**
-   * @license Angular v21.1.4
+   * @license Angular v21.2.0
    * (c) 2010-2026 Google LLC. https://angular.dev/
    * License: MIT
    *)