@angular-eslint/bundled-angular-compiler 21.1.1-alpha.1 → 21.1.1-alpha.11

package/dist/index.js

@@ -93,6 +93,8 @@ __export(index_exports, {
   LiteralExpr: () => LiteralExpr,
   LiteralMap: () => LiteralMap,
   LiteralMapExpr: () => LiteralMapExpr,
+  LiteralMapPropertyAssignment: () => LiteralMapPropertyAssignment,
+  LiteralMapSpreadAssignment: () => LiteralMapSpreadAssignment,
   LiteralPrimitive: () => LiteralPrimitive,
   LocalizedString: () => LocalizedString,
   MapType: () => MapType,
@@ -145,6 +147,8 @@ __export(index_exports, {
   SelectorlessMatcher: () => SelectorlessMatcher,
   Serializer: () => Serializer,
   SplitInterpolation: () => SplitInterpolation,
+  SpreadElement: () => SpreadElement,
+  SpreadElementExpr: () => SpreadElementExpr,
   Statement: () => Statement,
   StmtModifier: () => StmtModifier,
   StringToken: () => StringToken,
@@ -189,6 +193,7 @@ __export(index_exports, {
   TmplAstReference: () => Reference,
   TmplAstSwitchBlock: () => SwitchBlock,
   TmplAstSwitchBlockCase: () => SwitchBlockCase,
+  TmplAstSwitchBlockCaseGroup: () => SwitchBlockCaseGroup,
   TmplAstTemplate: () => Template,
   TmplAstText: () => Text$3,
   TmplAstTextAttribute: () => TextAttribute,
@@ -281,7 +286,7 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// ../../node_modules/.pnpm/@angular+compiler@21.0.2/node_modules/@angular/compiler/fesm2022/compiler.mjs
+// ../../node_modules/.pnpm/@angular+compiler@21.1.0/node_modules/@angular/compiler/fesm2022/compiler.mjs
 var _SELECTOR_REGEXP = new RegExp(`(\\:not\\()|(([\\.\\#]?)[-\\w]+)|(?:\\[([-.\\w*\\\\$]+)(?:=(["']?)([^\\]"']*)\\5)?\\])|(\\))|(\\s*,\\s*)`, "g");
 var CssSelector = class _CssSelector {
   static {
@@ -1955,9 +1960,9 @@ var LiteralArrayExpr = class _LiteralArrayExpr extends Expression {
     return new _LiteralArrayExpr(this.entries.map((e) => e.clone()), this.type, this.sourceSpan);
   }
 };
-var LiteralMapEntry = class _LiteralMapEntry {
+var LiteralMapPropertyAssignment = class _LiteralMapPropertyAssignment {
   static {
-    __name(this, "LiteralMapEntry");
+    __name(this, "LiteralMapPropertyAssignment");
   }
   key;
   value;
@@ -1971,7 +1976,28 @@ var LiteralMapEntry = class _LiteralMapEntry {
     return this.key === e.key && this.value.isEquivalent(e.value);
   }
   clone() {
-    return new _LiteralMapEntry(this.key, this.value.clone(), this.quoted);
+    return new _LiteralMapPropertyAssignment(this.key, this.value.clone(), this.quoted);
+  }
+  isConstant() {
+    return this.value.isConstant();
+  }
+};
+var LiteralMapSpreadAssignment = class _LiteralMapSpreadAssignment {
+  static {
+    __name(this, "LiteralMapSpreadAssignment");
+  }
+  expression;
+  constructor(expression) {
+    this.expression = expression;
+  }
+  isEquivalent(e) {
+    return e instanceof _LiteralMapSpreadAssignment && this.expression.isEquivalent(e.expression);
+  }
+  clone() {
+    return new _LiteralMapSpreadAssignment(this.expression.clone());
+  }
+  isConstant() {
+    return this.expression.isConstant();
   }
 };
 var LiteralMapExpr = class _LiteralMapExpr extends Expression {
@@ -1991,7 +2017,7 @@ var LiteralMapExpr = class _LiteralMapExpr extends Expression {
     return e instanceof _LiteralMapExpr && areAllEquivalent(this.entries, e.entries);
   }
   isConstant() {
-    return this.entries.every((e) => e.value.isConstant());
+    return this.entries.every((e) => e.isConstant());
   }
   visitExpression(visitor, context) {
     return visitor.visitLiteralMapExpr(this, context);
@@ -2023,6 +2049,28 @@ var CommaExpr = class _CommaExpr extends Expression {
     return new _CommaExpr(this.parts.map((p) => p.clone()));
   }
 };
+var SpreadElementExpr = class _SpreadElementExpr extends Expression {
+  static {
+    __name(this, "SpreadElementExpr");
+  }
+  expression;
+  constructor(expression, sourceSpan) {
+    super(null, sourceSpan);
+    this.expression = expression;
+  }
+  isEquivalent(e) {
+    return e instanceof _SpreadElementExpr && this.expression.isEquivalent(e.expression);
+  }
+  isConstant() {
+    return this.expression.isConstant();
+  }
+  visitExpression(visitor, context) {
+    return visitor.visitSpreadElementExpr(this, context);
+  }
+  clone() {
+    return new _SpreadElementExpr(this.expression.clone(), this.sourceSpan);
+  }
+};
 var NULL_EXPR = new LiteralExpr(null, null, null);
 var TYPED_NULL_EXPR = new LiteralExpr(null, INFERRED_TYPE, null);
 var StmtModifier;
@@ -2300,7 +2348,13 @@ var RecursiveAstVisitor$1 = class RecursiveAstVisitor {
     return this.visitExpression(ast, context);
   }
   visitLiteralMapExpr(ast, context) {
-    ast.entries.forEach((entry) => entry.value.visitExpression(this, context));
+    ast.entries.forEach((entry) => {
+      if (entry instanceof LiteralMapSpreadAssignment) {
+        entry.expression.visitExpression(this, context);
+      } else {
+        entry.value.visitExpression(this, context);
+      }
+    });
     return this.visitExpression(ast, context);
   }
   visitCommaExpr(ast, context) {
@@ -2319,6 +2373,10 @@ var RecursiveAstVisitor$1 = class RecursiveAstVisitor {
     ast.expr.visitExpression(this, context);
     return this.visitExpression(ast, context);
   }
+  visitSpreadElementExpr(ast, context) {
+    ast.expression.visitExpression(this, context);
+    return this.visitExpression(ast, context);
+  }
   visitAllExpressions(exprs, context) {
     exprs.forEach((expr) => expr.visitExpression(this, context));
   }
@@ -2393,7 +2451,7 @@ function literalArr(values, type, sourceSpan) {
 }
 __name(literalArr, "literalArr");
 function literalMap(values, type = null) {
-  return new LiteralMapExpr(values.map((e) => new LiteralMapEntry(e.key, e.value, e.quoted)), type, null);
+  return new LiteralMapExpr(values.map((e) => new LiteralMapPropertyAssignment(e.key, e.value, e.quoted)), type, null);
 }
 __name(literalMap, "literalMap");
 function unary(operator, expr, type, sourceSpan) {
@@ -2497,8 +2555,9 @@ var output_ast = /* @__PURE__ */ Object.freeze({
   LeadingComment,
   LiteralArrayExpr,
   LiteralExpr,
-  LiteralMapEntry,
   LiteralMapExpr,
+  LiteralMapPropertyAssignment,
+  LiteralMapSpreadAssignment,
   LiteralPiece,
   LocalizedString,
   MapType,
@@ -2515,6 +2574,7 @@ var output_ast = /* @__PURE__ */ Object.freeze({
   RegularExpressionLiteralExpr,
   ReturnStatement,
   STRING_TYPE,
+  SpreadElementExpr,
   Statement,
   get StmtModifier() {
     return StmtModifier;
@@ -2558,7 +2618,6 @@ var output_ast = /* @__PURE__ */ Object.freeze({
   variable
 });
 var CONSTANT_PREFIX = "_c";
-var UNKNOWN_VALUE_KEY = variable("<unknown>");
 var KEY_CONTEXT = {};
 var POOL_INCLUSION_LENGTH_THRESHOLD_FOR_STRINGS = 50;
 var FixupExpression = class _FixupExpression extends Expression {
@@ -2645,25 +2704,6 @@ var ConstantPool = class {
     }
     return this.sharedConstants.get(key);
   }
-  getLiteralFactory(literal2) {
-    if (literal2 instanceof LiteralArrayExpr) {
-      const argumentsForKey = literal2.entries.map((e) => e.isConstant() ? e : UNKNOWN_VALUE_KEY);
-      const key = GenericKeyFn.INSTANCE.keyOf(literalArr(argumentsForKey));
-      return this._getLiteralFactory(key, literal2.entries, (entries) => literalArr(entries));
-    } else {
-      const expressionForKey = literalMap(literal2.entries.map((e) => ({
-        key: e.key,
-        value: e.value.isConstant() ? e.value : UNKNOWN_VALUE_KEY,
-        quoted: e.quoted
-      })));
-      const key = GenericKeyFn.INSTANCE.keyOf(expressionForKey);
-      return this._getLiteralFactory(key, literal2.entries.map((e) => e.value), (entries) => literalMap(entries.map((value, index) => ({
-        key: literal2.entries[index].key,
-        value,
-        quoted: literal2.entries[index].quoted
-      }))));
-    }
-  }
   getSharedFunctionReference(fn2, prefix, useUniqueName = true) {
     const isArrow = fn2 instanceof ArrowFunctionExpr;
     for (const current of this.statements) {
@@ -2678,23 +2718,6 @@ var ConstantPool = class {
     this.statements.push(fn2 instanceof FunctionExpr ? fn2.toDeclStmt(name, StmtModifier.Final) : new DeclareVarStmt(name, fn2, INFERRED_TYPE, StmtModifier.Final, fn2.sourceSpan));
     return variable(name);
   }
-  _getLiteralFactory(key, values, resultMap) {
-    let literalFactory = this.literalFactories.get(key);
-    const literalFactoryArguments = values.filter((e) => !e.isConstant());
-    if (!literalFactory) {
-      const resultExpressions = values.map((e, index) => e.isConstant() ? this.getConstLiteral(e, true) : variable(`a${index}`));
-      const parameters = resultExpressions.filter(isVariable).map((e) => new FnParam(e.name, DYNAMIC_TYPE));
-      const pureFunctionDeclaration = arrowFn(parameters, resultMap(resultExpressions), INFERRED_TYPE);
-      const name = this.freshName();
-      this.statements.push(new DeclareVarStmt(name, pureFunctionDeclaration, INFERRED_TYPE, StmtModifier.Final));
-      literalFactory = variable(name);
-      this.literalFactories.set(key, literalFactory);
-    }
-    return {
-      literalFactory,
-      literalFactoryArguments
-    };
-  }
   uniqueName(name, alwaysIncludeSuffix = true) {
     const count = this._claimedNames.get(name) ?? 0;
     const result = count === 0 && !alwaysIncludeSuffix ? `${name}` : `${name}${count}`;
@@ -2726,11 +2749,15 @@ var GenericKeyFn = class _GenericKeyFn {
     } else if (expr instanceof LiteralMapExpr) {
       const entries = [];
       for (const entry of expr.entries) {
-        let key = entry.key;
-        if (entry.quoted) {
-          key = `"${key}"`;
+        if (entry instanceof LiteralMapSpreadAssignment) {
+          entries.push("..." + this.keyOf(entry.expression));
+        } else {
+          let key = entry.key;
+          if (entry.quoted) {
+            key = `"${key}"`;
+          }
+          entries.push(key + ":" + this.keyOf(entry.value));
         }
-        entries.push(key + ":" + this.keyOf(entry.value));
       }
       return `{${entries.join(",")}}`;
     } else if (expr instanceof ExternalExpr) {
@@ -2739,15 +2766,13 @@ var GenericKeyFn = class _GenericKeyFn {
       return `read(${expr.name})`;
     } else if (expr instanceof TypeofExpr) {
       return `typeof(${this.keyOf(expr.expr)})`;
+    } else if (expr instanceof SpreadElementExpr) {
+      return `...${this.keyOf(expr.expression)}`;
     } else {
       throw new Error(`${this.constructor.name} does not handle expressions of type ${expr.constructor.name}`);
     }
   }
 };
-function isVariable(e) {
-  return e instanceof ReadVarExpr;
-}
-__name(isVariable, "isVariable");
 function isLongStringLiteral(expr) {
   return expr instanceof LiteralExpr && typeof expr.value === "string" && expr.value.length >= POOL_INCLUSION_LENGTH_THRESHOLD_FOR_STRINGS;
 }
@@ -4194,8 +4219,13 @@ var AbstractEmitterVisitor = class {
   visitLiteralMapExpr(ast, ctx) {
     ctx.print(ast, `{`);
     this.visitAllObjects((entry) => {
-      ctx.print(ast, `${escapeIdentifier(entry.key, this._escapeDollarInStrings, entry.quoted)}:`);
-      entry.value.visitExpression(this, ctx);
+      if (entry instanceof LiteralMapSpreadAssignment) {
+        ctx.print(ast, "...");
+        entry.expression.visitExpression(this, ctx);
+      } else {
+        ctx.print(ast, `${escapeIdentifier(entry.key, this._escapeDollarInStrings, entry.quoted)}:`);
+        entry.value.visitExpression(this, ctx);
+      }
     }, ast.entries, ctx, ",");
     ctx.print(ast, `}`);
     return null;
@@ -4209,6 +4239,10 @@ var AbstractEmitterVisitor = class {
   visitParenthesizedExpr(ast, ctx) {
     ast.expr.visitExpression(this, ctx);
   }
+  visitSpreadElementExpr(ast, ctx) {
+    ctx.print(ast, "...");
+    ast.expression.visitExpression(this, ctx);
+  }
   visitAllExpressions(expressions, ctx, separator) {
     this.visitAllObjects((expr) => expr.visitExpression(this, ctx), expressions, ctx, separator);
   }
@@ -4551,7 +4585,7 @@ var ImplicitReceiver = class extends AST {
     return visitor.visitImplicitReceiver(this, context);
   }
 };
-var ThisReceiver = class extends ImplicitReceiver {
+var ThisReceiver = class extends AST {
   static {
     __name(this, "ThisReceiver");
   }
@@ -4699,6 +4733,19 @@ var LiteralArray = class extends AST {
     return visitor.visitLiteralArray(this, context);
   }
 };
+var SpreadElement = class extends AST {
+  static {
+    __name(this, "SpreadElement");
+  }
+  expression;
+  constructor(span, sourceSpan, expression) {
+    super(span, sourceSpan);
+    this.expression = expression;
+  }
+  visit(visitor, context = null) {
+    return visitor.visitSpreadElement(this, context);
+  }
+};
 var LiteralMap = class extends AST {
   static {
     __name(this, "LiteralMap");
@@ -5090,6 +5137,9 @@ var RecursiveAstVisitor2 = class {
   }
   visitRegularExpressionLiteral(ast, context) {
   }
+  visitSpreadElement(ast, context) {
+    this.visit(ast.expression, context);
+  }
   visitAll(asts, context) {
     for (const ast of asts) {
       this.visit(ast, context);
@@ -5622,12 +5672,12 @@ var SwitchBlock = class extends BlockNode {
     __name(this, "SwitchBlock");
   }
   expression;
-  cases;
+  groups;
   unknownBlocks;
-  constructor(expression, cases, unknownBlocks, sourceSpan, startSourceSpan, endSourceSpan, nameSpan) {
+  constructor(expression, groups, unknownBlocks, sourceSpan, startSourceSpan, endSourceSpan, nameSpan) {
     super(nameSpan, sourceSpan, startSourceSpan, endSourceSpan);
     this.expression = expression;
-    this.cases = cases;
+    this.groups = groups;
     this.unknownBlocks = unknownBlocks;
   }
   visit(visitor) {
@@ -5639,16 +5689,29 @@ var SwitchBlockCase = class extends BlockNode {
     __name(this, "SwitchBlockCase");
   }
   expression;
+  constructor(expression, sourceSpan, startSourceSpan, endSourceSpan, nameSpan) {
+    super(nameSpan, sourceSpan, startSourceSpan, endSourceSpan);
+    this.expression = expression;
+  }
+  visit(visitor) {
+    return visitor.visitSwitchBlockCase(this);
+  }
+};
+var SwitchBlockCaseGroup = class extends BlockNode {
+  static {
+    __name(this, "SwitchBlockCaseGroup");
+  }
+  cases;
   children;
   i18n;
-  constructor(expression, children, sourceSpan, startSourceSpan, endSourceSpan, nameSpan, i18n2) {
+  constructor(cases, children, sourceSpan, startSourceSpan, endSourceSpan, nameSpan, i18n2) {
     super(nameSpan, sourceSpan, startSourceSpan, endSourceSpan);
-    this.expression = expression;
+    this.cases = cases;
     this.children = children;
     this.i18n = i18n2;
   }
   visit(visitor) {
-    return visitor.visitSwitchBlockCase(this);
+    return visitor.visitSwitchBlockCaseGroup(this);
   }
 };
 var ForLoopBlock = class extends BlockNode {
@@ -6007,9 +6070,12 @@ var RecursiveVisitor$1 = class RecursiveVisitor {
     visitAll$1(this, block.children);
   }
   visitSwitchBlock(block) {
-    visitAll$1(this, block.cases);
+    visitAll$1(this, block.groups);
   }
   visitSwitchBlockCase(block) {
+  }
+  visitSwitchBlockCaseGroup(block) {
+    visitAll$1(this, block.cases);
     visitAll$1(this, block.children);
   }
   visitForLoopBlock(block) {
@@ -7419,7 +7485,7 @@ var JitEmitterVisitor = class extends AbstractJsEmitterVisitor {
     this.refResolver = refResolver;
   }
   createReturnStmt(ctx) {
-    const stmt = new ReturnStatement(new LiteralMapExpr(this._evalExportedVars.map((resultVar) => new LiteralMapEntry(resultVar, variable(resultVar), false))));
+    const stmt = new ReturnStatement(new LiteralMapExpr(this._evalExportedVars.map((resultVar) => new LiteralMapPropertyAssignment(resultVar, variable(resultVar), false))));
     stmt.visitStatement(this, ctx);
   }
   getArgs() {
@@ -8767,6 +8833,7 @@ function createControlOp(op) {
   return {
     kind: OpKind.Control,
     target: op.target,
+    name: op.name,
     expression: op.expression,
     bindingKind: op.bindingKind,
     securityContext: op.securityContext,
@@ -9746,8 +9813,12 @@ function transformExpressionsInExpression(expr, transform2, flags) {
       expr.entries[i] = transformExpressionsInExpression(expr.entries[i], transform2, flags);
     }
   } else if (expr instanceof LiteralMapExpr) {
-    for (let i = 0; i < expr.entries.length; i++) {
-      expr.entries[i].value = transformExpressionsInExpression(expr.entries[i].value, transform2, flags);
+    for (const entry of expr.entries) {
+      if (entry instanceof LiteralMapSpreadAssignment) {
+        entry.expression = transformExpressionsInExpression(entry.expression, transform2, flags);
+      } else {
+        entry.value = transformExpressionsInExpression(entry.value, transform2, flags);
+      }
     }
   } else if (expr instanceof ConditionalExpr) {
     expr.condition = transformExpressionsInExpression(expr.condition, transform2, flags);
@@ -9783,6 +9854,8 @@ function transformExpressionsInExpression(expr, transform2, flags) {
     }
   } else if (expr instanceof ParenthesizedExpr) {
     expr.expr = transformExpressionsInExpression(expr.expr, transform2, flags);
+  } else if (expr instanceof SpreadElementExpr) {
+    expr.expression = transformExpressionsInExpression(expr.expression, transform2, flags);
   } else if (expr instanceof ReadVarExpr || expr instanceof ExternalExpr || expr instanceof LiteralExpr || expr instanceof RegularExpressionLiteralExpr) ;
   else {
     throw new Error(`Unhandled expression kind: ${expr.constructor.name}`);
@@ -10834,7 +10907,7 @@ function extractAttributes(job) {
           }
           break;
         case OpKind.Control:
-          OpList.insertBefore(createExtractedAttributeOp(op.target, BindingKind.Property, null, "field", null, null, null, op.securityContext), lookupElement$3(elements, op.target));
+          OpList.insertBefore(createExtractedAttributeOp(op.target, BindingKind.Property, null, op.name, null, null, null, op.securityContext), lookupElement$3(elements, op.target));
           break;
         case OpKind.TwoWayProperty:
           OpList.insertBefore(createExtractedAttributeOp(op.target, BindingKind.TwoWayProperty, null, op.name, null, null, null, op.securityContext), lookupElement$3(elements, op.target));
@@ -10947,7 +11020,7 @@ function specializeBindings(job) {
             OpList.replace(op, createAttributeOp(op.target, null, op.name, op.expression, op.securityContext, false, op.isStructuralTemplateAttribute, op.templateKind, op.i18nMessage, op.sourceSpan));
           } else if (job.kind === CompilationJobKind.Host) {
             OpList.replace(op, createDomPropertyOp(op.name, op.expression, op.bindingKind, op.i18nContext, op.securityContext, op.sourceSpan));
-          } else if (op.name === "field") {
+          } else if (op.name === "formField") {
             OpList.replace(op, createControlOp(op));
           } else {
             OpList.replace(op, createPropertyOp(op.target, op.name, op.expression, op.bindingKind, op.securityContext, op.isStructuralTemplateAttribute, op.templateKind, op.i18nContext, op.i18nMessage, op.sourceSpan));
@@ -14799,6 +14872,11 @@ var _Tokenizer = class {
     if (this._attemptCharCode($LBRACE)) {
       this._beginToken(25);
       this._endToken([]);
+    } else if (this._isBlockStart() && (startToken.parts[0] === "case" || startToken.parts[0] === "default")) {
+      this._beginToken(25);
+      this._endToken([]);
+      this._beginToken(26);
+      this._endToken([]);
     } else {
       startToken.type = 28;
     }
@@ -16816,7 +16894,18 @@ var _Scanner = class {
     switch (peek) {
       case $PERIOD:
         this.advance();
-        return isDigit(this.peek) ? this.scanNumber(start) : newCharacterToken(start, this.index, $PERIOD);
+        if (isDigit(this.peek)) {
+          return this.scanNumber(start);
+        }
+        if (this.peek !== $PERIOD) {
+          return newCharacterToken(start, this.index, $PERIOD);
+        }
+        this.advance();
+        if (this.peek === $PERIOD) {
+          this.advance();
+          return newOperatorToken(start, this.index, "...");
+        }
+        return this.error(`Unexpected character [${String.fromCharCode(peek)}]`, 0);
       case $LPAREN:
       case $RPAREN:
       case $LBRACKET:
@@ -17791,14 +17880,14 @@ var _ParseAST = class {
           return new PrefixNot(this.span(start), this.sourceSpan(start), result);
       }
     } else if (this.next.isKeywordTypeof()) {
-      this.advance();
       const start = this.inputIndex;
-      let result = this.parsePrefix();
+      this.advance();
+      const result = this.parsePrefix();
       return new TypeofExpression(this.span(start), this.sourceSpan(start), result);
     } else if (this.next.isKeywordVoid()) {
-      this.advance();
       const start = this.inputIndex;
-      let result = this.parsePrefix();
+      this.advance();
+      const result = this.parsePrefix();
       return new VoidExpression(this.span(start), this.sourceSpan(start), result);
     }
     return this.parseCallChain();
@@ -17860,11 +17949,7 @@ var _ParseAST = class {
       this.advance();
       return new ThisReceiver(this.span(start), this.sourceSpan(start));
     } else if (this.consumeOptionalCharacter($LBRACKET)) {
-      this.rbracketsExpected++;
-      const elements = this.parseExpressionList($RBRACKET);
-      this.rbracketsExpected--;
-      this.expectCharacter($RBRACKET);
-      return new LiteralArray(this.span(start), this.sourceSpan(start), elements);
+      return this.parseLiteralArray(start);
     } else if (this.next.isCharacter($LBRACE)) {
       return this.parseLiteralMap();
     } else if (this.next.isIdentifier()) {
@@ -17894,16 +17979,21 @@ var _ParseAST = class {
       return new EmptyExpr$1(this.span(start), this.sourceSpan(start));
     }
   }
-  parseExpressionList(terminator) {
-    const result = [];
+  parseLiteralArray(arrayStart) {
+    this.rbracketsExpected++;
+    const elements = [];
     do {
-      if (!this.next.isCharacter(terminator)) {
-        result.push(this.parsePipe());
+      if (this.next.isOperator("...")) {
+        elements.push(this.parseSpreadElement());
+      } else if (!this.next.isCharacter($RBRACKET)) {
+        elements.push(this.parsePipe());
       } else {
         break;
       }
     } while (this.consumeOptionalCharacter($COMMA));
-    return result;
+    this.rbracketsExpected--;
+    this.expectCharacter($RBRACKET);
+    return new LiteralArray(this.span(arrayStart), this.sourceSpan(arrayStart), elements);
   }
   parseLiteralMap() {
     const keys = [];
@@ -17914,11 +18004,26 @@ var _ParseAST = class {
       this.rbracesExpected++;
       do {
         const keyStart = this.inputIndex;
+        if (this.next.isOperator("...")) {
+          this.advance();
+          keys.push({
+            kind: "spread",
+            span: this.span(keyStart),
+            sourceSpan: this.sourceSpan(keyStart)
+          });
+          values.push(this.parsePipe());
+          continue;
+        }
         const quoted = this.next.isString();
         const key = this.expectIdentifierOrKeywordOrString();
+        const keySpan = this.span(keyStart);
+        const keySourceSpan = this.sourceSpan(keyStart);
         const literalMapKey = {
+          kind: "property",
           key,
-          quoted
+          quoted,
+          span: keySpan,
+          sourceSpan: keySourceSpan
         };
         keys.push(literalMapKey);
         if (quoted) {
@@ -17928,9 +18033,7 @@ var _ParseAST = class {
           values.push(this.parsePipe());
         } else {
           literalMapKey.isShorthandInitialized = true;
-          const span = this.span(keyStart);
-          const sourceSpan = this.sourceSpan(keyStart);
-          values.push(new PropertyRead(span, sourceSpan, sourceSpan, new ImplicitReceiver(span, sourceSpan), key));
+          values.push(new PropertyRead(keySpan, keySourceSpan, keySourceSpan, new ImplicitReceiver(keySpan, keySourceSpan), key));
         }
       } while (this.consumeOptionalCharacter($COMMA) && !this.next.isCharacter($RBRACE));
       this.rbracesExpected--;
@@ -17985,13 +18088,26 @@ var _ParseAST = class {
     return isSafe ? new SafeCall(span, sourceSpan, receiver, args, argumentSpan) : new Call(span, sourceSpan, receiver, args, argumentSpan);
   }
   parseCallArguments() {
-    if (this.next.isCharacter($RPAREN)) return [];
+    if (this.next.isCharacter($RPAREN)) {
+      return [];
+    }
     const positionals = [];
     do {
-      positionals.push(this.parsePipe());
+      positionals.push(this.next.isOperator("...") ? this.parseSpreadElement() : this.parsePipe());
     } while (this.consumeOptionalCharacter($COMMA));
     return positionals;
   }
+  parseSpreadElement() {
+    if (!this.next.isOperator("...")) {
+      this.error("Spread element must start with '...' operator");
+    }
+    const spreadStart = this.inputIndex;
+    this.advance();
+    const expression = this.parsePipe();
+    const span = this.span(spreadStart);
+    const sourceSpan = this.sourceSpan(spreadStart);
+    return new SpreadElement(span, sourceSpan, expression);
+  }
   expectTemplateBindingKey() {
     let result = "";
     let operatorFound = false;
@@ -18284,7 +18400,12 @@ var SerializeExpressionVisitor = class {
     return `[${ast.expressions.map((e) => e.visit(this, context)).join(", ")}]`;
   }
   visitLiteralMap(ast, context) {
-    return `{${zip(ast.keys.map((literal2) => literal2.quoted ? `'${literal2.key}'` : literal2.key), ast.values.map((value) => value.visit(this, context))).map(([key, value]) => `${key}: ${value}`).join(", ")}}`;
+    return `{${zip(ast.keys.map((literal2) => {
+      if (literal2.kind === "spread") {
+        return "...";
+      }
+      return literal2.quoted ? `'${literal2.key}'` : literal2.key;
+    }), ast.values.map((value) => value.visit(this, context))).map(([key, value]) => `${key}: ${value}`).join(", ")}}`;
   }
   visitLiteralPrimitive(ast) {
     if (ast.value === null) return "null";
@@ -18310,7 +18431,7 @@ var SerializeExpressionVisitor = class {
     return `${ast.expression.visit(this, context)}!`;
   }
   visitPropertyRead(ast, context) {
-    if (ast.receiver instanceof ImplicitReceiver) {
+    if (ast.receiver instanceof ImplicitReceiver || ast.receiver instanceof ThisReceiver) {
       return ast.name;
     } else {
       return `${ast.receiver.visit(this, context)}.${ast.name}`;
@@ -18357,6 +18478,9 @@ var SerializeExpressionVisitor = class {
   visitTaggedTemplateLiteral(ast, context) {
     return ast.tag.visit(this, context) + ast.template.visit(this, context);
   }
+  visitSpreadElement(ast, context) {
+    return `...${ast.expression.visit(this, context)}`;
+  }
   visitParenthesizedExpression(ast, context) {
     return "(" + ast.expression.visit(this, context) + ")";
   }
@@ -18381,8 +18505,8 @@ function SECURITY_SCHEMA() {
     _SECURITY_SCHEMA = {};
     registerContext(SecurityContext.HTML, ["iframe|srcdoc", "*|innerHTML", "*|outerHTML"]);
     registerContext(SecurityContext.STYLE, ["*|style"]);
-    registerContext(SecurityContext.URL, ["*|formAction", "area|href", "area|ping", "audio|src", "a|href", "a|xlink:href", "a|ping", "blockquote|cite", "body|background", "del|cite", "form|action", "img|src", "input|src", "ins|cite", "q|cite", "source|src", "track|src", "video|poster", "video|src", "annotation|href", "annotation|xlink:href", "annotation-xml|href", "annotation-xml|xlink:href", "maction|href", "maction|xlink:href", "malignmark|href", "malignmark|xlink:href", "math|href", "math|xlink:href", "mroot|href", "mroot|xlink:href", "msqrt|href", "msqrt|xlink:href", "merror|href", "merror|xlink:href", "mfrac|href", "mfrac|xlink:href", "mglyph|href", "mglyph|xlink:href", "msub|href", "msub|xlink:href", "msup|href", "msup|xlink:href", "msubsup|href", "msubsup|xlink:href", "mmultiscripts|href", "mmultiscripts|xlink:href", "mprescripts|href", "mprescripts|xlink:href", "mi|href", "mi|xlink:href", "mn|href", "mn|xlink:href", "mo|href", "mo|xlink:href", "mpadded|href", "mpadded|xlink:href", "mphantom|href", "mphantom|xlink:href", "mrow|href", "mrow|xlink:href", "ms|href", "ms|xlink:href", "mspace|href", "mspace|xlink:href", "mstyle|href", "mstyle|xlink:href", "mtable|href", "mtable|xlink:href", "mtd|href", "mtd|xlink:href", "mtr|href", "mtr|xlink:href", "mtext|href", "mtext|xlink:href", "mover|href", "mover|xlink:href", "munder|href", "munder|xlink:href", "munderover|href", "munderover|xlink:href", "semantics|href", "semantics|xlink:href", "none|href", "none|xlink:href"]);
-    registerContext(SecurityContext.RESOURCE_URL, ["applet|code", "applet|codebase", "base|href", "embed|src", "frame|src", "head|profile", "html|manifest", "iframe|src", "link|href", "media|src", "object|codebase", "object|data", "script|src"]);
+    registerContext(SecurityContext.URL, ["*|formAction", "area|href", "a|href", "a|xlink:href", "form|action", "annotation|href", "annotation|xlink:href", "annotation-xml|href", "annotation-xml|xlink:href", "maction|href", "maction|xlink:href", "malignmark|href", "malignmark|xlink:href", "math|href", "math|xlink:href", "mroot|href", "mroot|xlink:href", "msqrt|href", "msqrt|xlink:href", "merror|href", "merror|xlink:href", "mfrac|href", "mfrac|xlink:href", "mglyph|href", "mglyph|xlink:href", "msub|href", "msub|xlink:href", "msup|href", "msup|xlink:href", "msubsup|href", "msubsup|xlink:href", "mmultiscripts|href", "mmultiscripts|xlink:href", "mprescripts|href", "mprescripts|xlink:href", "mi|href", "mi|xlink:href", "mn|href", "mn|xlink:href", "mo|href", "mo|xlink:href", "mpadded|href", "mpadded|xlink:href", "mphantom|href", "mphantom|xlink:href", "mrow|href", "mrow|xlink:href", "ms|href", "ms|xlink:href", "mspace|href", "mspace|xlink:href", "mstyle|href", "mstyle|xlink:href", "mtable|href", "mtable|xlink:href", "mtd|href", "mtd|xlink:href", "mtr|href", "mtr|xlink:href", "mtext|href", "mtext|xlink:href", "mover|href", "mover|xlink:href", "munder|href", "munder|xlink:href", "munderover|href", "munderover|xlink:href", "semantics|href", "semantics|xlink:href", "none|href", "none|xlink:href", "img|src", "video|src"]);
+    registerContext(SecurityContext.RESOURCE_URL, ["base|href", "embed|src", "frame|src", "iframe|src", "link|href", "object|codebase", "object|data", "script|src", "script|href", "script|xlink:href"]);
     registerContext(SecurityContext.ATTRIBUTE_NO_BINDING, ["animate|attributeName", "set|attributeName", "animateMotion|attributeName", "animateTransform|attributeName", "unknown|attributeName", "iframe|sandbox", "iframe|allow", "iframe|allowFullscreen", "iframe|referrerPolicy", "iframe|csp", "iframe|fetchPriority", "unknown|sandbox", "unknown|allow", "unknown|allowFullscreen", "unknown|referrerPolicy", "unknown|csp", "unknown|fetchPriority"]);
   }
   return _SECURITY_SCHEMA;
@@ -20270,6 +20394,8 @@ var UPDATE_ORDERING = [{
   test: nonInterpolationPropertyKindTest
 }, {
   test: kindWithInterpolationTest(OpKind.Attribute, false)
+}, {
+  test: kindTest(OpKind.Control)
 }];
 var UPDATE_HOST_ORDERING = [{
   test: kindWithInterpolationTest(OpKind.DomProperty, true)
@@ -20288,7 +20414,7 @@ var UPDATE_HOST_ORDERING = [{
 }, {
   test: kindTest(OpKind.ClassProp)
 }];
-var handledOpKinds = /* @__PURE__ */ new Set([OpKind.Listener, OpKind.TwoWayListener, OpKind.AnimationListener, OpKind.StyleMap, OpKind.ClassMap, OpKind.StyleProp, OpKind.ClassProp, OpKind.Property, OpKind.TwoWayProperty, OpKind.DomProperty, OpKind.Attribute, OpKind.Animation]);
+var handledOpKinds = /* @__PURE__ */ new Set([OpKind.Listener, OpKind.TwoWayListener, OpKind.AnimationListener, OpKind.StyleMap, OpKind.ClassMap, OpKind.StyleProp, OpKind.ClassProp, OpKind.Property, OpKind.TwoWayProperty, OpKind.DomProperty, OpKind.Attribute, OpKind.Animation, OpKind.Control]);
 function orderOps(job) {
   for (const unit of job.units) {
     orderWithin(unit.create, CREATE_ORDERING);
@@ -20551,6 +20677,16 @@ function transformLiteralArray(expr) {
   const derivedEntries = [];
   const nonConstantArgs = [];
   for (const entry of expr.entries) {
+    if (entry instanceof SpreadElementExpr) {
+      if (entry.expression.isConstant()) {
+        derivedEntries.push(entry);
+      } else {
+        const idx = nonConstantArgs.length;
+        nonConstantArgs.push(entry.expression);
+        derivedEntries.push(new SpreadElementExpr(new PureFunctionParameterExpr(idx)));
+      }
+      continue;
+    }
     if (entry.isConstant()) {
       derivedEntries.push(entry);
     } else {
@@ -20566,15 +20702,25 @@ function transformLiteralMap(expr) {
   let derivedEntries = [];
   const nonConstantArgs = [];
   for (const entry of expr.entries) {
+    if (entry instanceof LiteralMapSpreadAssignment) {
+      if (entry.expression.isConstant()) {
+        derivedEntries.push(entry);
+      } else {
+        const idx = nonConstantArgs.length;
+        nonConstantArgs.push(entry.expression);
+        derivedEntries.push(new LiteralMapSpreadAssignment(new PureFunctionParameterExpr(idx)));
+      }
+      continue;
+    }
     if (entry.value.isConstant()) {
       derivedEntries.push(entry);
     } else {
       const idx = nonConstantArgs.length;
       nonConstantArgs.push(entry.value);
-      derivedEntries.push(new LiteralMapEntry(entry.key, new PureFunctionParameterExpr(idx), entry.quoted));
+      derivedEntries.push(new LiteralMapPropertyAssignment(entry.key, new PureFunctionParameterExpr(idx), entry.quoted));
     }
   }
-  return new PureFunctionExpr(literalMap(derivedEntries), nonConstantArgs);
+  return new PureFunctionExpr(new LiteralMapExpr(derivedEntries), nonConstantArgs);
 }
 __name(transformLiteralMap, "transformLiteralMap");
 function optimizeRegularExpressions(job) {
@@ -20902,13 +21048,14 @@ function property(name, expression, sanitizer, sourceSpan) {
   return propertyBase(Identifiers.property, name, expression, sanitizer, sourceSpan);
 }
 __name(property, "property");
-function control(expression, sanitizer, sourceSpan) {
+function control(name, expression, sanitizer, sourceSpan) {
   const args = [];
   if (expression instanceof Interpolation2) {
     args.push(interpolationToExpression(expression, sourceSpan));
   } else {
     args.push(expression);
   }
+  args.push(literal(name));
   if (sanitizer !== null) {
     args.push(sanitizer);
   }
@@ -21021,7 +21168,7 @@ function pipeBindV(slot, varOffset, args) {
 __name(pipeBindV, "pipeBindV");
 function textInterpolate(strings, expressions, sourceSpan) {
   const interpolationArgs = collateInterpolationArgs(strings, expressions);
-  return callVariadicInstruction(TEXT_INTERPOLATE_CONFIG, [], interpolationArgs, [], sourceSpan);
+  return callVariadicInstruction(TEXT_INTERPOLATE_CONFIG, [], interpolationArgs, sourceSpan);
 }
 __name(textInterpolate, "textInterpolate");
 function i18nExp(expr, sourceSpan) {
@@ -21066,7 +21213,7 @@ function syntheticHostProperty(name, expression, sourceSpan) {
 }
 __name(syntheticHostProperty, "syntheticHostProperty");
 function pureFunction(varOffset, fn2, args) {
-  return callVariadicInstructionExpr(PURE_FUNCTION_CONFIG, [literal(varOffset), fn2], args, [], null);
+  return callVariadicInstructionExpr(PURE_FUNCTION_CONFIG, [literal(varOffset), fn2], args, null);
 }
 __name(pureFunction, "pureFunction");
 function attachSourceLocation(templatePath, locations) {
@@ -21092,7 +21239,7 @@ function collateInterpolationArgs(strings, expressions) {
 __name(collateInterpolationArgs, "collateInterpolationArgs");
 function interpolationToExpression(interpolation, sourceSpan) {
   const interpolationArgs = collateInterpolationArgs(interpolation.strings, interpolation.expressions);
-  return callVariadicInstructionExpr(VALUE_INTERPOLATE_CONFIG, [], interpolationArgs, [], sourceSpan);
+  return callVariadicInstructionExpr(VALUE_INTERPOLATE_CONFIG, [], interpolationArgs, sourceSpan);
 }
 __name(interpolationToExpression, "interpolationToExpression");
 function call(instruction, args, sourceSpan) {
@@ -21133,23 +21280,23 @@ var PURE_FUNCTION_CONFIG = {
   variable: Identifiers.pureFunctionV,
   mapping: /* @__PURE__ */ __name((n) => n, "mapping")
 };
-function callVariadicInstructionExpr(config, baseArgs, interpolationArgs, extraArgs, sourceSpan) {
+function callVariadicInstructionExpr(config, baseArgs, interpolationArgs, sourceSpan) {
   const n = config.mapping(interpolationArgs.length);
   const lastInterpolationArg = interpolationArgs.at(-1);
-  if (extraArgs.length === 0 && interpolationArgs.length > 1 && lastInterpolationArg instanceof LiteralExpr && lastInterpolationArg.value === "") {
+  if (interpolationArgs.length > 1 && lastInterpolationArg instanceof LiteralExpr && lastInterpolationArg.value === "") {
     interpolationArgs.pop();
   }
   if (n < config.constant.length) {
-    return importExpr(config.constant[n]).callFn([...baseArgs, ...interpolationArgs, ...extraArgs], sourceSpan);
+    return importExpr(config.constant[n]).callFn([...baseArgs, ...interpolationArgs], sourceSpan);
   } else if (config.variable !== null) {
-    return importExpr(config.variable).callFn([...baseArgs, literalArr(interpolationArgs), ...extraArgs], sourceSpan);
+    return importExpr(config.variable).callFn([...baseArgs, literalArr(interpolationArgs)], sourceSpan);
   } else {
     throw new Error(`AssertionError: unable to call variadic function`);
   }
 }
 __name(callVariadicInstructionExpr, "callVariadicInstructionExpr");
-function callVariadicInstruction(config, baseArgs, interpolationArgs, extraArgs, sourceSpan) {
-  return createStatementOp(callVariadicInstructionExpr(config, baseArgs, interpolationArgs, extraArgs, sourceSpan).toStmt());
+function callVariadicInstruction(config, baseArgs, interpolationArgs, sourceSpan) {
+  return createStatementOp(callVariadicInstructionExpr(config, baseArgs, interpolationArgs, sourceSpan).toStmt());
 }
 __name(callVariadicInstruction, "callVariadicInstruction");
 var GLOBAL_TARGET_RESOLVERS = /* @__PURE__ */ new Map([["window", Identifiers.resolveWindow], ["document", Identifiers.resolveDocument], ["body", Identifiers.resolveBody]]);
@@ -21497,7 +21644,7 @@ function reifyProperty(op) {
 }
 __name(reifyProperty, "reifyProperty");
 function reifyControl(op) {
-  return control(op.expression, op.sanitizer, op.sourceSpan);
+  return control(op.name, op.expression, op.sanitizer, op.sourceSpan);
 }
 __name(reifyControl, "reifyControl");
 function reifyIrExpression(expr) {
@@ -23336,6 +23483,10 @@ function ingestElement(unit, element2) {
   ingestNodes(unit, element2.children);
   const endOp = createElementEndOp(id, element2.endSourceSpan ?? element2.startSourceSpan);
   unit.create.push(endOp);
+  const fieldInput = element2.inputs.find((input) => input.name === "formField" && input.type === BindingType.Property);
+  if (fieldInput) {
+    unit.create.push(createControlCreateOp(fieldInput.sourceSpan));
+  }
   if (i18nBlockId !== null) {
     OpList.insertBefore(createI18nEndOp(i18nBlockId, element2.endSourceSpan ?? element2.startSourceSpan), endOp);
   }
@@ -23448,32 +23599,34 @@ function ingestIfBlock(unit, ifBlock) {
 }
 __name(ingestIfBlock, "ingestIfBlock");
 function ingestSwitchBlock(unit, switchBlock) {
-  if (switchBlock.cases.length === 0) {
+  if (switchBlock.groups.length === 0) {
     return;
   }
   let firstXref = null;
   let conditions = [];
-  for (let i = 0; i < switchBlock.cases.length; i++) {
-    const switchCase = switchBlock.cases[i];
+  for (let i = 0; i < switchBlock.groups.length; i++) {
+    const switchCaseGroup = switchBlock.groups[i];
     const cView = unit.job.allocateView(unit.xref);
-    const tagName = ingestControlFlowInsertionPoint(unit, cView.xref, switchCase);
+    const tagName = ingestControlFlowInsertionPoint(unit, cView.xref, switchCaseGroup);
     let switchCaseI18nMeta = void 0;
-    if (switchCase.i18n !== void 0) {
-      if (!(switchCase.i18n instanceof BlockPlaceholder)) {
-        throw Error(`Unhandled i18n metadata type for switch block: ${switchCase.i18n?.constructor.name}`);
+    if (switchCaseGroup.i18n !== void 0) {
+      if (!(switchCaseGroup.i18n instanceof BlockPlaceholder)) {
+        throw Error(`Unhandled i18n metadata type for switch block: ${switchCaseGroup.i18n?.constructor.name}`);
       }
-      switchCaseI18nMeta = switchCase.i18n;
+      switchCaseI18nMeta = switchCaseGroup.i18n;
     }
     const createOp = i === 0 ? createConditionalCreateOp : createConditionalBranchCreateOp;
-    const conditionalCreateOp = createOp(cView.xref, TemplateKind.Block, tagName, "Case", Namespace.HTML, switchCaseI18nMeta, switchCase.startSourceSpan, switchCase.sourceSpan);
+    const conditionalCreateOp = createOp(cView.xref, TemplateKind.Block, tagName, "Case", Namespace.HTML, switchCaseI18nMeta, switchCaseGroup.startSourceSpan, switchCaseGroup.sourceSpan);
     unit.create.push(conditionalCreateOp);
     if (firstXref === null) {
       firstXref = cView.xref;
     }
-    const caseExpr = switchCase.expression ? convertAst(switchCase.expression, unit.job, switchBlock.startSourceSpan) : null;
-    const conditionalCaseExpr = new ConditionalCaseExpr(caseExpr, conditionalCreateOp.xref, conditionalCreateOp.handle);
-    conditions.push(conditionalCaseExpr);
-    ingestNodes(cView, switchCase.children);
+    for (const switchCase of switchCaseGroup.cases) {
+      const caseExpr = switchCase.expression ? convertAst(switchCase.expression, unit.job, switchBlock.startSourceSpan) : null;
+      const conditionalCaseExpr = new ConditionalCaseExpr(caseExpr, conditionalCreateOp.xref, conditionalCreateOp.handle);
+      conditions.push(conditionalCaseExpr);
+    }
+    ingestNodes(cView, switchCaseGroup.children);
   }
   unit.update.push(createConditionalOp(firstXref, convertAst(switchBlock.expression, unit.job, null), conditions, switchBlock.sourceSpan));
 }
@@ -23708,8 +23861,7 @@ function convertAst(ast, job, baseSourceSpan) {
   if (ast instanceof ASTWithSource) {
     return convertAst(ast.ast, job, baseSourceSpan);
   } else if (ast instanceof PropertyRead) {
-    const isImplicitReceiver = ast.receiver instanceof ImplicitReceiver && !(ast.receiver instanceof ThisReceiver);
-    if (isImplicitReceiver) {
+    if (ast.receiver instanceof ImplicitReceiver) {
       return new LexicalReadExpr(ast.name);
     } else {
       return new ReadPropExpr(convertAst(ast.receiver, job, baseSourceSpan), ast.name, null, convertSourceSpan(ast.span, baseSourceSpan));
@@ -23745,8 +23897,8 @@ function convertAst(ast, job, baseSourceSpan) {
     throw new Error(`AssertionError: Chain in unknown context`);
   } else if (ast instanceof LiteralMap) {
     const entries = ast.keys.map((key, idx) => {
-      const value = ast.values[idx];
-      return new LiteralMapEntry(key.key, convertAst(value, job, baseSourceSpan), key.quoted);
+      const value = convertAst(ast.values[idx], job, baseSourceSpan);
+      return key.kind === "spread" ? new LiteralMapSpreadAssignment(value) : new LiteralMapPropertyAssignment(key.key, value, key.quoted);
     });
     return new LiteralMapExpr(entries, void 0, convertSourceSpan(ast.span, baseSourceSpan));
   } else if (ast instanceof LiteralArray) {
@@ -23779,6 +23931,8 @@ function convertAst(ast, job, baseSourceSpan) {
     return new ParenthesizedExpr(convertAst(ast.expression, job, baseSourceSpan), void 0, convertSourceSpan(ast.span, baseSourceSpan));
   } else if (ast instanceof RegularExpressionLiteral) {
     return new RegularExpressionLiteralExpr(ast.body, ast.flags, baseSourceSpan);
+  } else if (ast instanceof SpreadElement) {
+    return new SpreadElementExpr(convertAst(ast.expression, job, baseSourceSpan));
   } else {
     throw new Error(`Unhandled expression type "${ast.constructor.name}" in file "${baseSourceSpan?.start.file.url}"`);
   }
@@ -23832,9 +23986,6 @@ function ingestElementBindings(unit, op, element2) {
       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, asMessage(input.i18n) ?? null, input.sourceSpan));
-    if (input.type === BindingType.Property && input.name === "field") {
-      unit.create.push(createControlCreateOp(input.sourceSpan));
-    }
   }
   unit.create.push(bindings.filter((b) => b?.kind === OpKind.ExtractedAttribute));
   unit.update.push(bindings.filter((b) => b?.kind === OpKind.Binding));
@@ -24056,7 +24207,7 @@ function getQueryPredicate(query, constantPool) {
   }
 }
 __name(getQueryPredicate, "getQueryPredicate");
-function createQueryCreateCall(query, constantPool, queryTypeFns, prependParams) {
+function getQueryCreateParameters(query, constantPool, prependParams) {
   const parameters = [];
   if (prependParams !== void 0) {
     parameters.push(...prependParams);
@@ -24068,10 +24219,9 @@ function createQueryCreateCall(query, constantPool, queryTypeFns, prependParams)
   if (query.read) {
     parameters.push(query.read);
   }
-  const queryCreateFn = query.isSignal ? queryTypeFns.signalBased : queryTypeFns.nonSignal;
-  return importExpr(queryCreateFn).callFn(parameters);
+  return parameters;
 }
-__name(createQueryCreateCall, "createQueryCreateCall");
+__name(getQueryCreateParameters, "getQueryCreateParameters");
 var queryAdvancePlaceholder = Symbol("queryAdvancePlaceholder");
 function collapseAdvanceStatements(statements) {
   const result = [];
@@ -24099,12 +24249,17 @@ function createViewQueriesFunction(viewQueries, constantPool, name) {
   const createStatements = [];
   const updateStatements = [];
   const tempAllocator = temporaryAllocator((st) => updateStatements.push(st), TEMPORARY_NAME);
+  let viewQuerySignalCall = null;
+  let viewQueryCall = null;
   viewQueries.forEach((query) => {
-    const queryDefinitionCall = createQueryCreateCall(query, constantPool, {
-      signalBased: Identifiers.viewQuerySignal,
-      nonSignal: Identifiers.viewQuery
-    });
-    createStatements.push(queryDefinitionCall.toStmt());
+    const params = getQueryCreateParameters(query, constantPool);
+    if (query.isSignal) {
+      viewQuerySignalCall ??= importExpr(Identifiers.viewQuerySignal);
+      viewQuerySignalCall = viewQuerySignalCall.callFn(params);
+    } else {
+      viewQueryCall ??= importExpr(Identifiers.viewQuery);
+      viewQueryCall = viewQueryCall.callFn(params);
+    }
     if (query.isSignal) {
       updateStatements.push(queryAdvancePlaceholder);
       return;
@@ -24115,6 +24270,12 @@ function createViewQueriesFunction(viewQueries, constantPool, name) {
     const updateDirective = variable(CONTEXT_NAME).prop(query.propertyName).set(query.first ? temporary.prop("first") : temporary);
     updateStatements.push(refresh.and(updateDirective).toStmt());
   });
+  if (viewQuerySignalCall !== null) {
+    createStatements.push(new ExpressionStatement(viewQuerySignalCall));
+  }
+  if (viewQueryCall !== null) {
+    createStatements.push(new ExpressionStatement(viewQueryCall));
+  }
   const viewQueryFnName = name ? `${name}_Query` : null;
   return fn([new FnParam(RENDER_FLAGS, NUMBER_TYPE), new FnParam(CONTEXT_NAME, null)], [renderFlagCheckIfStmt(1, createStatements), renderFlagCheckIfStmt(2, collapseAdvanceStatements(updateStatements))], INFERRED_TYPE, null, viewQueryFnName);
 }
@@ -24123,11 +24284,17 @@ function createContentQueriesFunction(queries, constantPool, name) {
   const createStatements = [];
   const updateStatements = [];
   const tempAllocator = temporaryAllocator((st) => updateStatements.push(st), TEMPORARY_NAME);
+  let contentQuerySignalCall = null;
+  let contentQueryCall = null;
   for (const query of queries) {
-    createStatements.push(createQueryCreateCall(query, constantPool, {
-      nonSignal: Identifiers.contentQuery,
-      signalBased: Identifiers.contentQuerySignal
-    }, [variable("dirIndex")]).toStmt());
+    const params = getQueryCreateParameters(query, constantPool, [variable("dirIndex")]);
+    if (query.isSignal) {
+      contentQuerySignalCall ??= importExpr(Identifiers.contentQuerySignal);
+      contentQuerySignalCall = contentQuerySignalCall.callFn(params);
+    } else {
+      contentQueryCall ??= importExpr(Identifiers.contentQuery);
+      contentQueryCall = contentQueryCall.callFn(params);
+    }
     if (query.isSignal) {
       updateStatements.push(queryAdvancePlaceholder);
       continue;
@@ -24138,6 +24305,12 @@ function createContentQueriesFunction(queries, constantPool, name) {
     const updateDirective = variable(CONTEXT_NAME).prop(query.propertyName).set(query.first ? temporary.prop("first") : temporary);
     updateStatements.push(refresh.and(updateDirective).toStmt());
   }
+  if (contentQuerySignalCall !== null) {
+    createStatements.push(new ExpressionStatement(contentQuerySignalCall));
+  }
+  if (contentQueryCall !== null) {
+    createStatements.push(new ExpressionStatement(contentQueryCall));
+  }
   const contentQueriesFnName = name ? `${name}_ContentQueries` : null;
   return fn([new FnParam(RENDER_FLAGS, NUMBER_TYPE), new FnParam(CONTEXT_NAME, null), new FnParam("dirIndex", null)], [renderFlagCheckIfStmt(1, createStatements), renderFlagCheckIfStmt(2, collapseAdvanceStatements(updateStatements))], INFERRED_TYPE, null, contentQueriesFnName);
 }
@@ -24485,7 +24658,7 @@ var BindingParser = class {
     if (ast instanceof NonNullAssert) {
       return this._isAllowedAssignmentEvent(ast.expression);
     }
-    if (ast instanceof Call && ast.args.length === 1 && ast.receiver instanceof PropertyRead && ast.receiver.name === "$any" && ast.receiver.receiver instanceof ImplicitReceiver && !(ast.receiver.receiver instanceof ThisReceiver)) {
+    if (ast instanceof Call && ast.args.length === 1 && ast.receiver instanceof PropertyRead && ast.receiver.name === "$any" && ast.receiver.receiver instanceof ImplicitReceiver) {
       return this._isAllowedAssignmentEvent(ast.args[0]);
     }
     if (ast instanceof PropertyRead || ast instanceof KeyedRead) {
@@ -24706,30 +24879,46 @@ __name(createForLoop, "createForLoop");
 function createSwitchBlock(ast, visitor, bindingParser) {
   const errors = validateSwitchBlock(ast);
   const primaryExpression = ast.parameters.length > 0 ? parseBlockParameterToBinding(ast.parameters[0], bindingParser) : bindingParser.parseBinding("", false, ast.sourceSpan, 0);
-  const cases = [];
+  const groups = [];
   const unknownBlocks = [];
-  let defaultCase = null;
-  for (const node of ast.children) {
-    if (!(node instanceof Block)) {
+  let collectedCases = [];
+  let firstCaseStart = null;
+  for (const node2 of ast.children) {
+    if (!(node2 instanceof Block)) {
       continue;
     }
-    if ((node.name !== "case" || node.parameters.length === 0) && node.name !== "default") {
-      unknownBlocks.push(new UnknownBlock(node.name, node.sourceSpan, node.nameSpan));
+    if ((node2.name !== "case" || node2.parameters.length === 0) && node2.name !== "default") {
+      unknownBlocks.push(new UnknownBlock(node2.name, node2.sourceSpan, node2.nameSpan));
       continue;
     }
-    const expression = node.name === "case" ? parseBlockParameterToBinding(node.parameters[0], bindingParser) : null;
-    const ast2 = new SwitchBlockCase(expression, visitAll(visitor, node.children, node.children), node.sourceSpan, node.startSourceSpan, node.endSourceSpan, node.nameSpan, node.i18n);
-    if (expression === null) {
-      defaultCase = ast2;
-    } else {
-      cases.push(ast2);
+    const isCase = node2.name === "case";
+    let expression = null;
+    if (isCase) {
+      expression = parseBlockParameterToBinding(node2.parameters[0], bindingParser);
     }
+    const switchCase = new SwitchBlockCase(expression, node2.sourceSpan, node2.startSourceSpan, node2.endSourceSpan, node2.nameSpan);
+    collectedCases.push(switchCase);
+    const caseWithoutBody = node2.children.length === 0 && node2.endSourceSpan !== null && node2.endSourceSpan.start.offset === node2.endSourceSpan.end.offset;
+    if (caseWithoutBody) {
+      if (firstCaseStart === null) {
+        firstCaseStart = node2.sourceSpan;
+      }
+      continue;
+    }
+    let sourceSpan = node2.sourceSpan;
+    let startSourceSpan = node2.startSourceSpan;
+    if (firstCaseStart !== null) {
+      sourceSpan = new ParseSourceSpan(firstCaseStart.start, node2.sourceSpan.end);
+      startSourceSpan = new ParseSourceSpan(firstCaseStart.start, node2.startSourceSpan.end);
+      firstCaseStart = null;
+    }
+    const group = new SwitchBlockCaseGroup(collectedCases, visitAll(visitor, node2.children, node2.children), sourceSpan, startSourceSpan, node2.endSourceSpan, node2.nameSpan, node2.i18n);
+    groups.push(group);
+    collectedCases = [];
   }
-  if (defaultCase !== null) {
-    cases.push(defaultCase);
-  }
+  const node = new SwitchBlock(primaryExpression, groups, unknownBlocks, ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan, ast.nameSpan);
   return {
-    node: new SwitchBlock(primaryExpression, cases, unknownBlocks, ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan, ast.nameSpan),
+    node,
     errors
   };
 }
@@ -25274,17 +25463,19 @@ function createViewportTrigger(start, isHydrationTrigger, bindingParser, paramet
     const parsed = bindingParser.parseBinding(parameters[0].expression, false, sourceSpan, sourceSpan.start.offset + start + parameters[0].start);
     if (!(parsed.ast instanceof LiteralMap)) {
       throw new Error('Options parameter of the "viewport" trigger must be an object literal');
-    } else if (parsed.ast.keys.some((key) => key.key === "root")) {
+    } else if (parsed.ast.keys.some((key) => key.kind === "spread")) {
+      throw new Error("Spread operator are not allowed in this context");
+    } else if (parsed.ast.keys.some((key) => key.kind === "property" && key.key === "root")) {
       throw new Error('The "root" option is not supported in the options parameter of the "viewport" trigger');
     }
-    const triggerIndex = parsed.ast.keys.findIndex((key) => key.key === "trigger");
+    const triggerIndex = parsed.ast.keys.findIndex((key) => key.kind === "property" && key.key === "trigger");
     if (triggerIndex === -1) {
       reference2 = null;
       options = parsed.ast;
     } else {
       const value = parsed.ast.values[triggerIndex];
       const triggerFilter = /* @__PURE__ */ __name((_, index) => index !== triggerIndex, "triggerFilter");
-      if (!(value instanceof PropertyRead) || !(value.receiver instanceof ImplicitReceiver) || value.receiver instanceof ThisReceiver) {
+      if (!(value instanceof PropertyRead) || !(value.receiver instanceof ImplicitReceiver)) {
         throw new Error(`"trigger" option of the "viewport" trigger must be an identifier`);
       }
       reference2 = value.name;
@@ -26736,10 +26927,13 @@ var CombinedRecursiveAstVisitor = class extends RecursiveAstVisitor2 {
   }
   visitSwitchBlock(block) {
     this.visit(block.expression);
-    this.visitAllTemplateNodes(block.cases);
+    this.visitAllTemplateNodes(block.groups);
   }
   visitSwitchBlockCase(block) {
     block.expression && this.visit(block.expression);
+  }
+  visitSwitchBlockCaseGroup(block) {
+    this.visitAllTemplateNodes(block.cases);
     this.visitAllTemplateNodes(block.children);
   }
   visitForLoopBlock(block) {
@@ -26910,7 +27104,7 @@ var Scope2 = class _Scope {
       this.visitVariable(nodeOrNodes.item);
       nodeOrNodes.contextVariables.forEach((v) => this.visitVariable(v));
       nodeOrNodes.children.forEach((node) => node.visit(this));
-    } else if (nodeOrNodes instanceof SwitchBlockCase || nodeOrNodes instanceof ForLoopBlockEmpty || nodeOrNodes instanceof DeferredBlock || nodeOrNodes instanceof DeferredBlockError || nodeOrNodes instanceof DeferredBlockPlaceholder || nodeOrNodes instanceof DeferredBlockLoading || nodeOrNodes instanceof Content) {
+    } else if (nodeOrNodes instanceof SwitchBlockCaseGroup || nodeOrNodes instanceof ForLoopBlockEmpty || nodeOrNodes instanceof DeferredBlock || nodeOrNodes instanceof DeferredBlockError || nodeOrNodes instanceof DeferredBlockPlaceholder || nodeOrNodes instanceof DeferredBlockLoading || nodeOrNodes instanceof Content) {
       nodeOrNodes.children.forEach((node) => node.visit(this));
     } else if (!(nodeOrNodes instanceof HostElement)) {
       nodeOrNodes.forEach((node) => node.visit(this));
@@ -26946,9 +27140,11 @@ var Scope2 = class _Scope {
     this.ingestScopedNode(block);
   }
   visitSwitchBlock(block) {
-    block.cases.forEach((node) => node.visit(this));
+    block.groups.forEach((node) => node.visit(this));
   }
   visitSwitchBlockCase(block) {
+  }
+  visitSwitchBlockCaseGroup(block) {
     this.ingestScopedNode(block);
   }
   visitForLoopBlock(block) {
@@ -27076,9 +27272,11 @@ var DirectiveBinder = class _DirectiveBinder {
     block.children.forEach((child) => child.visit(this));
   }
   visitSwitchBlock(block) {
-    block.cases.forEach((node) => node.visit(this));
+    block.groups.forEach((node) => node.visit(this));
   }
   visitSwitchBlockCase(block) {
+  }
+  visitSwitchBlockCaseGroup(block) {
     block.children.forEach((node) => node.visit(this));
   }
   visitForLoopBlock(block) {
@@ -27279,7 +27477,7 @@ var TemplateBinder = class _TemplateBinder extends CombinedRecursiveAstVisitor {
       this.deferBlocks.push([nodeOrNodes, this.scope]);
       nodeOrNodes.children.forEach((node) => node.visit(this));
       this.nestingLevel.set(nodeOrNodes, this.level);
-    } else if (nodeOrNodes instanceof SwitchBlockCase || nodeOrNodes instanceof ForLoopBlockEmpty || nodeOrNodes instanceof DeferredBlockError || nodeOrNodes instanceof DeferredBlockPlaceholder || nodeOrNodes instanceof DeferredBlockLoading || nodeOrNodes instanceof Content) {
+    } else if (nodeOrNodes instanceof SwitchBlockCaseGroup || nodeOrNodes instanceof ForLoopBlockEmpty || nodeOrNodes instanceof DeferredBlockError || nodeOrNodes instanceof DeferredBlockPlaceholder || nodeOrNodes instanceof DeferredBlockLoading || nodeOrNodes instanceof Content) {
       nodeOrNodes.children.forEach((node) => node.visit(this));
       this.nestingLevel.set(nodeOrNodes, this.level);
     } else if (nodeOrNodes instanceof HostElement) {
@@ -27327,6 +27525,9 @@ var TemplateBinder = class _TemplateBinder extends CombinedRecursiveAstVisitor {
   }
   visitSwitchBlockCase(block) {
     block.expression?.visit(this);
+  }
+  visitSwitchBlockCaseGroup(block) {
+    block.cases.forEach((caseNode) => caseNode.visit(this));
     this.ingestScopedNode(block);
   }
   visitForLoopBlock(block) {
@@ -27371,7 +27572,7 @@ var TemplateBinder = class _TemplateBinder extends CombinedRecursiveAstVisitor {
     binder.ingest(node);
   }
   maybeMap(ast, name) {
-    if (!(ast.receiver instanceof ImplicitReceiver) || ast.receiver instanceof ThisReceiver) {
+    if (!(ast.receiver instanceof ImplicitReceiver)) {
       return;
     }
     const target = this.scope.lookup(name);
@@ -29886,7 +30087,7 @@ var MINIMUM_PARTIAL_LINKER_DEFER_SUPPORT_VERSION = "18.0.0";
 function compileDeclareClassMetadata(metadata) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION$5));
-  definitionMap.set("version", literal("21.0.2"));
+  definitionMap.set("version", literal("21.1.0"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", metadata.type);
   definitionMap.set("decorators", metadata.decorators);
@@ -29905,7 +30106,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.0.2"));
+  definitionMap.set("version", literal("21.1.0"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", metadata.type);
   definitionMap.set("resolveDeferredDeps", compileComponentMetadataAsyncResolver(dependencies));
@@ -29982,7 +30183,7 @@ function createDirectiveDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   const minVersion = getMinimumVersionForPartialOutput(meta);
   definitionMap.set("minVersion", literal(minVersion));
-  definitionMap.set("version", literal("21.0.2"));
+  definitionMap.set("version", literal("21.1.0"));
   definitionMap.set("type", meta.type.value);
   if (meta.isStandalone !== void 0) {
     definitionMap.set("isStandalone", literal(meta.isStandalone));
@@ -30323,12 +30524,15 @@ var BlockPresenceVisitor = class extends RecursiveVisitor$1 {
   visitSwitchBlockCase() {
     this.hasBlocks = true;
   }
+  visitSwitchBlockCaseGroup() {
+    this.hasBlocks = true;
+  }
 };
 var MINIMUM_PARTIAL_LINKER_VERSION$4 = "12.0.0";
 function compileDeclareFactoryFunction(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION$4));
-  definitionMap.set("version", literal("21.0.2"));
+  definitionMap.set("version", literal("21.1.0"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   definitionMap.set("deps", compileDependencies(meta.deps));
@@ -30355,7 +30559,7 @@ __name(compileDeclareInjectableFromMetadata, "compileDeclareInjectableFromMetada
 function createInjectableDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION$3));
-  definitionMap.set("version", literal("21.0.2"));
+  definitionMap.set("version", literal("21.1.0"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   if (meta.providedIn !== void 0) {
@@ -30397,7 +30601,7 @@ __name(compileDeclareInjectorFromMetadata, "compileDeclareInjectorFromMetadata")
 function createInjectorDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION$2));
-  definitionMap.set("version", literal("21.0.2"));
+  definitionMap.set("version", literal("21.1.0"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   definitionMap.set("providers", meta.providers);
@@ -30425,7 +30629,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.0.2"));
+  definitionMap.set("version", literal("21.1.0"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   if (meta.bootstrap.length > 0) {
@@ -30464,7 +30668,7 @@ __name(compileDeclarePipeFromMetadata, "compileDeclarePipeFromMetadata");
 function createPipeDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION));
-  definitionMap.set("version", literal("21.0.2"));
+  definitionMap.set("version", literal("21.1.0"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   if (meta.isStandalone !== void 0) {
@@ -30539,7 +30743,7 @@ function compileHmrUpdateCallback(definitions, constantStatements, meta) {
   return new DeclareFunctionStmt(`${meta.className}_UpdateMetadata`, params, body, null, StmtModifier.Final);
 }
 __name(compileHmrUpdateCallback, "compileHmrUpdateCallback");
-var VERSION = new Version("21.0.2");
+var VERSION = new Version("21.1.0");
 publishFacade(_global);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -30615,6 +30819,8 @@ publishFacade(_global);
   LiteralExpr,
   LiteralMap,
   LiteralMapExpr,
+  LiteralMapPropertyAssignment,
+  LiteralMapSpreadAssignment,
   LiteralPrimitive,
   LocalizedString,
   MapType,
@@ -30667,6 +30873,8 @@ publishFacade(_global);
   SelectorlessMatcher,
   Serializer,
   SplitInterpolation,
+  SpreadElement,
+  SpreadElementExpr,
   Statement,
   StmtModifier,
   StringToken,
@@ -30711,6 +30919,7 @@ publishFacade(_global);
   TmplAstReference,
   TmplAstSwitchBlock,
   TmplAstSwitchBlockCase,
+  TmplAstSwitchBlockCaseGroup,
   TmplAstTemplate,
   TmplAstText,
   TmplAstTextAttribute,
@@ -30805,8 +31014,8 @@ publishFacade(_global);
 
 @angular/compiler/fesm2022/compiler.mjs:
   (**
-   * @license Angular v21.0.2
-   * (c) 2010-2025 Google LLC. https://angular.dev/
+   * @license Angular v21.1.0
+   * (c) 2010-2026 Google LLC. https://angular.dev/
    * License: MIT
    *)
   (**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular-eslint/bundled-angular-compiler",
-  "version": "21.1.1-alpha.1",
+  "version": "21.1.1-alpha.11",
   "description": "A CJS bundled version of @angular/compiler",
   "license": "MIT",
   "main": "dist/index.js",