@angular/core 21.0.0-next.3 → 21.0.0-next.5

package/schematics/bundles/{project_tsconfig_paths-bRwOJEk9.cjs → project_tsconfig_paths-DX9KHLn9.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 /**
- * @license Angular v21.0.0-next.3
+ * @license Angular v21.0.0-next.5
  * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -1233,6 +1233,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) {
@@ -2007,6 +2028,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);
     }
@@ -2447,6 +2471,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) {
@@ -2851,10 +2878,6 @@ class Identifiers {
         name: 'ɵɵExternalStylesFeature',
         moduleName: CORE,
     };
-    static AnimationsFeature = {
-        name: 'ɵɵAnimationsFeature',
-        moduleName: CORE,
-    };
     static listener = { name: 'ɵɵlistener', moduleName: CORE };
     static getInheritedFactory = {
         name: 'ɵɵgetInheritedFactory',
@@ -2988,7 +3011,7 @@ function getJitStandaloneDefaultForVersion(version) {
 }
 
 // https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit
-const VERSION = 3;
+const VERSION$1 = 3;
 const JS_B64_PREFIX = '# sourceMappingURL=data:application/json;base64,';
 class SourceMapGenerator {
     file;
@@ -3082,7 +3105,7 @@ class SourceMapGenerator {
         mappings = mappings.slice(0, -1);
         return {
             'file': this.file || '',
-            'version': VERSION,
+            'version': VERSION$1,
             'sourceRoot': '',
             'sources': sources,
             'sourcesContent': sourcesContent,
@@ -3445,6 +3468,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);
@@ -4253,6 +4280,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.
@@ -4413,6 +4452,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) {
@@ -10328,7 +10368,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}`);
     }
@@ -11706,6 +11747,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.
  */
@@ -11751,7 +11802,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 {
@@ -18137,7 +18196,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) {
@@ -18232,6 +18293,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;
     }
@@ -18258,6 +18325,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();
@@ -18294,6 +18363,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;
@@ -18377,7 +18452,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:
@@ -18640,6 +18717,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) ||
@@ -18991,6 +19143,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;
@@ -19560,6 +19714,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));
@@ -19929,6 +20086,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.
      */
@@ -20142,6 +20328,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);
     }
