@angular/core 21.0.0-next.7 → 21.0.0-next.9

package/schematics/bundles/{project_tsconfig_paths-BbVhi4fG.cjs → project_tsconfig_paths-CiBzGSIa.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 /**
- * @license Angular v21.0.0-next.7
+ * @license Angular v21.0.0-next.9
  * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -2907,6 +2907,16 @@ class Identifiers {
         name: 'ɵɵvalidateIframeAttribute',
         moduleName: CORE,
     };
+    // Decorators
+    static inputDecorator = { name: 'Input', moduleName: CORE };
+    static outputDecorator = { name: 'Output', moduleName: CORE };
+    static viewChildDecorator = { name: 'ViewChild', moduleName: CORE };
+    static viewChildrenDecorator = { name: 'ViewChildren', moduleName: CORE };
+    static contentChildDecorator = { name: 'ContentChild', moduleName: CORE };
+    static contentChildrenDecorator = {
+        name: 'ContentChildren',
+        moduleName: CORE,
+    };
     // type-checking
     static InputSignalBrandWriteType = { name: 'ɵINPUT_SIGNAL_BRAND_WRITE_TYPE', moduleName: CORE };
     static UnwrapDirectiveSignalInputs = { name: 'ɵUnwrapDirectiveSignalInputs', moduleName: CORE };
@@ -4833,9 +4843,11 @@ class InteractionDeferredTrigger extends DeferredTrigger {
 }
 class ViewportDeferredTrigger extends DeferredTrigger {
     reference;
-    constructor(reference, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan) {
+    options;
+    constructor(reference, options, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan) {
         super(nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan);
         this.reference = reference;
+        this.options = options;
     }
 }
 class BlockNode {
@@ -8660,14 +8672,14 @@ var OpKind;
      */
     OpKind[OpKind["AnimationListener"] = 56] = "AnimationListener";
     /**
-     * An operation to bind an expression to a `control` property of an element.
+     * An operation to bind an expression to a `field` property of an element.
      */
     OpKind[OpKind["Control"] = 57] = "Control";
     /**
      * An operation to set up a corresponding {@link Control} operation.
      *
      * This is responsible for setting up event listeners on a native or custom form control when
-     * bound to a specialized control directive.
+     * bound to a specialized field directive.
      */
     OpKind[OpKind["ControlCreate"] = 58] = "ControlCreate";
 })(OpKind || (OpKind = {}));
