@angular/compiler 21.1.1 → 21.2.0-next.0

package/fesm2022/compiler.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v21.1.1
+ * @license Angular v21.2.0-next.0
  * (c) 2010-2026 Google LLC. https://angular.dev/
  * License: MIT
  */
@@ -784,15 +784,16 @@ var BinaryOperator;
   BinaryOperator[BinaryOperator["NullishCoalesce"] = 18] = "NullishCoalesce";
   BinaryOperator[BinaryOperator["Exponentiation"] = 19] = "Exponentiation";
   BinaryOperator[BinaryOperator["In"] = 20] = "In";
-  BinaryOperator[BinaryOperator["AdditionAssignment"] = 21] = "AdditionAssignment";
-  BinaryOperator[BinaryOperator["SubtractionAssignment"] = 22] = "SubtractionAssignment";
-  BinaryOperator[BinaryOperator["MultiplicationAssignment"] = 23] = "MultiplicationAssignment";
-  BinaryOperator[BinaryOperator["DivisionAssignment"] = 24] = "DivisionAssignment";
-  BinaryOperator[BinaryOperator["RemainderAssignment"] = 25] = "RemainderAssignment";
-  BinaryOperator[BinaryOperator["ExponentiationAssignment"] = 26] = "ExponentiationAssignment";
-  BinaryOperator[BinaryOperator["AndAssignment"] = 27] = "AndAssignment";
-  BinaryOperator[BinaryOperator["OrAssignment"] = 28] = "OrAssignment";
-  BinaryOperator[BinaryOperator["NullishCoalesceAssignment"] = 29] = "NullishCoalesceAssignment";
+  BinaryOperator[BinaryOperator["InstanceOf"] = 21] = "InstanceOf";
+  BinaryOperator[BinaryOperator["AdditionAssignment"] = 22] = "AdditionAssignment";
+  BinaryOperator[BinaryOperator["SubtractionAssignment"] = 23] = "SubtractionAssignment";
+  BinaryOperator[BinaryOperator["MultiplicationAssignment"] = 24] = "MultiplicationAssignment";
+  BinaryOperator[BinaryOperator["DivisionAssignment"] = 25] = "DivisionAssignment";
+  BinaryOperator[BinaryOperator["RemainderAssignment"] = 26] = "RemainderAssignment";
+  BinaryOperator[BinaryOperator["ExponentiationAssignment"] = 27] = "ExponentiationAssignment";
+  BinaryOperator[BinaryOperator["AndAssignment"] = 28] = "AndAssignment";
+  BinaryOperator[BinaryOperator["OrAssignment"] = 29] = "OrAssignment";
+  BinaryOperator[BinaryOperator["NullishCoalesceAssignment"] = 30] = "NullishCoalesceAssignment";
 })(BinaryOperator || (BinaryOperator = {}));
 function nullSafeIsEquivalent(base, other) {
   if (base == null || other == null) {
@@ -1357,7 +1358,7 @@ class FunctionExpr extends Expression {
     return new FunctionExpr(this.params.map(p => p.clone()), this.statements, this.type, this.sourceSpan, this.name);
   }
 }
-class ArrowFunctionExpr extends Expression {
+let ArrowFunctionExpr$1 = class ArrowFunctionExpr extends Expression {
   params;
   body;
   constructor(params, body, type, sourceSpan) {
@@ -1389,7 +1390,7 @@ class ArrowFunctionExpr extends Expression {
   toDeclStmt(name, modifiers) {
     return new DeclareVarStmt(name, this, INFERRED_TYPE, modifiers, this.sourceSpan);
   }
-}
+};
 class UnaryOperatorExpr extends Expression {
   operator;
   expr;
@@ -1981,7 +1982,7 @@ function fn(params, body, type, sourceSpan, name) {
   return new FunctionExpr(params, body, type, sourceSpan, name);
 }
 function arrowFn(params, body, type, sourceSpan) {
-  return new ArrowFunctionExpr(params, body, type, sourceSpan);
+  return new ArrowFunctionExpr$1(params, body, type, sourceSpan);
 }
 function ifStmt(condition, thenClause, elseClause, sourceSpan, leadingComments) {
   return new IfStmt(condition, thenClause, elseClause, sourceSpan, leadingComments);
@@ -2029,7 +2030,7 @@ function serializeTags(tags) {
 var output_ast = /*#__PURE__*/Object.freeze({
     __proto__: null,
     ArrayType: ArrayType,
-    ArrowFunctionExpr: ArrowFunctionExpr,
+    ArrowFunctionExpr: ArrowFunctionExpr$1,
     BOOL_TYPE: BOOL_TYPE,
     get BinaryOperator () { return BinaryOperator; },
     BinaryOperatorExpr: BinaryOperatorExpr,
@@ -2197,7 +2198,7 @@ class ConstantPool {
     return this.sharedConstants.get(key);
   }
   getSharedFunctionReference(fn, prefix, useUniqueName = true) {
-    const isArrow = fn instanceof ArrowFunctionExpr;
+    const isArrow = fn instanceof ArrowFunctionExpr$1;
     for (const current of this.statements) {
       if (isArrow && current instanceof DeclareVarStmt && current.value?.isEquivalent(fn)) {
         return variable(current.name);
@@ -2992,6 +2993,10 @@ class Identifiers {
     name: 'ɵɵreadContextLet',
     moduleName: CORE
   };
+  static arrowFunction = {
+    name: 'ɵɵarrowFunction',
+    moduleName: CORE
+  };
   static attachSourceLocations = {
     name: 'ɵɵattachSourceLocations',
     moduleName: CORE
@@ -3341,7 +3346,7 @@ class _EmittedLine {
     this.indent = indent;
   }
 }
-const BINARY_OPERATORS$1 = 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, '??=']]);
+const BINARY_OPERATORS$1 = 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, '??=']]);
 class EmitterVisitorContext {
   _indent;
   static createRoot() {
@@ -3525,7 +3530,7 @@ class AbstractEmitterVisitor {
     return null;
   }
   visitInvokeFunctionExpr(expr, ctx) {
-    const shouldParenthesize = expr.fn instanceof ArrowFunctionExpr;
+    const shouldParenthesize = expr.fn instanceof ArrowFunctionExpr$1;
     if (shouldParenthesize) {
       ctx.print(expr.fn, '(');
     }
@@ -4002,7 +4007,9 @@ class ASTWithName extends AST {
   }
 }
 let EmptyExpr$1 = class EmptyExpr extends AST {
-  visit(visitor, context = null) {}
+  visit(visitor, context = null) {
+    return visitor.visitEmptyExpr?.(this, context);
+  }
 };
 class ImplicitReceiver extends AST {
   visit(visitor, context = null) {
@@ -4314,6 +4321,28 @@ class ParenthesizedExpression extends AST {
     return visitor.visitParenthesizedExpression(this, context);
   }
 }
+class ArrowFunctionIdentifierParameter {
+  name;
+  span;
+  sourceSpan;
+  constructor(name, span, sourceSpan) {
+    this.name = name;
+    this.span = span;
+    this.sourceSpan = sourceSpan;
+  }
+}
+class ArrowFunction extends AST {
+  parameters;
+  body;
+  constructor(span, sourceSpan, parameters, body) {
+    super(span, sourceSpan);
+    this.parameters = parameters;
+    this.body = body;
+  }
+  visit(visitor, context) {
+    return visitor.visitArrowFunction(this, context);
+  }
+}
 class RegularExpressionLiteral extends AST {
   body;
   flags;
@@ -4462,10 +4491,14 @@ class RecursiveAstVisitor {
   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);
@@ -7461,6 +7494,7 @@ var ExpressionKind;
   ExpressionKind[ExpressionKind["ConditionalCase"] = 23] = "ConditionalCase";
   ExpressionKind[ExpressionKind["ConstCollected"] = 24] = "ConstCollected";
   ExpressionKind[ExpressionKind["TwoWayBindingSet"] = 25] = "TwoWayBindingSet";
+  ExpressionKind[ExpressionKind["ArrowFunction"] = 26] = "ArrowFunction";
 })(ExpressionKind || (ExpressionKind = {}));
 var VariableFlags;
 (function (VariableFlags) {
@@ -7539,6 +7573,219 @@ var TemplateKind;
   TemplateKind[TemplateKind["Block"] = 2] = "Block";
 })(TemplateKind || (TemplateKind = {}));
 
+class 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 !== undefined && 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
+  };
+}
+function createVariableOp(xref, variable, initializer, flags) {
+  return {
+    kind: OpKind.Variable,
+    xref,
+    variable,
+    initializer,
+    flags,
+    ...NEW_OP
+  };
+}
+const NEW_OP = {
+  debugListId: null,
+  prev: null,
+  next: null
+};
+
 const ConsumesSlot = Symbol('ConsumesSlot');
 const DependsOnSlotContext = Symbol('DependsOnSlotContext');
 const ConsumesVarsTrait = Symbol('ConsumesVars');
@@ -7566,29 +7813,6 @@ function hasUsesVarOffsetTrait(expr) {
   return expr[UsesVarOffset] === true;
 }
 
-function createStatementOp(statement) {
-  return {
-    kind: OpKind.Statement,
-    statement,
-    ...NEW_OP
-  };
-}
-function createVariableOp(xref, variable, initializer, flags) {
-  return {
-    kind: OpKind.Variable,
-    xref,
-    variable,
-    initializer,
-    flags,
-    ...NEW_OP
-  };
-}
-const NEW_OP = {
-  debugListId: null,
-  prev: null,
-  next: null
-};
-
 function createInterpolateTextOp(xref, interpolation, sourceSpan) {
   return {
     kind: OpKind.InterpolateText,
@@ -7994,9 +8218,6 @@ class TrackContextExpr extends ExpressionBase {
 class NextContextExpr extends ExpressionBase {
   kind = ExpressionKind.NextContext;
   steps = 1;
-  constructor() {
-    super();
-  }
   visitExpression() {}
   isEquivalent(e) {
     return e instanceof NextContextExpr && e.steps === this.steps;
@@ -8527,6 +8748,48 @@ class ConstCollectedExpr extends ExpressionBase {
     return new ConstCollectedExpr(this.expr);
   }
 }
+class ArrowFunctionExpr extends ExpressionBase {
+  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(transform, flags) {
+    for (const op of this.ops) {
+      transformExpressionsInOp(op, transform, 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);
@@ -8537,6 +8800,7 @@ var VisitorContextFlag;
 (function (VisitorContextFlag) {
   VisitorContextFlag[VisitorContextFlag["None"] = 0] = "None";
   VisitorContextFlag[VisitorContextFlag["InChildOperation"] = 1] = "InChildOperation";
+  VisitorContextFlag[VisitorContextFlag["InArrowFunctionOperation"] = 2] = "InArrowFunctionOperation";
 })(VisitorContextFlag || (VisitorContextFlag = {}));
 function transformExpressionsInInterpolation(interpolation, transform, flags) {
   for (let i = 0; i < interpolation.expressions.length; i++) {
@@ -8710,266 +8974,76 @@ function transformExpressionsInExpression(expr, transform, flags) {
     }
   } else if (expr instanceof LiteralMapExpr) {
     for (const entry of expr.entries) {
-      if (entry instanceof LiteralMapSpreadAssignment) {
-        entry.expression = transformExpressionsInExpression(entry.expression, transform, flags);
-      } else {
-        entry.value = transformExpressionsInExpression(entry.value, transform, flags);
-      }
-    }
-  } else if (expr instanceof ConditionalExpr) {
-    expr.condition = transformExpressionsInExpression(expr.condition, transform, flags);
-    expr.trueCase = transformExpressionsInExpression(expr.trueCase, transform, flags);
-    if (expr.falseCase !== null) {
-      expr.falseCase = transformExpressionsInExpression(expr.falseCase, transform, flags);
-    }
-  } else if (expr instanceof TypeofExpr) {
-    expr.expr = transformExpressionsInExpression(expr.expr, transform, flags);
-  } else if (expr instanceof VoidExpr) {
-    expr.expr = transformExpressionsInExpression(expr.expr, transform, flags);
-  } else if (expr instanceof LocalizedString) {
-    for (let i = 0; i < expr.expressions.length; i++) {
-      expr.expressions[i] = transformExpressionsInExpression(expr.expressions[i], transform, flags);
-    }
-  } else if (expr instanceof NotExpr) {
-    expr.condition = transformExpressionsInExpression(expr.condition, transform, flags);
-  } else if (expr instanceof TaggedTemplateLiteralExpr) {
-    expr.tag = transformExpressionsInExpression(expr.tag, transform, flags);
-    expr.template.expressions = expr.template.expressions.map(e => transformExpressionsInExpression(e, transform, flags));
-  } else if (expr instanceof ArrowFunctionExpr) {
-    if (Array.isArray(expr.body)) {
-      for (let i = 0; i < expr.body.length; i++) {
-        transformExpressionsInStatement(expr.body[i], transform, flags);
-      }
-    } else {
-      expr.body = transformExpressionsInExpression(expr.body, transform, 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], transform, flags);
-    }
-  } else if (expr instanceof ParenthesizedExpr) {
-    expr.expr = transformExpressionsInExpression(expr.expr, transform, flags);
-  } else if (expr instanceof SpreadElementExpr) {
-    expr.expression = transformExpressionsInExpression(expr.expression, transform, 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 transform(expr, flags);
-}
-function transformExpressionsInStatement(stmt, transform, flags) {
-  if (stmt instanceof ExpressionStatement) {
-    stmt.expr = transformExpressionsInExpression(stmt.expr, transform, flags);
-  } else if (stmt instanceof ReturnStatement) {
-    stmt.value = transformExpressionsInExpression(stmt.value, transform, flags);
-  } else if (stmt instanceof DeclareVarStmt) {
-    if (stmt.value !== undefined) {
-      stmt.value = transformExpressionsInExpression(stmt.value, transform, flags);
-    }
-  } else if (stmt instanceof IfStmt) {
-    stmt.condition = transformExpressionsInExpression(stmt.condition, transform, flags);
-    for (const caseStatement of stmt.trueCase) {
-      transformExpressionsInStatement(caseStatement, transform, flags);
-    }
-    for (const caseStatement of stmt.falseCase) {
-      transformExpressionsInStatement(caseStatement, transform, flags);
-    }
-  } else {
-    throw new Error(`Unhandled statement kind: ${stmt.constructor.name}`);
-  }
-}
-function isStringLiteral(expr) {
-  return expr instanceof LiteralExpr && typeof expr.value === 'string';
-}
-
-class 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;
+      if (entry instanceof LiteralMapSpreadAssignment) {
+        entry.expression = transformExpressionsInExpression(entry.expression, transform, flags);
+      } else {
+        entry.value = transformExpressionsInExpression(entry.value, transform, flags);
+      }
     }
-    const first = newOps[0];
-    const last = prev;
-    if (oldPrev !== null) {
-      oldPrev.next = first;
-      first.prev = oldPrev;
+  } else if (expr instanceof ConditionalExpr) {
+    expr.condition = transformExpressionsInExpression(expr.condition, transform, flags);
+    expr.trueCase = transformExpressionsInExpression(expr.trueCase, transform, flags);
+    if (expr.falseCase !== null) {
+      expr.falseCase = transformExpressionsInExpression(expr.falseCase, transform, flags);
     }
-    if (oldNext !== null) {
-      oldNext.prev = last;
-      last.next = oldNext;
+  } else if (expr instanceof TypeofExpr) {
+    expr.expr = transformExpressionsInExpression(expr.expr, transform, flags);
+  } else if (expr instanceof VoidExpr) {
+    expr.expr = transformExpressionsInExpression(expr.expr, transform, flags);
+  } else if (expr instanceof LocalizedString) {
+    for (let i = 0; i < expr.expressions.length; i++) {
+      expr.expressions[i] = transformExpressionsInExpression(expr.expressions[i], transform, flags);
     }
-  }
-  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);
+  } else if (expr instanceof NotExpr) {
+    expr.condition = transformExpressionsInExpression(expr.condition, transform, flags);
+  } else if (expr instanceof TaggedTemplateLiteralExpr) {
+    expr.tag = transformExpressionsInExpression(expr.tag, transform, flags);
+    expr.template.expressions = expr.template.expressions.map(e => transformExpressionsInExpression(e, transform, flags));
+  } else if (expr instanceof ArrowFunctionExpr$1) {
+    if (Array.isArray(expr.body)) {
+      for (let i = 0; i < expr.body.length; i++) {
+        transformExpressionsInStatement(expr.body[i], transform, flags | VisitorContextFlag.InChildOperation);
       }
-      return;
-    }
-    OpList.assertIsOwned(target);
-    if (target.prev === null) {
-      throw new Error(`AssertionError: illegal operation on list start`);
+    } else {
+      expr.body = transformExpressionsInExpression(expr.body, transform, flags | VisitorContextFlag.InChildOperation);
     }
-    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`);
+  } 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], transform, flags);
     }
-    OpList.assertIsNotEnd(op);
-    OpList.assertIsUnowned(op);
-    op.debugListId = target.debugListId;
-    target.next.prev = op;
-    op.next = target.next;
-    op.prev = target;
-    target.next = op;
+  } else if (expr instanceof ParenthesizedExpr) {
+    expr.expr = transformExpressionsInExpression(expr.expr, transform, flags);
+  } else if (expr instanceof SpreadElementExpr) {
+    expr.expression = transformExpressionsInExpression(expr.expression, transform, 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 assertIsUnowned(op) {
-    if (op.debugListId !== null) {
-      throw new Error(`AssertionError: illegal operation on owned node: ${OpKind[op.kind]}`);
+  return transform(expr, flags);
+}
+function transformExpressionsInStatement(stmt, transform, flags) {
+  if (stmt instanceof ExpressionStatement) {
+    stmt.expr = transformExpressionsInExpression(stmt.expr, transform, flags);
+  } else if (stmt instanceof ReturnStatement) {
+    stmt.value = transformExpressionsInExpression(stmt.value, transform, flags);
+  } else if (stmt instanceof DeclareVarStmt) {
+    if (stmt.value !== undefined) {
+      stmt.value = transformExpressionsInExpression(stmt.value, transform, flags);
     }
-  }
-  static assertIsOwned(op, byList) {
-    if (op.debugListId === null) {
-      throw new Error(`AssertionError: illegal operation on unowned node: ${OpKind[op.kind]}`);
-    } else if (byList !== undefined && op.debugListId !== byList) {
-      throw new Error(`AssertionError: node belongs to the wrong list (expected ${byList}, actual ${op.debugListId})`);
+  } else if (stmt instanceof IfStmt) {
+    stmt.condition = transformExpressionsInExpression(stmt.condition, transform, flags);
+    for (const caseStatement of stmt.trueCase) {
+      transformExpressionsInStatement(caseStatement, transform, flags);
     }
-  }
-  static assertIsNotEnd(op) {
-    if (op.kind === OpKind.ListEnd) {
-      throw new Error(`AssertionError: illegal operation on list head or tail`);
+    for (const caseStatement of stmt.falseCase) {
+      transformExpressionsInStatement(caseStatement, transform, flags);
     }
+  } else {
+    throw new Error(`Unhandled statement kind: ${stmt.constructor.name}`);
   }
 }
+function isStringLiteral(expr) {
+  return expr instanceof LiteralExpr && typeof expr.value === 'string';
+}
 
 class SlotHandle {
   slot = null;
@@ -9521,9 +9595,15 @@ class CompilationUnit {
   }
   create = new OpList();
   update = new OpList();
+  functions = 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) {
@@ -9965,7 +10045,7 @@ function generateConditionalExpressions(job) {
   }
 }
 
-const BINARY_OPERATORS = 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]]);
+const BINARY_OPERATORS = 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 = new Map([['svg', Namespace.SVG], ['math', Namespace.Math]]);
   if (namespacePrefixKey === null) {
@@ -10867,6 +10947,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));
+  }
 }
 function getScopeForView(view, parent) {
   const scope = {
@@ -15369,7 +15452,7 @@ var StringTokenKind;
   StringTokenKind[StringTokenKind["TemplateLiteralPart"] = 1] = "TemplateLiteralPart";
   StringTokenKind[StringTokenKind["TemplateLiteralEnd"] = 2] = "TemplateLiteralEnd";
 })(StringTokenKind || (StringTokenKind = {}));
-const KEYWORDS = ['var', 'let', 'as', 'null', 'undefined', 'true', 'false', 'if', 'else', 'this', 'typeof', 'void', 'in'];
+const KEYWORDS = ['var', 'let', 'as', 'null', 'undefined', 'true', 'false', 'if', 'else', 'this', 'typeof', 'void', 'in', 'instanceof'];
 class Lexer {
   tokenize(text) {
     return new _Scanner(text).scan();
@@ -15439,6 +15522,9 @@ class Token {
   isKeywordIn() {
     return this.type === TokenType.Keyword && this.strValue === 'in';
   }
+  isKeywordInstanceOf() {
+    return this.type === TokenType.Keyword && this.strValue === 'instanceof';
+  }
   isError() {
     return this.type === TokenType.Error;
   }
@@ -15615,8 +15701,9 @@ class _Scanner {
       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:
@@ -15663,6 +15750,23 @@ class _Scanner {
     }
     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();
@@ -16446,7 +16550,7 @@ class _ParseAST {
   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 '<':
@@ -16454,6 +16558,7 @@ class _ParseAST {
         case '<=':
         case '>=':
         case 'in':
+        case 'instanceof':
           this.advance();
           const right = this.parseAdditive();
           result = new Binary(this.span(start), this.sourceSpan(start), operator, result, right);
@@ -16572,7 +16677,9 @@ class _ParseAST {
   }
   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)) {
@@ -16586,7 +16693,7 @@ class _ParseAST {
       return new LiteralPrimitive(this.span(start), this.sourceSpan(start), null);
     } else if (this.next.isKeywordUndefined()) {
       this.advance();
-      return new LiteralPrimitive(this.span(start), this.sourceSpan(start), void 0);
+      return new LiteralPrimitive(this.span(start), this.sourceSpan(start), undefined);
     } else if (this.next.isKeywordTrue()) {
       this.advance();
       return new LiteralPrimitive(this.span(start), this.sourceSpan(start), true);
@@ -16947,6 +17054,78 @@ class _ParseAST {
     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);
   }
@@ -17101,6 +17280,15 @@ class SerializeExpressionVisitor {
   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);
   }
@@ -18828,7 +19016,7 @@ function getVariableName(unit, variable, state) {
         break;
       case SemanticVariableKind.Identifier:
         if (unit.job.compatibility === CompatibilityMode.TemplateDefinitionBuilder) {
-          const compatPrefix = variable.identifier === 'ctx' ? 'i' : '';
+          const compatPrefix = variable.identifier === CONTEXT_NAME ? 'i' : '';
           variable.name = `${variable.identifier}_${compatPrefix}r${++state.index}`;
         } else {
           variable.name = `${variable.identifier}_i${state.index++}`;
@@ -18854,6 +19042,9 @@ function stripImportant(name) {
 
 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);
@@ -19224,7 +19415,7 @@ class PureFunctionConstant extends GenericKeyFn {
       }
       return variable('a' + expr.index);
     }, VisitorContextFlag.None);
-    return new DeclareVarStmt(declName, new ArrowFunctionExpr(fnParams, returnExpr), undefined, StmtModifier.Final);
+    return new DeclareVarStmt(declName, new ArrowFunctionExpr$1(fnParams, returnExpr), undefined, StmtModifier.Final);
   }
 }
 
@@ -19716,6 +19907,9 @@ function pureFunction(varOffset, fn, args) {
 function attachSourceLocation(templatePath, locations) {
   return call(Identifiers.attachSourceLocations, [literal(templatePath), locations], null);
 }
+function arrowFunction(slotOffset, factory, contextRef) {
+  return importExpr(Identifiers.arrowFunction).callFn([literal(slotOffset), factory, contextRef]);
+}
 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`);
@@ -19800,7 +19994,7 @@ function reify(job) {
 }
 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));
@@ -20047,7 +20241,7 @@ function reifyCreateOperations(unit, ops) {
 }
 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));
@@ -20132,7 +20326,7 @@ function reifyProperty(op) {
 function reifyControl(op) {
   return control(op.name, op.expression, op.sanitizer, op.sourceSpan);
 }
-function reifyIrExpression(expr) {
+function reifyIrExpression(unit, expr) {
   if (!isIrExpression(expr)) {
     return expr;
   }
@@ -20188,6 +20382,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]}`);
   }
@@ -20229,6 +20428,18 @@ function reifyTrackBy(unit, op) {
   op.trackByFn = unit.job.pool.getSharedFunctionReference(fn$1, '_forTrack');
   return op.trackByFn;
 }
+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));
+}
 
 function removeEmptyBindings(job) {
   for (const unit of job.units) {
@@ -20304,13 +20515,16 @@ function removeUnusedI18nAttributesOps(job) {
 
 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);
   }
 }
 function processLexicalScope$1(view, ops) {
   const scope = 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:
@@ -20334,7 +20548,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 => {
@@ -20660,6 +20874,9 @@ function updatePlaceholder(op, value, i18nContexts, icuPlaceholders) {
 
 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);
   }
@@ -20710,7 +20927,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 => {
@@ -20783,38 +21000,45 @@ function getOnlySecurityContext(securityContext) {
 
 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);
-      }
     }
   }
 }
-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;
+}
+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);
     }
@@ -20972,6 +21196,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));
+    }
   }
 }
 function generateTemporaries(ops) {
@@ -21134,35 +21361,43 @@ 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);
-        }
-      });
+    const firstPassCountExpressionVars = 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);
+      }
+    };
+    const secondPassCountExpressionVars = expr => {
+      if (!isIrExpression(expr) || !(expr instanceof PureFunctionExpr)) {
+        return;
+      }
+      if (hasUsesVarOffsetTrait(expr)) {
+        expr.varOffset = varCount;
+      }
+      if (hasConsumesVarsTrait(expr)) {
+        varCount += varsUsedByIrExpression(expr);
+      }
+    };
+    for (const createOp of unit.create) {
+      visitExpressionsInOp(createOp, firstPassCountExpressionVars);
+    }
+    for (const updateOp of unit.update) {
+      visitExpressionsInOp(updateOp, firstPassCountExpressionVars);
     }
     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);
-          }
-        });
+      for (const createOp of unit.create) {
+        visitExpressionsInOp(createOp, secondPassCountExpressionVars);
+      }
+      for (const updateOp of unit.update) {
+        visitExpressionsInOp(updateOp, secondPassCountExpressionVars);
       }
     }
     unit.vars = varCount;
@@ -21230,6 +21465,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}`);
@@ -21247,6 +21483,9 @@ function isSingletonInterpolation(expr) {
 
 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) {
@@ -21256,15 +21495,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, job.compatibility, 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, job.compatibility, skipArrowFunctionOps);
+        optimizeSaveRestoreView(op.handlerOps);
       } else if (op.kind === OpKind.RepeaterCreate && op.trackByOps !== null) {
-        optimizeVariablesInOpList(op.trackByOps, job.compatibility);
+        optimizeVariablesInOpList(op.trackByOps, job.compatibility, skipArrowFunctionOps);
       }
     }
+    optimizeVariablesInOpList(unit.create, job.compatibility, skipArrowFunctionOps);
+    optimizeVariablesInOpList(unit.update, job.compatibility, skipArrowFunctionOps);
   }
 }
 var Fence;
@@ -21274,6 +21518,9 @@ var Fence;
   Fence[Fence["ViewContextWrite"] = 2] = "ViewContextWrite";
   Fence[Fence["SideEffectful"] = 4] = "SideEffectful";
 })(Fence || (Fence = {}));
+function skipArrowFunctionOps(flags) {
+  return !(flags & VisitorContextFlag.InArrowFunctionOperation);
+}
 function inlineAlwaysInlineVariables(ops) {
   const vars = new Map();
   for (const op of ops) {
@@ -21297,7 +21544,7 @@ function inlineAlwaysInlineVariables(ops) {
     OpList.remove(op);
   }
 }
-function optimizeVariablesInOpList(ops, compatibility) {
+function optimizeVariablesInOpList(ops, compatibility, predicate) {
   const varDecls = new Map();
   const varUsages = new Map();
   const varRemoteUsages = new Set();
@@ -21310,8 +21557,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()) {
@@ -21394,19 +21641,17 @@ function fencesForIrExpression(expr) {
       return Fence.None;
   }
 }
-function collectOpInfo(op) {
+function collectOpInfo(op, predicate) {
   let fences = Fence.None;
   const variablesUsed = 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 {
@@ -21414,9 +21659,9 @@ function collectOpInfo(op) {
     variablesUsed
   };
 }
-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) {
@@ -21492,7 +21737,7 @@ function tryInlineVariableInitializer(id, initializer, target, declFences) {
 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;
@@ -21502,6 +21747,14 @@ function allowConservativeInlining(decl, target) {
       return true;
   }
 }
+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;
+  }
+}
 
 function wrapI18nIcus(job) {
   for (const unit of job.units) {
@@ -21532,6 +21785,32 @@ function wrapI18nIcus(job) {
   }
 }
 
+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);
+    }
+  }
+}
+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 arrowFunction = new ArrowFunctionExpr(expr.params, expr.body);
+    unit.functions.add(arrowFunction);
+    return arrowFunction;
+  }, VisitorContextFlag.None);
+}
+
 /**
  *
  * @license
@@ -21600,6 +21879,9 @@ const phases = [{
 }, {
   kind: CompilationJobKind.Tmpl,
   fn: createVariadicPipes
+}, {
+  kind: CompilationJobKind.Both,
+  fn: generateArrowFunctions
 }, {
   kind: CompilationJobKind.Both,
   fn: generatePureLiteralStructures
@@ -21781,13 +22063,13 @@ function emitView(view) {
   }
   const createCond = maybeGenerateRfBlock(1, createStatements);
   const updateCond = maybeGenerateRfBlock(2, updateStatements);
-  return fn([new FnParam('rf'), new FnParam('ctx')], [...createCond, ...updateCond], undefined, undefined, view.fnName);
+  return fn([new FnParam(RENDER_FLAGS), new FnParam(CONTEXT_NAME)], [...createCond, ...updateCond], undefined, undefined, view.fnName);
 }
 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)];
 }
 function emitHostBindingFunction(job) {
   if (job.root.fnName === null) {
@@ -21812,7 +22094,7 @@ function emitHostBindingFunction(job) {
   }
   const createCond = maybeGenerateRfBlock(1, createStatements);
   const updateCond = maybeGenerateRfBlock(2, updateStatements);
-  return fn([new FnParam('rf'), new FnParam('ctx')], [...createCond, ...updateCond], undefined, undefined, job.root.fnName);
+  return fn([new FnParam(RENDER_FLAGS), new FnParam(CONTEXT_NAME)], [...createCond, ...updateCond], undefined, undefined, job.root.fnName);
 }
 
 const compatibilityMode = CompatibilityMode.TemplateDefinitionBuilder;
@@ -22362,6 +22644,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}"`);
   }
@@ -22585,6 +22869,19 @@ function ingestControlFlowInsertionPoint(unit, xref, node) {
   }
   return null;
 }
+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);
+}
 
 let ENABLE_TEMPLATE_SOURCE_LOCATIONS = false;
 function setEnableTemplateSourceLocations(value) {
@@ -28202,7 +28499,7 @@ const 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.1'));
+  definitionMap.set('version', literal('21.2.0-next.0'));
   definitionMap.set('ngImport', importExpr(Identifiers.core));
   definitionMap.set('type', metadata.type);
   definitionMap.set('decorators', metadata.decorators);
@@ -28220,7 +28517,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.1'));
+  definitionMap.set('version', literal('21.2.0-next.0'));
   definitionMap.set('ngImport', importExpr(Identifiers.core));
   definitionMap.set('type', metadata.type);
   definitionMap.set('resolveDeferredDeps', compileComponentMetadataAsyncResolver(dependencies));
@@ -28293,7 +28590,7 @@ function createDirectiveDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   const minVersion = getMinimumVersionForPartialOutput(meta);
   definitionMap.set('minVersion', literal(minVersion));
-  definitionMap.set('version', literal('21.1.1'));
+  definitionMap.set('version', literal('21.2.0-next.0'));
   definitionMap.set('type', meta.type.value);
   if (meta.isStandalone !== undefined) {
     definitionMap.set('isStandalone', literal(meta.isStandalone));
@@ -28628,7 +28925,7 @@ const 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.1'));
+  definitionMap.set('version', literal('21.2.0-next.0'));
   definitionMap.set('ngImport', importExpr(Identifiers.core));
   definitionMap.set('type', meta.type.value);
   definitionMap.set('deps', compileDependencies(meta.deps));
@@ -28654,7 +28951,7 @@ function compileDeclareInjectableFromMetadata(meta) {
 function createInjectableDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$3));
-  definitionMap.set('version', literal('21.1.1'));
+  definitionMap.set('version', literal('21.2.0-next.0'));
   definitionMap.set('ngImport', importExpr(Identifiers.core));
   definitionMap.set('type', meta.type.value);
   if (meta.providedIn !== undefined) {
@@ -28695,7 +28992,7 @@ function compileDeclareInjectorFromMetadata(meta) {
 function createInjectorDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$2));
-  definitionMap.set('version', literal('21.1.1'));
+  definitionMap.set('version', literal('21.2.0-next.0'));
   definitionMap.set('ngImport', importExpr(Identifiers.core));
   definitionMap.set('type', meta.type.value);
   definitionMap.set('providers', meta.providers);
@@ -28722,7 +29019,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.1'));
+  definitionMap.set('version', literal('21.2.0-next.0'));
   definitionMap.set('ngImport', importExpr(Identifiers.core));
   definitionMap.set('type', meta.type.value);
   if (meta.bootstrap.length > 0) {
@@ -28760,7 +29057,7 @@ function compileDeclarePipeFromMetadata(meta) {
 function createPipeDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION));
-  definitionMap.set('version', literal('21.1.1'));
+  definitionMap.set('version', literal('21.2.0-next.0'));
   definitionMap.set('ngImport', importExpr(Identifiers.core));
   definitionMap.set('type', meta.type.value);
   if (meta.isStandalone !== undefined) {
@@ -28834,9 +29131,9 @@ function compileHmrUpdateCallback(definitions, constantStatements, meta) {
   return new DeclareFunctionStmt(`${meta.className}_UpdateMetadata`, params, body, null, StmtModifier.Final);
 }
 
-const VERSION = new Version('21.1.1');
+const VERSION = new Version('21.2.0-next.0');
 
 publishFacade(_global);
 
-export { AST, ASTWithName, ASTWithSource, AbsoluteSourceSpan, ArrayType, ArrowFunctionExpr, Attribute, Binary, BinaryOperator, BinaryOperatorExpr, BindingPipe, BindingPipeType, BindingType, Block, BlockParameter, BoundElementProperty, BuiltinType, BuiltinTypeName, CUSTOM_ELEMENTS_SCHEMA, Call, Chain, ChangeDetectionStrategy, CombinedRecursiveAstVisitor, CommaExpr, Comment, CompilerConfig, CompilerFacadeImpl, Component, Conditional, ConditionalExpr, ConstantPool, CssSelector, DYNAMIC_TYPE, DeclareFunctionStmt, DeclareVarStmt, Directive, DomElementSchemaRegistry, DynamicImportExpr, EOF, Element, ElementSchemaRegistry, EmitterVisitorContext, EmptyExpr$1 as EmptyExpr, Expansion, ExpansionCase, Expression, ExpressionBinding, ExpressionStatement, ExpressionType, ExternalExpr, ExternalReference, FactoryTarget, FunctionExpr, HtmlParser, HtmlTagDefinition, I18NHtmlParser, IfStmt, ImplicitReceiver, InstantiateExpr, Interpolation$1 as Interpolation, InvokeFunctionExpr, JSDocComment, JitEvaluator, KeyedRead, LeadingComment, LetDeclaration, Lexer, LiteralArray, LiteralArrayExpr, LiteralExpr, LiteralMap, LiteralMapExpr, LiteralMapPropertyAssignment, LiteralMapSpreadAssignment, LiteralPrimitive, LocalizedString, MapType, MessageBundle, NONE_TYPE, NO_ERRORS_SCHEMA, NodeWithI18n, NonNullAssert, NotExpr, ParenthesizedExpr, ParenthesizedExpression, ParseError, ParseErrorLevel, ParseLocation, ParseSourceFile, ParseSourceSpan, ParseSpan, ParseTreeResult, ParsedEvent, ParsedEventType, ParsedProperty, ParsedPropertyType, ParsedVariable, Parser, PrefixNot, PropertyRead, Identifiers as R3Identifiers, R3NgModuleMetadataKind, R3SelectorScopeMode, R3TargetBinder, R3TemplateDependencyKind, ReadKeyExpr, ReadPropExpr, ReadVarExpr, RecursiveAstVisitor, RecursiveVisitor, RegularExpressionLiteral, RegularExpressionLiteralExpr, ResourceLoader, ReturnStatement, SCHEMA, SECURITY_SCHEMA, STRING_TYPE, SafeCall, SafeKeyedRead, SafePropertyRead, SelectorContext, SelectorListContext, SelectorMatcher, SelectorlessMatcher, Serializer, SplitInterpolation, SpreadElement, SpreadElementExpr, Statement, StmtModifier, StringToken, StringTokenKind, TagContentType, TaggedTemplateLiteral, TaggedTemplateLiteralExpr, TemplateBindingParseResult, TemplateLiteral, TemplateLiteralElement, TemplateLiteralElementExpr, TemplateLiteralExpr, Text, ThisReceiver, BlockNode as TmplAstBlockNode, BoundAttribute as TmplAstBoundAttribute, BoundDeferredTrigger as TmplAstBoundDeferredTrigger, BoundEvent as TmplAstBoundEvent, BoundText as TmplAstBoundText, Component$1 as TmplAstComponent, Content as TmplAstContent, DeferredBlock as TmplAstDeferredBlock, DeferredBlockError as TmplAstDeferredBlockError, DeferredBlockLoading as TmplAstDeferredBlockLoading, DeferredBlockPlaceholder as TmplAstDeferredBlockPlaceholder, DeferredTrigger as TmplAstDeferredTrigger, Directive$1 as TmplAstDirective, Element$1 as TmplAstElement, ForLoopBlock as TmplAstForLoopBlock, ForLoopBlockEmpty as TmplAstForLoopBlockEmpty, HostElement as TmplAstHostElement, HoverDeferredTrigger as TmplAstHoverDeferredTrigger, Icu$1 as TmplAstIcu, IdleDeferredTrigger as TmplAstIdleDeferredTrigger, IfBlock as TmplAstIfBlock, IfBlockBranch as TmplAstIfBlockBranch, ImmediateDeferredTrigger as TmplAstImmediateDeferredTrigger, InteractionDeferredTrigger as TmplAstInteractionDeferredTrigger, LetDeclaration$1 as TmplAstLetDeclaration, NeverDeferredTrigger as TmplAstNeverDeferredTrigger, RecursiveVisitor$1 as TmplAstRecursiveVisitor, Reference as TmplAstReference, SwitchBlock as TmplAstSwitchBlock, SwitchBlockCase as TmplAstSwitchBlockCase, SwitchBlockCaseGroup as TmplAstSwitchBlockCaseGroup, Template as TmplAstTemplate, Text$3 as TmplAstText, TextAttribute as TmplAstTextAttribute, TimerDeferredTrigger as TmplAstTimerDeferredTrigger, UnknownBlock as TmplAstUnknownBlock, Variable as TmplAstVariable, ViewportDeferredTrigger as TmplAstViewportDeferredTrigger, Token, TokenType, TransplantedType, TreeError, Type, TypeModifier, TypeofExpr, TypeofExpression, Unary, UnaryOperator, UnaryOperatorExpr, VERSION, VariableBinding, Version, ViewEncapsulation$1 as ViewEncapsulation, VoidExpr, VoidExpression, WrappedNodeExpr, Xliff, Xliff2, Xmb, XmlParser, Xtb, _ATTR_TO_PROP, compileClassDebugInfo, compileClassMetadata, compileComponentClassMetadata, compileComponentDeclareClassMetadata, compileComponentFromMetadata, compileDeclareClassMetadata, compileDeclareComponentFromMetadata, compileDeclareDirectiveFromMetadata, compileDeclareFactoryFunction, compileDeclareInjectableFromMetadata, compileDeclareInjectorFromMetadata, compileDeclareNgModuleFromMetadata, compileDeclarePipeFromMetadata, compileDeferResolverFunction, compileDirectiveFromMetadata, compileFactoryFunction, compileHmrInitializer, compileHmrUpdateCallback, compileInjectable, compileInjector, compileNgModule, compileOpaqueAsyncClassMetadata, compilePipeFromMetadata, computeMsgId, core, createCssSelectorFromNode, createInjectableType, createMayBeForwardRefExpression, devOnlyGuardedExpression, emitDistinctChangesOnlyDefaultValue, encapsulateStyle, escapeRegExp, findMatchingDirectivesAndPipes, getHtmlTagDefinition, getNsPrefix, getSafePropertyAccessString, identifierName, isNgContainer, isNgContent, isNgTemplate, jsDocComment, leadingComment, literal, literalMap, makeBindingParser, mergeNsAndName, output_ast as outputAst, parseHostBindings, parseTemplate, preserveWhitespacesDefault, publishFacade, r3JitTypeSourceSpan, sanitizeIdentifier, setEnableTemplateSourceLocations, splitNsName, visitAll$1 as tmplAstVisitAll, verifyHostBindings, visitAll };
+export { AST, ASTWithName, ASTWithSource, AbsoluteSourceSpan, ArrayType, ArrowFunction, ArrowFunctionExpr$1 as ArrowFunctionExpr, ArrowFunctionIdentifierParameter, Attribute, Binary, BinaryOperator, BinaryOperatorExpr, BindingPipe, BindingPipeType, BindingType, Block, BlockParameter, BoundElementProperty, BuiltinType, BuiltinTypeName, CUSTOM_ELEMENTS_SCHEMA, Call, Chain, ChangeDetectionStrategy, CombinedRecursiveAstVisitor, CommaExpr, Comment, CompilerConfig, CompilerFacadeImpl, Component, Conditional, ConditionalExpr, ConstantPool, CssSelector, DYNAMIC_TYPE, DeclareFunctionStmt, DeclareVarStmt, Directive, DomElementSchemaRegistry, DynamicImportExpr, EOF, Element, ElementSchemaRegistry, EmitterVisitorContext, EmptyExpr$1 as EmptyExpr, Expansion, ExpansionCase, Expression, ExpressionBinding, ExpressionStatement, ExpressionType, ExternalExpr, ExternalReference, FactoryTarget, FunctionExpr, HtmlParser, HtmlTagDefinition, I18NHtmlParser, IfStmt, ImplicitReceiver, InstantiateExpr, Interpolation$1 as Interpolation, InvokeFunctionExpr, JSDocComment, JitEvaluator, KeyedRead, LeadingComment, LetDeclaration, Lexer, LiteralArray, LiteralArrayExpr, LiteralExpr, LiteralMap, LiteralMapExpr, LiteralMapPropertyAssignment, LiteralMapSpreadAssignment, LiteralPrimitive, LocalizedString, MapType, MessageBundle, NONE_TYPE, NO_ERRORS_SCHEMA, NodeWithI18n, NonNullAssert, NotExpr, ParenthesizedExpr, ParenthesizedExpression, ParseError, ParseErrorLevel, ParseLocation, ParseSourceFile, ParseSourceSpan, ParseSpan, ParseTreeResult, ParsedEvent, ParsedEventType, ParsedProperty, ParsedPropertyType, ParsedVariable, Parser, PrefixNot, PropertyRead, Identifiers as R3Identifiers, R3NgModuleMetadataKind, R3SelectorScopeMode, R3TargetBinder, R3TemplateDependencyKind, ReadKeyExpr, ReadPropExpr, ReadVarExpr, RecursiveAstVisitor, RecursiveVisitor, RegularExpressionLiteral, RegularExpressionLiteralExpr, ResourceLoader, ReturnStatement, SCHEMA, SECURITY_SCHEMA, STRING_TYPE, SafeCall, SafeKeyedRead, SafePropertyRead, SelectorContext, SelectorListContext, SelectorMatcher, SelectorlessMatcher, Serializer, SplitInterpolation, SpreadElement, SpreadElementExpr, Statement, StmtModifier, StringToken, StringTokenKind, TagContentType, TaggedTemplateLiteral, TaggedTemplateLiteralExpr, TemplateBindingParseResult, TemplateLiteral, TemplateLiteralElement, TemplateLiteralElementExpr, TemplateLiteralExpr, Text, ThisReceiver, BlockNode as TmplAstBlockNode, BoundAttribute as TmplAstBoundAttribute, BoundDeferredTrigger as TmplAstBoundDeferredTrigger, BoundEvent as TmplAstBoundEvent, BoundText as TmplAstBoundText, Component$1 as TmplAstComponent, Content as TmplAstContent, DeferredBlock as TmplAstDeferredBlock, DeferredBlockError as TmplAstDeferredBlockError, DeferredBlockLoading as TmplAstDeferredBlockLoading, DeferredBlockPlaceholder as TmplAstDeferredBlockPlaceholder, DeferredTrigger as TmplAstDeferredTrigger, Directive$1 as TmplAstDirective, Element$1 as TmplAstElement, ForLoopBlock as TmplAstForLoopBlock, ForLoopBlockEmpty as TmplAstForLoopBlockEmpty, HostElement as TmplAstHostElement, HoverDeferredTrigger as TmplAstHoverDeferredTrigger, Icu$1 as TmplAstIcu, IdleDeferredTrigger as TmplAstIdleDeferredTrigger, IfBlock as TmplAstIfBlock, IfBlockBranch as TmplAstIfBlockBranch, ImmediateDeferredTrigger as TmplAstImmediateDeferredTrigger, InteractionDeferredTrigger as TmplAstInteractionDeferredTrigger, LetDeclaration$1 as TmplAstLetDeclaration, NeverDeferredTrigger as TmplAstNeverDeferredTrigger, RecursiveVisitor$1 as TmplAstRecursiveVisitor, Reference as TmplAstReference, SwitchBlock as TmplAstSwitchBlock, SwitchBlockCase as TmplAstSwitchBlockCase, SwitchBlockCaseGroup as TmplAstSwitchBlockCaseGroup, Template as TmplAstTemplate, Text$3 as TmplAstText, TextAttribute as TmplAstTextAttribute, TimerDeferredTrigger as TmplAstTimerDeferredTrigger, UnknownBlock as TmplAstUnknownBlock, Variable as TmplAstVariable, ViewportDeferredTrigger as TmplAstViewportDeferredTrigger, Token, TokenType, TransplantedType, TreeError, Type, TypeModifier, TypeofExpr, TypeofExpression, Unary, UnaryOperator, UnaryOperatorExpr, VERSION, VariableBinding, Version, ViewEncapsulation$1 as ViewEncapsulation, VoidExpr, VoidExpression, WrappedNodeExpr, Xliff, Xliff2, Xmb, XmlParser, Xtb, _ATTR_TO_PROP, compileClassDebugInfo, compileClassMetadata, compileComponentClassMetadata, compileComponentDeclareClassMetadata, compileComponentFromMetadata, compileDeclareClassMetadata, compileDeclareComponentFromMetadata, compileDeclareDirectiveFromMetadata, compileDeclareFactoryFunction, compileDeclareInjectableFromMetadata, compileDeclareInjectorFromMetadata, compileDeclareNgModuleFromMetadata, compileDeclarePipeFromMetadata, compileDeferResolverFunction, compileDirectiveFromMetadata, compileFactoryFunction, compileHmrInitializer, compileHmrUpdateCallback, compileInjectable, compileInjector, compileNgModule, compileOpaqueAsyncClassMetadata, compilePipeFromMetadata, computeMsgId, core, createCssSelectorFromNode, createInjectableType, createMayBeForwardRefExpression, devOnlyGuardedExpression, emitDistinctChangesOnlyDefaultValue, encapsulateStyle, escapeRegExp, findMatchingDirectivesAndPipes, getHtmlTagDefinition, getNsPrefix, getSafePropertyAccessString, identifierName, isNgContainer, isNgContent, isNgTemplate, jsDocComment, leadingComment, literal, literalMap, makeBindingParser, mergeNsAndName, output_ast as outputAst, parseHostBindings, parseTemplate, preserveWhitespacesDefault, publishFacade, r3JitTypeSourceSpan, sanitizeIdentifier, setEnableTemplateSourceLocations, splitNsName, visitAll$1 as tmplAstVisitAll, verifyHostBindings, visitAll };
 //# sourceMappingURL=compiler.mjs.map