@@ -20338,7 +20527,7 @@ const OBJECT = 'object';
 //
 // =================================================================================================
 const SCHEMA = [
-    '[Element]|textContent,%ariaAtomic,%ariaAutoComplete,%ariaBusy,%ariaChecked,%ariaColCount,%ariaColIndex,%ariaColSpan,%ariaCurrent,%ariaDescription,%ariaDisabled,%ariaExpanded,%ariaHasPopup,%ariaHidden,%ariaKeyShortcuts,%ariaLabel,%ariaLevel,%ariaLive,%ariaModal,%ariaMultiLine,%ariaMultiSelectable,%ariaOrientation,%ariaPlaceholder,%ariaPosInSet,%ariaPressed,%ariaReadOnly,%ariaRelevant,%ariaRequired,%ariaRoleDescription,%ariaRowCount,%ariaRowIndex,%ariaRowSpan,%ariaSelected,%ariaSetSize,%ariaSort,%ariaValueMax,%ariaValueMin,%ariaValueNow,%ariaValueText,%classList,className,elementTiming,id,innerHTML,*beforecopy,*beforecut,*beforepaste,*fullscreenchange,*fullscreenerror,*search,*webkitfullscreenchange,*webkitfullscreenerror,outerHTML,%part,#scrollLeft,#scrollTop,slot' +
+    '[Element]|textContent,%ariaAtomic,%ariaAutoComplete,%ariaBusy,%ariaChecked,%ariaColCount,%ariaColIndex,%ariaColSpan,%ariaCurrent,%ariaDescription,%ariaDisabled,%ariaExpanded,%ariaHasPopup,%ariaHidden,%ariaInvalid,%ariaKeyShortcuts,%ariaLabel,%ariaLevel,%ariaLive,%ariaModal,%ariaMultiLine,%ariaMultiSelectable,%ariaOrientation,%ariaPlaceholder,%ariaPosInSet,%ariaPressed,%ariaReadOnly,%ariaRelevant,%ariaRequired,%ariaRoleDescription,%ariaRowCount,%ariaRowIndex,%ariaRowSpan,%ariaSelected,%ariaSetSize,%ariaSort,%ariaValueMax,%ariaValueMin,%ariaValueNow,%ariaValueText,%classList,className,elementTiming,id,innerHTML,*beforecopy,*beforecut,*beforepaste,*fullscreenchange,*fullscreenerror,*search,*webkitfullscreenchange,*webkitfullscreenerror,outerHTML,%part,#scrollLeft,#scrollTop,slot' +
         /* added manually to avoid breaking changes */
         ',*message,*mozfullscreenchange,*mozfullscreenerror,*mozpointerlockchange,*mozpointerlockerror,*webglcontextcreationerror,*webglcontextlost,*webglcontextrestored',
     '[HTMLElement]^[Element]|accessKey,autocapitalize,!autofocus,contentEditable,dir,!draggable,enterKeyHint,!hidden,!inert,innerText,inputMode,lang,nonce,*abort,*animationend,*animationiteration,*animationstart,*auxclick,*beforexrselect,*blur,*cancel,*canplay,*canplaythrough,*change,*click,*close,*contextmenu,*copy,*cuechange,*cut,*dblclick,*drag,*dragend,*dragenter,*dragleave,*dragover,*dragstart,*drop,*durationchange,*emptied,*ended,*error,*focus,*formdata,*gotpointercapture,*input,*invalid,*keydown,*keypress,*keyup,*load,*loadeddata,*loadedmetadata,*loadstart,*lostpointercapture,*mousedown,*mouseenter,*mouseleave,*mousemove,*mouseout,*mouseover,*mouseup,*mousewheel,*paste,*pause,*play,*playing,*pointercancel,*pointerdown,*pointerenter,*pointerleave,*pointermove,*pointerout,*pointerover,*pointerrawupdate,*pointerup,*progress,*ratechange,*reset,*resize,*scroll,*securitypolicyviolation,*seeked,*seeking,*select,*selectionchange,*selectstart,*slotchange,*stalled,*submit,*suspend,*timeupdate,*toggle,*transitioncancel,*transitionend,*transitionrun,*transitionstart,*volumechange,*waiting,*webkitanimationend,*webkitanimationiteration,*webkitanimationstart,*webkittransitionend,*wheel,outerText,!spellcheck,%style,#tabIndex,title,!translate,virtualKeyboardPolicy',
@@ -23244,6 +23433,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, exports.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.
@@ -23857,7 +24067,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.
  */
@@ -24236,33 +24445,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.
  *
@@ -24273,9 +24455,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.
@@ -24287,7 +24467,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);
 }
@@ -26335,6 +26515,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 },
@@ -27181,6 +27362,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}"`);
     }
@@ -30106,184 +30290,9 @@ function makeBindingParser(interpolationConfig = DEFAULT_INTERPOLATION_CONFIG, s
     return new BindingParser(new Parser(new Lexer(), selectorlessEnabled), interpolationConfig, elementRegistry, []);
 }
 
