@angular/compiler 21.0.0-next.5 → 21.0.0-next.7

package/fesm2022/compiler.mjs

@@ -1,6 +1,6 @@
 /**
- * @license Angular v21.0.0-next.5
- * (c) 2010-2025 Google LLC. https://angular.io/
+ * @license Angular v21.0.0-next.7
+ * (c) 2010-2025 Google LLC. https://angular.dev/
  * License: MIT
  */
 
@@ -2844,6 +2844,8 @@ class Identifiers {
     static domProperty = { name: 'ɵɵdomProperty', moduleName: CORE };
     static ariaProperty = { name: 'ɵɵariaProperty', moduleName: CORE };
     static property = { name: 'ɵɵproperty', moduleName: CORE };
+    static control = { name: 'ɵɵcontrol', moduleName: CORE };
+    static controlCreate = { name: 'ɵɵcontrolCreate', moduleName: CORE };
     static animationEnterListener = {
         name: 'ɵɵanimateEnterListener',
         moduleName: CORE,
@@ -6430,48 +6432,6 @@ function createFactoryFunction(type) {
     return arrowFn([t], type.prop('ɵfac').callFn([variable(t.name)]));
 }
 
-const UNUSABLE_INTERPOLATION_REGEXPS = [
-    /@/, // control flow reserved symbol
-    /^\s*$/, // empty
-    /[<>]/, // html tag
-    /^[{}]$/, // i18n expansion
-    /&(#|[a-z])/i, // character reference,
-    /^\/\//, // comment
-];
-function assertInterpolationSymbols(identifier, value) {
-    if (value != null && !(Array.isArray(value) && value.length == 2)) {
-        throw new Error(`Expected '${identifier}' to be an array, [start, end].`);
-    }
-    else if (value != null) {
-        const start = value[0];
-        const end = value[1];
-        // Check for unusable interpolation symbols
-        UNUSABLE_INTERPOLATION_REGEXPS.forEach((regexp) => {
-            if (regexp.test(start) || regexp.test(end)) {
-                throw new Error(`['${start}', '${end}'] contains unusable interpolation symbol.`);
-            }
-        });
-    }
-}
-
-class InterpolationConfig {
-    start;
-    end;
-    static fromArray(markers) {
-        if (!markers) {
-            return DEFAULT_INTERPOLATION_CONFIG;
-        }
-        assertInterpolationSymbols('interpolation', markers);
-        return new InterpolationConfig(markers[0], markers[1]);
-    }
-    constructor(start, end) {
-        this.start = start;
-        this.end = end;
-    }
-}
-const DEFAULT_INTERPOLATION_CONFIG = new InterpolationConfig('{{', '}}');
-const DEFAULT_CONTAINER_BLOCKS = new Set(['switch']);
-
 const $EOF = 0;
 const $BSPACE = 8;
 const $TAB = 9;
@@ -8825,6 +8785,17 @@ var OpKind;
      * An operation to bind animation events to an element.
      */
     OpKind[OpKind["AnimationListener"] = 56] = "AnimationListener";
+    /**
+     * An operation to bind an expression to a `control` property of an element.
+     */
+    OpKind[OpKind["Control"] = 57] = "Control";
+    /**
+     * An operation to set up a corresponding {@link Control} operation.
+     *
+     * This is responsible for setting up event listeners on a native or custom form control when
+     * bound to a specialized control directive.
+     */
+    OpKind[OpKind["ControlCreate"] = 58] = "ControlCreate";
 })(OpKind || (OpKind = {}));
 /**
  * Distinguishes different kinds of IR expressions.
@@ -9495,6 +9466,25 @@ function createStoreLetOp(target, declaredName, value, sourceSpan) {
         ...NEW_OP,
     };
 }
+/** Creates a {@link ControlOp}. */
+function createControlOp(op) {
+    return {
+        kind: OpKind.Control,
+        target: op.target,
+        expression: op.expression,
+        bindingKind: op.bindingKind,
+        securityContext: op.securityContext,
+        sanitizer: null,
+        isStructuralTemplateAttribute: op.isStructuralTemplateAttribute,
+        templateKind: op.templateKind,
+        i18nContext: op.i18nContext,
+        i18nMessage: op.i18nMessage,
+        sourceSpan: op.sourceSpan,
+        ...TRAIT_DEPENDS_ON_SLOT_CONTEXT,
+        ...TRAIT_CONSUMES_VARS,
+        ...NEW_OP,
+    };
+}
 
 /**
  * Check whether a given `o.Expression` is a logical IR expression type.
@@ -10277,6 +10267,7 @@ function transformExpressionsInOp(op, transform, flags) {
         case OpKind.Property:
         case OpKind.DomProperty:
         case OpKind.Attribute:
+        case OpKind.Control:
             if (op.expression instanceof Interpolation) {
                 transformExpressionsInInterpolation(op.expression, transform, flags);
             }
@@ -10402,6 +10393,7 @@ function transformExpressionsInOp(op, transform, flags) {
         case OpKind.SourceLocation:
         case OpKind.ConditionalCreate:
         case OpKind.ConditionalBranchCreate:
+        case OpKind.ControlCreate:
             // These operations contain no expressions.
             break;
         default:
@@ -11302,6 +11294,10 @@ function createSourceLocationOp(templatePath, locations) {
         ...NEW_OP,
     };
 }
+/** Creates a {@link ControlCreateOp}. */
+function createControlCreateOp(sourceSpan) {
+    return { kind: OpKind.ControlCreate, sourceSpan, ...NEW_OP };
+}
 
 function createDomPropertyOp(name, expression, bindingKind, i18nContext, securityContext, sourceSpan) {
     return {
@@ -11780,6 +11776,14 @@ function extractAttributes(job) {
                         /* i18nMessage */ null, op.securityContext), lookupElement$3(elements, op.target));
                     }
                     break;
+                case OpKind.Control:
+                    OpList.insertBefore(
+                    // Deliberately null i18nMessage value
+                    createExtractedAttributeOp(op.target, BindingKind.Property, null, 'control', 
+                    /* expression */ null, 
+                    /* i18nContext */ null, 
+                    /* i18nMessage */ null, op.securityContext), lookupElement$3(elements, op.target));
+                    break;
                 case OpKind.TwoWayProperty:
                     OpList.insertBefore(createExtractedAttributeOp(op.target, BindingKind.TwoWayProperty, null, op.name, 
                     /* expression */ null, 
@@ -11939,6 +11943,9 @@ function specializeBindings(job) {
                     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 === 'control') {
+                        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));
                     }
@@ -16053,12 +16060,15 @@ const SUPPORTED_BLOCKS = [
     '@loading',
     '@error',
 ];
+const INTERPOLATION = {
+    start: '{{',
+    end: '}}',
+};
 // See https://www.w3.org/TR/html51/syntax.html#writing-html-documents
 class _Tokenizer {
     _getTagDefinition;
     _cursor;
     _tokenizeIcu;
-    _interpolationConfig;
     _leadingTriviaCodePoints;
     _currentTokenStart = null;
     _currentTokenType = null;
@@ -16081,7 +16091,6 @@ class _Tokenizer {
     constructor(_file, _getTagDefinition, options) {
         this._getTagDefinition = _getTagDefinition;
         this._tokenizeIcu = options.tokenizeExpansionForms || false;
-        this._interpolationConfig = options.interpolationConfig || DEFAULT_INTERPOLATION_CONFIG;
         this._leadingTriviaCodePoints =
             options.leadingTriviaChars && options.leadingTriviaChars.map((c) => c.codePointAt(0) || 0);
         const range = options.range || {
@@ -16912,7 +16921,7 @@ class _Tokenizer {
         const parts = [];
         while (!endPredicate()) {
             const current = this._cursor.clone();
-            if (this._interpolationConfig && this._attemptStr(this._interpolationConfig.start)) {
+            if (this._attemptStr(INTERPOLATION.start)) {
                 this._endToken([this._processCarriageReturns(parts.join(''))], current);
                 parts.length = 0;
                 this._consumeInterpolation(interpolationTokenType, current, endInterpolation);
@@ -16944,7 +16953,7 @@ class _Tokenizer {
     _consumeInterpolation(interpolationTokenType, interpolationStart, prematureEndPredicate) {
         const parts = [];
         this._beginToken(interpolationTokenType, interpolationStart);
-        parts.push(this._interpolationConfig.start);
+        parts.push(INTERPOLATION.start);
         // Find the end of the interpolation, ignoring content inside quotes.
         const expressionStart = this._cursor.clone();
         let inQuote = null;
@@ -16962,10 +16971,10 @@ class _Tokenizer {
                 return;
             }
             if (inQuote === null) {
-                if (this._attemptStr(this._interpolationConfig.end)) {
+                if (this._attemptStr(INTERPOLATION.end)) {
                     // We are not in a string, and we hit the end interpolation marker
                     parts.push(this._getProcessedChars(expressionStart, current));
-                    parts.push(this._interpolationConfig.end);
+                    parts.push(INTERPOLATION.end);
                     this._endToken(parts);
                     return;
                 }
@@ -17104,13 +17113,10 @@ class _Tokenizer {
         if (this._cursor.peek() !== $LBRACE) {
             return false;
         }
-        if (this._interpolationConfig) {
-            const start = this._cursor.clone();
-            const isInterpolation = this._attemptStr(this._interpolationConfig.start);
-            this._cursor = start;
-            return !isInterpolation;
-        }
-        return true;
+        const start = this._cursor.clone();
+        const isInterpolation = this._attemptStr(INTERPOLATION.start);
+        this._cursor = start;
+        return !isInterpolation;
     }
 }
 function isNotWhitespace(code) {
@@ -18430,9 +18436,6 @@ class Token {
     isTemplateLiteralInterpolationStart() {
         return this.isOperator('${');
     }
-    isTemplateLiteralInterpolationEnd() {
-        return this.isOperator('}');
-    }
     toString() {
         switch (this.type) {
             case TokenType.Character:
@@ -18615,7 +18618,7 @@ class _Scanner {
         this.advance();
         const currentBrace = this.braceStack.pop();
         if (currentBrace === 'interpolation') {
-            this.tokens.push(newOperatorToken(start, this.index, '}'));
+            this.tokens.push(newCharacterToken(start, this.index, $RBRACE));
             return this.scanTemplateLiteralPart(this.index);
         }
         return newCharacterToken(start, this.index, code);
@@ -18979,17 +18982,17 @@ class Parser {
         this._lexer = _lexer;
         this._supportsDirectPipeReferences = _supportsDirectPipeReferences;
     }
-    parseAction(input, parseSourceSpan, absoluteOffset, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
+    parseAction(input, parseSourceSpan, absoluteOffset) {
         const errors = [];
-        this._checkNoInterpolation(errors, input, parseSourceSpan, interpolationConfig);
+        this._checkNoInterpolation(errors, input, parseSourceSpan);
         const { stripped: sourceToLex } = this._stripComments(input);
         const tokens = this._lexer.tokenize(sourceToLex);
         const ast = new _ParseAST(input, parseSourceSpan, absoluteOffset, tokens, 1 /* ParseFlags.Action */, errors, 0, this._supportsDirectPipeReferences).parseChain();
         return new ASTWithSource(ast, input, getLocation(parseSourceSpan), absoluteOffset, errors);
     }
-    parseBinding(input, parseSourceSpan, absoluteOffset, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
+    parseBinding(input, parseSourceSpan, absoluteOffset) {
         const errors = [];
-        const ast = this._parseBindingAst(input, parseSourceSpan, absoluteOffset, interpolationConfig, errors);
+        const ast = this._parseBindingAst(input, parseSourceSpan, absoluteOffset, errors);
         return new ASTWithSource(ast, input, getLocation(parseSourceSpan), absoluteOffset, errors);
     }
     checkSimpleExpression(ast) {
@@ -18998,17 +19001,17 @@ class Parser {
         return checker.errors;
     }
     // Host bindings parsed here
-    parseSimpleBinding(input, parseSourceSpan, absoluteOffset, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
+    parseSimpleBinding(input, parseSourceSpan, absoluteOffset) {
         const errors = [];
-        const ast = this._parseBindingAst(input, parseSourceSpan, absoluteOffset, interpolationConfig, errors);
+        const ast = this._parseBindingAst(input, parseSourceSpan, absoluteOffset, errors);
         const simplExpressionErrors = this.checkSimpleExpression(ast);
         if (simplExpressionErrors.length > 0) {
             errors.push(getParseError(`Host binding expression cannot contain ${simplExpressionErrors.join(' ')}`, input, '', parseSourceSpan));
         }
         return new ASTWithSource(ast, input, getLocation(parseSourceSpan), absoluteOffset, errors);
     }
-    _parseBindingAst(input, parseSourceSpan, absoluteOffset, interpolationConfig, errors) {
-        this._checkNoInterpolation(errors, input, parseSourceSpan, interpolationConfig);
+    _parseBindingAst(input, parseSourceSpan, absoluteOffset, errors) {
+        this._checkNoInterpolation(errors, input, parseSourceSpan);
         const { stripped: sourceToLex } = this._stripComments(input);
         const tokens = this._lexer.tokenize(sourceToLex);
         return new _ParseAST(input, parseSourceSpan, absoluteOffset, tokens, 0 /* ParseFlags.None */, errors, 0, this._supportsDirectPipeReferences).parseChain();
@@ -19048,9 +19051,9 @@ class Parser {
             span: new AbsoluteSourceSpan(absoluteKeyOffset, absoluteKeyOffset + templateKey.length),
         });
     }
-    parseInterpolation(input, parseSourceSpan, absoluteOffset, interpolatedTokens, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
+    parseInterpolation(input, parseSourceSpan, absoluteOffset, interpolatedTokens) {
         const errors = [];
-        const { strings, expressions, offsets } = this.splitInterpolation(input, parseSourceSpan, errors, interpolatedTokens, interpolationConfig);
+        const { strings, expressions, offsets } = this.splitInterpolation(input, parseSourceSpan, errors, interpolatedTokens);
         if (expressions.length === 0)
             return null;
         const expressionNodes = [];
@@ -19097,7 +19100,7 @@ class Parser {
      * `SplitInterpolation` with splits that look like
      *   <raw text> <expression> <raw text> ... <raw text> <expression> <raw text>
      */
-    splitInterpolation(input, parseSourceSpan, errors, interpolatedTokens, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
+    splitInterpolation(input, parseSourceSpan, errors, interpolatedTokens) {
         const strings = [];
         const expressions = [];
         const offsets = [];
@@ -19107,7 +19110,8 @@ class Parser {
         let i = 0;
         let atInterpolation = false;
         let extendLastString = false;
-        let { start: interpStart, end: interpEnd } = interpolationConfig;
+        const interpStart = '{{';
+        const interpEnd = '}}';
         while (i < input.length) {
             if (!atInterpolation) {
                 // parse until starting {{
@@ -19186,24 +19190,24 @@ class Parser {
         }
         return null;
     }
-    _checkNoInterpolation(errors, input, parseSourceSpan, { start, end }) {
+    _checkNoInterpolation(errors, input, parseSourceSpan) {
         let startIndex = -1;
         let endIndex = -1;
         for (const charIndex of this._forEachUnquotedChar(input, 0)) {
             if (startIndex === -1) {
-                if (input.startsWith(start)) {
+                if (input.startsWith('{{')) {
                     startIndex = charIndex;
                 }
             }
             else {
-                endIndex = this._getInterpolationEndIndex(input, end, charIndex);
+                endIndex = this._getInterpolationEndIndex(input, '}}', charIndex);
                 if (endIndex > -1) {
                     break;
                 }
             }
         }
         if (startIndex > -1 && endIndex > -1) {
-            errors.push(getParseError(`Got interpolation (${start}${end}) where expression was expected`, input, `at column ${startIndex} in`, parseSourceSpan));
+            errors.push(getParseError(`Got interpolation ({{}}) where expression was expected`, input, `at column ${startIndex} in`, parseSourceSpan));
         }
     }
     /**
@@ -20189,6 +20193,7 @@ class _ParseAST {
             }
             else if (token.isTemplateLiteralInterpolationStart()) {
                 this.advance();
+                this.rbracesExpected++;
                 const expression = this.parsePipe();
                 if (expression instanceof EmptyExpr$1) {
                     this.error('Template literal interpolation cannot be empty');
@@ -20196,6 +20201,7 @@ class _ParseAST {
                 else {
                     expressions.push(expression);
                 }
+                this.rbracesExpected--;
             }
             else {
                 this.advance();
@@ -21369,10 +21375,10 @@ class PlaceholderRegistry {
 
 const _expParser = new Parser(new Lexer());
 /**
- * Returns a function converting html nodes to an i18n Message given an interpolationConfig
+ * Returns a function converting html nodes to an i18n Message
  */
-function createI18nMessageFactory(interpolationConfig, containerBlocks, retainEmptyTokens, preserveExpressionWhitespace) {
-    const visitor = new _I18nVisitor(_expParser, interpolationConfig, containerBlocks, retainEmptyTokens, preserveExpressionWhitespace);
+function createI18nMessageFactory(containerBlocks, retainEmptyTokens, preserveExpressionWhitespace) {
+    const visitor = new _I18nVisitor(_expParser, containerBlocks, retainEmptyTokens, preserveExpressionWhitespace);
     return (nodes, meaning, description, customId, visitNodeFn) => visitor.toI18nMessage(nodes, meaning, description, customId, visitNodeFn);
 }
 function noopVisitNodeFn(_html, i18n) {
@@ -21380,13 +21386,11 @@ function noopVisitNodeFn(_html, i18n) {
 }
 class _I18nVisitor {
     _expressionParser;
-    _interpolationConfig;
     _containerBlocks;
     _retainEmptyTokens;
     _preserveExpressionWhitespace;
-    constructor(_expressionParser, _interpolationConfig, _containerBlocks, _retainEmptyTokens, _preserveExpressionWhitespace) {
+    constructor(_expressionParser, _containerBlocks, _retainEmptyTokens, _preserveExpressionWhitespace) {
         this._expressionParser = _expressionParser;
-        this._interpolationConfig = _interpolationConfig;
         this._containerBlocks = _containerBlocks;
         this._retainEmptyTokens = _retainEmptyTokens;
         this._preserveExpressionWhitespace = _preserveExpressionWhitespace;
@@ -21608,7 +21612,7 @@ class _I18nVisitor {
         const expression = token.parts[1];
         const expr = this._expressionParser.parseBinding(expression, 
         /* location */ token.sourceSpan, 
-        /* absoluteOffset */ token.sourceSpan.start.offset, this._interpolationConfig);
+        /* absoluteOffset */ token.sourceSpan.start.offset);
         return serialize(expr);
     }
 }
@@ -21673,6 +21677,51 @@ function extractPlaceholderName(input) {
     return input.split(_CUSTOM_PH_EXP)[2];
 }
 
+const UNUSABLE_INTERPOLATION_REGEXPS = [
+    /@/, // control flow reserved symbol
+    /^\s*$/, // empty
+    /[<>]/, // html tag
+    /^[{}]$/, // i18n expansion
+    /&(#|[a-z])/i, // character reference,
+    /^\/\//, // comment
+];
+function assertInterpolationSymbols(identifier, value) {
+    if (value != null && !(Array.isArray(value) && value.length == 2)) {
+        throw new Error(`Expected '${identifier}' to be an array, [start, end].`);
+    }
+    else if (value != null) {
+        const start = value[0];
+        const end = value[1];
+        // Check for unusable interpolation symbols
+        UNUSABLE_INTERPOLATION_REGEXPS.forEach((regexp) => {
+            if (regexp.test(start) || regexp.test(end)) {
+                throw new Error(`['${start}', '${end}'] contains unusable interpolation symbol.`);
+            }
+        });
+    }
+}
+
+class InterpolationConfig {
+    start;
+    end;
+    static fromArray(markers) {
+        if (!markers) {
+            return DEFAULT_INTERPOLATION_CONFIG;
+        }
+        assertInterpolationSymbols('interpolation', markers);
+        return new InterpolationConfig(markers[0], markers[1]);
+    }
+    constructor(start, end) {
+        this.start = start;
+        this.end = end;
+    }
+}
+/**
+ * This symbol is referenced inside G3 and will require some cleanup.
+ */
+const DEFAULT_INTERPOLATION_CONFIG = new InterpolationConfig('{{', '}}');
+const DEFAULT_CONTAINER_BLOCKS = new Set(['switch']);
+
 /**
  * Set of tagName|propertyName corresponding to Trusted Types sinks. Properties applying to all
  * tags use '*'.
@@ -21734,7 +21783,6 @@ const setI18nRefs = (originalNodeMap) => {
  * stored with other element's and attribute's information.
  */
 class I18nMetaVisitor {
-    interpolationConfig;
     keepI18nAttrs;
     enableI18nLegacyMessageIdFormat;
     containerBlocks;
@@ -21743,7 +21791,7 @@ class I18nMetaVisitor {
     // whether visited nodes contain i18n information
     hasI18nMeta = false;
     _errors = [];
-    constructor(interpolationConfig = DEFAULT_INTERPOLATION_CONFIG, keepI18nAttrs = false, enableI18nLegacyMessageIdFormat = false, containerBlocks = DEFAULT_CONTAINER_BLOCKS, preserveSignificantWhitespace = true, 
+    constructor(keepI18nAttrs = false, enableI18nLegacyMessageIdFormat = false, containerBlocks = DEFAULT_CONTAINER_BLOCKS, preserveSignificantWhitespace = true, 
     // When dropping significant whitespace we need to retain empty tokens or
     // else we won't be able to reuse source spans because empty tokens would be
     // removed and cause a mismatch. Unfortunately this still needs to be
@@ -21751,7 +21799,6 @@ class I18nMetaVisitor {
     // sure the number of nodes don't change between parses, even when
     // `preserveSignificantWhitespace` changes.
     retainEmptyTokens = !preserveSignificantWhitespace) {
-        this.interpolationConfig = interpolationConfig;
         this.keepI18nAttrs = keepI18nAttrs;
         this.enableI18nLegacyMessageIdFormat = enableI18nLegacyMessageIdFormat;
         this.containerBlocks = containerBlocks;
@@ -21760,7 +21807,7 @@ class I18nMetaVisitor {
     }
     _generateI18nMessage(nodes, meta = '', visitNodeFn) {
         const { meaning, description, customId } = this._parseMetadata(meta);
-        const createI18nMessage = createI18nMessageFactory(this.interpolationConfig, this.containerBlocks, this.retainEmptyTokens, 
+        const createI18nMessage = createI18nMessageFactory(this.containerBlocks, this.retainEmptyTokens, 
         /* preserveExpressionWhitespace */ this.preserveSignificantWhitespace);
         const message = createI18nMessage(nodes, meaning, description, customId, visitNodeFn);
         this._setMessageId(message, meta);
@@ -23911,6 +23958,22 @@ function ariaProperty(name, expression, sourceSpan) {
 function property(name, expression, sanitizer, sourceSpan) {
     return propertyBase(Identifiers.property, name, expression, sanitizer, sourceSpan);
 }
+function control(expression, sanitizer, sourceSpan) {
+    const args = [];
+    if (expression instanceof Interpolation) {
+        args.push(interpolationToExpression(expression, sourceSpan));
+    }
+    else {
+        args.push(expression);
+    }
+    if (sanitizer !== null) {
+        args.push(sanitizer);
+    }
+    return call(Identifiers.control, args, sourceSpan);
+}
+function controlCreate(sourceSpan) {
+    return call(Identifiers.controlCreate, [], sourceSpan);
+}
 function twoWayProperty(name, expression, sanitizer, sourceSpan) {
     const args = [literal(name), expression];
     if (sanitizer !== null) {
@@ -24471,6 +24534,9 @@ function reifyCreateOperations(unit, ops) {
                 }));
                 OpList.replace(op, attachSourceLocation(op.templatePath, locationsLiteral));
                 break;
+            case OpKind.ControlCreate:
+                OpList.replace(op, controlCreate(op.sourceSpan));
+                break;
             case OpKind.Statement:
                 // Pass statement operations directly through.
                 break;
@@ -24493,6 +24559,9 @@ function reifyUpdateOperations(unit, ops) {
                     ? reifyDomProperty(op)
                     : reifyProperty(op));
                 break;
+            case OpKind.Control:
+                OpList.replace(op, reifyControl(op));
+                break;
             case OpKind.TwoWayProperty:
                 OpList.replace(op, twoWayProperty(op.name, op.expression, op.sanitizer, op.sourceSpan));
                 break;
@@ -24588,6 +24657,9 @@ function reifyProperty(op) {
         ? 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);
+}
 function reifyIrExpression(expr) {
     if (!isIrExpression(expr)) {
         return expr;
@@ -26100,6 +26172,7 @@ function varsUsedByOp(op) {
             return slots;
         case OpKind.Property:
         case OpKind.DomProperty:
+        case OpKind.Control:
             slots = 1;
             // We need to assign a slot even for singleton interpolations, because the
             // runtime needs to store both the raw value and the stringified one.
@@ -27567,6 +27640,11 @@ function ingestElementBindings(unit, op, element) {
         }
         // All dynamic bindings (both attribute and property bindings).
         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 the input name is 'control', this could be a form control binding which requires a
+        // `ControlCreateOp` to properly initialize.
+        if (input.type === BindingType.Property && input.name === 'control') {
+            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));
@@ -28087,18 +28165,13 @@ const LEGACY_ANIMATE_PROP_PREFIX = 'animate-';
  */
 class BindingParser {
     _exprParser;
-    _interpolationConfig;
     _schemaRegistry;
     errors;
-    constructor(_exprParser, _interpolationConfig, _schemaRegistry, errors) {
+    constructor(_exprParser, _schemaRegistry, errors) {
         this._exprParser = _exprParser;
-        this._interpolationConfig = _interpolationConfig;
         this._schemaRegistry = _schemaRegistry;
         this.errors = errors;
     }
-    get interpolationConfig() {
-        return this._interpolationConfig;
-    }
     createBoundHostProperties(properties, sourceSpan) {
         const boundProps = [];
         for (const propName of Object.keys(properties)) {
@@ -28142,7 +28215,7 @@ class BindingParser {
     parseInterpolation(value, sourceSpan, interpolatedTokens) {
         const absoluteOffset = sourceSpan.fullStart.offset;
         try {
-            const ast = this._exprParser.parseInterpolation(value, sourceSpan, absoluteOffset, interpolatedTokens, this._interpolationConfig);
+            const ast = this._exprParser.parseInterpolation(value, sourceSpan, absoluteOffset, interpolatedTokens);
             if (ast) {
                 this.errors.push(...ast.errors);
             }
@@ -28314,8 +28387,8 @@ class BindingParser {
     parseBinding(value, isHostBinding, sourceSpan, absoluteOffset) {
         try {
             const ast = isHostBinding
-                ? this._exprParser.parseSimpleBinding(value, sourceSpan, absoluteOffset, this._interpolationConfig)
-                : this._exprParser.parseBinding(value, sourceSpan, absoluteOffset, this._interpolationConfig);
+                ? this._exprParser.parseSimpleBinding(value, sourceSpan, absoluteOffset)
+                : this._exprParser.parseBinding(value, sourceSpan, absoluteOffset);
             if (ast) {
                 this.errors.push(...ast.errors);
             }
@@ -28450,7 +28523,7 @@ class BindingParser {
     _parseAction(value, sourceSpan) {
         const absoluteOffset = sourceSpan && sourceSpan.start ? sourceSpan.start.offset : 0;
         try {
-            const ast = this._exprParser.parseAction(value, sourceSpan, absoluteOffset, this._interpolationConfig);
+            const ast = this._exprParser.parseAction(value, sourceSpan, absoluteOffset);
             if (ast) {
                 this.errors.push(...ast.errors);
             }
@@ -29716,6 +29789,13 @@ class HtmlAstToIvyAst {
         }
         else {
             const attrs = this.categorizePropertyAttributes(element.name, parsedProperties, i18nAttrsMeta);
+            if (element.name === 'ng-container') {
+                for (const bound of attrs.bound) {
+                    if (bound.type === BindingType.Attribute) {
+                        this.reportError(`Attribute bindings are not supported on ng-container. Use property bindings instead.`, bound.sourceSpan);
+                    }
+                }
+            }
             parsedElement = new Element$1(element.name, attributes, attrs.bound, boundEvents, directives, children, references, element.isSelfClosing, element.sourceSpan, element.startSourceSpan, element.endSourceSpan, element.isVoid, element.i18n);
         }
         if (elementHasInlineTemplate) {
@@ -30300,9 +30380,9 @@ const LEADING_TRIVIA_CHARS = [' ', '\n', '\r', '\t'];
  * @param options options to modify how the template is parsed
  */
 function parseTemplate(template, templateUrl, options = {}) {
-    const { interpolationConfig, preserveWhitespaces, enableI18nLegacyMessageIdFormat } = options;
+    const { preserveWhitespaces, enableI18nLegacyMessageIdFormat } = options;
     const selectorlessEnabled = options.enableSelectorless ?? false;
-    const bindingParser = makeBindingParser(interpolationConfig, selectorlessEnabled);
+    const bindingParser = makeBindingParser(selectorlessEnabled);
     const htmlParser = new HtmlParser();
     const parseResult = htmlParser.parse(template, templateUrl, {
         leadingTriviaChars: LEADING_TRIVIA_CHARS,
@@ -30316,7 +30396,6 @@ function parseTemplate(template, templateUrl, options = {}) {
         parseResult.errors &&
         parseResult.errors.length > 0) {
         const parsedTemplate = {
-            interpolationConfig,
             preserveWhitespaces,
             errors: parseResult.errors,
             nodes: [],
@@ -30339,7 +30418,7 @@ function parseTemplate(template, templateUrl, options = {}) {
     // before we run whitespace removal process, because existing i18n
     // extraction process (ng extract-i18n) relies on a raw content to generate
     // message ids
-    const i18nMetaVisitor = new I18nMetaVisitor(interpolationConfig, 
+    const i18nMetaVisitor = new I18nMetaVisitor(
     /* keepI18nAttrs */ !preserveWhitespaces, enableI18nLegacyMessageIdFormat, 
     /* containerBlocks */ undefined, options.preserveSignificantWhitespace, retainEmptyTokens);
     const i18nMetaResult = i18nMetaVisitor.visitAllWithErrors(rootNodes);
@@ -30347,7 +30426,6 @@ function parseTemplate(template, templateUrl, options = {}) {
         i18nMetaResult.errors &&
         i18nMetaResult.errors.length > 0) {
         const parsedTemplate = {
-            interpolationConfig,
             preserveWhitespaces,
             errors: i18nMetaResult.errors,
             nodes: [],
@@ -30382,7 +30460,7 @@ function parseTemplate(template, templateUrl, options = {}) {
         // template. During this pass i18n IDs generated at the first pass will be preserved, so we can
         // mimic existing extraction process (ng extract-i18n)
         if (i18nMetaVisitor.hasI18nMeta) {
-            rootNodes = visitAll(new I18nMetaVisitor(interpolationConfig, 
+            rootNodes = visitAll(new I18nMetaVisitor(
             /* keepI18nAttrs */ false, 
             /* enableI18nLegacyMessageIdFormat */ undefined, 
             /* containerBlocks */ undefined, 
@@ -30392,7 +30470,6 @@ function parseTemplate(template, templateUrl, options = {}) {
     const { nodes, errors, styleUrls, styles, ngContentSelectors, commentNodes } = htmlAstToRender3Ast(rootNodes, bindingParser, { collectCommentNodes: !!options.collectCommentNodes });
     errors.push(...parseResult.errors, ...i18nMetaResult.errors);
     const parsedTemplate = {
-        interpolationConfig,
         preserveWhitespaces,
         errors: errors.length > 0 ? errors : null,
         nodes,
@@ -30409,8 +30486,8 @@ const elementRegistry = new DomElementSchemaRegistry();
 /**
  * Construct a `BindingParser` with a default configuration.
  */
-function makeBindingParser(interpolationConfig = DEFAULT_INTERPOLATION_CONFIG, selectorlessEnabled = false) {
-    return new BindingParser(new Parser(new Lexer(), selectorlessEnabled), interpolationConfig, elementRegistry, []);
+function makeBindingParser(selectorlessEnabled = false) {
+    return new BindingParser(new Parser(new Lexer(), selectorlessEnabled), elementRegistry, []);
 }
 
 const COMPONENT_VARIABLE = '%COMP%';
@@ -30529,7 +30606,7 @@ function compileComponentFromMetadata(meta, constantPool, bindingParser) {
         : TemplateCompilationMode.Full;
     // First the template is ingested into IR:
     const tpl = ingestComponent(meta.name, meta.template.nodes, constantPool, compilationMode, meta.relativeContextFilePath, meta.i18nUseExternalIds, meta.defer, allDeferrableDepsFn, meta.relativeTemplatePath, getTemplateSourceLocationsEnabled());
-    // Then the IR is transformed to prepare it for cod egeneration.
+    // Then the IR is transformed to prepare it for code generation.
     transform(tpl, CompilationJobKind.Tmpl);
     // Finally we emit the template function:
     const templateFn = emitTemplateFn(tpl, constantPool);
@@ -32132,7 +32209,7 @@ class CompilerFacadeImpl {
     }
     compileComponent(angularCoreEnv, sourceMapUrl, facade) {
         // Parse the template and check for errors.
-        const { template, interpolation, defer } = parseJitTemplate(facade.template, facade.name, sourceMapUrl, facade.preserveWhitespaces, facade.interpolation, undefined);
+        const { template, defer } = parseJitTemplate(facade.template, facade.name, sourceMapUrl, facade.preserveWhitespaces, undefined);
         // Compile the component metadata, including template, into an expression.
         const meta = {
             ...facade,
@@ -32144,7 +32221,6 @@ class CompilerFacadeImpl {
             defer,
             styles: [...facade.styles, ...template.styles],
             encapsulation: facade.encapsulation,
-            interpolation,
             changeDetection: facade.changeDetection ?? null,
             animations: facade.animations != null ? new WrappedNodeExpr(facade.animations) : null,
             viewProviders: facade.viewProviders != null ? new WrappedNodeExpr(facade.viewProviders) : null,
@@ -32162,7 +32238,7 @@ class CompilerFacadeImpl {
     }
     compileComponentFromMeta(angularCoreEnv, sourceMapUrl, meta) {
         const constantPool = new ConstantPool();
-        const bindingParser = makeBindingParser(meta.interpolation);
+        const bindingParser = makeBindingParser();
         const res = compileComponentFromMetadata(meta, constantPool, bindingParser);
         return this.jitExpression(res.expression, angularCoreEnv, sourceMapUrl, constantPool.statements);
     }
@@ -32368,7 +32444,7 @@ function convertOpaqueValuesToExpressions(obj) {
     return result;
 }
 function convertDeclareComponentFacadeToMetadata(decl, typeSourceSpan, sourceMapUrl) {
-    const { template, interpolation, defer } = parseJitTemplate(decl.template, decl.type.name, sourceMapUrl, decl.preserveWhitespaces ?? false, decl.interpolation, decl.deferBlockDependencies);
+    const { template, defer } = parseJitTemplate(decl.template, decl.type.name, sourceMapUrl, decl.preserveWhitespaces ?? false, decl.deferBlockDependencies);
     const declarations = [];
     if (decl.dependencies) {
         for (const innerDep of decl.dependencies) {
@@ -32403,7 +32479,6 @@ function convertDeclareComponentFacadeToMetadata(decl, typeSourceSpan, sourceMap
         defer,
         changeDetection: decl.changeDetection ?? ChangeDetectionStrategy.Default,
         encapsulation: decl.encapsulation ?? ViewEncapsulation$1.Emulated,
-        interpolation,
         declarationListEmitMode: 2 /* DeclarationListEmitMode.ClosureResolved */,
         relativeContextFilePath: '',
         i18nUseExternalIds: true,
@@ -32447,15 +32522,9 @@ function convertPipeDeclarationToMetadata(pipe) {
         type: new WrappedNodeExpr(pipe.type),
     };
 }
-function parseJitTemplate(template, typeName, sourceMapUrl, preserveWhitespaces, interpolation, deferBlockDependencies) {
-    const interpolationConfig = interpolation
-        ? InterpolationConfig.fromArray(interpolation)
-        : DEFAULT_INTERPOLATION_CONFIG;
+function parseJitTemplate(template, typeName, sourceMapUrl, preserveWhitespaces, deferBlockDependencies) {
     // Parse the template and check for errors.
-    const parsed = parseTemplate(template, sourceMapUrl, {
-        preserveWhitespaces,
-        interpolationConfig,
-    });
+    const parsed = parseTemplate(template, sourceMapUrl, { preserveWhitespaces });
     if (parsed.errors !== null) {
         const errors = parsed.errors.map((err) => err.toString()).join(', ');
         throw new Error(`Errors during JIT compilation of template for ${typeName}: ${errors}`);
@@ -32464,7 +32533,6 @@ function parseJitTemplate(template, typeName, sourceMapUrl, preserveWhitespaces,
     const boundTarget = binder.bind({ template: parsed.nodes });
     return {
         template: parsed,
-        interpolation: interpolationConfig,
         defer: createR3ComponentDeferMetadata(boundTarget, deferBlockDependencies),
     };
 }
@@ -32702,13 +32770,13 @@ let i18nCommentsWarned = false;
 /**
  * Extract translatable messages from an html AST
  */
-function extractMessages(nodes, interpolationConfig, implicitTags, implicitAttrs, preserveSignificantWhitespace) {
+function extractMessages(nodes, implicitTags, implicitAttrs, preserveSignificantWhitespace) {
     const visitor = new _Visitor(implicitTags, implicitAttrs, preserveSignificantWhitespace);
-    return visitor.extract(nodes, interpolationConfig);
+    return visitor.extract(nodes);
 }
-function mergeTranslations(nodes, translations, interpolationConfig, implicitTags, implicitAttrs) {
+function mergeTranslations(nodes, translations, implicitTags, implicitAttrs) {
     const visitor = new _Visitor(implicitTags, implicitAttrs);
-    return visitor.merge(nodes, translations, interpolationConfig);
+    return visitor.merge(nodes, translations);
 }
 class ExtractionResult {
     messages;
@@ -32763,8 +32831,8 @@ class _Visitor {
     /**
      * Extracts the messages from the tree
      */
-    extract(nodes, interpolationConfig) {
-        this._init(_VisitorMode.Extract, interpolationConfig);
+    extract(nodes) {
+        this._init(_VisitorMode.Extract);
         nodes.forEach((node) => node.visit(this, null));
         if (this._inI18nBlock) {
             this._reportError(nodes[nodes.length - 1], 'Unclosed block');
@@ -32774,8 +32842,8 @@ class _Visitor {
     /**
      * Returns a tree where all translatable nodes are translated
      */
-    merge(nodes, translations, interpolationConfig) {
-        this._init(_VisitorMode.Merge, interpolationConfig);
+    merge(nodes, translations) {
+        this._init(_VisitorMode.Merge);
         this._translations = translations;
         // Construct a single fake root element
         const wrapper = new Element('wrapper', [], [], nodes, false, undefined, undefined, undefined, false);
@@ -32880,7 +32948,7 @@ class _Visitor {
     visitDirective(directive, context) {
         throw new Error('unreachable code');
     }
-    _init(mode, interpolationConfig) {
+    _init(mode) {
         this._mode = mode;
         this._inI18nBlock = false;
         this._inI18nNode = false;
@@ -32890,7 +32958,7 @@ class _Visitor {
         this._errors = [];
         this._messages = [];
         this._inImplicitNode = false;
-        this._createI18nMessage = createI18nMessageFactory(interpolationConfig, DEFAULT_CONTAINER_BLOCKS, 
+        this._createI18nMessage = createI18nMessageFactory(DEFAULT_CONTAINER_BLOCKS, 
         // When dropping significant whitespace we need to retain whitespace tokens or
         // else we won't be able to reuse source spans because empty tokens would be
         // removed and cause a mismatch.
@@ -34233,12 +34301,11 @@ class I18NHtmlParser {
         }
     }
     parse(source, url, options = {}) {
-        const interpolationConfig = options.interpolationConfig || DEFAULT_INTERPOLATION_CONFIG;
-        const parseResult = this._htmlParser.parse(source, url, { interpolationConfig, ...options });
+        const parseResult = this._htmlParser.parse(source, url, { ...options });
         if (parseResult.errors.length) {
             return new ParseTreeResult(parseResult.rootNodes, parseResult.errors);
         }
-        return mergeTranslations(parseResult.rootNodes, this._translationBundle, interpolationConfig, [], {});
+        return mergeTranslations(parseResult.rootNodes, this._translationBundle, [], {});
     }
 }
 function createSerializer(format) {
@@ -34275,11 +34342,8 @@ class MessageBundle {
         this._locale = _locale;
         this._preserveWhitespace = _preserveWhitespace;
     }
-    updateFromTemplate(source, url, interpolationConfig) {
-        const htmlParserResult = this._htmlParser.parse(source, url, {
-            tokenizeExpansionForms: true,
-            interpolationConfig,
-        });
+    updateFromTemplate(source, url) {
+        const htmlParserResult = this._htmlParser.parse(source, url, { tokenizeExpansionForms: true });
         if (htmlParserResult.errors.length) {
             return htmlParserResult.errors;
         }
@@ -34289,7 +34353,7 @@ class MessageBundle {
         const rootNodes = this._preserveWhitespace
             ? htmlParserResult.rootNodes
             : visitAllWithSiblings(new WhitespaceVisitor(/* preserveSignificantWhitespace */ false), htmlParserResult.rootNodes);
-        const i18nParserResult = extractMessages(rootNodes, interpolationConfig, this._implicitTags, this._implicitAttrs, 
+        const i18nParserResult = extractMessages(rootNodes, this._implicitTags, this._implicitAttrs, 
         /* preserveSignificantWhitespace */ this._preserveWhitespace);
         if (i18nParserResult.errors.length) {
             return i18nParserResult.errors;
@@ -34450,7 +34514,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.0.0-next.5'));
+    definitionMap.set('version', literal('21.0.0-next.7'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('decorators', metadata.decorators);
@@ -34468,7 +34532,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.0-next.5'));
+    definitionMap.set('version', literal('21.0.0-next.7'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('resolveDeferredDeps', compileComponentMetadataAsyncResolver(dependencies));
@@ -34563,7 +34627,7 @@ function createDirectiveDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     const minVersion = getMinimumVersionForPartialOutput(meta);
     definitionMap.set('minVersion', literal(minVersion));
-    definitionMap.set('version', literal('21.0.0-next.5'));
+    definitionMap.set('version', literal('21.0.0-next.7'));
     // e.g. `type: MyDirective`
     definitionMap.set('type', meta.type.value);
     if (meta.isStandalone !== undefined) {
@@ -34833,9 +34897,6 @@ function createComponentDefinitionMap(meta, template, templateInfo) {
     if (meta.encapsulation !== ViewEncapsulation$1.Emulated) {
         definitionMap.set('encapsulation', importExpr(Identifiers.ViewEncapsulation).prop(ViewEncapsulation$1[meta.encapsulation]));
     }
-    if (meta.interpolation !== DEFAULT_INTERPOLATION_CONFIG) {
-        definitionMap.set('interpolation', literalArr([literal(meta.interpolation.start), literal(meta.interpolation.end)]));
-    }
     if (template.preserveWhitespaces === true) {
         definitionMap.set('preserveWhitespaces', literal(true));
     }
@@ -34979,7 +35040,7 @@ const MINIMUM_PARTIAL_LINKER_VERSION$4 = '12.0.0';
 function compileDeclareFactoryFunction(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$4));
-    definitionMap.set('version', literal('21.0.0-next.5'));
+    definitionMap.set('version', literal('21.0.0-next.7'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('deps', compileDependencies(meta.deps));
@@ -35014,7 +35075,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.0.0-next.5'));
+    definitionMap.set('version', literal('21.0.0-next.7'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     // Only generate providedIn property if it has a non-null value
@@ -35065,7 +35126,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.0.0-next.5'));
+    definitionMap.set('version', literal('21.0.0-next.7'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('providers', meta.providers);
@@ -35098,7 +35159,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.0-next.5'));
+    definitionMap.set('version', literal('21.0.0-next.7'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     // We only generate the keys in the metadata if the arrays contain values.
@@ -35149,7 +35210,7 @@ function compileDeclarePipeFromMetadata(meta) {
 function createPipeDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION));
-    definitionMap.set('version', literal('21.0.0-next.5'));
+    definitionMap.set('version', literal('21.0.0-next.7'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     // e.g. `type: MyPipe`
     definitionMap.set('type', meta.type.value);
@@ -35305,7 +35366,7 @@ function compileHmrUpdateCallback(definitions, constantStatements, meta) {
  * @description
  * Entry point for all public APIs of the compiler package.
  */
-const VERSION = new Version('21.0.0-next.5');
+const VERSION = new Version('21.0.0-next.7');
 
 //////////////////////////////////////
 // THIS FILE HAS GLOBAL SIDE EFFECT //