@angular/core 17.2.0-next.1 → 17.2.0-rc.1

package/schematics/migrations/block-template-entities/bundle.js

@@ -1821,6 +1821,7 @@ var ConstantPool = class {
     this.literals = /* @__PURE__ */ new Map();
     this.literalFactories = /* @__PURE__ */ new Map();
     this.sharedConstants = /* @__PURE__ */ new Map();
+    this._claimedNames = /* @__PURE__ */ new Map();
     this.nextNameIndex = 0;
   }
   getConstLiteral(literal2, forceShared) {
@@ -1913,8 +1914,12 @@ var ConstantPool = class {
     }
     return { literalFactory, literalFactoryArguments };
   }
-  uniqueName(prefix) {
-    return `${prefix}${this.nextNameIndex++}`;
+  uniqueName(name, alwaysIncludeSuffix = true) {
+    var _a2;
+    const count = (_a2 = this._claimedNames.get(name)) != null ? _a2 : 0;
+    const result = count === 0 && !alwaysIncludeSuffix ? `${name}` : `${name}${count}`;
+    this._claimedNames.set(name, count + 1);
+    return result;
   }
   freshName() {
     return this.uniqueName(CONSTANT_PREFIX);
@@ -2548,6 +2553,15 @@ var Identifiers = _Identifiers;
 (() => {
   _Identifiers.queryAdvance = { name: "\u0275\u0275queryAdvance", moduleName: CORE };
 })();
+(() => {
+  _Identifiers.twoWayProperty = { name: "\u0275\u0275twoWayProperty", moduleName: CORE };
+})();
+(() => {
+  _Identifiers.twoWayBindingSet = { name: "\u0275\u0275twoWayBindingSet", moduleName: CORE };
+})();
+(() => {
+  _Identifiers.twoWayListener = { name: "\u0275\u0275twoWayListener", moduleName: CORE };
+})();
 (() => {
   _Identifiers.NgOnChangesFeature = { name: "\u0275\u0275NgOnChangesFeature", moduleName: CORE };
 })();
@@ -2617,6 +2631,9 @@ var Identifiers = _Identifiers;
 (() => {
   _Identifiers.UnwrapDirectiveSignalInputs = { name: "\u0275UnwrapDirectiveSignalInputs", moduleName: CORE };
 })();
+(() => {
+  _Identifiers.unwrapWritableSignal = { name: "\u0275unwrapWritableSignal", moduleName: CORE };
+})();
 
 // bazel-out/k8-fastbuild/bin/packages/compiler/src/util.mjs
 var DASH_CASE_REGEXP = /-+([a-z0-9])/g;
@@ -4288,7 +4305,9 @@ var CHAINABLE_INSTRUCTIONS = /* @__PURE__ */ new Set([
   Identifiers.textInterpolate7,
   Identifiers.textInterpolate8,
   Identifiers.textInterpolateV,
-  Identifiers.templateCreate
+  Identifiers.templateCreate,
+  Identifiers.twoWayProperty,
+  Identifiers.twoWayListener
 ]);
 function invokeInstruction(span, reference2, params) {
   return importExpr(reference2, null, span).callFn(params, span);
@@ -5921,30 +5940,10 @@ var EventHandlerVars = _EventHandlerVars;
   _EventHandlerVars.event = variable("$event");
 })();
 function convertActionBinding(localResolver, implicitReceiver, action, bindingId, baseSourceSpan, implicitReceiverAccesses, globals) {
-  if (!localResolver) {
-    localResolver = new DefaultLocalResolver(globals);
-  }
-  const actionWithoutBuiltins = convertPropertyBindingBuiltins({
-    createLiteralArrayConverter: (argCount) => {
-      return (args) => literalArr(args);
-    },
-    createLiteralMapConverter: (keys) => {
-      return (values) => {
-        const entries = keys.map((k, i) => ({
-          key: k.key,
-          value: values[i],
-          quoted: k.quoted
-        }));
-        return literalMap(entries);
-      };
-    },
-    createPipeConverter: (name) => {
-      throw new Error(`Illegal State: Actions are not allowed to contain pipes. Pipe: ${name}`);
-    }
-  }, action);
+  localResolver != null ? localResolver : localResolver = new DefaultLocalResolver(globals);
   const visitor = new _AstToIrVisitor(localResolver, implicitReceiver, bindingId, false, baseSourceSpan, implicitReceiverAccesses);
   const actionStmts = [];
-  flattenStatements(actionWithoutBuiltins.visit(visitor, _Mode.Statement), actionStmts);
+  flattenStatements(convertActionBuiltins(action).visit(visitor, _Mode.Statement), actionStmts);
   prependTemporaryDecls(visitor.temporaryCount, bindingId, actionStmts);
   if (visitor.usesImplicitReceiver) {
     localResolver.notifyImplicitReceiverUse();
@@ -5958,6 +5957,55 @@ function convertActionBinding(localResolver, implicitReceiver, action, bindingId
   }
   return actionStmts;
 }
+function convertAssignmentActionBinding(localResolver, implicitReceiver, action, bindingId, baseSourceSpan, implicitReceiverAccesses, globals) {
+  localResolver != null ? localResolver : localResolver = new DefaultLocalResolver(globals);
+  const visitor = new _AstToIrVisitor(localResolver, implicitReceiver, bindingId, false, baseSourceSpan, implicitReceiverAccesses);
+  let convertedAction = convertActionBuiltins(action).visit(visitor, _Mode.Statement);
+  if (!(convertedAction instanceof ExpressionStatement)) {
+    throw new Error(`Illegal state: unsupported expression in two-way action binding.`);
+  }
+  convertedAction = wrapAssignmentAction(convertedAction.expr).toStmt();
+  const actionStmts = [];
+  flattenStatements(convertedAction, actionStmts);
+  prependTemporaryDecls(visitor.temporaryCount, bindingId, actionStmts);
+  actionStmts.push(new ReturnStatement(EventHandlerVars.event));
+  implicitReceiverAccesses == null ? void 0 : implicitReceiverAccesses.add(EventHandlerVars.event.name);
+  if (visitor.usesImplicitReceiver) {
+    localResolver.notifyImplicitReceiverUse();
+  }
+  return actionStmts;
+}
+function wrapAssignmentReadExpression(ast) {
+  return new ExternalExpr(Identifiers.twoWayBindingSet).callFn([ast, EventHandlerVars.event]).or(ast.set(EventHandlerVars.event));
+}
+function isReadExpression(value) {
+  return value instanceof ReadPropExpr || value instanceof ReadKeyExpr;
+}
+function wrapAssignmentAction(ast) {
+  if (isReadExpression(ast)) {
+    return wrapAssignmentReadExpression(ast);
+  }
+  if (ast instanceof BinaryOperatorExpr && isReadExpression(ast.rhs)) {
+    return new BinaryOperatorExpr(ast.operator, ast.lhs, wrapAssignmentReadExpression(ast.rhs));
+  }
+  if (ast instanceof ConditionalExpr && isReadExpression(ast.falseCase)) {
+    return new ConditionalExpr(ast.condition, ast.trueCase, wrapAssignmentReadExpression(ast.falseCase));
+  }
+  if (ast instanceof NotExpr) {
+    let expr = ast.condition;
+    while (true) {
+      if (expr instanceof NotExpr) {
+        expr = expr.condition;
+      } else {
+        if (isReadExpression(expr)) {
+          return wrapAssignmentReadExpression(expr);
+        }
+        break;
+      }
+    }
+  }
+  throw new Error(`Illegal state: unsupported expression in two-way action binding.`);
+}
 function convertPropertyBindingBuiltins(converterFactory, ast) {
   return convertBuiltins(converterFactory, ast);
 }
@@ -6019,6 +6067,27 @@ function convertBuiltins(converterFactory, ast) {
   const visitor = new _BuiltinAstConverter(converterFactory);
   return ast.visit(visitor);
 }
+function convertActionBuiltins(action) {
+  const converterFactory = {
+    createLiteralArrayConverter: () => {
+      return (args) => literalArr(args);
+    },
+    createLiteralMapConverter: (keys) => {
+      return (values) => {
+        const entries = keys.map((k, i) => ({
+          key: k.key,
+          value: values[i],
+          quoted: k.quoted
+        }));
+        return literalMap(entries);
+      };
+    },
+    createPipeConverter: (name) => {
+      throw new Error(`Illegal State: Actions are not allowed to contain pipes. Pipe: ${name}`);
+    }
+  };
+  return convertPropertyBindingBuiltins(converterFactory, action);
+}
 function temporaryName(bindingId, temporaryNumber) {
   return `tmp_${bindingId}_${temporaryNumber}`;
 }
@@ -7123,16 +7192,18 @@ var OpKind;
   OpKind2[OpKind2["Projection"] = 33] = "Projection";
   OpKind2[OpKind2["RepeaterCreate"] = 34] = "RepeaterCreate";
   OpKind2[OpKind2["Repeater"] = 35] = "Repeater";
-  OpKind2[OpKind2["I18nStart"] = 36] = "I18nStart";
-  OpKind2[OpKind2["I18n"] = 37] = "I18n";
-  OpKind2[OpKind2["I18nEnd"] = 38] = "I18nEnd";
-  OpKind2[OpKind2["I18nExpression"] = 39] = "I18nExpression";
-  OpKind2[OpKind2["I18nApply"] = 40] = "I18nApply";
-  OpKind2[OpKind2["IcuStart"] = 41] = "IcuStart";
-  OpKind2[OpKind2["IcuEnd"] = 42] = "IcuEnd";
-  OpKind2[OpKind2["IcuPlaceholder"] = 43] = "IcuPlaceholder";
-  OpKind2[OpKind2["I18nContext"] = 44] = "I18nContext";
-  OpKind2[OpKind2["I18nAttributes"] = 45] = "I18nAttributes";
+  OpKind2[OpKind2["TwoWayProperty"] = 36] = "TwoWayProperty";
+  OpKind2[OpKind2["TwoWayListener"] = 37] = "TwoWayListener";
+  OpKind2[OpKind2["I18nStart"] = 38] = "I18nStart";
+  OpKind2[OpKind2["I18n"] = 39] = "I18n";
+  OpKind2[OpKind2["I18nEnd"] = 40] = "I18nEnd";
+  OpKind2[OpKind2["I18nExpression"] = 41] = "I18nExpression";
+  OpKind2[OpKind2["I18nApply"] = 42] = "I18nApply";
+  OpKind2[OpKind2["IcuStart"] = 43] = "IcuStart";
+  OpKind2[OpKind2["IcuEnd"] = 44] = "IcuEnd";
+  OpKind2[OpKind2["IcuPlaceholder"] = 45] = "IcuPlaceholder";
+  OpKind2[OpKind2["I18nContext"] = 46] = "I18nContext";
+  OpKind2[OpKind2["I18nAttributes"] = 47] = "I18nAttributes";
 })(OpKind || (OpKind = {}));
 var ExpressionKind;
 (function(ExpressionKind2) {
@@ -7162,6 +7233,7 @@ var ExpressionKind;
   ExpressionKind2[ExpressionKind2["ConditionalCase"] = 23] = "ConditionalCase";
   ExpressionKind2[ExpressionKind2["DerivedRepeaterVar"] = 24] = "DerivedRepeaterVar";
   ExpressionKind2[ExpressionKind2["ConstCollected"] = 25] = "ConstCollected";
+  ExpressionKind2[ExpressionKind2["TwoWayBindingSet"] = 26] = "TwoWayBindingSet";
 })(ExpressionKind || (ExpressionKind = {}));
 var VariableFlags;
 (function(VariableFlags2) {
@@ -7195,6 +7267,7 @@ var BindingKind;
   BindingKind2[BindingKind2["Template"] = 4] = "Template";
   BindingKind2[BindingKind2["I18n"] = 5] = "I18n";
   BindingKind2[BindingKind2["Animation"] = 6] = "Animation";
+  BindingKind2[BindingKind2["TwoWayProperty"] = 7] = "TwoWayProperty";
 })(BindingKind || (BindingKind = {}));
 var I18nParamResolutionTime;
 (function(I18nParamResolutionTime2) {
@@ -7349,6 +7422,21 @@ function createPropertyOp(target, name, expression, isAnimationTrigger, security
     sourceSpan
   }, TRAIT_DEPENDS_ON_SLOT_CONTEXT), TRAIT_CONSUMES_VARS), NEW_OP);
 }