@@ -11653,7 +11665,7 @@ function extractAttributes(job) {
                 case OpKind.Control:
                     OpList.insertBefore(
                     // Deliberately null i18nMessage value
-                    createExtractedAttributeOp(op.target, BindingKind.Property, null, 'control', 
+                    createExtractedAttributeOp(op.target, BindingKind.Property, null, 'field', 
                     /* expression */ null, 
                     /* i18nContext */ null, 
                     /* i18nMessage */ null, op.securityContext), lookupElement$3(elements, op.target));
@@ -11817,7 +11829,7 @@ function specializeBindings(job) {
                     else if (job.kind === CompilationJobKind.Host) {
                         OpList.replace(op, createDomPropertyOp(op.name, op.expression, op.bindingKind, op.i18nContext, op.securityContext, op.sourceSpan));
                     }
-                    else if (op.name === 'control') {
+                    else if (op.name === 'field') {
                         OpList.replace(op, createControlOp(op));
                     }
                     else {
@@ -16405,7 +16417,7 @@ class _Tokenizer {
             this._cursor.advance();
             try {
                 const charCode = parseInt(strNum, isHex ? 16 : 10);
-                this._endToken([String.fromCharCode(charCode), this._cursor.getChars(start)]);
+                this._endToken([String.fromCodePoint(charCode), this._cursor.getChars(start)]);
             }
             catch {
                 throw this._createError(_unknownEntityErrorMsg(this._cursor.getChars(start)), this._cursor.getSpan());
@@ -23669,7 +23681,7 @@ function deferOn(trigger, args, modifier, sourceSpan) {
     if (instructionToCall === undefined) {
         throw new Error(`Unable to determine instruction for trigger ${trigger}`);
     }
-    return call(instructionToCall, args.map((a) => literal(a)), sourceSpan);
+    return call(instructionToCall, args, sourceSpan);
 }
 function projectionDef(def) {
     return call(Identifiers.projectionDef, def ? [def] : [], null);
@@ -24260,11 +24272,30 @@ function reifyCreateOperations(unit, ops) {
                     case DeferTriggerKind.Immediate:
                         break;
                     case DeferTriggerKind.Timer:
-                        args = [op.trigger.delay];
+                        args = [literal(op.trigger.delay)];
+                        break;
+                    case DeferTriggerKind.Viewport:
+                        // `hydrate` triggers don't support targets.
+                        if (op.modifier === "hydrate" /* ir.DeferOpModifierKind.HYDRATE */) {
+                            args = op.trigger.options ? [op.trigger.options] : [];
+                        }
+                        else {
+                            // The slots not being defined at this point is invalid, however we
+                            // catch it during type checking. Pass in null in such cases.
+                            args = [literal(op.trigger.targetSlot?.slot ?? null)];
+                            if (op.trigger.targetSlotViewSteps !== 0) {
+                                args.push(literal(op.trigger.targetSlotViewSteps));
+                            }
+                            else if (op.trigger.options) {
+                                args.push(literal(null));
+                            }
+                            if (op.trigger.options) {
+                                args.push(op.trigger.options);
+                            }
+                        }
                         break;
                     case DeferTriggerKind.Interaction:
                     case DeferTriggerKind.Hover:
-                    case DeferTriggerKind.Viewport:
                         // `hydrate` triggers don't support targets.
                         if (op.modifier === "hydrate" /* ir.DeferOpModifierKind.HYDRATE */) {
                             args = [];
@@ -24272,9 +24303,9 @@ function reifyCreateOperations(unit, ops) {
                         else {
                             // The slots not being defined at this point is invalid, however we
                             // catch it during type checking. Pass in null in such cases.
-                            args = [op.trigger.targetSlot?.slot ?? null];
+                            args = [literal(op.trigger.targetSlot?.slot ?? null)];
                             if (op.trigger.targetSlotViewSteps !== 0) {
-                                args.push(op.trigger.targetSlotViewSteps);
+                                args.push(literal(op.trigger.targetSlotViewSteps));
                             }
                         }
                         break;
@@ -27150,6 +27181,9 @@ function ingestDeferTriggers(modifier, triggers, onOps, whenOps, unit, deferXref
             targetSlot: null,
             targetView: null,
             targetSlotViewSteps: null,
+            options: triggers.viewport.options
+                ? convertAst(triggers.viewport.options, unit.job, triggers.viewport.sourceSpan)
+                : null,
         }, modifier, triggers.viewport.sourceSpan);
         onOps.push(deferOnOp);
     }
@@ -27480,9 +27514,9 @@ function ingestElementBindings(unit, op, element) {
         }
         // All dynamic bindings (both attribute and property bindings).
         bindings.push(createBindingOp(op.xref, BINDING_KINDS.get(input.type), input.name, convertAstWithInterpolation(unit.job, astOf(input.value), input.i18n), input.unit, input.securityContext, false, false, null, asMessage(input.i18n) ?? null, input.sourceSpan));
-        // If the input name is 'control', this could be a form control binding which requires a
+        // If the input name is 'field', this could be a form control binding which requires a
         // `ControlCreateOp` to properly initialize.
-        if (input.type === exports.BindingType.Property && input.name === 'control') {
+        if (input.type === exports.BindingType.Property && input.name === 'field') {
             unit.create.push(createControlCreateOp(input.sourceSpan));
         }
     }
@@ -28661,6 +28695,7 @@ function createForLoop(ast, connectedBlocks, visitor, bindingParser) {
             // main `for` body, use `mainSourceSpan`.
             const endSpan = empty?.endSourceSpan ?? ast.endSourceSpan;
             const sourceSpan = new ParseSourceSpan(ast.sourceSpan.start, endSpan?.end ?? ast.sourceSpan.end);
+            validateTrackByExpression(params.trackBy.expression, params.trackBy.keywordSpan, errors);
             node = new ForLoopBlock(params.itemName, params.expression, params.trackBy.expression, params.trackBy.keywordSpan, params.context, visitAll(visitor, ast.children, ast.children), empty, sourceSpan, ast.sourceSpan, ast.startSourceSpan, endSpan, ast.nameSpan, ast.i18n);
         }
     }
@@ -28760,6 +28795,13 @@ function parseForLoopParameters(block, errors, bindingParser) {
     }
     return result;
 }
+function validateTrackByExpression(expression, parseSourceSpan, errors) {
+    const visitor = new PipeVisitor();
+    expression.ast.visit(visitor);
+    if (visitor.hasPipe) {
+        errors.push(new ParseError(parseSourceSpan, 'Cannot use pipes in track expressions'));
+    }
+}
 /** Parses the `let` parameter of a `for` loop block. */
 function parseLetParameter(sourceSpan, expression, span, loopItemName, context, errors) {
     const parts = expression.split(',');
@@ -28970,6 +29012,12 @@ function stripOptionalParentheses(param, errors) {
     }
     return expression.slice(start, end);
 }
+class PipeVisitor extends RecursiveAstVisitor {
+    hasPipe = false;
+    visitPipe() {
+        this.hasPipe = true;
+    }
+}
 
 /** Pattern for a timing value in a trigger. */
 const TIME_PATTERN = /^\d+\.?\d*(ms|s)?$/;
@@ -29025,7 +29073,7 @@ function parseWhenTrigger({ expression, sourceSpan }, bindingParser, triggers, e
     }
 }
 /** Parses an `on` trigger */
-function parseOnTrigger({ expression, sourceSpan }, triggers, errors, placeholder) {
+function parseOnTrigger({ expression, sourceSpan }, bindingParser, triggers, errors, placeholder) {
     const onIndex = expression.indexOf('on');
     const onSourceSpan = new ParseSourceSpan(sourceSpan.start.moveBy(onIndex), sourceSpan.start.moveBy(onIndex + 'on'.length));
     const prefetchSpan = getPrefetchSpan(expression, sourceSpan);
@@ -29037,9 +29085,10 @@ function parseOnTrigger({ expression, sourceSpan }, triggers, errors, placeholde
     }
     else {
         const start = getTriggerParametersStart(expression, onIndex + 1);
-        const parser = new OnTriggerParser(expression, start, sourceSpan, triggers, errors, expression.startsWith('hydrate')
+        const isHydrationTrigger = expression.startsWith('hydrate');
+        const parser = new OnTriggerParser(expression, bindingParser, start, sourceSpan, triggers, errors, isHydrationTrigger
             ? validateHydrateReferenceBasedTrigger
-            : validatePlainReferenceBasedTrigger, placeholder, prefetchSpan, onSourceSpan, hydrateSpan);
+            : validatePlainReferenceBasedTrigger, isHydrationTrigger, prefetchSpan, onSourceSpan, hydrateSpan);
         parser.parse();
     }
 }
@@ -29057,25 +29106,27 @@ function getHydrateSpan(expression, sourceSpan) {
 }
 class OnTriggerParser {
     expression;
+    bindingParser;
     start;
     span;
     triggers;
     errors;
     validator;
-    placeholder;
+    isHydrationTrigger;
     prefetchSpan;
     onSourceSpan;
     hydrateSpan;
     index = 0;
     tokens;
-    constructor(expression, start, span, triggers, errors, validator, placeholder, prefetchSpan, onSourceSpan, hydrateSpan) {
+    constructor(expression, bindingParser, start, span, triggers, errors, validator, isHydrationTrigger, prefetchSpan, onSourceSpan, hydrateSpan) {
         this.expression = expression;
+        this.bindingParser = bindingParser;
         this.start = start;
         this.span = span;
         this.triggers = triggers;
         this.errors = errors;
         this.validator = validator;
-        this.placeholder = placeholder;
+        this.isHydrationTrigger = isHydrationTrigger;
         this.prefetchSpan = prefetchSpan;
         this.onSourceSpan = onSourceSpan;
         this.hydrateSpan = hydrateSpan;
@@ -29149,10 +29200,10 @@ class OnTriggerParser {
                     this.trackTrigger('immediate', createImmediateTrigger(parameters, nameSpan, sourceSpan, this.prefetchSpan, this.onSourceSpan, this.hydrateSpan));
                     break;
                 case OnTriggerType.HOVER:
-                    this.trackTrigger('hover', createHoverTrigger(parameters, nameSpan, sourceSpan, this.prefetchSpan, this.onSourceSpan, this.hydrateSpan, this.placeholder, this.validator));
+                    this.trackTrigger('hover', createHoverTrigger(parameters, nameSpan, sourceSpan, this.prefetchSpan, this.onSourceSpan, this.hydrateSpan, this.validator));
                     break;
                 case OnTriggerType.VIEWPORT:
-                    this.trackTrigger('viewport', createViewportTrigger(parameters, nameSpan, sourceSpan, this.prefetchSpan, this.onSourceSpan, this.hydrateSpan, this.validator));
+                    this.trackTrigger('viewport', createViewportTrigger(this.start, this.isHydrationTrigger, this.bindingParser, parameters, nameSpan, sourceSpan, this.prefetchSpan, this.onSourceSpan, this.hydrateSpan, this.validator));
                     break;
                 default:
                     throw new Error(`Unrecognized trigger type "${identifier}"`);
@@ -29170,15 +29221,15 @@ class OnTriggerParser {
         }
         this.advance();
         const commaDelimStack = [];
-        let current = '';
+        let tokens = [];
         while (this.index < this.tokens.length) {
             const token = this.token();
             // Stop parsing if we've hit the end character and we're outside of a comma-delimited syntax.
             // Note that we don't need to account for strings here since the lexer already parsed them
             // into string tokens.
             if (token.isCharacter($RPAREN) && commaDelimStack.length === 0) {
-                if (current.length) {
-                    parameters.push(current);
+                if (tokens.length) {
+                    parameters.push({ expression: this.tokenRangeText(tokens), start: tokens[0].index });
                 }
                 break;
             }
@@ -29197,14 +29248,14 @@ class OnTriggerParser {
             }
             // If we hit a comma outside of a comma-delimited syntax, it means
             // that we're at the top level and we're starting a new parameter.
-            if (commaDelimStack.length === 0 && token.isCharacter($COMMA) && current.length > 0) {
-                parameters.push(current);
-                current = '';
+            if (commaDelimStack.length === 0 && token.isCharacter($COMMA) && tokens.length > 0) {
+                parameters.push({ expression: this.tokenRangeText(tokens), start: tokens[0].index });
                 this.advance();
+                tokens = [];
                 continue;
             }
             // Otherwise treat the token as a plain text character in the current parameter.
-            current += this.tokenText();
+            tokens.push(token);
             this.advance();
         }
         if (!this.token().isCharacter($RPAREN) || commaDelimStack.length > 0) {
@@ -29216,10 +29267,11 @@ class OnTriggerParser {
         }
         return parameters;
     }
-    tokenText() {
-        // Tokens have a toString already which we could use, but for string tokens it omits the quotes.
-        // Eventually we could expose this information on the token directly.
-        return this.expression.slice(this.start + this.token().index, this.start + this.token().end);
+    tokenRangeText(tokens) {
+        if (tokens.length === 0) {
+            return '';
+        }
+        return this.expression.slice(this.start + tokens[0].index, this.start + tokens[tokens.length - 1].end);
     }
     trackTrigger(name, trigger) {
         trackTrigger(name, this.triggers, this.errors, trigger);
@@ -29252,7 +29304,7 @@ function createTimerTrigger(parameters, nameSpan, sourceSpan, prefetchSpan, onSo
     if (parameters.length !== 1) {
         throw new Error(`"${OnTriggerType.TIMER}" trigger must have exactly one parameter`);
     }
-    const delay = parseDeferredTime(parameters[0]);
+    const delay = parseDeferredTime(parameters[0].expression);
     if (delay === null) {
         throw new Error(`Could not parse time value of trigger "${OnTriggerType.TIMER}"`);
     }
@@ -29264,17 +29316,61 @@ function createImmediateTrigger(parameters, nameSpan, sourceSpan, prefetchSpan,
     }
     return new ImmediateDeferredTrigger(nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan);
 }
-function createHoverTrigger(parameters, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan, placeholder, validator) {
+function createHoverTrigger(parameters, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan, validator) {
     validator(OnTriggerType.HOVER, parameters);
-    return new HoverDeferredTrigger(parameters[0] ?? null, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan);
+    return new HoverDeferredTrigger(parameters[0]?.expression ?? null, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan);
 }
 function createInteractionTrigger(parameters, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan, validator) {
     validator(OnTriggerType.INTERACTION, parameters);
-    return new InteractionDeferredTrigger(parameters[0] ?? null, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan);
+    return new InteractionDeferredTrigger(parameters[0]?.expression ?? null, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan);
 }
-function createViewportTrigger(parameters, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan, validator) {
+function createViewportTrigger(start, isHydrationTrigger, bindingParser, parameters, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan, validator) {
     validator(OnTriggerType.VIEWPORT, parameters);
-    return new ViewportDeferredTrigger(parameters[0] ?? null, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan);
+    let reference;
+    let options;
+    if (parameters.length === 0) {
+        reference = options = null;
+    }
+    else if (!parameters[0].expression.startsWith('{')) {
+        reference = parameters[0].expression;
+        options = null;
+    }
+    else {
+        const parsed = bindingParser.parseBinding(parameters[0].expression, false, sourceSpan, sourceSpan.start.offset + start + parameters[0].start);
+        if (!(parsed.ast instanceof LiteralMap)) {
+            throw new Error('Options parameter of the "viewport" trigger must be an object literal');
+        }
+        else if (parsed.ast.keys.some((key) => key.key === 'root')) {
+            throw new Error('The "root" option is not supported in the options parameter of the "viewport" trigger');
+        }
+        const triggerIndex = parsed.ast.keys.findIndex((key) => key.key === 'trigger');
+        if (triggerIndex === -1) {
+            reference = null;
+            options = parsed.ast;
+        }
+        else {
+            const value = parsed.ast.values[triggerIndex];
+            const triggerFilter = (_, index) => index !== triggerIndex;
+            if (!(value instanceof PropertyRead) ||
+                !(value.receiver instanceof ImplicitReceiver) ||
+                value.receiver instanceof ThisReceiver) {
+                throw new Error(`"trigger" option of the "viewport" trigger must be an identifier`);
+            }
+            reference = value.name;
+            options = new LiteralMap(parsed.ast.span, parsed.ast.sourceSpan, parsed.ast.keys.filter(triggerFilter), parsed.ast.values.filter(triggerFilter));
+        }
+    }
+    if (isHydrationTrigger && reference !== null) {
+        throw new Error(`"viewport" hydration trigger cannot have a "trigger"`);
+    }
+    else if (options) {
+        const dynamicNode = DynamicAstValidator.findDynamicNode(options);
+        if (dynamicNode !== null) {
+            throw new Error(`Options of the "viewport" trigger must be an object ` +
+                `literal containing only literal values, but "${dynamicNode.constructor.name}" was found`);
+        }
+    }
+    return new ViewportDeferredTrigger(reference, options, nameSpan, sourceSpan, prefetchSpan, onSourceSpan, hydrateSpan);
 }
 /**
  * Checks whether the structure of a non-hydrate reference-based trigger is valid.
@@ -29292,6 +29388,12 @@ function validatePlainReferenceBasedTrigger(type, parameters) {
  * @param parameters Parameters of the trigger.
  */
 function validateHydrateReferenceBasedTrigger(type, parameters) {
+    if (type === OnTriggerType.VIEWPORT) {
+        if (parameters.length > 1) {
+            throw new Error(`Hydration trigger "${type}" cannot have more than one parameter`);
+        }
+        return;
+    }
     if (parameters.length > 0) {
         throw new Error(`Hydration trigger "${type}" cannot have parameters`);
     }
@@ -29321,6 +29423,25 @@ function parseDeferredTime(value) {
     const [time, units] = match;
     return parseFloat(time) * (units === 's' ? 1000 : 1);
 }
+class DynamicAstValidator extends RecursiveAstVisitor {
+    dynamicNode = null;
+    static findDynamicNode(ast) {
+        const visitor = new DynamicAstValidator();
+        visitor.visit(ast);
+        return visitor.dynamicNode;
+    }
+    visit(ast) {
+        if (!(ast instanceof ASTWithSource) &&
+            !(ast instanceof LiteralPrimitive) &&
+            !(ast instanceof LiteralArray) &&
+            !(ast instanceof LiteralMap)) {
+            this.dynamicNode = ast;
+        }
+        else {
+            super.visit(ast);
+        }
+    }
+}
 
 /** Pattern to identify a `prefetch when` trigger. */
 const PREFETCH_WHEN_PATTERN = /^prefetch\s+when\s/;
@@ -29351,7 +29472,7 @@ function isConnectedDeferLoopBlock(name) {
 function createDeferredBlock(ast, connectedBlocks, visitor, bindingParser) {
     const errors = [];
     const { placeholder, loading, error } = parseConnectedBlocks(connectedBlocks, errors, visitor);
-    const { triggers, prefetchTriggers, hydrateTriggers } = parsePrimaryTriggers(ast, bindingParser, errors, placeholder);
+    const { triggers, prefetchTriggers, hydrateTriggers } = parsePrimaryTriggers(ast, bindingParser, errors);
     // The `defer` block has a main span encompassing all of the connected branches as well.
     let lastEndSourceSpan = ast.endSourceSpan;
     let endOfLastSourceSpan = ast.sourceSpan.end;
@@ -29473,19 +29594,19 @@ function parsePrimaryTriggers(ast, bindingParser, errors, placeholder) {
             parseWhenTrigger(param, bindingParser, triggers, errors);
         }
         else if (ON_PARAMETER_PATTERN.test(param.expression)) {
-            parseOnTrigger(param, triggers, errors, placeholder);
+            parseOnTrigger(param, bindingParser, triggers, errors);
         }
         else if (PREFETCH_WHEN_PATTERN.test(param.expression)) {
             parseWhenTrigger(param, bindingParser, prefetchTriggers, errors);
         }
         else if (PREFETCH_ON_PATTERN.test(param.expression)) {
-            parseOnTrigger(param, prefetchTriggers, errors, placeholder);
+            parseOnTrigger(param, bindingParser, prefetchTriggers, errors);
         }
         else if (HYDRATE_WHEN_PATTERN.test(param.expression)) {
             parseWhenTrigger(param, bindingParser, hydrateTriggers, errors);
         }
         else if (HYDRATE_ON_PATTERN.test(param.expression)) {
-            parseOnTrigger(param, hydrateTriggers, errors, placeholder);
+            parseOnTrigger(param, bindingParser, hydrateTriggers, errors);
         }
         else if (HYDRATE_NEVER_PATTERN.test(param.expression)) {
             parseNeverTrigger(param, hydrateTriggers, errors);
@@ -30895,6 +31016,9 @@ class CombinedRecursiveAstVisitor extends RecursiveAstVisitor {
         if (trigger instanceof BoundDeferredTrigger) {
             this.visit(trigger.value);
         }
+        else if (trigger instanceof ViewportDeferredTrigger && trigger.options !== null) {
+            this.visit(trigger.options);
+        }
     }
     visitDeferredBlockPlaceholder(block) {
         this.visitAllTemplateNodes(block.children);
@@ -32989,7 +33113,7 @@ function isAttrNode(ast) {
  * @description
  * Entry point for all public APIs of the compiler package.
  */
-const VERSION = new Version('21.0.0-next.7');
+const VERSION = new Version('21.0.0-next.9');
 
 //////////////////////////////////////
 // THIS FILE HAS GLOBAL SIDE EFFECT //
@@ -33156,6 +33280,11 @@ exports.ErrorCode = void 0;
      * Raised for `@Component` fields that aren't supported in a selectorless context.
      */
     ErrorCode[ErrorCode["UNSUPPORTED_SELECTORLESS_COMPONENT_FIELD"] = 2026] = "UNSUPPORTED_SELECTORLESS_COMPONENT_FIELD";
+    /**
+     * A component is using both the `animations` property and `animate.enter` or `animate.leave`
+     * in the template.
+     */
+    ErrorCode[ErrorCode["COMPONENT_ANIMATIONS_CONFLICT"] = 2027] = "COMPONENT_ANIMATIONS_CONFLICT";
     ErrorCode[ErrorCode["SYMBOL_NOT_EXPORTED"] = 3001] = "SYMBOL_NOT_EXPORTED";
     /**
      * Raised when a relationship between directives and/or pipes would cause a cyclic import to be
@@ -33365,6 +33494,12 @@ exports.ErrorCode = void 0;
      * ```
      */
     ErrorCode[ErrorCode["DEFER_IMPLICIT_TRIGGER_INVALID_PLACEHOLDER"] = 8020] = "DEFER_IMPLICIT_TRIGGER_INVALID_PLACEHOLDER";
+    /**
+     * Raised when an `@defer` block defines unreachable or redundant triggers.
+     * Examples: multiple main triggers, 'on immediate' together with other mains or any prefetch,
+     * prefetch timer delay that is not earlier than the main timer, or an identical prefetch
+     */
+    ErrorCode[ErrorCode["DEFER_TRIGGER_MISCONFIGURATION"] = 8021] = "DEFER_TRIGGER_MISCONFIGURATION";
     /**
      * A two way binding in a template has an incorrect syntax,
      * parentheses outside brackets. For example:
@@ -33726,6 +33861,7 @@ exports.ExtendedTemplateDiagnosticName = void 0;
     ExtendedTemplateDiagnosticName["UNUSED_STANDALONE_IMPORTS"] = "unusedStandaloneImports";
     ExtendedTemplateDiagnosticName["UNPARENTHESIZED_NULLISH_COALESCING"] = "unparenthesizedNullishCoalescing";
     ExtendedTemplateDiagnosticName["UNINVOKED_FUNCTION_IN_TEXT_INTERPOLATION"] = "uninvokedFunctionInTextInterpolation";
+    ExtendedTemplateDiagnosticName["DEFER_TRIGGER_MISCONFIGURATION"] = "deferTriggerMisconfiguration";
 })(exports.ExtendedTemplateDiagnosticName || (exports.ExtendedTemplateDiagnosticName = {}));
 
 /**
@@ -34052,7 +34188,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-BbVhi4fG.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-CiBzGSIa.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
@@ -34080,6 +34216,9 @@ class NodeJSReadonlyFileSystem extends NodeJSPathManipulation {
         return fs$1.readFileSync(path, 'utf8');
     }
     readFileBuffer(path) {
+        // TODO: go/ts59upgrade - Remove the suppression after TS 5.9.2 upgrade
+        //   TS2322: Type 'Buffer' is not assignable to type 'Uint8Array<ArrayBufferLike>'.
+        // @ts-ignore
         return fs$1.readFileSync(path);
     }
     readdir(path) {
@@ -40455,6 +40594,120 @@ function parseFieldStringArrayValue(directive, field, evaluator) {
     }
     return value;
 }
+/**
+ * Returns a function that can be used to extract data for the `setClassMetadata`
+ * calls from undecorated directive class members.
+ */
+function getDirectiveUndecoratedMetadataExtractor(reflector, importTracker) {
+    return (member) => {
+        const input = tryParseSignalInputMapping(member, reflector, importTracker);
+        if (input !== null) {
+            return getDecoratorMetaArray([
+                [new ExternalExpr(Identifiers.inputDecorator), memberMetadataFromSignalInput(input)],
+            ]);
+        }
+        const output = tryParseInitializerBasedOutput(member, reflector, importTracker);
+        if (output !== null) {
+            return getDecoratorMetaArray([
+                [
+                    new ExternalExpr(Identifiers.outputDecorator),
+                    memberMetadataFromInitializerOutput(output.metadata),
+                ],
+            ]);
+        }
+        const model = tryParseSignalModelMapping(member, reflector, importTracker);
+        if (model !== null) {
+            return getDecoratorMetaArray([
+                [
+                    new ExternalExpr(Identifiers.inputDecorator),
+                    memberMetadataFromSignalInput(model.input),
+                ],
+                [
+                    new ExternalExpr(Identifiers.outputDecorator),
+                    memberMetadataFromInitializerOutput(model.output),
+                ],
+            ]);
+        }
+        const query = tryParseSignalQueryFromInitializer(member, reflector, importTracker);
+        if (query !== null) {
+            let identifier;
+            if (query.name === 'viewChild') {
+                identifier = Identifiers.viewChildDecorator;
+            }
+            else if (query.name === 'viewChildren') {
+                identifier = Identifiers.viewChildrenDecorator;
+            }
+            else if (query.name === 'contentChild') {
+                identifier = Identifiers.contentChildDecorator;
+            }
+            else if (query.name === 'contentChildren') {
+                identifier = Identifiers.contentChildrenDecorator;
+            }
+            else {
+                return null;
+            }
+            return getDecoratorMetaArray([
+                [new ExternalExpr(identifier), memberMetadataFromSignalQuery(query.call)],
+            ]);
+        }
+        return null;
+    };
+}
+function getDecoratorMetaArray(decorators) {
+    return new LiteralArrayExpr(decorators.map(([type, args]) => literalMap([
+        { key: 'type', value: type, quoted: false },
+        { key: 'args', value: args, quoted: false },
+    ])));
+}
+function memberMetadataFromSignalInput(input) {
+    // Note that for signal inputs the transform is captured in the signal
+    // initializer so we don't need to capture it here.
+    return new LiteralArrayExpr([
+        literalMap([
+            {
+                key: 'isSignal',
+                value: literal(true),
+                quoted: false,
+            },
+            {
+                key: 'alias',
+                value: literal(input.bindingPropertyName),
+                quoted: false,
+            },
+            {
+                key: 'required',
+                value: literal(input.required),
+                quoted: false,
+            },
+        ]),
+    ]);
+}
+function memberMetadataFromInitializerOutput(output) {
+    return new LiteralArrayExpr([literal(output.bindingPropertyName)]);
+}
+function memberMetadataFromSignalQuery(call) {
+    const firstArg = call.arguments[0];
+    const firstArgMeta = ts.isStringLiteralLike(firstArg) || ts.isCallExpression(firstArg)
+        ? new WrappedNodeExpr(firstArg)
+        : // If the first argument is a class reference, we need to wrap it in a `forwardRef`
+            // because the reference might occur after the current class. This wouldn't be flagged
+            // on the query initializer, because it executes after the class is initialized, whereas
+            // `setClassMetadata` runs immediately.
+            new ExternalExpr(Identifiers.forwardRef).callFn([
+                new ArrowFunctionExpr([], new WrappedNodeExpr(firstArg)),
+            ]);
+    const entries = [
+        // We use wrapped nodes here, because the output AST doesn't support spread assignments.
+        firstArgMeta,
+        new WrappedNodeExpr(ts.factory.createObjectLiteralExpression([
+            ...(call.arguments.length > 1
+                ? [ts.factory.createSpreadAssignment(call.arguments[1])]
+                : []),
+            ts.factory.createPropertyAssignment('isSignal', ts.factory.createTrue()),
+        ])),
+    ];
+    return new LiteralArrayExpr(entries);
+}
 function isStringArrayOrDie(value, name, node) {
     if (!Array.isArray(value)) {
         return false;
@@ -44775,10 +45028,10 @@ class OutOfBandDiagnosticRecorderImpl {
         this._diagnostics.push(makeTemplateDiagnostic(id, this.resolver.getTemplateSourceMapping(id), node.keySpan || node.sourceSpan, ts.DiagnosticCategory.Error, ngErrorCode(exports.ErrorCode.UNCLAIMED_DIRECTIVE_BINDING), errorMsg));
     }
     deferImplicitTriggerMissingPlaceholder(id, trigger) {
-        this._diagnostics.push(makeTemplateDiagnostic(id, this.resolver.getTemplateSourceMapping(id), trigger.sourceSpan, ts.DiagnosticCategory.Error, ngErrorCode(exports.ErrorCode.DEFER_IMPLICIT_TRIGGER_MISSING_PLACEHOLDER), 'Trigger with no parameters can only be placed on an @defer that has a @placeholder block'));
+        this._diagnostics.push(makeTemplateDiagnostic(id, this.resolver.getTemplateSourceMapping(id), trigger.sourceSpan, ts.DiagnosticCategory.Error, ngErrorCode(exports.ErrorCode.DEFER_IMPLICIT_TRIGGER_MISSING_PLACEHOLDER), 'Trigger with no target can only be placed on an @defer that has a @placeholder block'));
     }
     deferImplicitTriggerInvalidPlaceholder(id, trigger) {
-        this._diagnostics.push(makeTemplateDiagnostic(id, this.resolver.getTemplateSourceMapping(id), trigger.sourceSpan, ts.DiagnosticCategory.Error, ngErrorCode(exports.ErrorCode.DEFER_IMPLICIT_TRIGGER_INVALID_PLACEHOLDER), 'Trigger with no parameters can only be placed on an @defer that has a ' +
+        this._diagnostics.push(makeTemplateDiagnostic(id, this.resolver.getTemplateSourceMapping(id), trigger.sourceSpan, ts.DiagnosticCategory.Error, ngErrorCode(exports.ErrorCode.DEFER_IMPLICIT_TRIGGER_INVALID_PLACEHOLDER), 'Trigger with no target can only be placed on an @defer that has a ' +
             '@placeholder block with exactly one root element node'));
     }
 }
@@ -46996,6 +47249,28 @@ class TcbForOfOp extends TcbOp {
         return null;
     }
 }
+/**
+ * A `TcbOp` which can be used to type check the options of an `IntersectionObserver`.
+ */
+class TcbIntersectionObserverOp extends TcbOp {
+    tcb;
+    scope;
+    options;
+    constructor(tcb, scope, options) {
+        super();
+        this.tcb = tcb;
+        this.scope = scope;
+        this.options = options;
+    }
+    optional = false;
+    execute() {
+        const options = tcbExpression(this.options, this.tcb, this.scope);
+        const callback = ts.factory.createNonNullExpression(ts.factory.createNull());
+        const expression = ts.factory.createNewExpression(ts.factory.createIdentifier('IntersectionObserver'), undefined, [callback, options]);
+        this.scope.addStatement(ts.factory.createExpressionStatement(expression));
+        return null;
+    }
+}
 /**
  * Overall generation context for the type check block.
  *
@@ -47767,6 +48042,9 @@ class Scope {
         if (triggers.when !== undefined) {
             this.opQueue.push(new TcbExpressionOp(this.tcb, this, triggers.when.value));
         }
+        if (triggers.viewport !== undefined && triggers.viewport.options !== null) {
+            this.opQueue.push(new TcbIntersectionObserverOp(this.tcb, this, triggers.viewport.options));
+        }
         if (triggers.hover !== undefined) {
             this.validateReferenceBasedDeferredTrigger(block, triggers.hover);
         }
@@ -49737,6 +50015,9 @@ class TemplateTypeCheckerImpl {
         const { data } = this.getLatestComponentState(directive, optimizeFor);
         return data?.hostElement ?? null;
     }
+    getDirectivesOfNode(component, node) {
+        return (this.getLatestComponentState(component).data?.boundTarget.getDirectivesOfNode(node) ?? null);
+    }
     getUsedDirectives(component) {
         return this.getLatestComponentState(component).data?.boundTarget.getUsedDirectives() ?? null;
     }
@@ -51072,6 +51353,7 @@ exports.Declaration = Declaration;
 exports.DeclareFunctionStmt = DeclareFunctionStmt;
 exports.DeclareVarStmt = DeclareVarStmt;
 exports.DefaultImportTracker = DefaultImportTracker;
+exports.DeferredBlock = DeferredBlock;
 exports.DefinitionMap = DefinitionMap;
 exports.Directive = Directive$1;
 exports.DomElementSchemaRegistry = DomElementSchemaRegistry;
@@ -51086,14 +51368,17 @@ exports.FatalDiagnosticError = FatalDiagnosticError;
 exports.FnParam = FnParam;
 exports.ForLoopBlock = ForLoopBlock;
 exports.FunctionExpr = FunctionExpr;
+exports.HoverDeferredTrigger = HoverDeferredTrigger;
 exports.HtmlParser = HtmlParser;
 exports.INPUT_INITIALIZER_FN = INPUT_INITIALIZER_FN;
 exports.Icu = Icu;
 exports.IcuPlaceholder = IcuPlaceholder;
 exports.Identifiers = Identifiers;
 exports.IfBlock = IfBlock;
+exports.ImmediateDeferredTrigger = ImmediateDeferredTrigger;
 exports.ImplicitReceiver = ImplicitReceiver;
 exports.ImportManager = ImportManager;
+exports.InteractionDeferredTrigger = InteractionDeferredTrigger;
 exports.Interpolation = Interpolation$1;
 exports.InvokeFunctionExpr = InvokeFunctionExpr;
 exports.KeyedRead = KeyedRead;
@@ -51148,6 +51433,7 @@ exports.Text$1 = Text$1;
 exports.Text$2 = Text$2;
 exports.TextAttribute = TextAttribute;
 exports.ThisReceiver = ThisReceiver;
+exports.TimerDeferredTrigger = TimerDeferredTrigger;
 exports.Trait = Trait;
 exports.TypeCheckShimGenerator = TypeCheckShimGenerator;
 exports.TypeScriptReflectionHost = TypeScriptReflectionHost;
@@ -51155,6 +51441,7 @@ exports.UNSAFE_OBJECT_KEY_NAME_REGEXP = UNSAFE_OBJECT_KEY_NAME_REGEXP;
 exports.UnifiedModulesStrategy = UnifiedModulesStrategy;
 exports.Variable = Variable;
 exports.Version = Version;
+exports.ViewportDeferredTrigger = ViewportDeferredTrigger;
 exports.WhitespaceVisitor = WhitespaceVisitor;
 exports.WrappedNodeExpr = WrappedNodeExpr;
 exports.Xmb = Xmb;
@@ -51210,6 +51497,7 @@ exports.getConstructorDependencies = getConstructorDependencies;
 exports.getContainingImportDeclaration = getContainingImportDeclaration;
 exports.getDefaultImportDeclaration = getDefaultImportDeclaration;
 exports.getDirectiveDiagnostics = getDirectiveDiagnostics;
+exports.getDirectiveUndecoratedMetadataExtractor = getDirectiveUndecoratedMetadataExtractor;
 exports.getFileSystem = getFileSystem;
 exports.getOriginNodeForDiagnostics = getOriginNodeForDiagnostics;
 exports.getProjectTsConfigPaths = getProjectTsConfigPaths;