-/*!
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.dev/license
- */
-/**
- * Visitor that traverses all template and expression AST nodes in a template.
- * Useful for cases where every single node needs to be visited.
- */
-class CombinedRecursiveAstVisitor extends RecursiveAstVisitor {
-    visit(node) {
-        if (node instanceof ASTWithSource) {
-            this.visit(node.ast);
-        }
-        else {
-            node.visit(this);
-        }
-    }
-    visitElement(element) {
-        this.visitAllTemplateNodes(element.attributes);
-        this.visitAllTemplateNodes(element.inputs);
-        this.visitAllTemplateNodes(element.outputs);
-        this.visitAllTemplateNodes(element.directives);
-        this.visitAllTemplateNodes(element.references);
-        this.visitAllTemplateNodes(element.children);
-    }
-    visitTemplate(template) {
-        this.visitAllTemplateNodes(template.attributes);
-        this.visitAllTemplateNodes(template.inputs);
-        this.visitAllTemplateNodes(template.outputs);
-        this.visitAllTemplateNodes(template.directives);
-        this.visitAllTemplateNodes(template.templateAttrs);
-        this.visitAllTemplateNodes(template.variables);
-        this.visitAllTemplateNodes(template.references);
-        this.visitAllTemplateNodes(template.children);
-    }
-    visitContent(content) {
-        this.visitAllTemplateNodes(content.children);
-    }
-    visitBoundAttribute(attribute) {
-        this.visit(attribute.value);
-    }
-    visitBoundEvent(attribute) {
-        this.visit(attribute.handler);
-    }
-    visitBoundText(text) {
-        this.visit(text.value);
-    }
-    visitIcu(icu) {
-        Object.keys(icu.vars).forEach((key) => this.visit(icu.vars[key]));
-        Object.keys(icu.placeholders).forEach((key) => this.visit(icu.placeholders[key]));
-    }
-    visitDeferredBlock(deferred) {
-        deferred.visitAll(this);
-    }
-    visitDeferredTrigger(trigger) {
-        if (trigger instanceof BoundDeferredTrigger) {
-            this.visit(trigger.value);
-        }
-    }
-    visitDeferredBlockPlaceholder(block) {
-        this.visitAllTemplateNodes(block.children);
-    }
-    visitDeferredBlockError(block) {
-        this.visitAllTemplateNodes(block.children);
-    }
-    visitDeferredBlockLoading(block) {
-        this.visitAllTemplateNodes(block.children);
-    }
-    visitSwitchBlock(block) {
-        this.visit(block.expression);
-        this.visitAllTemplateNodes(block.cases);
-    }
-    visitSwitchBlockCase(block) {
-        block.expression && this.visit(block.expression);
-        this.visitAllTemplateNodes(block.children);
-    }
-    visitForLoopBlock(block) {
-        block.item.visit(this);
-        this.visitAllTemplateNodes(block.contextVariables);
-        this.visit(block.expression);
-        this.visitAllTemplateNodes(block.children);
-        block.empty?.visit(this);
-    }
-    visitForLoopBlockEmpty(block) {
-        this.visitAllTemplateNodes(block.children);
-    }
-    visitIfBlock(block) {
-        this.visitAllTemplateNodes(block.branches);
-    }
-    visitIfBlockBranch(block) {
-        block.expression && this.visit(block.expression);
-        block.expressionAlias?.visit(this);
-        this.visitAllTemplateNodes(block.children);
-    }
-    visitLetDeclaration(decl) {
-        this.visit(decl.value);
-    }
-    visitComponent(component) {
-        this.visitAllTemplateNodes(component.attributes);
-        this.visitAllTemplateNodes(component.inputs);
-        this.visitAllTemplateNodes(component.outputs);
-        this.visitAllTemplateNodes(component.directives);
-        this.visitAllTemplateNodes(component.references);
-        this.visitAllTemplateNodes(component.children);
-    }
-    visitDirective(directive) {
-        this.visitAllTemplateNodes(directive.attributes);
-        this.visitAllTemplateNodes(directive.inputs);
-        this.visitAllTemplateNodes(directive.outputs);
-        this.visitAllTemplateNodes(directive.references);
-    }
-    visitVariable(variable) { }
-    visitReference(reference) { }
-    visitTextAttribute(attribute) { }
-    visitText(text) { }
-    visitUnknownBlock(block) { }
-    visitAllTemplateNodes(nodes) {
-        for (const node of nodes) {
-            this.visit(node);
-        }
-    }
-}
-
-/*!
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.dev/license
- */
-const ANIMATE_LEAVE$1 = `animate.leave`;
-/**
- * Analyzes a component's template to determine if it's using animate.enter
- * or animate.leave syntax.
- */
-function analyzeTemplateForAnimations(template) {
-    const analyzer = new AnimationsAnalyzer();
-    visitAll$1(analyzer, template);
-    // The template is considered selectorless only if there
-    // are direct references to directives or pipes.
-    return analyzer.hasAnimations;
-}
-/**
- * Visitor that traverses all the template nodes and
- * expressions to look for selectorless references.
- */
-class AnimationsAnalyzer extends CombinedRecursiveAstVisitor {
-    hasAnimations = false;
-    visitElement(element) {
-        // check for regular strings
-        for (const attr of element.attributes) {
-            if (attr.name === ANIMATE_LEAVE$1) {
-                this.hasAnimations = true;
-            }
-        }
-        // check for attribute bindings
-        for (const input of element.inputs) {
-            if (input.name === ANIMATE_LEAVE$1) {
-                this.hasAnimations = true;
-            }
-        }
-        // check for event bindings
-        for (const output of element.outputs) {
-            if (output.name === ANIMATE_LEAVE$1) {
-                this.hasAnimations = true;
-            }
-        }
-        super.visitElement(element);
-    }
-}
-
 const COMPONENT_VARIABLE = '%COMP%';
 const HOST_ATTR = `_nghost-${COMPONENT_VARIABLE}`;
 const CONTENT_ATTR = `_ngcontent-${COMPONENT_VARIABLE}`;