+function createTwoWayPropertyOp(target, name, expression, securityContext, isStructuralTemplateAttribute, templateKind, i18nContext, i18nMessage, sourceSpan) {
+  return __spreadValues(__spreadValues(__spreadValues({
+    kind: OpKind.TwoWayProperty,
+    target,
+    name,
+    expression,
+    securityContext,
+    sanitizer: null,
+    isStructuralTemplateAttribute,
+    templateKind,
+    i18nContext,
+    i18nMessage,
+    sourceSpan
+  }, TRAIT_DEPENDS_ON_SLOT_CONTEXT), TRAIT_CONSUMES_VARS), NEW_OP);
+}
 function createStylePropOp(xref, name, expression, unit, sourceSpan) {
   return __spreadValues(__spreadValues(__spreadValues({
     kind: OpKind.StyleProp,
@@ -7656,6 +7744,31 @@ var ResetViewExpr = class extends ExpressionBase {
     return new ResetViewExpr(this.expr.clone());
   }
 };
+var TwoWayBindingSetExpr = class extends ExpressionBase {
+  constructor(target, value) {
+    super();
+    this.target = target;
+    this.value = value;
+    this.kind = ExpressionKind.TwoWayBindingSet;
+  }
+  visitExpression(visitor, context) {
+    this.target.visitExpression(visitor, context);
+    this.value.visitExpression(visitor, context);
+  }
+  isEquivalent(other) {
+    return this.target.isEquivalent(other.target) && this.value.isEquivalent(other.value);
+  }
+  isConstant() {
+    return false;
+  }
+  transformInternalExpressions(transform2, flags) {
+    this.target = transformExpressionsInExpression(this.target, transform2, flags);
+    this.value = transformExpressionsInExpression(this.value, transform2, flags);
+  }
+  clone() {
+    return new TwoWayBindingSetExpr(this.target, this.value);
+  }
+};
 var ReadVariableExpr = class extends ExpressionBase {
   constructor(xref) {
     super();
@@ -8107,6 +8220,10 @@ function transformExpressionsInOp(op, transform2, flags) {
       }
       op.sanitizer = op.sanitizer && transformExpressionsInExpression(op.sanitizer, transform2, flags);
       break;
+    case OpKind.TwoWayProperty:
+      op.expression = transformExpressionsInExpression(op.expression, transform2, flags);
+      op.sanitizer = op.sanitizer && transformExpressionsInExpression(op.sanitizer, transform2, flags);
+      break;
     case OpKind.I18nExpression:
       op.expression = transformExpressionsInExpression(op.expression, transform2, flags);
       break;
@@ -8134,6 +8251,7 @@ function transformExpressionsInOp(op, transform2, flags) {
       }
       break;
     case OpKind.Listener:
+    case OpKind.TwoWayListener:
       for (const innerOp of op.handlerOps) {
         transformExpressionsInOp(innerOp, transform2, flags | VisitorContextFlag.InChildOperation);
       }
@@ -8615,6 +8733,20 @@ function createListenerOp(target, targetSlot, name, tag, handlerOps, animationPh
     sourceSpan
   }, NEW_OP);
 }
+function createTwoWayListenerOp(target, targetSlot, name, tag, handlerOps, sourceSpan) {
+  const handlerList = new OpList();
+  handlerList.push(handlerOps);
+  return __spreadValues({
+    kind: OpKind.TwoWayListener,
+    target,
+    targetSlot,
+    tag,
+    name,
+    handlerOps: handlerList,
+    handlerFnName: null,
+    sourceSpan
+  }, NEW_OP);
+}
 function createPipeOp(xref, slot, name) {
   return __spreadValues(__spreadValues({
     kind: OpKind.Pipe,
@@ -8865,7 +8997,7 @@ var CompilationUnit = class {
   *ops() {
     for (const op of this.create) {
       yield op;
-      if (op.kind === OpKind.Listener) {
+      if (op.kind === OpKind.Listener || op.kind === OpKind.TwoWayListener) {
         for (const listenerOp of op.handlerOps) {
           yield listenerOp;
         }
@@ -9060,6 +9192,18 @@ function extractAttributes(job) {
             );
           }
           break;
+        case OpKind.TwoWayProperty:
+          OpList.insertBefore(createExtractedAttributeOp(
+            op.target,
+            BindingKind.TwoWayProperty,
+            null,
+            op.name,
+            null,
+            null,
+            null,
+            op.securityContext
+          ), lookupElement(elements, op.target));
+          break;
         case OpKind.StyleProp:
         case OpKind.ClassProp:
           if (unit.job.compatibility === CompatibilityMode.TemplateDefinitionBuilder && op.expression instanceof EmptyExpr2) {
@@ -9097,6 +9241,21 @@ function extractAttributes(job) {
             }
           }
           break;
+        case OpKind.TwoWayListener:
+          if (job.kind !== CompilationJobKind.Host) {
+            const extractedAttributeOp = createExtractedAttributeOp(
+              op.target,
+              BindingKind.Property,
+              null,
+              op.name,
+              null,
+              null,
+              null,
+              SecurityContext.NONE
+            );
+            OpList.insertBefore(extractedAttributeOp, lookupElement(elements, op.target));
+          }
+          break;
       }
     }
   }
@@ -9170,6 +9329,12 @@ function specializeBindings(job) {
             OpList.replace(op, createPropertyOp(op.target, op.name, op.expression, op.bindingKind === BindingKind.Animation, op.securityContext, op.isStructuralTemplateAttribute, op.templateKind, op.i18nContext, op.i18nMessage, op.sourceSpan));
           }
           break;
+        case BindingKind.TwoWayProperty:
+          if (!(op.expression instanceof Expression)) {
+            throw new Error(`Expected value of two-way property binding "${op.name}" to be an expression`);
+          }
+          OpList.replace(op, createTwoWayPropertyOp(op.target, op.name, op.expression, op.securityContext, op.isStructuralTemplateAttribute, op.templateKind, op.i18nContext, op.i18nMessage, op.sourceSpan));
+          break;
         case BindingKind.I18n:
         case BindingKind.ClassName:
         case BindingKind.StyleProperty:
@@ -9206,7 +9371,9 @@ var CHAINABLE = /* @__PURE__ */ new Set([
   Identifiers.stylePropInterpolateV,
   Identifiers.syntheticHostListener,
   Identifiers.syntheticHostProperty,
-  Identifiers.templateCreate
+  Identifiers.templateCreate,
+  Identifiers.twoWayProperty,
+  Identifiers.twoWayListener
 ]);
 function chain(job) {
   for (const unit of job.units) {
@@ -9415,7 +9582,7 @@ var ElementAttributes = class {
   }
   get bindings() {
     var _a2;
-    return (_a2 = this.byKind.get(BindingKind.Property)) != null ? _a2 : FLYWEIGHT_ARRAY;
+    return (_a2 = this.propertyBindings) != null ? _a2 : FLYWEIGHT_ARRAY;
   }
   get template() {
     var _a2;
@@ -9429,6 +9596,7 @@ var ElementAttributes = class {
     this.compatibility = compatibility;
     this.known = /* @__PURE__ */ new Map();
     this.byKind = /* @__PURE__ */ new Map();
+    this.propertyBindings = null;
     this.projectAs = null;
   }
   isKnown(kind, name, value) {
@@ -9470,10 +9638,16 @@ var ElementAttributes = class {
     }
   }
   arrayFor(kind) {
-    if (!this.byKind.has(kind)) {
-      this.byKind.set(kind, []);
+    var _a2;
+    if (kind === BindingKind.Property || kind === BindingKind.TwoWayProperty) {
+      (_a2 = this.propertyBindings) != null ? _a2 : this.propertyBindings = [];
+      return this.propertyBindings;
+    } else {
+      if (!this.byKind.has(kind)) {
+        this.byKind.set(kind, []);
+      }
+      return this.byKind.get(kind);
     }
-    return this.byKind.get(kind);
   }
 };
 function getAttributeNameLiterals(namespace, name) {
@@ -9563,7 +9737,10 @@ function createDeferDepsFns(job) {
         const dependencies = [];
         for (const dep of op.metadata.deps) {
           if (dep.isDeferrable) {
-            const innerFn = arrowFn([new FnParam("m", DYNAMIC_TYPE)], variable("m").prop(dep.symbolName));
+            const innerFn = arrowFn(
+              [new FnParam("m", DYNAMIC_TYPE)],
+              variable("m").prop(dep.isDefaultImport ? "default" : dep.symbolName)
+            );
             const importExpr2 = new DynamicImportExpr(dep.importPath).prop("then").callFn([innerFn]);
             dependencies.push(importExpr2);
           } else {
@@ -10169,6 +10346,7 @@ function recursivelyProcessView(view, parentScope) {
         }
         break;
       case OpKind.Listener:
+      case OpKind.TwoWayListener:
         op.handlerOps.prepend(generateVariablesInScopeForView(view, scope));
         break;
     }
@@ -10740,15 +10918,11 @@ var Parser = class {
     this._lexer = _lexer;
     this.errors = [];
   }
-  parseAction(input, isAssignmentEvent, location, absoluteOffset, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
+  parseAction(input, location, absoluteOffset, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
     this._checkNoInterpolation(input, location, interpolationConfig);
     const sourceToLex = this._stripComments(input);
     const tokens = this._lexer.tokenize(sourceToLex);
-    let flags = 1;
-    if (isAssignmentEvent) {
-      flags |= 2;
-    }
-    const ast = new _ParseAST(input, location, absoluteOffset, tokens, flags, this.errors, 0).parseChain();
+    const ast = new _ParseAST(input, location, absoluteOffset, tokens, 1, this.errors, 0).parseChain();
     return new ASTWithSource(ast, input, location, absoluteOffset, this.errors);
   }
   parseBinding(input, location, absoluteOffset, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
@@ -11101,7 +11275,7 @@ var _ParseAST = class {
     let result = this.parseExpression();
     if (this.consumeOptionalOperator("|")) {
       if (this.parseFlags & 1) {
-        this.error("Cannot have a pipe in an action expression");
+        this.error(`Cannot have a pipe in an action expression`);
       }
       do {
         const nameStart = this.inputIndex;
@@ -11395,14 +11569,14 @@ var _ParseAST = class {
     const nameSpan = this.sourceSpan(nameStart);
     let receiver;
     if (isSafe) {
-      if (this.consumeOptionalAssignment()) {
+      if (this.consumeOptionalOperator("=")) {
         this.error("The '?.' operator cannot be used in the assignment");
         receiver = new EmptyExpr(this.span(start), this.sourceSpan(start));
       } else {
         receiver = new SafePropertyRead(this.span(start), this.sourceSpan(start), nameSpan, readReceiver, id);
       }
     } else {
-      if (this.consumeOptionalAssignment()) {
+      if (this.consumeOptionalOperator("=")) {
         if (!(this.parseFlags & 1)) {
           this.error("Bindings cannot contain assignments");
           return new EmptyExpr(this.span(start), this.sourceSpan(start));
@@ -11426,14 +11600,6 @@ var _ParseAST = class {
     const sourceSpan = this.sourceSpan(start);
     return isSafe ? new SafeCall(span, sourceSpan, receiver, args, argumentSpan) : new Call(span, sourceSpan, receiver, args, argumentSpan);
   }
-  consumeOptionalAssignment() {
-    if (this.parseFlags & 2 && this.next.isOperator("!") && this.peek(1).isOperator("=")) {
-      this.advance();
-      this.advance();
-      return true;
-    }
-    return this.consumeOptionalOperator("=");
-  }
   parseCallArguments() {
     if (this.next.isCharacter($RPAREN))
       return [];
@@ -16641,7 +16807,7 @@ function nameFunctionsAndVariables(job) {
 }
 function addNamesToView(unit, baseName, state, compatibility) {
   if (unit.fnName === null) {
-    unit.fnName = sanitizeIdentifier(`${baseName}_${unit.job.fnSuffix}`);
+    unit.fnName = unit.job.pool.uniqueName(sanitizeIdentifier(`${baseName}_${unit.job.fnSuffix}`), false);
   }
   const varNames = /* @__PURE__ */ new Map();
   for (const op of unit.ops()) {
@@ -16671,6 +16837,15 @@ function addNamesToView(unit, baseName, state, compatibility) {
         }
         op.handlerFnName = sanitizeIdentifier(op.handlerFnName);
         break;
+      case OpKind.TwoWayListener:
+        if (op.handlerFnName !== null) {
+          break;
+        }
+        if (op.targetSlot.slot === null) {
+          throw new Error(`Expected a slot to be assigned`);
+        }
+        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));
         break;
@@ -16759,7 +16934,7 @@ function stripImportant(name) {
 function mergeNextContextExpressions(job) {
   for (const unit of job.units) {
     for (const op of unit.create) {
-      if (op.kind === OpKind.Listener) {
+      if (op.kind === OpKind.Listener || op.kind === OpKind.TwoWayListener) {
         mergeNextContextsInOps(op.handlerOps);
       }
     }
@@ -16873,9 +17048,15 @@ function kindWithInterpolationTest(kind, interpolation) {
     return op.kind === kind && interpolation === op.expression instanceof Interpolation2;
   };
 }
+function basicListenerKindTest(op) {
+  return op.kind === OpKind.Listener && !(op.hostListener && op.isAnimationListener) || op.kind === OpKind.TwoWayListener;
+}
+function nonInterpolationPropertyKindTest(op) {
+  return (op.kind === OpKind.Property || op.kind === OpKind.TwoWayProperty) && !(op.expression instanceof Interpolation2);
+}
 var CREATE_ORDERING = [
   { test: (op) => op.kind === OpKind.Listener && op.hostListener && op.isAnimationListener },
-  { test: (op) => op.kind === OpKind.Listener && !(op.hostListener && op.isAnimationListener) }
+  { test: basicListenerKindTest }
 ];
 var UPDATE_ORDERING = [
   { test: kindTest(OpKind.StyleMap), transform: keepLast },
@@ -16884,7 +17065,7 @@ var UPDATE_ORDERING = [
   { test: kindTest(OpKind.ClassProp) },
   { test: kindWithInterpolationTest(OpKind.Attribute, true) },
   { test: kindWithInterpolationTest(OpKind.Property, true) },
-  { test: kindWithInterpolationTest(OpKind.Property, false) },
+  { test: nonInterpolationPropertyKindTest },
   { test: kindWithInterpolationTest(OpKind.Attribute, false) }
 ];
 var UPDATE_HOST_ORDERING = [
@@ -16898,11 +17079,13 @@ var UPDATE_HOST_ORDERING = [
 ];
 var handledOpKinds = /* @__PURE__ */ new Set([
   OpKind.Listener,
+  OpKind.TwoWayListener,
   OpKind.StyleMap,
   OpKind.ClassMap,
   OpKind.StyleProp,
   OpKind.ClassProp,
   OpKind.Property,
+  OpKind.TwoWayProperty,
   OpKind.HostProperty,
   OpKind.Attribute
 ]);
@@ -17282,6 +17465,12 @@ function listener(name, handlerFn, eventTargetResolver, syntheticHost, sourceSpa
   }
   return call(syntheticHost ? Identifiers.syntheticHostListener : Identifiers.listener, args, sourceSpan);
 }
+function twoWayBindingSet(target, value) {
+  return importExpr(Identifiers.twoWayBindingSet).callFn([target, value]);
+}
+function twoWayListener(name, handlerFn, sourceSpan) {
+  return call(Identifiers.twoWayListener, [literal(name), handlerFn], sourceSpan);
+}
 function pipe(slot, name) {
   return call(Identifiers.pipe, [
     literal(slot),
@@ -17442,6 +17631,13 @@ function property(name, expression, sanitizer, sourceSpan) {
   }
   return call(Identifiers.property, args, sourceSpan);
 }
+function twoWayProperty(name, expression, sanitizer, sourceSpan) {
+  const args = [literal(name), expression];
+  if (sanitizer !== null) {
+    args.push(sanitizer);
+  }
+  return call(Identifiers.twoWayProperty, args, sourceSpan);
+}
 function attribute(name, expression, sanitizer, namespace) {
   const args = [literal(name), expression];
   if (sanitizer !== null || namespace !== null) {
@@ -17818,6 +18014,9 @@ function reifyCreateOperations(unit, ops) {
         }
         OpList.replace(op, listener(op.name, listenerFn, eventTargetResolver, op.hostListener && op.isAnimationListener, op.sourceSpan));
         break;
+      case OpKind.TwoWayListener:
+        OpList.replace(op, twoWayListener(op.name, reifyListenerHandler(unit, op.handlerFnName, op.handlerOps, true), op.sourceSpan));
+        break;
       case OpKind.Variable:
         if (op.variable.name === null) {
           throw new Error(`AssertionError: unnamed variable ${op.xref}`);
@@ -17924,6 +18123,9 @@ function reifyUpdateOperations(_unit, ops) {
           OpList.replace(op, property(op.name, op.expression, op.sanitizer, op.sourceSpan));
         }
         break;
+      case OpKind.TwoWayProperty:
+        OpList.replace(op, twoWayProperty(op.name, op.expression, op.sanitizer, op.sourceSpan));
+        break;
       case OpKind.StyleProp:
         if (op.expression instanceof Interpolation2) {
           OpList.replace(op, stylePropInterpolate(op.name, op.expression.strings, op.expression.expressions, op.unit, op.sourceSpan));
@@ -18014,6 +18216,8 @@ function reifyIrExpression(expr) {
       return reference(expr.targetSlot.slot + 1 + expr.offset);
     case ExpressionKind.LexicalRead:
       throw new Error(`AssertionError: unresolved LexicalRead of ${expr.name}`);
+    case ExpressionKind.TwoWayBindingSet:
+      throw new Error(`AssertionError: unresolved TwoWayBindingSet`);
     case ExpressionKind.RestoreView:
       if (typeof expr.view === "number") {
         throw new Error(`AssertionError: unresolved RestoreView`);
@@ -18150,6 +18354,7 @@ function processLexicalScope(view, ops) {
         }
         break;
       case OpKind.Listener:
+      case OpKind.TwoWayListener:
         processLexicalScope(view, op.handlerOps);
         break;
     }
@@ -18180,10 +18385,12 @@ function resolveDollarEvent(job) {
 }
 function transformDollarEvent(unit, ops) {
   for (const op of ops) {
-    if (op.kind === OpKind.Listener) {
+    if (op.kind === OpKind.Listener || op.kind === OpKind.TwoWayListener) {
       transformExpressionsInOp(op, (expr) => {
         if (expr instanceof LexicalReadExpr && expr.name === "$event") {
-          op.consumesDollarEvent = true;
+          if (op.kind === OpKind.Listener) {
+            op.consumesDollarEvent = true;
+          }
           return new ReadVarExpr(expr.name);
         }
         return expr;
@@ -18453,12 +18660,13 @@ function processLexicalScope2(unit, ops, savedView) {
         }
         break;
       case OpKind.Listener:
+      case OpKind.TwoWayListener:
         processLexicalScope2(unit, op.handlerOps, savedView);
         break;
     }
   }
   for (const op of ops) {
-    if (op.kind == OpKind.Listener) {
+    if (op.kind == OpKind.Listener || op.kind === OpKind.TwoWayListener) {
       continue;
     }
     transformExpressionsInOp(op, (expr, flags) => {
@@ -18558,6 +18766,53 @@ function getOnlySecurityContext(securityContext) {
   return securityContext;
 }
 
+// bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/transform_two_way_binding_set.mjs
+function transformTwoWayBindingSet(job) {
+  for (const unit of job.units) {
+    for (const op of unit.create) {
+      if (op.kind === OpKind.TwoWayListener) {
+        transformExpressionsInOp(op, (expr) => {
+          if (expr instanceof TwoWayBindingSetExpr) {
+            return wrapAction(expr.target, expr.value);
+          }
+          return expr;
+        }, VisitorContextFlag.InChildOperation);
+      }
+    }
+  }
+}
+function wrapSetOperation(target, value) {
+  return twoWayBindingSet(target, value).or(target.set(value));
+}
+function isReadExpression2(value) {
+  return value instanceof ReadPropExpr || value instanceof ReadKeyExpr;
+}
+function wrapAction(target, value) {
+  if (isReadExpression2(target)) {
+    return wrapSetOperation(target, value);
+  }
+  if (target instanceof BinaryOperatorExpr && isReadExpression2(target.rhs)) {
+    return new BinaryOperatorExpr(target.operator, target.lhs, wrapSetOperation(target.rhs, value));
+  }
+  if (target instanceof ConditionalExpr && isReadExpression2(target.falseCase)) {
+    return new ConditionalExpr(target.condition, target.trueCase, wrapSetOperation(target.falseCase, value));
+  }
+  if (target instanceof NotExpr) {
+    let expr = target.condition;
+    while (true) {
+      if (expr instanceof NotExpr) {
+        expr = expr.condition;
+      } else {
+        if (isReadExpression2(expr)) {
+          return wrapSetOperation(expr, value);
+        }
+        break;
+      }
+    }
+  }
+  throw new Error(`Unsupported expression in two-way action binding.`);
+}
+
 // bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/save_restore_view.mjs
 function saveAndRestoreView(job) {
   for (const unit of job.units) {
@@ -18569,7 +18824,7 @@ function saveAndRestoreView(job) {
       }, new GetCurrentViewExpr(), VariableFlags.None)
     ]);
     for (const op of unit.create) {
-      if (op.kind !== OpKind.Listener) {
+      if (op.kind !== OpKind.Listener && op.kind !== OpKind.TwoWayListener) {
         continue;
       }
       let needsRestoreView = unit !== job.root;
@@ -18702,7 +18957,7 @@ function generateTemporaries(ops) {
     });
     generatedStatements.push(...Array.from(new Set(defs.values())).map((name) => createStatementOp(new DeclareVarStmt(name))));
     opCount++;
-    if (op.kind === OpKind.Listener) {
+    if (op.kind === OpKind.Listener || op.kind === OpKind.TwoWayListener) {
       op.handlerOps.prepend(generateTemporaries(op.handlerOps));
     }
   }
@@ -18882,6 +19137,8 @@ function varsUsedByOp(op) {
         slots += op.expression.expressions.length;
       }
       return slots;
+    case OpKind.TwoWayProperty:
+      return 1;
     case OpKind.StyleProp:
     case OpKind.ClassProp:
     case OpKind.StyleMap:
@@ -18931,14 +19188,14 @@ function optimizeVariables(job) {
     inlineAlwaysInlineVariables(unit.create);
     inlineAlwaysInlineVariables(unit.update);
     for (const op of unit.create) {
-      if (op.kind === OpKind.Listener) {
+      if (op.kind === OpKind.Listener || op.kind === OpKind.TwoWayListener) {
         inlineAlwaysInlineVariables(op.handlerOps);
       }
     }
     optimizeVariablesInOpList(unit.create, job.compatibility);
     optimizeVariablesInOpList(unit.update, job.compatibility);
     for (const op of unit.create) {
-      if (op.kind === OpKind.Listener) {
+      if (op.kind === OpKind.Listener || op.kind === OpKind.TwoWayListener) {
         optimizeVariablesInOpList(op.handlerOps, job.compatibility);
       }
     }
@@ -19239,6 +19496,7 @@ var phases = [
   { kind: CompilationJobKind.Tmpl, fn: generateTrackVariables },
   { kind: CompilationJobKind.Both, fn: resolveNames },
   { kind: CompilationJobKind.Tmpl, fn: resolveDeferTargetNames },
+  { kind: CompilationJobKind.Tmpl, fn: transformTwoWayBindingSet },
   { kind: CompilationJobKind.Tmpl, fn: optimizeTrackFns },
   { kind: CompilationJobKind.Both, fn: resolveContexts },
   { kind: CompilationJobKind.Both, fn: resolveSanitizers },
@@ -19897,7 +20155,7 @@ function convertAstWithInterpolation(job, value, i18nMeta, sourceSpan) {
 }
 var BINDING_KINDS = /* @__PURE__ */ new Map([
   [0, BindingKind.Property],
-  [5, BindingKind.Property],
+  [5, BindingKind.TwoWayProperty],
   [1, BindingKind.Attribute],
   [2, BindingKind.ClassName],
   [3, BindingKind.StyleProperty],
@@ -19919,11 +20177,18 @@ function asMessage(i18nMeta) {
 function ingestElementBindings(unit, op, element2) {
   var _a2;
   let bindings = new Array();
+  let i18nAttributeBindingNames = /* @__PURE__ */ new Set();
   for (const attr of element2.attributes) {
     const securityContext = domSchema.securityContext(element2.name, attr.name, true);
     bindings.push(createBindingOp(op.xref, BindingKind.Attribute, attr.name, convertAstWithInterpolation(unit.job, attr.value, attr.i18n), null, securityContext, true, false, null, asMessage(attr.i18n), attr.sourceSpan));
+    if (attr.i18n) {
+      i18nAttributeBindingNames.add(attr.name);
+    }
   }
   for (const input of element2.inputs) {
+    if (i18nAttributeBindingNames.has(input.name)) {
+      console.error(`On component ${unit.job.componentName}, the binding ${input.name} is both an i18n attribute and a property. You may want to remove the property binding. This will become a compilation error in future versions of Angular.`);
+    }
     bindings.push(createBindingOp(op.xref, BINDING_KINDS.get(input.type), input.name, convertAstWithInterpolation(unit.job, astOf(input.value), input.i18n), input.unit, input.securityContext, false, false, null, (_a2 = asMessage(input.i18n)) != null ? _a2 : null, input.sourceSpan));
   }
   unit.create.push(bindings.filter((b) => (b == null ? void 0 : b.kind) === OpKind.ExtractedAttribute));
@@ -19932,7 +20197,11 @@ function ingestElementBindings(unit, op, element2) {
     if (output.type === 1 && output.phase === null) {
       throw Error("Animation listener should have a phase");
     }
-    unit.create.push(createListenerOp(op.xref, op.handle, output.name, op.tag, makeListenerHandlerOps(unit, output.handler, output.handlerSpan), output.phase, output.target, false, output.sourceSpan));
+    if (output.type === 2) {
+      unit.create.push(createTwoWayListenerOp(op.xref, op.handle, output.name, op.tag, makeTwoWayListenerHandlerOps(unit, output.handler, output.handlerSpan), output.sourceSpan));
+    } else {
+      unit.create.push(createListenerOp(op.xref, op.handle, output.name, op.tag, makeListenerHandlerOps(unit, output.handler, output.handlerSpan), output.phase, output.target, false, output.sourceSpan));
+    }
   }
   if (bindings.some((b) => b == null ? void 0 : b.i18nMessage) !== null) {
     unit.create.push(createI18nAttributesOp(unit.job.allocateXrefId(), new SlotHandle(), op.xref));
@@ -19962,7 +20231,11 @@ function ingestTemplateBindings(unit, op, template2, templateKind) {
       throw Error("Animation listener should have a phase");
     }
     if (templateKind === TemplateKind.NgTemplate) {
-      unit.create.push(createListenerOp(op.xref, op.handle, output.name, op.tag, makeListenerHandlerOps(unit, output.handler, output.handlerSpan), output.phase, output.target, false, output.sourceSpan));
+      if (output.type === 2) {
+        unit.create.push(createTwoWayListenerOp(op.xref, op.handle, output.name, op.tag, makeTwoWayListenerHandlerOps(unit, output.handler, output.handlerSpan), output.sourceSpan));
+      } else {
+        unit.create.push(createListenerOp(op.xref, op.handle, output.name, op.tag, makeListenerHandlerOps(unit, output.handler, output.handlerSpan), output.phase, output.target, false, output.sourceSpan));
+      }
     }
     if (templateKind === TemplateKind.Structural && output.type !== 1) {
       const securityContext = domSchema.securityContext(NG_TEMPLATE_TAG_NAME, output.name, false);
@@ -19976,8 +20249,15 @@ function ingestTemplateBindings(unit, op, template2, templateKind) {
 function createTemplateBinding(view, xref, type, name, value, unit, securityContext, isStructuralTemplateAttribute, templateKind, i18nMessage, sourceSpan) {
   const isTextBinding = typeof value === "string";
   if (templateKind === TemplateKind.Structural) {
-    if (!isStructuralTemplateAttribute && (type === 0 || type === 5 || type === 2 || type === 3)) {
-      return createExtractedAttributeOp(xref, BindingKind.Property, null, name, null, null, i18nMessage, securityContext);
+    if (!isStructuralTemplateAttribute) {
+      switch (type) {
+        case 0:
+        case 2:
+        case 3:
+          return createExtractedAttributeOp(xref, BindingKind.Property, null, name, null, null, i18nMessage, securityContext);
+        case 5:
+          return createExtractedAttributeOp(xref, BindingKind.TwoWayProperty, null, name, null, null, i18nMessage, securityContext);
+      }
     }
     if (!isTextBinding && (type === 1 || type === 4)) {
       return null;
@@ -20004,6 +20284,23 @@ function makeListenerHandlerOps(unit, handler, handlerSpan) {
   handlerOps.push(createStatementOp(new ReturnStatement(returnExpr, returnExpr.sourceSpan)));
   return handlerOps;
 }
+function makeTwoWayListenerHandlerOps(unit, handler, handlerSpan) {
+  handler = astOf(handler);
+  const handlerOps = new Array();
+  if (handler instanceof Chain) {
+    if (handler.expressions.length === 1) {
+      handler = handler.expressions[0];
+    } else {
+      throw new Error("Expected two-way listener to have a single expression.");
+    }
+  }
+  const handlerExpr = convertAst(handler, unit.job, handlerSpan);
+  const eventReference = new LexicalReadExpr("$event");
+  const twoWaySetExpr = new TwoWayBindingSetExpr(handlerExpr, eventReference);
+  handlerOps.push(createStatementOp(new ExpressionStatement(twoWaySetExpr)));
+  handlerOps.push(createStatementOp(new ReturnStatement(eventReference)));
+  return handlerOps;
+}
 function astOf(ast) {
   return ast instanceof ASTWithSource ? ast.ast : ast;
 }
@@ -20370,7 +20667,7 @@ var BindingParser = class {
       if (keySpan !== void 0) {
         keySpan = moveParseSourceSpan(keySpan, new AbsoluteSourceSpan(keySpan.start.offset + 1, keySpan.end.offset));
       }
-      this._parseAnimationEvent(name, expression, isAssignmentEvent, sourceSpan, handlerSpan, targetEvents, keySpan);
+      this._parseAnimationEvent(name, expression, sourceSpan, handlerSpan, targetEvents, keySpan);
     } else {
       this._parseRegularEvent(name, expression, isAssignmentEvent, sourceSpan, handlerSpan, targetMatchableAttrs, targetEvents, keySpan);
     }
@@ -20379,11 +20676,11 @@ var BindingParser = class {
     const prop = this._schemaRegistry.getMappedPropName(propName);
     return calcPossibleSecurityContexts(this._schemaRegistry, selector, prop, isAttribute);
   }
-  _parseAnimationEvent(name, expression, isAssignmentEvent, sourceSpan, handlerSpan, targetEvents, keySpan) {
+  _parseAnimationEvent(name, expression, sourceSpan, handlerSpan, targetEvents, keySpan) {
     const matches = splitAtPeriod(name, [name, ""]);
     const eventName = matches[0];
     const phase = matches[1].toLowerCase();
-    const ast = this._parseAction(expression, isAssignmentEvent, handlerSpan);
+    const ast = this._parseAction(expression, handlerSpan);
     targetEvents.push(new ParsedEvent(eventName, phase, 1, ast, sourceSpan, handlerSpan, keySpan));
     if (eventName.length === 0) {
       this._reportError(`Animation event name is missing in binding`, sourceSpan);
@@ -20398,15 +20695,20 @@ var BindingParser = class {
   }
   _parseRegularEvent(name, expression, isAssignmentEvent, sourceSpan, handlerSpan, targetMatchableAttrs, targetEvents, keySpan) {
     const [target, eventName] = splitAtColon(name, [null, name]);
-    const ast = this._parseAction(expression, isAssignmentEvent, handlerSpan);
+    const prevErrorCount = this.errors.length;
+    const ast = this._parseAction(expression, handlerSpan);
+    const isValid = this.errors.length === prevErrorCount;
     targetMatchableAttrs.push([name, ast.source]);
+    if (isAssignmentEvent && isValid && !this._isAllowedAssignmentEvent(ast)) {
+      this._reportError("Unsupported expression in a two-way binding", sourceSpan);
+    }
     targetEvents.push(new ParsedEvent(eventName, target, isAssignmentEvent ? 2 : 0, ast, sourceSpan, handlerSpan, keySpan));
   }
-  _parseAction(value, isAssignmentEvent, sourceSpan) {
+  _parseAction(value, sourceSpan) {
     const sourceInfo = (sourceSpan && sourceSpan.start || "(unknown").toString();
     const absoluteOffset = sourceSpan && sourceSpan.start ? sourceSpan.start.offset : 0;
     try {
-      const ast = this._exprParser.parseAction(value, isAssignmentEvent, sourceInfo, absoluteOffset, this._interpolationConfig);
+      const ast = this._exprParser.parseAction(value, sourceInfo, absoluteOffset, this._interpolationConfig);
       if (ast) {
         this._reportExpressionParserErrors(ast.errors, sourceSpan);
       }
@@ -20434,6 +20736,21 @@ var BindingParser = class {
       this._reportError(report.msg, sourceSpan, ParseErrorLevel.ERROR);
     }
   }
+  _isAllowedAssignmentEvent(ast) {
+    if (ast instanceof ASTWithSource) {
+      return this._isAllowedAssignmentEvent(ast.ast);
+    }
+    if (ast instanceof NonNullAssert) {
+      return this._isAllowedAssignmentEvent(ast.expression);
+    }
+    if (ast instanceof PropertyRead || ast instanceof KeyedRead) {
+      return true;
+    }
+    if (ast instanceof Binary) {
+      return (ast.operation === "&&" || ast.operation === "||" || ast.operation === "??") && (ast.right instanceof PropertyRead || ast.right instanceof KeyedRead);
+    }
+    return ast instanceof Conditional || ast instanceof PrefixNot;
+  }
 };
 function isAnimationLabel(name) {
   return name[0] == "@";
@@ -21598,7 +21915,7 @@ var HtmlAstToIvyAst = class {
   }
   parseAssignmentEvent(name, expression, sourceSpan, valueSpan, targetMatchableAttrs, boundEvents, keySpan) {
     const events = [];
-    this.bindingParser.parseEvent(`${name}Change`, `${expression} =$event`, true, sourceSpan, valueSpan || sourceSpan, targetMatchableAttrs, events, keySpan);
+    this.bindingParser.parseEvent(`${name}Change`, expression, true, sourceSpan, valueSpan || sourceSpan, targetMatchableAttrs, events, keySpan);
     addEvents(events, boundEvents);
   }
   reportError(message, sourceSpan, level = ParseErrorLevel.ERROR) {
@@ -22171,7 +22488,7 @@ function prepareEventListenerParameters(eventAst, handlerName = null, scope = nu
   const eventArgumentName = "$event";
   const implicitReceiverAccesses = /* @__PURE__ */ new Set();
   const implicitReceiverExpr = scope === null || scope.bindingLevel === 0 ? variable(CONTEXT_NAME) : scope.getOrCreateSharedContextVar(0);
-  const bindingStatements = convertActionBinding(scope, implicitReceiverExpr, handler, "b", eventAst.handlerSpan, implicitReceiverAccesses, EVENT_BINDING_SCOPE_GLOBALS);
+  const bindingStatements = eventAst.type === 2 ? convertAssignmentActionBinding(scope, implicitReceiverExpr, handler, "b", eventAst.handlerSpan, implicitReceiverAccesses, EVENT_BINDING_SCOPE_GLOBALS) : convertActionBinding(scope, implicitReceiverExpr, handler, "b", eventAst.handlerSpan, implicitReceiverAccesses, EVENT_BINDING_SCOPE_GLOBALS);
   const statements = [];
   const variableDeclarations = scope == null ? void 0 : scope.variableDeclarations();
   const restoreViewStatement = scope == null ? void 0 : scope.restoreViewStatement();
@@ -22597,7 +22914,7 @@ var TemplateDefinitionBuilder = class {
       }
       if (element2.outputs.length > 0) {
         for (const outputAst of element2.outputs) {
-          this.creationInstruction(outputAst.sourceSpan, Identifiers.listener, this.prepareListenerParameter(element2.name, outputAst, elementIndex));
+          this.creationInstruction(outputAst.sourceSpan, outputAst.type === 2 ? Identifiers.twoWayListener : Identifiers.listener, this.prepareListenerParameter(element2.name, outputAst, elementIndex));
         }
       }
       if (isI18nRootElement) {
@@ -22621,6 +22938,7 @@ var TemplateDefinitionBuilder = class {
         this.allocateBindingSlots(value);
         propertyBindings.push({
           span: input.sourceSpan,
+          reference: Identifiers.property,
           paramsOrFn: getBindingFunctionParams(() => hasValue ? this.convertPropertyBinding(value) : emptyValueBindInstruction, prepareSyntheticPropertyName(input.name))
         });
       } else {
@@ -22655,6 +22973,7 @@ var TemplateDefinitionBuilder = class {
             } else {
               propertyBindings.push({
                 span: input.sourceSpan,
+                reference: inputType === 5 ? Identifiers.twoWayProperty : Identifiers.property,
                 paramsOrFn: getBindingFunctionParams(() => this.convertPropertyBinding(value), attrName, params)
               });
             }
@@ -22682,7 +23001,7 @@ var TemplateDefinitionBuilder = class {
       }
     });
     for (const propertyBinding of propertyBindings) {
-      this.updateInstructionWithAdvance(elementIndex, propertyBinding.span, Identifiers.property, propertyBinding.paramsOrFn);
+      this.updateInstructionWithAdvance(elementIndex, propertyBinding.span, propertyBinding.reference, propertyBinding.paramsOrFn);
     }
     for (const attributeBinding of attributeBindings) {
       this.updateInstructionWithAdvance(elementIndex, attributeBinding.span, Identifiers.attribute, attributeBinding.paramsOrFn);
@@ -22712,7 +23031,7 @@ var TemplateDefinitionBuilder = class {
       }
     }
     const contextName = `${this.contextName}${contextNameSuffix}_${index}`;
-    const name = `${contextName}_Template`;
+    const name = this.constantPool.uniqueName(`${contextName}_Template`, false);
     const visitor = new TemplateDefinitionBuilder(this.constantPool, this._bindingScope, this.level + 1, contextName, this.i18n, index, name, this._namespace, this.fileBasedI18nSuffix, this.i18nUseExternalIds, this.deferBlocks, this.elementLocations, this.allDeferrableDepsFn, this._constants);
     this._nestedTemplateFns.push(() => {
       const templateFunctionExpr = visitor.buildTemplateFunction(children, variables, this._ngContentReservedSlots.length + this._ngContentSelectorsOffset, i18nMeta, variableAliases);
@@ -22758,7 +23077,7 @@ var TemplateDefinitionBuilder = class {
         this.templatePropertyBindings(templateIndex, inputs);
       }
       for (const outputAst of template2.outputs) {
-        this.creationInstruction(outputAst.sourceSpan, Identifiers.listener, this.prepareListenerParameter("ng_template", outputAst, templateIndex));
+        this.creationInstruction(outputAst.sourceSpan, outputAst.type === 2 ? Identifiers.twoWayListener : Identifiers.listener, this.prepareListenerParameter("ng_template", outputAst, templateIndex));
       }
     }
   }
@@ -22921,7 +23240,10 @@ var TemplateDefinitionBuilder = class {
     const dependencyExp = [];
     for (const deferredDep of metadata.deps) {
       if (deferredDep.isDeferrable) {
-        const innerFn = arrowFn([new FnParam("m", DYNAMIC_TYPE)], variable("m").prop(deferredDep.symbolName));
+        const innerFn = arrowFn(
+          [new FnParam("m", DYNAMIC_TYPE)],
+          variable("m").prop(deferredDep.isDefaultImport ? "default" : deferredDep.symbolName)
+        );
         const importExpr2 = new DynamicImportExpr(deferredDep.importPath).prop("then").callFn([innerFn]);
         dependencyExp.push(importExpr2);
       } else {
@@ -24035,8 +24357,8 @@ function compileDirectiveFromMetadata(meta, constantPool, bindingParser) {
 }
 function createDeferredDepsFunction(constantPool, name, deps) {
   const dependencyExp = [];
-  for (const [symbolName, importPath] of deps) {
-    const innerFn = arrowFn([new FnParam("m", DYNAMIC_TYPE)], variable("m").prop(symbolName));
+  for (const [symbolName, { importPath, isDefaultImport }] of deps) {
+    const innerFn = arrowFn([new FnParam("m", DYNAMIC_TYPE)], variable("m").prop(isDefaultImport ? "default" : symbolName));
     const importExpr2 = new DynamicImportExpr(importPath).prop("then").callFn([innerFn]);
     dependencyExp.push(importExpr2);
   }
@@ -25739,7 +26061,7 @@ function publishFacade(global) {
 }
 
 // bazel-out/k8-fastbuild/bin/packages/compiler/src/version.mjs
-var VERSION2 = new Version("17.2.0-next.1");
+var VERSION2 = new Version("17.2.0-rc.1");
 
 // bazel-out/k8-fastbuild/bin/packages/compiler/src/i18n/extractor_merger.mjs
 var _VisitorMode;