@angular/core 18.0.0-next.1 → 18.0.0-next.2

package/schematics/migrations/block-template-entities/bundle.js

@@ -1871,12 +1871,12 @@ var ConstantPool = class {
       if (isArrow && current instanceof DeclareVarStmt && ((_a2 = current.value) == null ? void 0 : _a2.isEquivalent(fn2))) {
         return variable(current.name);
       }
-      if (!isArrow && current instanceof DeclareFunctionStmt && fn2.isEquivalent(current)) {
+      if (!isArrow && current instanceof DeclareFunctionStmt && fn2 instanceof FunctionExpr && fn2.isEquivalent(current)) {
         return variable(current.name);
       }
     }
     const name = useUniqueName ? this.uniqueName(prefix) : prefix;
-    this.statements.push(fn2.toDeclStmt(name, StmtModifier.Final));
+    this.statements.push(fn2 instanceof FunctionExpr ? fn2.toDeclStmt(name, StmtModifier.Final) : new DeclareVarStmt(name, fn2, INFERRED_TYPE, StmtModifier.Final, fn2.sourceSpan));
     return variable(name);
   }
   _getLiteralFactory(key, values, resultMap) {
@@ -2502,6 +2502,9 @@ var Identifiers = _Identifiers;
 (() => {
   _Identifiers.declareClassMetadata = { name: "\u0275\u0275ngDeclareClassMetadata", moduleName: CORE };
 })();
+(() => {
+  _Identifiers.declareClassMetadataAsync = { name: "\u0275\u0275ngDeclareClassMetadataAsync", moduleName: CORE };
+})();
 (() => {
   _Identifiers.setClassMetadata = { name: "\u0275setClassMetadata", moduleName: CORE };
 })();
@@ -4301,9 +4304,10 @@ var Template = class {
   }
 };
 var Content = class {
-  constructor(selector, attributes, sourceSpan, i18n2) {
+  constructor(selector, attributes, children, sourceSpan, i18n2) {
     this.selector = selector;
     this.attributes = attributes;
+    this.children = children;
     this.sourceSpan = sourceSpan;
     this.i18n = i18n2;
     this.name = "ng-content";
@@ -7563,18 +7567,21 @@ function createProjectionDefOp(def) {
     def
   }, NEW_OP);
 }
-function createProjectionOp(xref, selector, i18nPlaceholder, sourceSpan) {
-  return __spreadValues(__spreadValues({
+function createProjectionOp(xref, selector, i18nPlaceholder, fallbackView, sourceSpan) {
+  return __spreadProps(__spreadValues(__spreadValues({
     kind: OpKind.Projection,
     xref,
     handle: new SlotHandle(),
     selector,
     i18nPlaceholder,
+    fallbackView,
     projectionSlotIndex: 0,
     attributes: null,
     localRefs: [],
     sourceSpan
-  }, NEW_OP), TRAIT_CONSUMES_SLOT);
+  }, NEW_OP), TRAIT_CONSUMES_SLOT), {
+    numSlotsUsed: fallbackView === null ? 1 : 2
+  });
 }
 function createExtractedAttributeOp(target, bindingKind, namespace, name, expression, i18nContext, i18nMessage, securityContext) {
   return __spreadValues({
@@ -9120,6 +9127,11 @@ function recursivelyProcessView(view, parentScope) {
       case OpKind.Template:
         recursivelyProcessView(view.job.views.get(op.xref), scope);
         break;
+      case OpKind.Projection:
+        if (op.fallbackView !== null) {
+          recursivelyProcessView(view.job.views.get(op.fallbackView), scope);
+        }
+        break;
       case OpKind.RepeaterCreate:
         recursivelyProcessView(view.job.views.get(op.xref), scope);
         if (op.emptyView) {
@@ -15741,6 +15753,18 @@ function addNamesToView(unit, baseName, state, compatibility) {
         }
         addNamesToView(unit.job.views.get(op.xref), `${baseName}_${op.functionNameSuffix}_${op.handle.slot + 1}`, state, compatibility);
         break;
+      case OpKind.Projection:
+        if (!(unit instanceof ViewCompilationUnit)) {
+          throw new Error(`AssertionError: must be compiling a component`);
+        }
+        if (op.handle.slot === null) {
+          throw new Error(`Expected slot to be assigned`);
+        }
+        if (op.fallbackView !== null) {
+          const fallbackView = unit.job.views.get(op.fallbackView);
+          addNamesToView(fallbackView, `${baseName}_ProjectionFallback_${op.handle.slot}`, state, compatibility);
+        }
+        break;
       case OpKind.Template:
         if (!(unit instanceof ViewCompilationUnit)) {
           throw new Error(`AssertionError: must be compiling a component`);
@@ -16407,13 +16431,19 @@ function deferOn(trigger, args, prefetch, sourceSpan) {
 function projectionDef(def) {
   return call(Identifiers.projectionDef, def ? [def] : [], null);
 }
-function projection(slot, projectionSlotIndex, attributes, sourceSpan) {
+function projection(slot, projectionSlotIndex, attributes, fallbackFnName, fallbackDecls, fallbackVars, sourceSpan) {
   const args = [literal(slot)];
-  if (projectionSlotIndex !== 0 || attributes !== null) {
+  if (projectionSlotIndex !== 0 || attributes !== null || fallbackFnName !== null) {
     args.push(literal(projectionSlotIndex));
     if (attributes !== null) {
       args.push(attributes);
     }
+    if (fallbackFnName !== null) {
+      if (attributes === null) {
+        args.push(literal(null));
+      }
+      args.push(variable(fallbackFnName), literal(fallbackDecls), literal(fallbackVars));
+    }
   }
   return call(Identifiers.projection, args, sourceSpan);
 }
@@ -16916,7 +16946,25 @@ function reifyCreateOperations(unit, ops) {
         if (op.handle.slot === null) {
           throw new Error("No slot was assigned for project instruction");
         }
-        OpList.replace(op, projection(op.handle.slot, op.projectionSlotIndex, op.attributes, op.sourceSpan));
+        let fallbackViewFnName = null;
+        let fallbackDecls = null;
+        let fallbackVars = null;
+        if (op.fallbackView !== null) {
+          if (!(unit instanceof ViewCompilationUnit)) {
+            throw new Error(`AssertionError: must be compiling a component`);
+          }
+          const fallbackView = unit.job.views.get(op.fallbackView);
+          if (fallbackView === void 0) {
+            throw new Error("AssertionError: projection had fallback view xref, but fallback view was not found");
+          }
+          if (fallbackView.fnName === null || fallbackView.decls === null || fallbackView.vars === null) {
+            throw new Error(`AssertionError: expected projection fallback view to have been named and counted`);
+          }
+          fallbackViewFnName = fallbackView.fnName;
+          fallbackDecls = fallbackView.decls;
+          fallbackVars = fallbackView.vars;
+        }
+        OpList.replace(op, projection(op.handle.slot, op.projectionSlotIndex, op.attributes, fallbackViewFnName, fallbackDecls, fallbackVars, op.sourceSpan));
         break;
       case OpKind.RepeaterCreate:
         if (op.handle.slot === null) {
@@ -17863,6 +17911,7 @@ function optimizeTrackFns(job) {
       } else if (op.track instanceof ReadVarExpr && op.track.name === "$item") {
         op.trackByFn = importExpr(Identifiers.repeaterTrackByIdentity);
       } else if (isTrackByFunctionCall(job.root.xref, op.track)) {
+        op.usesComponentInstance = true;
         if (op.track.receiver.receiver.view === unit.xref) {
           op.trackByFn = op.track.receiver;
         } else {
@@ -17907,7 +17956,7 @@ function generateTrackVariables(job) {
       }
       op.track = transformExpressionsInExpression(op.track, (expr) => {
         if (expr instanceof LexicalReadExpr) {
-          if (expr.name === op.varNames.$index) {
+          if (op.varNames.$index.has(expr.name)) {
             return variable("$index");
           } else if (expr.name === op.varNames.$implicit) {
             return variable("$item");
@@ -18624,10 +18673,17 @@ function ingestTemplate(unit, tmpl) {
   }
 }
 function ingestContent(unit, content) {
+  var _a2;
   if (content.i18n !== void 0 && !(content.i18n instanceof TagPlaceholder)) {
     throw Error(`Unhandled i18n metadata type for element: ${content.i18n.constructor.name}`);
   }
-  const op = createProjectionOp(unit.job.allocateXrefId(), content.selector, content.i18n, content.sourceSpan);
+  const id = unit.job.allocateXrefId();
+  let fallbackView = null;
+  if (content.children.some((child) => !(child instanceof Comment) && (!(child instanceof Text) || child.value.trim().length > 0))) {
+    fallbackView = unit.job.allocateView(unit.xref);
+    ingestNodes(fallbackView, content.children);
+  }
+  const op = createProjectionOp(id, content.selector, content.i18n, (_a2 = fallbackView == null ? void 0 : fallbackView.xref) != null ? _a2 : null, content.sourceSpan);
   for (const attr of content.attributes) {
     const securityContext = domSchema.securityContext(content.name, attr.name, true);
     unit.update.push(createBindingOp(op.xref, BindingKind.Attribute, attr.name, literal(attr.value), null, securityContext, true, false, null, asMessage(attr.i18n), attr.sourceSpan));
@@ -18666,10 +18722,7 @@ function ingestIfBlock(unit, ifBlock) {
   for (let i = 0; i < ifBlock.branches.length; i++) {
     const ifCase = ifBlock.branches[i];
     const cView = unit.job.allocateView(unit.xref);
-    let tagName = null;
-    if (i === 0) {
-      tagName = ingestControlFlowInsertionPoint(unit, cView.xref, ifCase);
-    }
+    const tagName = ingestControlFlowInsertionPoint(unit, cView.xref, ifCase);
     if (ifCase.expressionAlias !== null) {
       cView.contextVariables.set(ifCase.expressionAlias.name, CTX_REF);
     }
@@ -18704,6 +18757,7 @@ function ingestSwitchBlock(unit, switchBlock) {
   let conditions = [];
   for (const switchCase of switchBlock.cases) {
     const cView = unit.job.allocateView(unit.xref);
+    const tagName = ingestControlFlowInsertionPoint(unit, cView.xref, switchCase);
     let switchCaseI18nMeta = void 0;
     if (switchCase.i18n !== void 0) {
       if (!(switchCase.i18n instanceof BlockPlaceholder)) {
@@ -18711,7 +18765,7 @@ function ingestSwitchBlock(unit, switchBlock) {
       }
       switchCaseI18nMeta = switchCase.i18n;
     }
-    const templateOp = createTemplateOp(cView.xref, TemplateKind.Block, null, "Case", Namespace.HTML, switchCaseI18nMeta, switchCase.startSourceSpan, switchCase.sourceSpan);
+    const templateOp = createTemplateOp(cView.xref, TemplateKind.Block, tagName, "Case", Namespace.HTML, switchCaseI18nMeta, switchCase.startSourceSpan, switchCase.sourceSpan);
     unit.create.push(templateOp);
     if (firstXref === null) {
       firstXref = cView.xref;
@@ -18845,37 +18899,27 @@ function ingestIcu(unit, icu) {
 function ingestForBlock(unit, forBlock) {
   var _a2, _b2, _c2;
   const repeaterView = unit.job.allocateView(unit.xref);
+  const indexName = `\u0275$index_${repeaterView.xref}`;
+  const countName = `\u0275$count_${repeaterView.xref}`;
+  const indexVarNames = /* @__PURE__ */ new Set();
   repeaterView.contextVariables.set(forBlock.item.name, forBlock.item.value);
-  repeaterView.contextVariables.set(forBlock.contextVariables.$index.name, forBlock.contextVariables.$index.value);
-  repeaterView.contextVariables.set(forBlock.contextVariables.$count.name, forBlock.contextVariables.$count.value);
-  const indexName = `\u0275${forBlock.contextVariables.$index.name}_${repeaterView.xref}`;
-  const countName = `\u0275${forBlock.contextVariables.$count.name}_${repeaterView.xref}`;
-  repeaterView.contextVariables.set(indexName, forBlock.contextVariables.$index.value);
-  repeaterView.contextVariables.set(countName, forBlock.contextVariables.$count.value);
-  repeaterView.aliases.add({
-    kind: SemanticVariableKind.Alias,
-    name: null,
-    identifier: forBlock.contextVariables.$first.name,
-    expression: new LexicalReadExpr(indexName).identical(literal(0))
-  });
-  repeaterView.aliases.add({
-    kind: SemanticVariableKind.Alias,
-    name: null,
-    identifier: forBlock.contextVariables.$last.name,
-    expression: new LexicalReadExpr(indexName).identical(new LexicalReadExpr(countName).minus(literal(1)))
-  });
-  repeaterView.aliases.add({
-    kind: SemanticVariableKind.Alias,
-    name: null,
-    identifier: forBlock.contextVariables.$even.name,
-    expression: new LexicalReadExpr(indexName).modulo(literal(2)).identical(literal(0))
-  });
-  repeaterView.aliases.add({
-    kind: SemanticVariableKind.Alias,
-    name: null,
-    identifier: forBlock.contextVariables.$odd.name,
-    expression: new LexicalReadExpr(indexName).modulo(literal(2)).notIdentical(literal(0))
-  });
+  for (const variable2 of forBlock.contextVariables) {
+    if (variable2.value === "$index") {
+      indexVarNames.add(variable2.name);
+    }
+    if (variable2.name === "$index") {
+      repeaterView.contextVariables.set("$index", variable2.value).set(indexName, variable2.value);
+    } else if (variable2.name === "$count") {
+      repeaterView.contextVariables.set("$count", variable2.value).set(countName, variable2.value);
+    } else {
+      repeaterView.aliases.add({
+        kind: SemanticVariableKind.Alias,
+        name: null,
+        identifier: variable2.name,
+        expression: getComputedForLoopVariableExpression(variable2, indexName, countName)
+      });
+    }
+  }
   const sourceSpan = convertSourceSpan(forBlock.trackBy.span, forBlock.sourceSpan);
   const track = convertAst(forBlock.trackBy, unit.job, sourceSpan);
   ingestNodes(repeaterView, forBlock.children);
@@ -18887,12 +18931,7 @@ function ingestForBlock(unit, forBlock) {
     emptyTagName = ingestControlFlowInsertionPoint(unit, emptyView.xref, forBlock.empty);
   }
   const varNames = {
-    $index: forBlock.contextVariables.$index.name,
-    $count: forBlock.contextVariables.$count.name,
-    $first: forBlock.contextVariables.$first.name,
-    $last: forBlock.contextVariables.$last.name,
-    $even: forBlock.contextVariables.$even.name,
-    $odd: forBlock.contextVariables.$odd.name,
+    $index: indexVarNames,
     $implicit: forBlock.item.name
   };
   if (forBlock.i18n !== void 0 && !(forBlock.i18n instanceof BlockPlaceholder)) {
@@ -18910,6 +18949,24 @@ function ingestForBlock(unit, forBlock) {
   const repeater2 = createRepeaterOp(repeaterCreate2.xref, repeaterCreate2.handle, expression, forBlock.sourceSpan);
   unit.update.push(repeater2);
 }
+function getComputedForLoopVariableExpression(variable2, indexName, countName) {
+  switch (variable2.value) {
+    case "$index":
+      return new LexicalReadExpr(indexName);
+    case "$count":
+      return new LexicalReadExpr(countName);
+    case "$first":
+      return new LexicalReadExpr(indexName).identical(literal(0));
+    case "$last":
+      return new LexicalReadExpr(indexName).identical(new LexicalReadExpr(countName).minus(literal(1)));
+    case "$even":
+      return new LexicalReadExpr(indexName).modulo(literal(2)).identical(literal(0));
+    case "$odd":
+      return new LexicalReadExpr(indexName).modulo(literal(2)).notIdentical(literal(0));
+    default:
+      throw new Error(`AssertionError: unknown @for loop variable ${variable2.value}`);
+  }
+}
 function convertAst(ast, job, baseSourceSpan) {
   if (ast instanceof ASTWithSource) {
     return convertAst(ast.ast, job, baseSourceSpan);
@@ -19945,19 +20002,25 @@ function parseForLoopParameters(block, errors, bindingParser) {
     return null;
   }
   const [, itemName, rawExpression] = match;
+  if (ALLOWED_FOR_LOOP_LET_VARIABLES.has(itemName)) {
+    errors.push(new ParseError(expressionParam.sourceSpan, `@for loop item name cannot be one of ${Array.from(ALLOWED_FOR_LOOP_LET_VARIABLES).join(", ")}.`));
+  }
   const variableName = expressionParam.expression.split(" ")[0];
   const variableSpan = new ParseSourceSpan(expressionParam.sourceSpan.start, expressionParam.sourceSpan.start.moveBy(variableName.length));
   const result = {
     itemName: new Variable(itemName, "$implicit", variableSpan, variableSpan),
     trackBy: null,
     expression: parseBlockParameterToBinding(expressionParam, bindingParser, rawExpression),
-    context: {}
+    context: Array.from(ALLOWED_FOR_LOOP_LET_VARIABLES, (variableName2) => {
+      const emptySpanAfterForBlockStart = new ParseSourceSpan(block.startSourceSpan.end, block.startSourceSpan.end);
+      return new Variable(variableName2, variableName2, emptySpanAfterForBlockStart, emptySpanAfterForBlockStart);
+    })
   };
   for (const param of secondaryParams) {
     const letMatch = param.expression.match(FOR_LOOP_LET_PATTERN);
     if (letMatch !== null) {
       const variablesSpan = new ParseSourceSpan(param.sourceSpan.start.moveBy(letMatch[0].length - letMatch[1].length), param.sourceSpan.end);
-      parseLetParameter(param.sourceSpan, letMatch[1], variablesSpan, result.context, errors);
+      parseLetParameter(param.sourceSpan, letMatch[1], variablesSpan, itemName, result.context, errors);
       continue;
     }
     const trackMatch = param.expression.match(FOR_LOOP_TRACK_PATTERN);
@@ -19976,15 +20039,9 @@ function parseForLoopParameters(block, errors, bindingParser) {
     }
     errors.push(new ParseError(param.sourceSpan, `Unrecognized @for loop paramater "${param.expression}"`));
   }
-  for (const variableName2 of ALLOWED_FOR_LOOP_LET_VARIABLES) {
-    if (!result.context.hasOwnProperty(variableName2)) {
-      const emptySpanAfterForBlockStart = new ParseSourceSpan(block.startSourceSpan.end, block.startSourceSpan.end);
-      result.context[variableName2] = new Variable(variableName2, variableName2, emptySpanAfterForBlockStart, emptySpanAfterForBlockStart);
-    }
-  }
   return result;
 }
-function parseLetParameter(sourceSpan, expression, span, context, errors) {
+function parseLetParameter(sourceSpan, expression, span, loopItemName, context, errors) {
   var _a2, _b2, _c2;
   const parts = expression.split(",");
   let startSpan = span.start;
@@ -19996,7 +20053,9 @@ function parseLetParameter(sourceSpan, expression, span, context, errors) {
       errors.push(new ParseError(sourceSpan, `Invalid @for loop "let" parameter. Parameter should match the pattern "<name> = <variable name>"`));
     } else if (!ALLOWED_FOR_LOOP_LET_VARIABLES.has(variableName)) {
       errors.push(new ParseError(sourceSpan, `Unknown "let" parameter variable "${variableName}". The allowed variables are: ${Array.from(ALLOWED_FOR_LOOP_LET_VARIABLES).join(", ")}`));
-    } else if (context.hasOwnProperty(variableName)) {
+    } else if (name === loopItemName) {
+      errors.push(new ParseError(sourceSpan, `Invalid @for loop "let" parameter. Variable cannot be called "${loopItemName}"`));
+    } else if (context.some((v) => v.name === name)) {
       errors.push(new ParseError(sourceSpan, `Duplicate "let" parameter variable "${variableName}"`));
     } else {
       const [, keyLeadingWhitespace, keyName] = (_a2 = expressionParts[0].match(CHARACTERS_IN_SURROUNDING_WHITESPACE_PATTERN)) != null ? _a2 : [];
@@ -20010,7 +20069,7 @@ function parseLetParameter(sourceSpan, expression, span, context, errors) {
         valueSpan = valueLeadingWhitespace !== void 0 ? new ParseSourceSpan(startSpan.moveBy(expressionParts[0].length + 1 + valueLeadingWhitespace.length), startSpan.moveBy(expressionParts[0].length + 1 + valueLeadingWhitespace.length + implicit.length)) : void 0;
       }
       const sourceSpan2 = new ParseSourceSpan(keySpan.start, (_c2 = valueSpan == null ? void 0 : valueSpan.end) != null ? _c2 : keySpan.end);
-      context[variableName] = new Variable(name, variableName, sourceSpan2, keySpan, valueSpan);
+      context.push(new Variable(name, variableName, sourceSpan2, keySpan, valueSpan));
     }
     startSpan = startSpan.moveBy(part.length + 1);
   }
@@ -20648,12 +20707,9 @@ var HtmlAstToIvyAst = class {
     }
     let parsedElement;
     if (preparsedElement.type === PreparsedElementType.NG_CONTENT) {
-      if (element2.children && !element2.children.every((node) => isEmptyTextNode(node) || isCommentNode(node))) {
-        this.reportError(`<ng-content> element cannot have content.`, element2.sourceSpan);
-      }
       const selector = preparsedElement.selectAttr;
       const attrs = element2.attrs.map((attr) => this.visitAttribute(attr));
-      parsedElement = new Content(selector, attrs, element2.sourceSpan, element2.i18n);
+      parsedElement = new Content(selector, attrs, children, element2.sourceSpan, element2.i18n);
       this.ngContentSelectors.push(selector);
     } else if (isTemplateElement) {
       const attrs = this.extractAttributes(element2.name, parsedProperties, i18nAttrsMeta);
@@ -20957,12 +21013,6 @@ function normalizeAttributeName(attrName) {
 function addEvents(events, boundEvents) {
   boundEvents.push(...events.map((e) => BoundEvent.fromParsedEvent(e)));
 }
-function isEmptyTextNode(node) {
-  return node instanceof Text4 && node.value.trim().length == 0;
-}
-function isCommentNode(node) {
-  return node instanceof Comment2;
-}
 function textContents(node) {
   if (node.children.length !== 1 || !(node.children[0] instanceof Text4)) {
     return null;
@@ -21139,7 +21189,7 @@ function compileComponentFromMetadata(meta, constantPool, bindingParser) {
   let allDeferrableDepsFn = null;
   if (meta.defer.mode === 1 && meta.defer.dependenciesFn !== null) {
     const fnName = `${templateTypeName}_DeferFn`;
-    constantPool.statements.push(meta.defer.dependenciesFn.toDeclStmt(fnName, StmtModifier.Final));
+    constantPool.statements.push(new DeclareVarStmt(fnName, meta.defer.dependenciesFn, void 0, StmtModifier.Final));
     allDeferrableDepsFn = variable(fnName);
   }
   const tpl = ingestComponent(meta.name, meta.template.nodes, constantPool, meta.relativeContextFilePath, meta.i18nUseExternalIds, meta.defer, allDeferrableDepsFn);
@@ -21451,9 +21501,9 @@ var Scope2 = class {
       nodeOrNodes.children.forEach((node) => node.visit(this));
     } else if (nodeOrNodes instanceof ForLoopBlock) {
       this.visitVariable(nodeOrNodes.item);
-      Object.values(nodeOrNodes.contextVariables).forEach((v) => this.visitVariable(v));
+      nodeOrNodes.contextVariables.forEach((v) => this.visitVariable(v));
       nodeOrNodes.children.forEach((node) => node.visit(this));
-    } else if (nodeOrNodes instanceof SwitchBlockCase || nodeOrNodes instanceof ForLoopBlockEmpty || nodeOrNodes instanceof DeferredBlock || nodeOrNodes instanceof DeferredBlockError || nodeOrNodes instanceof DeferredBlockPlaceholder || nodeOrNodes instanceof DeferredBlockLoading) {
+    } else if (nodeOrNodes instanceof SwitchBlockCase || nodeOrNodes instanceof ForLoopBlockEmpty || nodeOrNodes instanceof DeferredBlock || nodeOrNodes instanceof DeferredBlockError || nodeOrNodes instanceof DeferredBlockPlaceholder || nodeOrNodes instanceof DeferredBlockLoading || nodeOrNodes instanceof Content) {
       nodeOrNodes.children.forEach((node) => node.visit(this));
     } else {
       nodeOrNodes.forEach((node) => node.visit(this));
@@ -21511,6 +21561,7 @@ var Scope2 = class {
     this.ingestScopedNode(block);
   }
   visitContent(content) {
+    this.ingestScopedNode(content);
   }
   visitBoundAttribute(attr) {
   }
@@ -21649,7 +21700,7 @@ var DirectiveBinder = class {
   visitForLoopBlock(block) {
     var _a2;
     block.item.visit(this);
-    Object.values(block.contextVariables).forEach((v) => v.visit(this));
+    block.contextVariables.forEach((v) => v.visit(this));
     block.children.forEach((node) => node.visit(this));
     (_a2 = block.empty) == null ? void 0 : _a2.visit(this);
   }
@@ -21665,6 +21716,7 @@ var DirectiveBinder = class {
     block.children.forEach((node) => node.visit(this));
   }
   visitContent(content) {
+    content.children.forEach((child) => child.visit(this));
   }
   visitVariable(variable2) {
   }
@@ -21717,7 +21769,7 @@ var TemplateBinder = class extends RecursiveAstVisitor {
     const usedPipes = /* @__PURE__ */ new Set();
     const eagerPipes = /* @__PURE__ */ new Set();
     const template2 = nodes instanceof Template ? nodes : null;
-    const deferBlocks = /* @__PURE__ */ new Map();
+    const deferBlocks = [];
     const binder = new TemplateBinder(expressions, symbols, usedPipes, eagerPipes, deferBlocks, nestingLevel, scope, template2, 0);
     binder.ingest(nodes);
     return { expressions, symbols, nestingLevel, usedPipes, eagerPipes, deferBlocks };
@@ -21735,7 +21787,7 @@ var TemplateBinder = class extends RecursiveAstVisitor {
       this.nestingLevel.set(nodeOrNodes, this.level);
     } else if (nodeOrNodes instanceof ForLoopBlock) {
       this.visitNode(nodeOrNodes.item);
-      Object.values(nodeOrNodes.contextVariables).forEach((v) => this.visitNode(v));
+      nodeOrNodes.contextVariables.forEach((v) => this.visitNode(v));
       nodeOrNodes.trackBy.visit(this);
       nodeOrNodes.children.forEach(this.visitNode);
       this.nestingLevel.set(nodeOrNodes, this.level);
@@ -21743,10 +21795,10 @@ var TemplateBinder = class extends RecursiveAstVisitor {
       if (this.scope.rootNode !== nodeOrNodes) {
         throw new Error(`Assertion error: resolved incorrect scope for deferred block ${nodeOrNodes}`);
       }
-      this.deferBlocks.set(nodeOrNodes, this.scope);
+      this.deferBlocks.push([nodeOrNodes, this.scope]);
       nodeOrNodes.children.forEach((node) => node.visit(this));
       this.nestingLevel.set(nodeOrNodes, this.level);
-    } else if (nodeOrNodes instanceof SwitchBlockCase || nodeOrNodes instanceof ForLoopBlockEmpty || nodeOrNodes instanceof DeferredBlockError || nodeOrNodes instanceof DeferredBlockPlaceholder || nodeOrNodes instanceof DeferredBlockLoading) {
+    } else if (nodeOrNodes instanceof SwitchBlockCase || nodeOrNodes instanceof ForLoopBlockEmpty || nodeOrNodes instanceof DeferredBlockError || nodeOrNodes instanceof DeferredBlockPlaceholder || nodeOrNodes instanceof DeferredBlockLoading || nodeOrNodes instanceof Content) {
       nodeOrNodes.children.forEach((node) => node.visit(this));
       this.nestingLevel.set(nodeOrNodes, this.level);
     } else {
@@ -21778,8 +21830,6 @@ var TemplateBinder = class extends RecursiveAstVisitor {
   }
   visitText(text2) {
   }
-  visitContent(content) {
-  }
   visitTextAttribute(attribute2) {
   }
   visitUnknownBlock(block) {
@@ -21840,6 +21890,9 @@ var TemplateBinder = class extends RecursiveAstVisitor {
     (_a2 = block.expression) == null ? void 0 : _a2.visit(this);
     this.ingestScopedNode(block);
   }
+  visitContent(content) {
+    this.ingestScopedNode(content);
+  }
   visitBoundText(text2) {
     text2.value.visit(this);
   }
@@ -21878,7 +21931,7 @@ var TemplateBinder = class extends RecursiveAstVisitor {
   }
 };
 var R3BoundTarget = class {
-  constructor(target, directives, eagerDirectives, bindings, references, exprTargets, symbols, nestingLevel, scopedNodeEntities, usedPipes, eagerPipes, deferBlocks) {
+  constructor(target, directives, eagerDirectives, bindings, references, exprTargets, symbols, nestingLevel, scopedNodeEntities, usedPipes, eagerPipes, rawDeferred) {
     this.target = target;
     this.directives = directives;
     this.eagerDirectives = eagerDirectives;
@@ -21890,7 +21943,8 @@ var R3BoundTarget = class {
     this.scopedNodeEntities = scopedNodeEntities;
     this.usedPipes = usedPipes;
     this.eagerPipes = eagerPipes;
-    this.deferBlocks = deferBlocks;
+    this.deferredBlocks = rawDeferred.map((current) => current[0]);
+    this.deferredScopes = new Map(rawDeferred);
   }
   getEntitiesInScope(node) {
     var _a2;
@@ -21930,7 +21984,7 @@ var R3BoundTarget = class {
     return Array.from(this.eagerPipes);
   }
   getDeferBlocks() {
-    return Array.from(this.deferBlocks.keys());
+    return this.deferredBlocks;
   }
   getDeferredTriggerTarget(block, trigger) {
     if (!(trigger instanceof InteractionDeferredTrigger) && !(trigger instanceof ViewportDeferredTrigger) && !(trigger instanceof HoverDeferredTrigger)) {
@@ -21971,8 +22025,11 @@ var R3BoundTarget = class {
     return null;
   }
   isDeferred(element2) {
-    for (const deferredScope of this.deferBlocks.values()) {
-      const stack = [deferredScope];
+    for (const block of this.deferredBlocks) {
+      if (!this.deferredScopes.has(block)) {
+        continue;
+      }
+      const stack = [this.deferredScopes.get(block)];
       while (stack.length > 0) {
         const current = stack.pop();
         if (current.elementsInScope.has(element2)) {
@@ -21985,9 +22042,9 @@ var R3BoundTarget = class {
   }
   findEntityInScope(rootNode, name) {
     const entities = this.getEntitiesInScope(rootNode);
-    for (const entitity of entities) {
-      if (entitity.name === name) {
-        return entitity;
+    for (const entity of entities) {
+      if (entity.name === name) {
+        return entity;
       }
     }
     return null;
@@ -22153,7 +22210,7 @@ var CompilerFacadeImpl = class {
   }
   compileComponent(angularCoreEnv, sourceMapUrl, facade) {
     var _a2;
-    const { template: template2, interpolation, defer: defer2 } = parseJitTemplate(facade.template, facade.name, sourceMapUrl, facade.preserveWhitespaces, facade.interpolation);
+    const { template: template2, interpolation, defer: defer2 } = parseJitTemplate(facade.template, facade.name, sourceMapUrl, facade.preserveWhitespaces, facade.interpolation, void 0);
     const meta = __spreadProps(__spreadValues(__spreadValues({}, facade), convertDirectiveFacadeToMetadata(facade)), {
       selector: facade.selector || this.elementSchemaRegistry.getDefaultComponentElementName(),
       template: template2,
@@ -22342,7 +22399,7 @@ function convertOpaqueValuesToExpressions(obj) {
 }
 function convertDeclareComponentFacadeToMetadata(decl, typeSourceSpan, sourceMapUrl) {
   var _a2, _b2, _c2, _d2;
-  const { template: template2, interpolation, defer: defer2 } = parseJitTemplate(decl.template, decl.type.name, sourceMapUrl, (_a2 = decl.preserveWhitespaces) != null ? _a2 : false, decl.interpolation);
+  const { template: template2, interpolation, defer: defer2 } = parseJitTemplate(decl.template, decl.type.name, sourceMapUrl, (_a2 = decl.preserveWhitespaces) != null ? _a2 : false, decl.interpolation, decl.deferBlockDependencies);
   const declarations = [];
   if (decl.dependencies) {
     for (const innerDep of decl.dependencies) {
@@ -22412,7 +22469,7 @@ function convertPipeDeclarationToMetadata(pipe2) {
     type: new WrappedNodeExpr(pipe2.type)
   };
 }
-function parseJitTemplate(template2, typeName, sourceMapUrl, preserveWhitespaces, interpolation) {
+function parseJitTemplate(template2, typeName, sourceMapUrl, preserveWhitespaces, interpolation, deferBlockDependencies) {
   const interpolationConfig = interpolation ? InterpolationConfig.fromArray(interpolation) : DEFAULT_INTERPOLATION_CONFIG;
   const parsed = parseTemplate(template2, sourceMapUrl, { preserveWhitespaces, interpolationConfig });
   if (parsed.errors !== null) {
@@ -22424,7 +22481,7 @@ function parseJitTemplate(template2, typeName, sourceMapUrl, preserveWhitespaces
   return {
     template: parsed,
     interpolation: interpolationConfig,
-    defer: createR3ComponentDeferMetadata(boundTarget)
+    defer: createR3ComponentDeferMetadata(boundTarget, deferBlockDependencies)
   };
 }
 function convertToProviderExpression(obj, property2) {
@@ -22464,11 +22521,12 @@ function createR3DependencyMetadata(token, isAttributeDep, host, optional, self,
   const attributeNameType = isAttributeDep ? literal("unknown") : null;
   return { token, attributeNameType, host, optional, self, skipSelf };
 }
-function createR3ComponentDeferMetadata(boundTarget) {
+function createR3ComponentDeferMetadata(boundTarget, deferBlockDependencies) {
   const deferredBlocks = boundTarget.getDeferBlocks();
   const blocks = /* @__PURE__ */ new Map();
-  for (const block of deferredBlocks) {
-    blocks.set(block, null);
+  for (let i = 0; i < deferredBlocks.length; i++) {
+    const dependencyFn = deferBlockDependencies == null ? void 0 : deferBlockDependencies[i];
+    blocks.set(deferredBlocks[i], dependencyFn ? new WrappedNodeExpr(dependencyFn) : null);
   }
   return { mode: 0, blocks };
 }
@@ -22598,7 +22656,7 @@ function publishFacade(global) {
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/version.mjs
-var VERSION2 = new Version("18.0.0-next.1");
+var VERSION2 = new Version("18.0.0-next.2");
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/i18n/extractor_merger.mjs
 var _VisitorMode;