@angular/compiler 21.1.0-next.4 → 21.1.0

package/fesm2022/compiler.mjs

@@ -1,6 +1,6 @@
 /**
- * @license Angular v21.1.0-next.4
- * (c) 2010-2025 Google LLC. https://angular.dev/
+ * @license Angular v21.1.0
+ * (c) 2010-2026 Google LLC. https://angular.dev/
  * License: MIT
  */
 
@@ -1529,7 +1529,7 @@ class LiteralArrayExpr extends Expression {
     return new LiteralArrayExpr(this.entries.map(e => e.clone()), this.type, this.sourceSpan);
   }
 }
-class LiteralMapEntry {
+class LiteralMapPropertyAssignment {
   key;
   value;
   quoted;
@@ -1542,7 +1542,25 @@ 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();
+  }
+}
+class 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();
   }
 }
 class LiteralMapExpr extends Expression {
@@ -1559,7 +1577,7 @@ 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);
@@ -1588,6 +1606,25 @@ class CommaExpr extends Expression {
     return new CommaExpr(this.parts.map(p => p.clone()));
   }
 }
+class SpreadElementExpr extends Expression {
+  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);
+  }
+}
 const NULL_EXPR = new LiteralExpr(null, null, null);
 const TYPED_NULL_EXPR = new LiteralExpr(null, INFERRED_TYPE, null);
 var StmtModifier;
@@ -1838,7 +1875,13 @@ let 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) {
@@ -1857,6 +1900,10 @@ let 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));
   }