-const ANIMATE_LEAVE = `animate.leave`;
 function baseDirectiveFields(meta, constantPool, bindingParser) {
     const definitionMap = new DefinitionMap();
     const selectors = parseSelectorToR3Selector(meta.selector);
@@ -30317,11 +30326,6 @@ function baseDirectiveFields(meta, constantPool, bindingParser) {
     }
     return definitionMap;
 }
-function hasAnimationHostBinding(meta) {
-    return (meta.host.attributes[ANIMATE_LEAVE] !== undefined ||
-        meta.host.properties[ANIMATE_LEAVE] !== undefined ||
-        meta.host.listeners[ANIMATE_LEAVE] !== undefined);
-}
 /**
  * Add features to the definition map.
  */
@@ -30356,12 +30360,6 @@ function addFeatures(definitionMap, meta) {
         const externalStyleNodes = meta.externalStyles.map((externalStyle) => literal(externalStyle));
         features.push(importExpr(Identifiers.ExternalStylesFeature).callFn([literalArr(externalStyleNodes)]));
     }
-    const template = meta.template;
-    if (hasAnimationHostBinding(meta) || (template && template.nodes.length > 0)) {
-        if (hasAnimationHostBinding(meta) || analyzeTemplateForAnimations(template.nodes)) {
-            features.push(importExpr(Identifiers.AnimationsFeature).callFn([]));
-        }
-    }
     if (features.length) {
         definitionMap.set('features', literalArr(features));
     }
@@ -30802,6 +30800,132 @@ function compileDeferResolverFunction(meta) {
     return arrowFn([], literalArr(depExpressions));
 }
 
