@angular/compiler 21.0.0-next.4 → 21.0.0-next.6

package/fesm2022/compiler.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v21.0.0-next.4
+ * @license Angular v21.0.0-next.6
  * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -1237,6 +1237,27 @@ class InstantiateExpr extends Expression {
         return new InstantiateExpr(this.classExpr.clone(), this.args.map((arg) => arg.clone()), this.type, this.sourceSpan);
     }
 }
+let RegularExpressionLiteral$1 = class RegularExpressionLiteral extends Expression {
+    body;
+    flags;
+    constructor(body, flags, sourceSpan) {
+        super(null, sourceSpan);
+        this.body = body;
+        this.flags = flags;
+    }
+    isEquivalent(e) {
+        return e instanceof RegularExpressionLiteral && this.body === e.body && this.flags === e.flags;
+    }
+    isConstant() {
+        return true;
+    }
+    visitExpression(visitor, context) {
+        return visitor.visitRegularExpressionLiteral(this, context);
+    }
+    clone() {
+        return new RegularExpressionLiteral(this.body, this.flags, this.sourceSpan);
+    }
+};
 class LiteralExpr extends Expression {
     value;
     constructor(value, type, sourceSpan) {
@@ -2030,6 +2051,9 @@ let RecursiveAstVisitor$1 = class RecursiveAstVisitor {
     visitLiteralExpr(ast, context) {
         return this.visitExpression(ast, context);
     }
+    visitRegularExpressionLiteral(ast, context) {
+        return this.visitExpression(ast, context);
+    }
     visitLocalizedString(ast, context) {
         return this.visitExpression(ast, context);
     }
@@ -2290,6 +2314,7 @@ var output_ast = /*#__PURE__*/Object.freeze({
     ReadPropExpr: ReadPropExpr,
     ReadVarExpr: ReadVarExpr,
     RecursiveAstVisitor: RecursiveAstVisitor$1,
+    RegularExpressionLiteral: RegularExpressionLiteral$1,
     ReturnStatement: ReturnStatement,
     STRING_TYPE: STRING_TYPE,
     Statement: Statement,
@@ -2565,6 +2590,9 @@ class GenericKeyFn {
         else if (expr instanceof LiteralExpr) {
             return String(expr.value);
         }
+        else if (expr instanceof RegularExpressionLiteral$1) {
+            return `/${expr.body}/${expr.flags ?? ''}`;
+        }
         else if (expr instanceof LiteralArrayExpr) {
             const entries = [];
             for (const entry of expr.entries) {
@@ -3566,6 +3594,10 @@ class AbstractEmitterVisitor {
         }
         return null;
     }
+    visitRegularExpressionLiteral(ast, ctx) {
+        ctx.print(ast, `/${ast.body}/${ast.flags || ''}`);
+        return null;
+    }
     visitLocalizedString(ast, ctx) {
         const head = ast.serializeI18nHead();
         ctx.print(ast, '$localize `' + head.raw);
@@ -4374,6 +4406,18 @@ class ParenthesizedExpression extends AST {
         return visitor.visitParenthesizedExpression(this, context);
     }
 }
+class RegularExpressionLiteral extends AST {
+    body;
+    flags;
+    constructor(span, sourceSpan, body, flags) {
+        super(span, sourceSpan);
+        this.body = body;
+        this.flags = flags;
+    }
+    visit(visitor, context) {
+        return visitor.visitRegularExpressionLiteral(this, context);
+    }
+}
 /**
  * Records the absolute position of a text span in a source file, where `start` and `end` are the
  * starting and ending byte offsets, respectively, of the text span in a source file.
@@ -4534,6 +4578,7 @@ class RecursiveAstVisitor {
     visitParenthesizedExpression(ast, context) {
         this.visit(ast.expression, context);
     }
+    visitRegularExpressionLiteral(ast, context) { }
     // This is not part of the AstVisitor interface, just a helper method
     visitAll(asts, context) {
         for (const ast of asts) {
@@ -6385,48 +6430,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;
@@ -10449,7 +10452,8 @@ function transformExpressionsInExpression(expr, transform, flags) {
     }
     else if (expr instanceof ReadVarExpr ||
         expr instanceof ExternalExpr ||
-        expr instanceof LiteralExpr) ;
+        expr instanceof LiteralExpr ||
+        expr instanceof RegularExpressionLiteral$1) ;
     else {
         throw new Error(`Unhandled expression kind: ${expr.constructor.name}`);
     }
@@ -11827,6 +11831,16 @@ function extractAttributeOp(unit, op, elements) {
     }
 }
 
+const ARIA_PREFIX = 'aria-';
+/**
+ * Returns whether `name` is an ARIA attribute name.
+ *
+ * This is a heuristic based on whether name begins with and is longer than `aria-`.
+ */
+function isAriaAttribute(name) {
+    return name.startsWith(ARIA_PREFIX) && name.length > ARIA_PREFIX.length;
+}
+
 /**
  * Looks up an element in the given map by xref ID.
  */
@@ -11872,7 +11886,15 @@ function specializeBindings(job) {
                     break;
                 case BindingKind.Property:
                 case BindingKind.LegacyAnimation:
-                    if (job.kind === CompilationJobKind.Host) {
+                    // Convert a property binding targeting an ARIA attribute (e.g. [aria-label]) into an
+                    // attribute binding when we know it can't also target an input. Note that a `Host` job is
+                    // always `DomOnly`, so this condition must be checked first.
+                    if (job.mode === TemplateCompilationMode.DomOnly && isAriaAttribute(op.name)) {
+                        OpList.replace(op, createAttributeOp(op.target, 
+                        /* namespace= */ null, op.name, op.expression, op.securityContext, 
+                        /* isTextAttribute= */ 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 {
@@ -15989,12 +16011,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;
@@ -16017,7 +16042,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 || {
@@ -16848,7 +16872,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);
@@ -16880,7 +16904,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;
@@ -16898,10 +16922,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;
                 }
@@ -17040,13 +17064,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) {
@@ -18249,7 +18270,9 @@ var TokenType;
     TokenType[TokenType["String"] = 4] = "String";
     TokenType[TokenType["Operator"] = 5] = "Operator";
     TokenType[TokenType["Number"] = 6] = "Number";
-    TokenType[TokenType["Error"] = 7] = "Error";
+    TokenType[TokenType["RegExpBody"] = 7] = "RegExpBody";
+    TokenType[TokenType["RegExpFlags"] = 8] = "RegExpFlags";
+    TokenType[TokenType["Error"] = 9] = "Error";
 })(TokenType || (TokenType = {}));
 var StringTokenKind;
 (function (StringTokenKind) {
@@ -18344,6 +18367,12 @@ class Token {
     isError() {
         return this.type === TokenType.Error;
     }
+    isRegExpBody() {
+        return this.type === TokenType.RegExpBody;
+    }
+    isRegExpFlags() {
+        return this.type === TokenType.RegExpFlags;
+    }
     toNumber() {
         return this.type === TokenType.Number ? this.numValue : -1;
     }
@@ -18358,9 +18387,6 @@ class Token {
     isTemplateLiteralInterpolationStart() {
         return this.isOperator('${');
     }
-    isTemplateLiteralInterpolationEnd() {
-        return this.isOperator('}');
-    }
     toString() {
         switch (this.type) {
             case TokenType.Character:
@@ -18370,6 +18396,8 @@ class Token {
             case TokenType.PrivateIdentifier:
             case TokenType.String:
             case TokenType.Error:
+            case TokenType.RegExpBody:
+            case TokenType.RegExpFlags:
                 return this.strValue;
             case TokenType.Number:
                 return this.numValue.toString();
@@ -18406,6 +18434,12 @@ function newNumberToken(index, end, n) {
 function newErrorToken(index, end, message) {
     return new Token(index, end, TokenType.Error, 0, message);
 }
+function newRegExpBodyToken(index, end, text) {
+    return new Token(index, end, TokenType.RegExpBody, 0, text);
+}
+function newRegExpFlagsToken(index, end, text) {
+    return new Token(index, end, TokenType.RegExpFlags, 0, text);
+}
 const EOF = new Token(-1, -1, TokenType.Character, 0, '');
 class _Scanner {
     input;
@@ -18489,7 +18523,9 @@ class _Scanner {
             case $MINUS:
                 return this.scanComplexOperator(start, '-', $EQ, '=');
             case $SLASH:
-                return this.scanComplexOperator(start, '/', $EQ, '=');
+                return this.isStartOfRegex()
+                    ? this.scanRegex(index)
+                    : this.scanComplexOperator(start, '/', $EQ, '=');
             case $PERCENT:
                 return this.scanComplexOperator(start, '%', $EQ, '=');
             case $CARET:
@@ -18533,7 +18569,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);
@@ -18752,6 +18788,81 @@ class _Scanner {
         }
         return newOperatorToken(start, this.index, operator);
     }
+    isStartOfRegex() {
+        if (this.tokens.length === 0) {
+            return true;
+        }
+        const prevToken = this.tokens[this.tokens.length - 1];
+        // If a slash is preceded by a `!` operator, we need to distinguish whether it's a
+        // negation or a non-null assertion. Regexes can only be precded by negations.
+        if (prevToken.isOperator('!')) {
+            const beforePrevToken = this.tokens.length > 1 ? this.tokens[this.tokens.length - 2] : null;
+            const isNegation = beforePrevToken === null ||
+                (beforePrevToken.type !== TokenType.Identifier &&
+                    !beforePrevToken.isCharacter($RPAREN) &&
+                    !beforePrevToken.isCharacter($RBRACKET));
+            return isNegation;
+        }
+        // Only consider the slash a regex if it's preceded either by:
+        // - Any operator, aside from `!` which is special-cased above.
+        // - Opening paren (e.g. `(/a/)`).
+        // - Opening bracket (e.g. `[/a/]`).
+        // - A comma (e.g. `[1, /a/]`).
+        // - A colon (e.g. `{foo: /a/}`).
+        return (prevToken.type === TokenType.Operator ||
+            prevToken.isCharacter($LPAREN) ||
+            prevToken.isCharacter($LBRACKET) ||
+            prevToken.isCharacter($COMMA) ||
+            prevToken.isCharacter($COLON));
+    }
+    scanRegex(tokenStart) {
+        this.advance();
+        const textStart = this.index;
+        let inEscape = false;
+        let inCharacterClass = false;
+        while (true) {
+            const peek = this.peek;
+            if (peek === $EOF) {
+                return this.error('Unterminated regular expression', 0);
+            }
+            if (inEscape) {
+                inEscape = false;
+            }
+            else if (peek === $BACKSLASH) {
+                inEscape = true;
+            }
+            else if (peek === $LBRACKET) {
+                inCharacterClass = true;
+            }
+            else if (peek === $RBRACKET) {
+                inCharacterClass = false;
+            }
+            else if (peek === $SLASH && !inCharacterClass) {
+                break;
+            }
+            this.advance();
+        }
+        // Note that we want the text without the slashes,
+        // but we still want the slashes to be part of the span.
+        const value = this.input.substring(textStart, this.index);
+        this.advance();
+        const bodyToken = newRegExpBodyToken(tokenStart, this.index, value);
+        const flagsToken = this.scanRegexFlags(this.index);
+        if (flagsToken !== null) {
+            this.tokens.push(bodyToken);
+            return flagsToken;
+        }
+        return bodyToken;
+    }
+    scanRegexFlags(start) {
+        if (!isAsciiLetter(this.peek)) {
+            return null;
+        }
+        while (isAsciiLetter(this.peek)) {
+            this.advance();
+        }
+        return newRegExpFlagsToken(start, this.index, this.input.substring(start, this.index));
+    }
 }
 function isIdentifierStart(code) {
     return (($a <= code && code <= $z) ||
@@ -18822,17 +18933,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) {
@@ -18841,17 +18952,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();
@@ -18891,9 +19002,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 = [];
@@ -18940,7 +19051,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 = [];
@@ -18950,7 +19061,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 {{
@@ -19029,24 +19141,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));
         }
     }
     /**
@@ -19103,6 +19215,8 @@ var ParseContextFlags;
      */
     ParseContextFlags[ParseContextFlags["Writable"] = 1] = "Writable";
 })(ParseContextFlags || (ParseContextFlags = {}));
+/** Possible flags that can be used in a regex literal. */
+const SUPPORTED_REGEX_FLAGS = new Set(['d', 'g', 'i', 'm', 's', 'u', 'v', 'y']);
 class _ParseAST {
     input;
     parseSourceSpan;
@@ -19672,6 +19786,9 @@ class _ParseAST {
             this._reportErrorForPrivateIdentifier(this.next, null);
             return new EmptyExpr$1(this.span(start), this.sourceSpan(start));
         }
+        else if (this.next.isRegExpBody()) {
+            return this.parseRegularExpressionLiteral();
+        }
         else if (this.index >= this.tokens.length) {
             this.error(`Unexpected end of expression: ${this.input}`);
             return new EmptyExpr$1(this.span(start), this.sourceSpan(start));
@@ -20027,6 +20144,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');
@@ -20034,6 +20152,7 @@ class _ParseAST {
                 else {
                     expressions.push(expression);
                 }
+                this.rbracesExpected--;
             }
             else {
                 this.advance();
@@ -20041,6 +20160,35 @@ class _ParseAST {
         }
         return new TemplateLiteral(this.span(start), this.sourceSpan(start), elements, expressions);
     }
+    parseRegularExpressionLiteral() {
+        const bodyToken = this.next;
+        this.advance();
+        if (!bodyToken.isRegExpBody()) {
+            return new EmptyExpr$1(this.span(this.inputIndex), this.sourceSpan(this.inputIndex));
+        }
+        let flagsToken = null;
+        if (this.next.isRegExpFlags()) {
+            flagsToken = this.next;
+            this.advance();
+            const seenFlags = new Set();
+            for (let i = 0; i < flagsToken.strValue.length; i++) {
+                const char = flagsToken.strValue[i];
+                if (!SUPPORTED_REGEX_FLAGS.has(char)) {
+                    this.error(`Unsupported regular expression flag "${char}". The supported flags are: ` +
+                        Array.from(SUPPORTED_REGEX_FLAGS, (f) => `"${f}"`).join(', '), flagsToken.index + i);
+                }
+                else if (seenFlags.has(char)) {
+                    this.error(`Duplicate regular expression flag "${char}"`, flagsToken.index + i);
+                }
+                else {
+                    seenFlags.add(char);
+                }
+            }
+        }
+        const start = bodyToken.index;
+        const end = flagsToken ? flagsToken.end : bodyToken.end;
+        return new RegularExpressionLiteral(this.span(start, end), this.sourceSpan(start, end), bodyToken.strValue, flagsToken ? flagsToken.strValue : null);
+    }
     /**
      * Consume the optional statement terminator: semicolon or comma.
      */
@@ -20254,6 +20402,9 @@ class SerializeExpressionVisitor {
     visitVoidExpression(ast, context) {
         return `void ${ast.expression.visit(this, context)}`;
     }
+    visitRegularExpressionLiteral(ast, context) {
+        return `/${ast.body}/${ast.flags || ''}`;
+    }
     visitASTWithSource(ast, context) {
         return ast.ast.visit(this, context);
     }
@@ -21175,10 +21326,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) {
@@ -21186,13 +21337,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;
@@ -21414,7 +21563,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);
     }
 }
@@ -21479,6 +21628,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 '*'.
@@ -21540,7 +21734,6 @@ const setI18nRefs = (originalNodeMap) => {
  * stored with other element's and attribute's information.
  */
 class I18nMetaVisitor {
-    interpolationConfig;
     keepI18nAttrs;
     enableI18nLegacyMessageIdFormat;
     containerBlocks;
@@ -21549,7 +21742,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
@@ -21557,7 +21750,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;
@@ -21566,7 +21758,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);
@@ -23356,6 +23548,27 @@ function transformLiteralMap(expr) {
     return new PureFunctionExpr(literalMap(derivedEntries), nonConstantArgs);
 }
 
+/** Optimizes regular expressions used in expressions. */
+function optimizeRegularExpressions(job) {
+    for (const view of job.units) {
+        for (const op of view.ops()) {
+            transformExpressionsInOp(op, (expr) => {
+                if (expr instanceof RegularExpressionLiteral$1 &&
+                    // We can't optimize global regexes, because they're stateful.
+                    (expr.flags === null || !expr.flags.includes('g'))) {
+                    return job.pool.getSharedConstant(new RegularExpressionConstant(), expr);
+                }
+                return expr;
+            }, VisitorContextFlag.None);
+        }
+    }
+}
+class RegularExpressionConstant extends GenericKeyFn {
+    toSharedConstantDeclaration(declName, keyExpr) {
+        return new DeclareVarStmt(declName, keyExpr, undefined, StmtModifier.Final);
+    }
+}
+
 // This file contains helpers for generating calls to Ivy instructions. In particular, each
 // instruction type is represented as a function, which may select a specific instruction variant
 // depending on the exact arguments.
@@ -23969,7 +24182,6 @@ function callVariadicInstruction(config, baseArgs, interpolationArgs, extraArgs,
     return createStatementOp(callVariadicInstructionExpr(config, baseArgs, interpolationArgs, extraArgs, sourceSpan).toStmt());
 }
 
-const ARIA_PREFIX = 'aria';
 /**
  * Map of target resolvers for event listeners.
  */
@@ -24348,33 +24560,6 @@ function reifyUpdateOperations(unit, ops) {
         }
     }
 }
-/**
- * Converts an ARIA property name to its corresponding attribute name, if necessary.
- *
- * For example, converts `ariaLabel` to `aria-label`.
- *
- * https://www.w3.org/TR/wai-aria-1.2/#accessibilityroleandproperties-correspondence
- *
- * This must be kept in sync with the the function of the same name in
- * packages/core/src/render3/instructions/aria_property.ts.
- *
- * @param name A property name that starts with `aria`.
- * @returns The corresponding attribute name.
- */
-function ariaAttrName(name) {
-    return name.charAt(ARIA_PREFIX.length) !== '-'
-        ? ARIA_PREFIX + '-' + name.slice(ARIA_PREFIX.length).toLowerCase()
-        : name; // Property already has attribute name.
-}
-/**
- * Returns whether `name` is an ARIA property (or attribute) name.
- *
- * This is a heuristic based on whether name begins with and is longer than `aria`. For example,
- * this returns true for both `ariaLabel` and `aria-label`.
- */
-function isAriaProperty(name) {
-    return name.startsWith(ARIA_PREFIX) && name.length > ARIA_PREFIX.length;
-}
 /**
  * Reifies a DOM property binding operation.
  *
@@ -24385,9 +24570,7 @@ function isAriaProperty(name) {
  * @returns A statement to update the property at runtime.
  */
 function reifyDomProperty(op) {
-    return isAriaProperty(op.name)
-        ? attribute(ariaAttrName(op.name), op.expression, null, null, op.sourceSpan)
-        : domProperty(DOM_PROPERTY_REMAPPING.get(op.name) ?? op.name, op.expression, op.sanitizer, op.sourceSpan);
+    return domProperty(DOM_PROPERTY_REMAPPING.get(op.name) ?? op.name, op.expression, op.sanitizer, op.sourceSpan);
 }
 /**
  * Reifies a property binding operation.
@@ -24399,7 +24582,7 @@ function reifyDomProperty(op) {
  * @returns A statement to update the property at runtime.
  */
 function reifyProperty(op) {
-    return isAriaProperty(op.name)
+    return isAriaAttribute(op.name)
         ? ariaProperty(op.name, op.expression, op.sourceSpan)
         : property(op.name, op.expression, op.sanitizer, op.sourceSpan);
 }
@@ -26447,6 +26630,7 @@ function wrapI18nIcus(job) {
  */
 const phases = [
     { kind: CompilationJobKind.Tmpl, fn: removeContentSelectors },
+    { kind: CompilationJobKind.Both, fn: optimizeRegularExpressions },
     { kind: CompilationJobKind.Host, fn: parseHostStyleProperties },
     { kind: CompilationJobKind.Tmpl, fn: emitNamespaceChanges },
     { kind: CompilationJobKind.Tmpl, fn: propagateI18nBlocks },
@@ -27293,6 +27477,9 @@ function convertAst(ast, job, baseSourceSpan) {
     else if (ast instanceof ParenthesizedExpression) {
         return new ParenthesizedExpr(convertAst(ast.expression, job, baseSourceSpan), undefined, convertSourceSpan(ast.span, baseSourceSpan));
     }
+    else if (ast instanceof RegularExpressionLiteral) {
+        return new RegularExpressionLiteral$1(ast.body, ast.flags, baseSourceSpan);
+    }
     else {
         throw new Error(`Unhandled expression type "${ast.constructor.name}" in file "${baseSourceSpan?.start.file.url}"`);
     }
@@ -27898,18 +28085,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)) {
@@ -27953,7 +28135,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);
             }
@@ -28125,8 +28307,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);
             }
@@ -28261,7 +28443,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);
             }
@@ -29527,6 +29709,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) {
@@ -30111,9 +30300,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,
@@ -30127,7 +30316,6 @@ function parseTemplate(template, templateUrl, options = {}) {
         parseResult.errors &&
         parseResult.errors.length > 0) {
         const parsedTemplate = {
-            interpolationConfig,
             preserveWhitespaces,
             errors: parseResult.errors,
             nodes: [],
@@ -30150,7 +30338,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);
@@ -30158,7 +30346,6 @@ function parseTemplate(template, templateUrl, options = {}) {
         i18nMetaResult.errors &&
         i18nMetaResult.errors.length > 0) {
         const parsedTemplate = {
-            interpolationConfig,
             preserveWhitespaces,
             errors: i18nMetaResult.errors,
             nodes: [],
@@ -30193,7 +30380,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, 
@@ -30203,7 +30390,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,
@@ -30220,8 +30406,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%';
@@ -31943,7 +32129,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,
@@ -31955,7 +32141,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,
@@ -31973,7 +32158,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);
     }
@@ -32179,7 +32364,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) {
@@ -32214,7 +32399,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,
@@ -32258,15 +32442,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}`);
@@ -32275,7 +32453,6 @@ function parseJitTemplate(template, typeName, sourceMapUrl, preserveWhitespaces,
     const boundTarget = binder.bind({ template: parsed.nodes });
     return {
         template: parsed,
-        interpolation: interpolationConfig,
         defer: createR3ComponentDeferMetadata(boundTarget, deferBlockDependencies),
     };
 }
@@ -32513,13 +32690,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;
@@ -32574,8 +32751,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');
@@ -32585,8 +32762,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);
@@ -32691,7 +32868,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;
@@ -32701,7 +32878,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.
@@ -34044,12 +34221,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) {
@@ -34086,11 +34262,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;
         }
@@ -34100,7 +34273,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;
@@ -34261,7 +34434,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.4'));
+    definitionMap.set('version', literal('21.0.0-next.6'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('decorators', metadata.decorators);
@@ -34279,7 +34452,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.4'));
+    definitionMap.set('version', literal('21.0.0-next.6'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('resolveDeferredDeps', compileComponentMetadataAsyncResolver(dependencies));
@@ -34374,7 +34547,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.4'));
+    definitionMap.set('version', literal('21.0.0-next.6'));
     // e.g. `type: MyDirective`
     definitionMap.set('type', meta.type.value);
     if (meta.isStandalone !== undefined) {
@@ -34644,9 +34817,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));
     }
@@ -34790,7 +34960,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.4'));
+    definitionMap.set('version', literal('21.0.0-next.6'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('deps', compileDependencies(meta.deps));
@@ -34825,7 +34995,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.4'));
+    definitionMap.set('version', literal('21.0.0-next.6'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     // Only generate providedIn property if it has a non-null value
@@ -34876,7 +35046,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.4'));
+    definitionMap.set('version', literal('21.0.0-next.6'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('providers', meta.providers);
@@ -34909,7 +35079,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.4'));
+    definitionMap.set('version', literal('21.0.0-next.6'));
     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.
@@ -34960,7 +35130,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.4'));
+    definitionMap.set('version', literal('21.0.0-next.6'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     // e.g. `type: MyPipe`
     definitionMap.set('type', meta.type.value);
@@ -35116,7 +35286,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.4');
+const VERSION = new Version('21.0.0-next.6');
 
 //////////////////////////////////////
 // THIS FILE HAS GLOBAL SIDE EFFECT //
@@ -35142,5 +35312,5 @@ const VERSION = new Version('21.0.0-next.4');
 // the late binding of the Compiler to the @angular/core for jit compilation.
 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, DEFAULT_INTERPOLATION_CONFIG, 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, InterpolationConfig, 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, 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, DEFAULT_INTERPOLATION_CONFIG, 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, InterpolationConfig, 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, 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 };
 //# sourceMappingURL=compiler.mjs.map