@@ -1922,7 +1969,7 @@ function literalArr(values, type, sourceSpan) {
   return new LiteralArrayExpr(values, type, sourceSpan);
 }
 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);
 }
 function unary(operator, expr, type, sourceSpan) {
   return new UnaryOperatorExpr(operator, expr, type, sourceSpan);
@@ -2011,8 +2058,9 @@ var output_ast = /*#__PURE__*/Object.freeze({
     LeadingComment: LeadingComment,
     LiteralArrayExpr: LiteralArrayExpr,
     LiteralExpr: LiteralExpr,
-    LiteralMapEntry: LiteralMapEntry,
     LiteralMapExpr: LiteralMapExpr,
+    LiteralMapPropertyAssignment: LiteralMapPropertyAssignment,
+    LiteralMapSpreadAssignment: LiteralMapSpreadAssignment,
     LiteralPiece: LiteralPiece,
     LocalizedString: LocalizedString,
     MapType: MapType,
@@ -2029,6 +2077,7 @@ var output_ast = /*#__PURE__*/Object.freeze({
     RegularExpressionLiteralExpr: RegularExpressionLiteralExpr,
     ReturnStatement: ReturnStatement,
     STRING_TYPE: STRING_TYPE,
+    SpreadElementExpr: SpreadElementExpr,
     Statement: Statement,
     get StmtModifier () { return StmtModifier; },
     TYPED_NULL_EXPR: TYPED_NULL_EXPR,
@@ -2067,7 +2116,6 @@ var output_ast = /*#__PURE__*/Object.freeze({
 });
 
 const CONSTANT_PREFIX = '_c';
-const UNKNOWN_VALUE_KEY = variable('<unknown>');
 const KEY_CONTEXT = {};
 const POOL_INCLUSION_LENGTH_THRESHOLD_FOR_STRINGS = 50;
 class FixupExpression extends Expression {
@@ -2148,25 +2196,6 @@ class ConstantPool {
     }
     return this.sharedConstants.get(key);
   }
-  getLiteralFactory(literal) {
-    if (literal instanceof LiteralArrayExpr) {
-      const argumentsForKey = literal.entries.map(e => e.isConstant() ? e : UNKNOWN_VALUE_KEY);
-      const key = GenericKeyFn.INSTANCE.keyOf(literalArr(argumentsForKey));
-      return this._getLiteralFactory(key, literal.entries, entries => literalArr(entries));
-    } else {
-      const expressionForKey = literalMap(literal.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, literal.entries.map(e => e.value), entries => literalMap(entries.map((value, index) => ({
-        key: literal.entries[index].key,
-        value,
-        quoted: literal.entries[index].quoted
-      }))));
-    }
-  }
   getSharedFunctionReference(fn, prefix, useUniqueName = true) {
     const isArrow = fn instanceof ArrowFunctionExpr;
     for (const current of this.statements) {
@@ -2181,23 +2210,6 @@ class ConstantPool {
     this.statements.push(fn instanceof FunctionExpr ? fn.toDeclStmt(name, StmtModifier.Final) : new DeclareVarStmt(name, fn, INFERRED_TYPE, StmtModifier.Final, fn.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}`;
@@ -2226,11 +2238,15 @@ 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) {
@@ -2239,14 +2255,13 @@ 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;
-}
 function isLongStringLiteral(expr) {
   return expr instanceof LiteralExpr && typeof expr.value === 'string' && expr.value.length >= POOL_INCLUSION_LENGTH_THRESHOLD_FOR_STRINGS;
 }
@@ -3666,8 +3681,13 @@ class AbstractEmitterVisitor {
   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;
@@ -3681,6 +3701,10 @@ class AbstractEmitterVisitor {
   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);
   }
@@ -3988,7 +4012,7 @@ class ImplicitReceiver extends AST {
     return visitor.visitImplicitReceiver(this, context);
   }
 }
-class ThisReceiver extends ImplicitReceiver {
+class ThisReceiver extends AST {
   visit(visitor, context = null) {
     return visitor.visitThisReceiver?.(this, context);
   }
@@ -4106,6 +4130,16 @@ class LiteralArray extends AST {
     return visitor.visitLiteralArray(this, context);
   }
 }
+class SpreadElement extends AST {
+  expression;
+  constructor(span, sourceSpan, expression) {
+    super(span, sourceSpan);
+    this.expression = expression;
+  }
+  visit(visitor, context = null) {
+    return visitor.visitSpreadElement(this, context);
+  }
+}
 class LiteralMap extends AST {
   keys;
   values;
@@ -4432,6 +4466,9 @@ class RecursiveAstVisitor {
     this.visit(ast.expression, context);
   }
   visitRegularExpressionLiteral(ast, context) {}
+  visitSpreadElement(ast, context) {
+    this.visit(ast.expression, context);
+  }
   visitAll(asts, context) {
     for (const ast of asts) {
       this.visit(ast, context);
@@ -4879,12 +4916,12 @@ class DeferredBlock extends BlockNode {
 }
 class SwitchBlock extends BlockNode {
   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) {
@@ -4893,16 +4930,26 @@ class SwitchBlock extends BlockNode {
 }
 class SwitchBlockCase extends BlockNode {
   expression;
+  constructor(expression, sourceSpan, startSourceSpan, endSourceSpan, nameSpan) {
+    super(nameSpan, sourceSpan, startSourceSpan, endSourceSpan);
+    this.expression = expression;
+  }
+  visit(visitor) {
+    return visitor.visitSwitchBlockCase(this);
+  }
+}
+class SwitchBlockCaseGroup extends BlockNode {
+  cases;
   children;
   i18n;
-  constructor(expression, children, sourceSpan, startSourceSpan, endSourceSpan, nameSpan, i18n) {
+  constructor(cases, children, sourceSpan, startSourceSpan, endSourceSpan, nameSpan, i18n) {
     super(nameSpan, sourceSpan, startSourceSpan, endSourceSpan);
-    this.expression = expression;
+    this.cases = cases;
     this.children = children;
     this.i18n = i18n;
   }
   visit(visitor) {
-    return visitor.visitSwitchBlockCase(this);
+    return visitor.visitSwitchBlockCaseGroup(this);
   }
 }
 class ForLoopBlock extends BlockNode {
@@ -5216,9 +5263,11 @@ let RecursiveVisitor$1 = class RecursiveVisitor {
     visitAll$1(this, block.children);
   }
   visitSwitchBlock(block) {
-    visitAll$1(this, block.cases);
+    visitAll$1(this, block.groups);
   }
-  visitSwitchBlockCase(block) {
+  visitSwitchBlockCase(block) {}
+  visitSwitchBlockCaseGroup(block) {
+    visitAll$1(this, block.cases);
     visitAll$1(this, block.children);
   }
   visitForLoopBlock(block) {
@@ -6494,7 +6543,7 @@ class JitEmitterVisitor 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() {
@@ -7793,6 +7842,7 @@ function createControlOp(op) {
   return {
     kind: OpKind.Control,
     target: op.target,
+    name: op.name,
     expression: op.expression,
     bindingKind: op.bindingKind,
     securityContext: op.securityContext,
@@ -8662,8 +8712,12 @@ function transformExpressionsInExpression(expr, transform, flags) {
       expr.entries[i] = transformExpressionsInExpression(expr.entries[i], transform, flags);
     }
   } else if (expr instanceof LiteralMapExpr) {
-    for (let i = 0; i < expr.entries.length; i++) {
-      expr.entries[i].value = transformExpressionsInExpression(expr.entries[i].value, transform, flags);
+    for (const entry of expr.entries) {
+      if (entry instanceof LiteralMapSpreadAssignment) {
+        entry.expression = transformExpressionsInExpression(entry.expression, transform, flags);
+      } else {
+        entry.value = transformExpressionsInExpression(entry.value, transform, flags);
+      }
     }
   } else if (expr instanceof ConditionalExpr) {
     expr.condition = transformExpressionsInExpression(expr.condition, transform, flags);
@@ -8698,6 +8752,8 @@ function transformExpressionsInExpression(expr, transform, flags) {
     }
   } else if (expr instanceof ParenthesizedExpr) {
     expr.expr = transformExpressionsInExpression(expr.expr, transform, flags);
+  } else if (expr instanceof SpreadElementExpr) {
+    expr.expression = transformExpressionsInExpression(expr.expression, transform, flags);
   } else if (expr instanceof ReadVarExpr || expr instanceof ExternalExpr || expr instanceof LiteralExpr || expr instanceof RegularExpressionLiteralExpr) ; else {
     throw new Error(`Unhandled expression kind: ${expr.constructor.name}`);
   }
@@ -9692,7 +9748,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));
@@ -9802,7 +9858,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));
@@ -13557,6 +13613,11 @@ class _Tokenizer {
     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;
     }
@@ -15507,7 +15568,18 @@ class _Scanner {
     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:
@@ -16462,14 +16534,14 @@ class _ParseAST {
           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();
@@ -16531,11 +16603,7 @@ class _ParseAST {
       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()) {
@@ -16565,16 +16633,21 @@ class _ParseAST {
       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 = [];
@@ -16585,11 +16658,26 @@ class _ParseAST {
       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) {
@@ -16599,9 +16687,7 @@ class _ParseAST {
           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--;
@@ -16656,13 +16742,26 @@ class _ParseAST {
     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;
@@ -16947,7 +17046,12 @@ class SerializeExpressionVisitor {
     return `[${ast.expressions.map(e => e.visit(this, context)).join(', ')}]`;
   }
   visitLiteralMap(ast, context) {
-    return `{${zip(ast.keys.map(literal => literal.quoted ? `'${literal.key}'` : literal.key), ast.values.map(value => value.visit(this, context))).map(([key, value]) => `${key}: ${value}`).join(', ')}}`;
+    return `{${zip(ast.keys.map(literal => {
+      if (literal.kind === 'spread') {
+        return '...';
+      }
+      return literal.quoted ? `'${literal.key}'` : literal.key;
+    }), ast.values.map(value => value.visit(this, context))).map(([key, value]) => `${key}: ${value}`).join(', ')}}`;
   }
   visitLiteralPrimitive(ast) {
     if (ast.value === null) return 'null';
@@ -16973,7 +17077,7 @@ class SerializeExpressionVisitor {
     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}`;
@@ -17020,6 +17124,9 @@ class SerializeExpressionVisitor {
   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) + ')';
   }
@@ -17044,7 +17151,7 @@ function SECURITY_SCHEMA() {
     registerContext(SecurityContext.HTML, ['iframe|srcdoc', '*|innerHTML', '*|outerHTML']);
     registerContext(SecurityContext.STYLE, ['*|style']);
     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']);
+    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;
@@ -18876,6 +18983,8 @@ const UPDATE_ORDERING = [{
   test: nonInterpolationPropertyKindTest
 }, {
   test: kindWithInterpolationTest(OpKind.Attribute, false)
+}, {
+  test: kindTest(OpKind.Control)
 }];
 const UPDATE_HOST_ORDERING = [{
   test: kindWithInterpolationTest(OpKind.DomProperty, true)
@@ -18894,7 +19003,7 @@ const UPDATE_HOST_ORDERING = [{
 }, {
   test: kindTest(OpKind.ClassProp)
 }];
-const handledOpKinds = 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]);
+const handledOpKinds = 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);
@@ -19143,6 +19252,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 {
@@ -19157,15 +19276,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);
 }
 
 function optimizeRegularExpressions(job) {
@@ -19446,13 +19575,14 @@ function ariaProperty(name, expression, sourceSpan) {
 function property(name, expression, sanitizer, sourceSpan) {
   return propertyBase(Identifiers.property, name, expression, sanitizer, sourceSpan);
 }
-function control(expression, sanitizer, sourceSpan) {
+function control(name, expression, sanitizer, sourceSpan) {
   const args = [];
   if (expression instanceof Interpolation) {
     args.push(interpolationToExpression(expression, sourceSpan));
   } else {
     args.push(expression);
   }
+  args.push(literal(name));
   if (sanitizer !== null) {
     args.push(sanitizer);
   }
@@ -19547,7 +19677,7 @@ function pipeBindV(slot, varOffset, args) {
 }
 function textInterpolate(strings, expressions, sourceSpan) {
   const interpolationArgs = collateInterpolationArgs(strings, expressions);
-  return callVariadicInstruction(TEXT_INTERPOLATE_CONFIG, [], interpolationArgs, [], sourceSpan);
+  return callVariadicInstruction(TEXT_INTERPOLATE_CONFIG, [], interpolationArgs, sourceSpan);
 }
 function i18nExp(expr, sourceSpan) {
   return call(Identifiers.i18nExp, [expr], sourceSpan);
@@ -19584,7 +19714,7 @@ function syntheticHostProperty(name, expression, sourceSpan) {
   return call(Identifiers.syntheticHostProperty, [literal(name), expression], sourceSpan);
 }
 function pureFunction(varOffset, fn, args) {
-  return callVariadicInstructionExpr(PURE_FUNCTION_CONFIG, [literal(varOffset), fn], args, [], null);
+  return callVariadicInstructionExpr(PURE_FUNCTION_CONFIG, [literal(varOffset), fn], args, null);
 }
 function attachSourceLocation(templatePath, locations) {
   return call(Identifiers.attachSourceLocations, [literal(templatePath), locations], null);
@@ -19607,7 +19737,7 @@ function collateInterpolationArgs(strings, expressions) {
 }
 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);
 }
 function call(instruction, args, sourceSpan) {
   const expr = importExpr(instruction).callFn(args, sourceSpan);
@@ -19645,22 +19775,22 @@ const PURE_FUNCTION_CONFIG = {
   variable: Identifiers.pureFunctionV,
   mapping: n => n
 };
-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`);
   }
 }
-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());
 }
 
 const GLOBAL_TARGET_RESOLVERS = new Map([['window', Identifiers.resolveWindow], ['document', Identifiers.resolveDocument], ['body', Identifiers.resolveBody]]);
@@ -20003,7 +20133,7 @@ function reifyProperty(op) {
   return isAriaAttribute(op.name) ? ariaProperty(op.name, op.expression, op.sourceSpan) : property(op.name, op.expression, op.sanitizer, op.sourceSpan);
 }
 function reifyControl(op) {
-  return control(op.expression, op.sanitizer, op.sourceSpan);
+  return control(op.name, op.expression, op.sanitizer, op.sourceSpan);
 }
 function reifyIrExpression(expr) {
   if (!isIrExpression(expr)) {
@@ -21800,7 +21930,7 @@ function ingestElement(unit, element) {
   ingestNodes(unit, element.children);
   const endOp = createElementEndOp(id, element.endSourceSpan ?? element.startSourceSpan);
   unit.create.push(endOp);
-  const fieldInput = element.inputs.find(input => input.name === 'field' && input.type === BindingType.Property);
+  const fieldInput = element.inputs.find(input => input.name === 'formField' && input.type === BindingType.Property);
   if (fieldInput) {
     unit.create.push(createControlCreateOp(fieldInput.sourceSpan));
   }
@@ -21910,32 +22040,34 @@ function ingestIfBlock(unit, ifBlock) {
   unit.update.push(createConditionalOp(firstXref, null, conditions, ifBlock.sourceSpan));
 }
 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 = undefined;
-    if (switchCase.i18n !== undefined) {
-      if (!(switchCase.i18n instanceof BlockPlaceholder)) {
-        throw Error(`Unhandled i18n metadata type for switch block: ${switchCase.i18n?.constructor.name}`);
+    if (switchCaseGroup.i18n !== undefined) {
+      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));
 }
@@ -22161,8 +22293,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));
@@ -22198,8 +22329,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, undefined, convertSourceSpan(ast.span, baseSourceSpan));
   } else if (ast instanceof LiteralArray) {
@@ -22232,6 +22363,8 @@ function convertAst(ast, job, baseSourceSpan) {
     return new ParenthesizedExpr(convertAst(ast.expression, job, baseSourceSpan), undefined, 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}"`);
   }
@@ -22931,7 +23064,7 @@ class BindingParser {
     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) {
@@ -23141,9 +23274,10 @@ function createForLoop(ast, connectedBlocks, visitor, bindingParser) {
 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;
+  let collectedCases = [];
+  let firstCaseStart = null;
   for (const node of ast.children) {
     if (!(node instanceof Block)) {
       continue;
@@ -23152,19 +23286,34 @@ function createSwitchBlock(ast, visitor, bindingParser) {
       unknownBlocks.push(new UnknownBlock(node.name, node.sourceSpan, node.nameSpan));
       continue;
     }
-    const expression = node.name === 'case' ? parseBlockParameterToBinding(node.parameters[0], bindingParser) : null;
-    const ast = new SwitchBlockCase(expression, visitAll(visitor, node.children, node.children), node.sourceSpan, node.startSourceSpan, node.endSourceSpan, node.nameSpan, node.i18n);
-    if (expression === null) {
-      defaultCase = ast;
-    } else {
-      cases.push(ast);
+    const isCase = node.name === 'case';
+    let expression = null;
+    if (isCase) {
+      expression = parseBlockParameterToBinding(node.parameters[0], bindingParser);
     }
+    const switchCase = new SwitchBlockCase(expression, node.sourceSpan, node.startSourceSpan, node.endSourceSpan, node.nameSpan);
+    collectedCases.push(switchCase);
+    const caseWithoutBody = node.children.length === 0 && node.endSourceSpan !== null && node.endSourceSpan.start.offset === node.endSourceSpan.end.offset;
+    if (caseWithoutBody) {
+      if (firstCaseStart === null) {
+        firstCaseStart = node.sourceSpan;
+      }
+      continue;
+    }
+    let sourceSpan = node.sourceSpan;
+    let startSourceSpan = node.startSourceSpan;
+    if (firstCaseStart !== null) {
+      sourceSpan = new ParseSourceSpan(firstCaseStart.start, node.sourceSpan.end);
+      startSourceSpan = new ParseSourceSpan(firstCaseStart.start, node.startSourceSpan.end);
+      firstCaseStart = null;
+    }
+    const group = new SwitchBlockCaseGroup(collectedCases, visitAll(visitor, node.children, node.children), sourceSpan, startSourceSpan, node.endSourceSpan, node.nameSpan, node.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
   };
 }
@@ -23684,17 +23833,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) {
       reference = null;
       options = parsed.ast;
     } else {
       const value = parsed.ast.values[triggerIndex];
       const triggerFilter = (_, index) => index !== triggerIndex;
-      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`);
       }
       reference = value.name;
@@ -25099,10 +25250,13 @@ class CombinedRecursiveAstVisitor extends RecursiveAstVisitor {
   }
   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) {
@@ -25261,7 +25415,7 @@ 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));
@@ -25297,9 +25451,10 @@ class Scope {
     this.ingestScopedNode(block);
   }
   visitSwitchBlock(block) {
-    block.cases.forEach(node => node.visit(this));
+    block.groups.forEach(node => node.visit(this));
   }
-  visitSwitchBlockCase(block) {
+  visitSwitchBlockCase(block) {}
+  visitSwitchBlockCaseGroup(block) {
     this.ingestScopedNode(block);
   }
   visitForLoopBlock(block) {
@@ -25416,9 +25571,10 @@ 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) {
+  visitSwitchBlockCase(block) {}
+  visitSwitchBlockCaseGroup(block) {
     block.children.forEach(node => node.visit(this));
   }
   visitForLoopBlock(block) {
@@ -25604,7 +25760,7 @@ 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) {
@@ -25652,6 +25808,9 @@ class TemplateBinder extends CombinedRecursiveAstVisitor {
   }
   visitSwitchBlockCase(block) {
     block.expression?.visit(this);
+  }
+  visitSwitchBlockCaseGroup(block) {
+    block.cases.forEach(caseNode => caseNode.visit(this));
     this.ingestScopedNode(block);
   }
   visitForLoopBlock(block) {
@@ -25696,7 +25855,7 @@ 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);
@@ -28046,7 +28205,7 @@ const MINIMUM_PARTIAL_LINKER_DEFER_SUPPORT_VERSION = '18.0.0';
 function compileDeclareClassMetadata(metadata) {
   const definitionMap = new DefinitionMap();
   definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$5));
-  definitionMap.set('version', literal('21.1.0-next.4'));
+  definitionMap.set('version', literal('21.1.0'));
   definitionMap.set('ngImport', importExpr(Identifiers.core));
   definitionMap.set('type', metadata.type);
   definitionMap.set('decorators', metadata.decorators);
@@ -28064,7 +28223,7 @@ function compileComponentDeclareClassMetadata(metadata, dependencies) {
   callbackReturnDefinitionMap.set('ctorParameters', metadata.ctorParameters ?? literal(null));
   callbackReturnDefinitionMap.set('propDecorators', metadata.propDecorators ?? literal(null));
   definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_DEFER_SUPPORT_VERSION));
-  definitionMap.set('version', literal('21.1.0-next.4'));
+  definitionMap.set('version', literal('21.1.0'));
   definitionMap.set('ngImport', importExpr(Identifiers.core));
   definitionMap.set('type', metadata.type);
   definitionMap.set('resolveDeferredDeps', compileComponentMetadataAsyncResolver(dependencies));
@@ -28137,7 +28296,7 @@ function createDirectiveDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   const minVersion = getMinimumVersionForPartialOutput(meta);
   definitionMap.set('minVersion', literal(minVersion));
-  definitionMap.set('version', literal('21.1.0-next.4'));
+  definitionMap.set('version', literal('21.1.0'));
   definitionMap.set('type', meta.type.value);
   if (meta.isStandalone !== undefined) {
     definitionMap.set('isStandalone', literal(meta.isStandalone));
@@ -28463,13 +28622,16 @@ class BlockPresenceVisitor extends RecursiveVisitor$1 {
   visitSwitchBlockCase() {
     this.hasBlocks = true;
   }
+  visitSwitchBlockCaseGroup() {
+    this.hasBlocks = true;
+  }
 }
 
 const MINIMUM_PARTIAL_LINKER_VERSION$4 = '12.0.0';
 function compileDeclareFactoryFunction(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$4));
-  definitionMap.set('version', literal('21.1.0-next.4'));
+  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));
@@ -28495,7 +28657,7 @@ function compileDeclareInjectableFromMetadata(meta) {
 function createInjectableDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$3));
-  definitionMap.set('version', literal('21.1.0-next.4'));
+  definitionMap.set('version', literal('21.1.0'));
   definitionMap.set('ngImport', importExpr(Identifiers.core));
   definitionMap.set('type', meta.type.value);
   if (meta.providedIn !== undefined) {
@@ -28536,7 +28698,7 @@ function compileDeclareInjectorFromMetadata(meta) {
 function createInjectorDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$2));
-  definitionMap.set('version', literal('21.1.0-next.4'));
+  definitionMap.set('version', literal('21.1.0'));
   definitionMap.set('ngImport', importExpr(Identifiers.core));
   definitionMap.set('type', meta.type.value);
   definitionMap.set('providers', meta.providers);
@@ -28563,7 +28725,7 @@ function createNgModuleDefinitionMap(meta) {
     throw new Error('Invalid path! Local compilation mode should not get into the partial compilation path');
   }
   definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$1));
-  definitionMap.set('version', literal('21.1.0-next.4'));
+  definitionMap.set('version', literal('21.1.0'));
   definitionMap.set('ngImport', importExpr(Identifiers.core));
   definitionMap.set('type', meta.type.value);
   if (meta.bootstrap.length > 0) {
@@ -28601,7 +28763,7 @@ function compileDeclarePipeFromMetadata(meta) {
 function createPipeDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION));
-  definitionMap.set('version', literal('21.1.0-next.4'));
+  definitionMap.set('version', literal('21.1.0'));
   definitionMap.set('ngImport', importExpr(Identifiers.core));
   definitionMap.set('type', meta.type.value);
   if (meta.isStandalone !== undefined) {
@@ -28675,9 +28837,9 @@ function compileHmrUpdateCallback(definitions, constantStatements, meta) {
   return new DeclareFunctionStmt(`${meta.className}_UpdateMetadata`, params, body, null, StmtModifier.Final);
 }
 
-const VERSION = new Version('21.1.0-next.4');
+const VERSION = new Version('21.1.0');
 
 publishFacade(_global);
 
-export { AST, ASTWithName, ASTWithSource, AbsoluteSourceSpan, ArrayType, ArrowFunctionExpr, Attribute, Binary, BinaryOperator, BinaryOperatorExpr, BindingPipe, BindingPipeType, BindingType, Block, BlockParameter, BoundElementProperty, BuiltinType, BuiltinTypeName, CUSTOM_ELEMENTS_SCHEMA, Call, Chain, ChangeDetectionStrategy, CombinedRecursiveAstVisitor, CommaExpr, Comment, CompilerConfig, CompilerFacadeImpl, Component, Conditional, ConditionalExpr, ConstantPool, CssSelector, DYNAMIC_TYPE, DeclareFunctionStmt, DeclareVarStmt, Directive, DomElementSchemaRegistry, DynamicImportExpr, EOF, Element, ElementSchemaRegistry, EmitterVisitorContext, EmptyExpr$1 as EmptyExpr, Expansion, ExpansionCase, Expression, ExpressionBinding, ExpressionStatement, ExpressionType, ExternalExpr, ExternalReference, FactoryTarget, FunctionExpr, HtmlParser, HtmlTagDefinition, I18NHtmlParser, IfStmt, ImplicitReceiver, InstantiateExpr, Interpolation$1 as Interpolation, InvokeFunctionExpr, JSDocComment, JitEvaluator, KeyedRead, LeadingComment, LetDeclaration, Lexer, LiteralArray, LiteralArrayExpr, LiteralExpr, LiteralMap, LiteralMapExpr, LiteralPrimitive, LocalizedString, MapType, MessageBundle, NONE_TYPE, NO_ERRORS_SCHEMA, NodeWithI18n, NonNullAssert, NotExpr, ParenthesizedExpr, ParenthesizedExpression, ParseError, ParseErrorLevel, ParseLocation, ParseSourceFile, ParseSourceSpan, ParseSpan, ParseTreeResult, ParsedEvent, ParsedEventType, ParsedProperty, ParsedPropertyType, ParsedVariable, Parser, PrefixNot, PropertyRead, Identifiers as R3Identifiers, R3NgModuleMetadataKind, R3SelectorScopeMode, R3TargetBinder, R3TemplateDependencyKind, ReadKeyExpr, ReadPropExpr, ReadVarExpr, RecursiveAstVisitor, RecursiveVisitor, RegularExpressionLiteral, RegularExpressionLiteralExpr, ResourceLoader, ReturnStatement, SCHEMA, SECURITY_SCHEMA, STRING_TYPE, SafeCall, SafeKeyedRead, SafePropertyRead, SelectorContext, SelectorListContext, SelectorMatcher, SelectorlessMatcher, Serializer, SplitInterpolation, Statement, StmtModifier, StringToken, StringTokenKind, TagContentType, TaggedTemplateLiteral, TaggedTemplateLiteralExpr, TemplateBindingParseResult, TemplateLiteral, TemplateLiteralElement, TemplateLiteralElementExpr, TemplateLiteralExpr, Text, ThisReceiver, BlockNode as TmplAstBlockNode, BoundAttribute as TmplAstBoundAttribute, BoundDeferredTrigger as TmplAstBoundDeferredTrigger, BoundEvent as TmplAstBoundEvent, BoundText as TmplAstBoundText, Component$1 as TmplAstComponent, Content as TmplAstContent, DeferredBlock as TmplAstDeferredBlock, DeferredBlockError as TmplAstDeferredBlockError, DeferredBlockLoading as TmplAstDeferredBlockLoading, DeferredBlockPlaceholder as TmplAstDeferredBlockPlaceholder, DeferredTrigger as TmplAstDeferredTrigger, Directive$1 as TmplAstDirective, Element$1 as TmplAstElement, ForLoopBlock as TmplAstForLoopBlock, ForLoopBlockEmpty as TmplAstForLoopBlockEmpty, HostElement as TmplAstHostElement, HoverDeferredTrigger as TmplAstHoverDeferredTrigger, Icu$1 as TmplAstIcu, IdleDeferredTrigger as TmplAstIdleDeferredTrigger, IfBlock as TmplAstIfBlock, IfBlockBranch as TmplAstIfBlockBranch, ImmediateDeferredTrigger as TmplAstImmediateDeferredTrigger, InteractionDeferredTrigger as TmplAstInteractionDeferredTrigger, LetDeclaration$1 as TmplAstLetDeclaration, NeverDeferredTrigger as TmplAstNeverDeferredTrigger, RecursiveVisitor$1 as TmplAstRecursiveVisitor, Reference as TmplAstReference, SwitchBlock as TmplAstSwitchBlock, SwitchBlockCase as TmplAstSwitchBlockCase, Template as TmplAstTemplate, Text$3 as TmplAstText, TextAttribute as TmplAstTextAttribute, TimerDeferredTrigger as TmplAstTimerDeferredTrigger, UnknownBlock as TmplAstUnknownBlock, Variable as TmplAstVariable, ViewportDeferredTrigger as TmplAstViewportDeferredTrigger, Token, TokenType, TransplantedType, TreeError, Type, TypeModifier, TypeofExpr, TypeofExpression, Unary, UnaryOperator, UnaryOperatorExpr, VERSION, VariableBinding, Version, ViewEncapsulation$1 as ViewEncapsulation, VoidExpr, VoidExpression, WrappedNodeExpr, Xliff, Xliff2, Xmb, XmlParser, Xtb, _ATTR_TO_PROP, compileClassDebugInfo, compileClassMetadata, compileComponentClassMetadata, compileComponentDeclareClassMetadata, compileComponentFromMetadata, compileDeclareClassMetadata, compileDeclareComponentFromMetadata, compileDeclareDirectiveFromMetadata, compileDeclareFactoryFunction, compileDeclareInjectableFromMetadata, compileDeclareInjectorFromMetadata, compileDeclareNgModuleFromMetadata, compileDeclarePipeFromMetadata, compileDeferResolverFunction, compileDirectiveFromMetadata, compileFactoryFunction, compileHmrInitializer, compileHmrUpdateCallback, compileInjectable, compileInjector, compileNgModule, compileOpaqueAsyncClassMetadata, compilePipeFromMetadata, computeMsgId, core, createCssSelectorFromNode, createInjectableType, createMayBeForwardRefExpression, devOnlyGuardedExpression, emitDistinctChangesOnlyDefaultValue, encapsulateStyle, escapeRegExp, findMatchingDirectivesAndPipes, getHtmlTagDefinition, getNsPrefix, getSafePropertyAccessString, identifierName, isNgContainer, isNgContent, isNgTemplate, jsDocComment, leadingComment, literal, literalMap, makeBindingParser, mergeNsAndName, output_ast as outputAst, parseHostBindings, parseTemplate, preserveWhitespacesDefault, publishFacade, r3JitTypeSourceSpan, sanitizeIdentifier, setEnableTemplateSourceLocations, splitNsName, visitAll$1 as tmplAstVisitAll, verifyHostBindings, visitAll };
+export { AST, ASTWithName, ASTWithSource, AbsoluteSourceSpan, ArrayType, ArrowFunctionExpr, Attribute, Binary, BinaryOperator, BinaryOperatorExpr, BindingPipe, BindingPipeType, BindingType, Block, BlockParameter, BoundElementProperty, BuiltinType, BuiltinTypeName, CUSTOM_ELEMENTS_SCHEMA, Call, Chain, ChangeDetectionStrategy, CombinedRecursiveAstVisitor, CommaExpr, Comment, CompilerConfig, CompilerFacadeImpl, Component, Conditional, ConditionalExpr, ConstantPool, CssSelector, DYNAMIC_TYPE, DeclareFunctionStmt, DeclareVarStmt, Directive, DomElementSchemaRegistry, DynamicImportExpr, EOF, Element, ElementSchemaRegistry, EmitterVisitorContext, EmptyExpr$1 as EmptyExpr, Expansion, ExpansionCase, Expression, ExpressionBinding, ExpressionStatement, ExpressionType, ExternalExpr, ExternalReference, FactoryTarget, FunctionExpr, HtmlParser, HtmlTagDefinition, I18NHtmlParser, IfStmt, ImplicitReceiver, InstantiateExpr, Interpolation$1 as Interpolation, InvokeFunctionExpr, JSDocComment, JitEvaluator, KeyedRead, LeadingComment, LetDeclaration, Lexer, LiteralArray, LiteralArrayExpr, LiteralExpr, LiteralMap, LiteralMapExpr, LiteralMapPropertyAssignment, LiteralMapSpreadAssignment, LiteralPrimitive, LocalizedString, MapType, MessageBundle, NONE_TYPE, NO_ERRORS_SCHEMA, NodeWithI18n, NonNullAssert, NotExpr, ParenthesizedExpr, ParenthesizedExpression, ParseError, ParseErrorLevel, ParseLocation, ParseSourceFile, ParseSourceSpan, ParseSpan, ParseTreeResult, ParsedEvent, ParsedEventType, ParsedProperty, ParsedPropertyType, ParsedVariable, Parser, PrefixNot, PropertyRead, Identifiers as R3Identifiers, R3NgModuleMetadataKind, R3SelectorScopeMode, R3TargetBinder, R3TemplateDependencyKind, ReadKeyExpr, ReadPropExpr, ReadVarExpr, RecursiveAstVisitor, RecursiveVisitor, RegularExpressionLiteral, RegularExpressionLiteralExpr, ResourceLoader, ReturnStatement, SCHEMA, SECURITY_SCHEMA, STRING_TYPE, SafeCall, SafeKeyedRead, SafePropertyRead, SelectorContext, SelectorListContext, SelectorMatcher, SelectorlessMatcher, Serializer, SplitInterpolation, SpreadElement, SpreadElementExpr, Statement, StmtModifier, StringToken, StringTokenKind, TagContentType, TaggedTemplateLiteral, TaggedTemplateLiteralExpr, TemplateBindingParseResult, TemplateLiteral, TemplateLiteralElement, TemplateLiteralElementExpr, TemplateLiteralExpr, Text, ThisReceiver, BlockNode as TmplAstBlockNode, BoundAttribute as TmplAstBoundAttribute, BoundDeferredTrigger as TmplAstBoundDeferredTrigger, BoundEvent as TmplAstBoundEvent, BoundText as TmplAstBoundText, Component$1 as TmplAstComponent, Content as TmplAstContent, DeferredBlock as TmplAstDeferredBlock, DeferredBlockError as TmplAstDeferredBlockError, DeferredBlockLoading as TmplAstDeferredBlockLoading, DeferredBlockPlaceholder as TmplAstDeferredBlockPlaceholder, DeferredTrigger as TmplAstDeferredTrigger, Directive$1 as TmplAstDirective, Element$1 as TmplAstElement, ForLoopBlock as TmplAstForLoopBlock, ForLoopBlockEmpty as TmplAstForLoopBlockEmpty, HostElement as TmplAstHostElement, HoverDeferredTrigger as TmplAstHoverDeferredTrigger, Icu$1 as TmplAstIcu, IdleDeferredTrigger as TmplAstIdleDeferredTrigger, IfBlock as TmplAstIfBlock, IfBlockBranch as TmplAstIfBlockBranch, ImmediateDeferredTrigger as TmplAstImmediateDeferredTrigger, InteractionDeferredTrigger as TmplAstInteractionDeferredTrigger, LetDeclaration$1 as TmplAstLetDeclaration, NeverDeferredTrigger as TmplAstNeverDeferredTrigger, RecursiveVisitor$1 as TmplAstRecursiveVisitor, Reference as TmplAstReference, SwitchBlock as TmplAstSwitchBlock, SwitchBlockCase as TmplAstSwitchBlockCase, SwitchBlockCaseGroup as TmplAstSwitchBlockCaseGroup, Template as TmplAstTemplate, Text$3 as TmplAstText, TextAttribute as TmplAstTextAttribute, TimerDeferredTrigger as TmplAstTimerDeferredTrigger, UnknownBlock as TmplAstUnknownBlock, Variable as TmplAstVariable, ViewportDeferredTrigger as TmplAstViewportDeferredTrigger, Token, TokenType, TransplantedType, TreeError, Type, TypeModifier, TypeofExpr, TypeofExpression, Unary, UnaryOperator, UnaryOperatorExpr, VERSION, VariableBinding, Version, ViewEncapsulation$1 as ViewEncapsulation, VoidExpr, VoidExpression, WrappedNodeExpr, Xliff, Xliff2, Xmb, XmlParser, Xtb, _ATTR_TO_PROP, compileClassDebugInfo, compileClassMetadata, compileComponentClassMetadata, compileComponentDeclareClassMetadata, compileComponentFromMetadata, compileDeclareClassMetadata, compileDeclareComponentFromMetadata, compileDeclareDirectiveFromMetadata, compileDeclareFactoryFunction, compileDeclareInjectableFromMetadata, compileDeclareInjectorFromMetadata, compileDeclareNgModuleFromMetadata, compileDeclarePipeFromMetadata, compileDeferResolverFunction, compileDirectiveFromMetadata, compileFactoryFunction, compileHmrInitializer, compileHmrUpdateCallback, compileInjectable, compileInjector, compileNgModule, compileOpaqueAsyncClassMetadata, compilePipeFromMetadata, computeMsgId, core, createCssSelectorFromNode, createInjectableType, createMayBeForwardRefExpression, devOnlyGuardedExpression, emitDistinctChangesOnlyDefaultValue, encapsulateStyle, escapeRegExp, findMatchingDirectivesAndPipes, getHtmlTagDefinition, getNsPrefix, getSafePropertyAccessString, identifierName, isNgContainer, isNgContent, isNgTemplate, jsDocComment, leadingComment, literal, literalMap, makeBindingParser, mergeNsAndName, output_ast as outputAst, parseHostBindings, parseTemplate, preserveWhitespacesDefault, publishFacade, r3JitTypeSourceSpan, sanitizeIdentifier, setEnableTemplateSourceLocations, splitNsName, visitAll$1 as tmplAstVisitAll, verifyHostBindings, visitAll };
 //# sourceMappingURL=compiler.mjs.map