+/*!
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+/**
+ * Visitor that traverses all template and expression AST nodes in a template.
+ * Useful for cases where every single node needs to be visited.
+ */
+class CombinedRecursiveAstVisitor extends RecursiveAstVisitor {
+    visit(node) {
+        if (node instanceof ASTWithSource) {
+            this.visit(node.ast);
+        }
+        else {
+            node.visit(this);
+        }
+    }
+    visitElement(element) {
+        this.visitAllTemplateNodes(element.attributes);
+        this.visitAllTemplateNodes(element.inputs);
+        this.visitAllTemplateNodes(element.outputs);
+        this.visitAllTemplateNodes(element.directives);
+        this.visitAllTemplateNodes(element.references);
+        this.visitAllTemplateNodes(element.children);
+    }
+    visitTemplate(template) {
+        this.visitAllTemplateNodes(template.attributes);
+        this.visitAllTemplateNodes(template.inputs);
+        this.visitAllTemplateNodes(template.outputs);
+        this.visitAllTemplateNodes(template.directives);
+        this.visitAllTemplateNodes(template.templateAttrs);
+        this.visitAllTemplateNodes(template.variables);
+        this.visitAllTemplateNodes(template.references);
+        this.visitAllTemplateNodes(template.children);
+    }
+    visitContent(content) {
+        this.visitAllTemplateNodes(content.children);
+    }
+    visitBoundAttribute(attribute) {
+        this.visit(attribute.value);
+    }
+    visitBoundEvent(attribute) {
+        this.visit(attribute.handler);
+    }
+    visitBoundText(text) {
+        this.visit(text.value);
+    }
+    visitIcu(icu) {
+        Object.keys(icu.vars).forEach((key) => this.visit(icu.vars[key]));
+        Object.keys(icu.placeholders).forEach((key) => this.visit(icu.placeholders[key]));
+    }
+    visitDeferredBlock(deferred) {
+        deferred.visitAll(this);
+    }
+    visitDeferredTrigger(trigger) {
+        if (trigger instanceof BoundDeferredTrigger) {
+            this.visit(trigger.value);
+        }
+    }
+    visitDeferredBlockPlaceholder(block) {
+        this.visitAllTemplateNodes(block.children);
+    }
+    visitDeferredBlockError(block) {
+        this.visitAllTemplateNodes(block.children);
+    }
+    visitDeferredBlockLoading(block) {
+        this.visitAllTemplateNodes(block.children);
+    }
+    visitSwitchBlock(block) {
+        this.visit(block.expression);
+        this.visitAllTemplateNodes(block.cases);
+    }
+    visitSwitchBlockCase(block) {
+        block.expression && this.visit(block.expression);
+        this.visitAllTemplateNodes(block.children);
+    }
+    visitForLoopBlock(block) {
+        block.item.visit(this);
+        this.visitAllTemplateNodes(block.contextVariables);
+        this.visit(block.expression);
+        this.visitAllTemplateNodes(block.children);
+        block.empty?.visit(this);
+    }
+    visitForLoopBlockEmpty(block) {
+        this.visitAllTemplateNodes(block.children);
+    }
+    visitIfBlock(block) {
+        this.visitAllTemplateNodes(block.branches);
+    }
+    visitIfBlockBranch(block) {
+        block.expression && this.visit(block.expression);
+        block.expressionAlias?.visit(this);
+        this.visitAllTemplateNodes(block.children);
+    }
+    visitLetDeclaration(decl) {
+        this.visit(decl.value);
+    }
+    visitComponent(component) {
+        this.visitAllTemplateNodes(component.attributes);
+        this.visitAllTemplateNodes(component.inputs);
+        this.visitAllTemplateNodes(component.outputs);
+        this.visitAllTemplateNodes(component.directives);
+        this.visitAllTemplateNodes(component.references);
+        this.visitAllTemplateNodes(component.children);
+    }
+    visitDirective(directive) {
+        this.visitAllTemplateNodes(directive.attributes);
+        this.visitAllTemplateNodes(directive.inputs);
+        this.visitAllTemplateNodes(directive.outputs);
+        this.visitAllTemplateNodes(directive.references);
+    }
+    visitVariable(variable) { }
+    visitReference(reference) { }
+    visitTextAttribute(attribute) { }
+    visitText(text) { }
+    visitUnknownBlock(block) { }
+    visitAllTemplateNodes(nodes) {
+        for (const node of nodes) {
+            this.visit(node);
+        }
+    }
+}
+
 /**
  * Processes `Target`s with a given set of directives and performs a binding operation, which
  * returns an object similar to TypeScript's `ts.TypeChecker` that contains knowledge about the
@@ -32840,7 +32964,7 @@ function isAttrNode(ast) {
  * @description
  * Entry point for all public APIs of the compiler package.
  */
