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

package/fesm2022/compiler.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v21.0.0-next.7
+ * @license Angular v21.0.0-next.9
  * (c) 2010-2025 Google LLC. https://angular.dev/
  * License: MIT
  */
@@ -3026,6 +3026,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 };
@@ -4959,9 +4969,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 {
@@ -8786,14 +8798,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 = {}));
@@ -11779,7 +11791,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));
@@ -11943,7 +11955,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 {
@@ -16522,7 +16534,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());
@@ -23829,7 +23841,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);
@@ -24420,11 +24432,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 = [];
@@ -24432,9 +24463,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;
@@ -27310,6 +27341,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);
     }
@@ -27640,9 +27674,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 === BindingType.Property && input.name === 'control') {
+        if (input.type === BindingType.Property && input.name === 'field') {
             unit.create.push(createControlCreateOp(input.sourceSpan));
         }
     }
@@ -28827,6 +28861,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);
         }
     }
@@ -28926,6 +28961,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(',');
@@ -29136,6 +29178,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)?$/;
@@ -29191,7 +29239,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);
@@ -29203,9 +29251,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();
     }
 }
@@ -29223,25 +29272,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;
@@ -29315,10 +29366,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}"`);
@@ -29336,15 +29387,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;
             }
@@ -29363,14 +29414,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) {
@@ -29382,10 +29433,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);
@@ -29418,7 +29470,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}"`);
     }
@@ -29430,17 +29482,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.
@@ -29458,6 +29554,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`);
     }
@@ -29487,6 +29589,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/;
@@ -29517,7 +29638,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;
@@ -29639,19 +29760,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);
@@ -31080,6 +31201,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);
@@ -34514,7 +34638,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.7'));
+    definitionMap.set('version', literal('21.0.0-next.9'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('decorators', metadata.decorators);
@@ -34532,7 +34656,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.7'));
+    definitionMap.set('version', literal('21.0.0-next.9'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('resolveDeferredDeps', compileComponentMetadataAsyncResolver(dependencies));
@@ -34627,7 +34751,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.7'));
+    definitionMap.set('version', literal('21.0.0-next.9'));
     // e.g. `type: MyDirective`
     definitionMap.set('type', meta.type.value);
     if (meta.isStandalone !== undefined) {
@@ -35040,7 +35164,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.7'));
+    definitionMap.set('version', literal('21.0.0-next.9'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('deps', compileDependencies(meta.deps));
@@ -35075,7 +35199,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.7'));
+    definitionMap.set('version', literal('21.0.0-next.9'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     // Only generate providedIn property if it has a non-null value
@@ -35126,7 +35250,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.7'));
+    definitionMap.set('version', literal('21.0.0-next.9'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('providers', meta.providers);
@@ -35159,7 +35283,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.7'));
+    definitionMap.set('version', literal('21.0.0-next.9'));
     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.
@@ -35210,7 +35334,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.7'));
+    definitionMap.set('version', literal('21.0.0-next.9'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     // e.g. `type: MyPipe`
     definitionMap.set('type', meta.type.value);
@@ -35366,7 +35490,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.7');
+const VERSION = new Version('21.0.0-next.9');
 
 //////////////////////////////////////
 // THIS FILE HAS GLOBAL SIDE EFFECT //