-new Version('21.0.0-next.3');
+const VERSION = new Version('21.0.0-next.5');
 
 //////////////////////////////////////
 // THIS FILE HAS GLOBAL SIDE EFFECT //
@@ -33388,6 +33512,21 @@ exports.ErrorCode = void 0;
      * ```
      */
     ErrorCode[ErrorCode["UNINVOKED_FUNCTION_IN_TEXT_INTERPOLATION"] = 8117] = "UNINVOKED_FUNCTION_IN_TEXT_INTERPOLATION";
+    /**
+     * A required initializer is being invoked in a forbidden context such as a property initializer
+     * or a constructor.
+     *
+     * For example:
+     * ```ts
+     * class MyComponent {
+     *  myInput = input.required();
+     *  somValue = this.myInput(); // Error
+     *
+     *  constructor() {
+     *    this.myInput(); // Error
+     *  }
+     */
+    ErrorCode[ErrorCode["FORBIDDEN_REQUIRED_INITIALIZER_INVOCATION"] = 8118] = "FORBIDDEN_REQUIRED_INITIALIZER_INVOCATION";
     /**
      * The template type-checking engine would need to generate an inline type check block for a
      * component, but the current type-checking environment doesn't support it.
@@ -33522,6 +33661,18 @@ function isFatalDiagnosticError(err) {
     return err._isFatalDiagnosticError === true;
 }
 
+/**
+ * Base URL for the error details page.
+ *
+ * Keep the files below in full sync:
+ *  - packages/compiler-cli/src/ngtsc/diagnostics/src/error_details_base_url.ts
+ *  - packages/core/src/error_details_base_url.ts
+ */
+const ERROR_DETAILS_PAGE_BASE_URL = (() => {
+    const versionSubDomain = VERSION.major !== '0' ? `v${VERSION.major}.` : '';
+    return `https://${versionSubDomain}angular.dev/errors`;
+})();
+
 /**
  * Enum holding the name of each extended template diagnostic. The name is used as a user-meaningful
  * value for configuring the diagnostic in the project's options.
@@ -33876,7 +34027,7 @@ class NodeJSPathManipulation {
 // G3-ESM-MARKER: G3 uses CommonJS, but externally everything in ESM.
 // CommonJS/ESM interop for determining the current file name and containing dir.
 const isCommonJS = typeof __filename !== 'undefined';
-const currentFileUrl = isCommonJS ? null : (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('project_tsconfig_paths-bRwOJEk9.cjs', document.baseURI).href));
+const currentFileUrl = isCommonJS ? null : (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('project_tsconfig_paths-DX9KHLn9.cjs', document.baseURI).href));
 // Note, when this code loads in the browser, `url` may be an empty `{}` due to the Closure shims.
 const currentFileName = isCommonJS
     ? __filename
@@ -38276,6 +38427,9 @@ class ExpressionTranslatorVisitor {
     visitLiteralExpr(ast, _context) {
         return this.setSourceMapRange(this.factory.createLiteral(ast.value), ast.sourceSpan);
     }
+    visitRegularExpressionLiteral(ast, context) {
+        return this.setSourceMapRange(this.factory.createRegularExpressionLiteral(ast.body, ast.flags), ast.sourceSpan);
+    }
     visitLocalizedString(ast, context) {
         // A `$localize` message consists of `messageParts` and `expressions`, which get interleaved
         // together. The interleaved pieces look like:
@@ -38773,6 +38927,9 @@ class TypeTranslatorVisitor {
     visitDynamicImportExpr(ast, context) {
         throw new Error('Method not implemented.');
     }
+    visitRegularExpressionLiteral(ast, context) {
+        throw new Error('Method not implemented.');
+    }
     visitNotExpr(ast, context) {
         throw new Error('Method not implemented.');
     }
@@ -39076,6 +39233,9 @@ class TypeScriptAstFactory {
             ts.factory.createVariableDeclaration(variableName, undefined, undefined, initializer ?? undefined),
         ], this.VAR_TYPES[type]));
     }
+    createRegularExpressionLiteral(body, flags) {
+        return ts.factory.createRegularExpressionLiteral(`/${body}/${flags ?? ''}`);
+    }
     setSourceMapRange(node, sourceMapRange) {
         if (sourceMapRange === null) {
             return node;
@@ -42475,6 +42635,10 @@ class MagicString {
 			if (chunk.outro.length) mappings.advance(chunk.outro);
 		});
 
+		if (this.outro) {
+			mappings.advance(this.outro);
+		}
+
 		return {
 			file: options.file ? options.file.split(/[/\\]/).pop() : undefined,
 			sources: [
@@ -43140,7 +43304,12 @@ class MagicString {
 		const index = original.indexOf(string);
 
 		if (index !== -1) {
-			this.overwrite(index, index + string.length, replacement);
+			if (typeof replacement === 'function') {
+				replacement = replacement(string, index, original);
+			}
+			if (string !== replacement) {
+				this.overwrite(index, index + string.length, replacement);
+			}
 		}
 
 		return this;
@@ -43163,7 +43332,11 @@ class MagicString {
 			index = original.indexOf(string, index + stringLength)
 		) {
 			const previous = original.slice(index, index + stringLength);
-			if (previous !== replacement) this.overwrite(index, index + stringLength, replacement);
+			let _replacement = replacement;
+			if (typeof replacement === 'function') {
+				_replacement = replacement(previous, index, original);
+			}
+			if (previous !== _replacement) this.overwrite(index, index + stringLength, _replacement);
 		}
 
 		return this;
@@ -44844,6 +45017,9 @@ class AstTranslator {
     visitThisReceiver(ast) {
         throw new Error('Method not implemented.');
     }
+    visitRegularExpressionLiteral(ast, context) {
+        return wrapForTypeChecker(ts.factory.createRegularExpressionLiteral(`/${ast.body}/${ast.flags ?? ''}`));
+    }
     visitInterpolation(ast) {
         // Build up a chain of binary + operations to simulate the string concatenation of the
         // interpolation's expressions. The chain is started using an actual string literal to ensure
@@ -45170,6 +45346,9 @@ class VeSafeLhsInferenceBugDetector {
     visitParenthesizedExpression(ast, context) {
         return ast.expression.visit(this);
     }
+    visitRegularExpressionLiteral(ast, context) {
+        return false;
+    }
 }
 
 /**
@@ -47871,11 +48050,17 @@ function getBoundAttributes(directive, node) {
             });
         }
     };
-    node.inputs.forEach(processAttribute);
-    node.attributes.forEach(processAttribute);
     if (node instanceof Template) {
+        if (node.tagName === 'ng-template') {
+            node.inputs.forEach(processAttribute);
+            node.attributes.forEach(processAttribute);
+        }
         node.templateAttrs.forEach(processAttribute);
     }
+    else {
+        node.inputs.forEach(processAttribute);
+        node.attributes.forEach(processAttribute);
+    }
     return boundInputs;
 }
 /**
@@ -50868,6 +51053,7 @@ exports.Directive = Directive$1;
 exports.DomElementSchemaRegistry = DomElementSchemaRegistry;
 exports.DynamicImportExpr = DynamicImportExpr;
 exports.DynamicValue = DynamicValue;
+exports.ERROR_DETAILS_PAGE_BASE_URL = ERROR_DETAILS_PAGE_BASE_URL;
 exports.Element = Element;
 exports.Element$1 = Element$1;
 exports.EnumValue = EnumValue;
@@ -50887,6 +51073,7 @@ exports.ImportManager = ImportManager;
 exports.Interpolation = Interpolation$1;
 exports.InterpolationConfig = InterpolationConfig;
 exports.InvokeFunctionExpr = InvokeFunctionExpr;
+exports.KeyedRead = KeyedRead;
 exports.KnownFn = KnownFn;
 exports.LetDeclaration = LetDeclaration$1;
 exports.LiteralArrayExpr = LiteralArrayExpr;