@angular/core 17.0.0-next.2 → 17.0.0-next.3

package/schematics/ng-generate/standalone-migration/bundle.js

@@ -1803,7 +1803,7 @@ var FunctionExpr = class extends Expression {
     this.name = name;
   }
   isEquivalent(e) {
-    return e instanceof FunctionExpr && areAllEquivalent(this.params, e.params) && areAllEquivalent(this.statements, e.statements);
+    return (e instanceof FunctionExpr || e instanceof DeclareFunctionStmt) && areAllEquivalent(this.params, e.params) && areAllEquivalent(this.statements, e.statements);
   }
   isConstant() {
     return false;
@@ -1845,6 +1845,9 @@ var ArrowFunctionExpr = class extends Expression {
   clone() {
     return new ArrowFunctionExpr(this.params.map((p2) => p2.clone()), Array.isArray(this.body) ? this.body : this.body.clone(), this.type, this.sourceSpan);
   }
+  toDeclStmt(name, modifiers) {
+    return new DeclareVarStmt(name, this, INFERRED_TYPE, modifiers, this.sourceSpan);
+  }
 };
 var UnaryOperatorExpr = class extends Expression {
   constructor(operator, expr, type, sourceSpan, parens = true) {
@@ -2478,13 +2481,28 @@ var ConstantPool = class {
       }))));
     }
   }
+  getSharedFunctionReference(fn2, prefix) {
+    var _a2;
+    const isArrow = fn2 instanceof ArrowFunctionExpr;
+    for (const current of this.statements) {
+      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)) {
+        return variable(current.name);
+      }
+    }
+    const name = this.uniqueName(prefix);
+    this.statements.push(fn2.toDeclStmt(name, StmtModifier.Final));
+    return variable(name);
+  }
   _getLiteralFactory(key, values, resultMap) {
     let literalFactory = this.literalFactories.get(key);
     const literalFactoryArguments = values.filter((e) => !e.isConstant());
     if (!literalFactory) {
       const resultExpressions = values.map((e, index) => e.isConstant() ? this.getConstLiteral(e, true) : variable(`a${index}`));
       const parameters = resultExpressions.filter(isVariable).map((e) => new FnParam(e.name, DYNAMIC_TYPE));
-      const pureFunctionDeclaration = fn(parameters, [new ReturnStatement(resultMap(resultExpressions))], INFERRED_TYPE);
+      const pureFunctionDeclaration = arrowFn(parameters, resultMap(resultExpressions), INFERRED_TYPE);
       const name = this.freshName();
       this.statements.push(variable(name).set(pureFunctionDeclaration).toDeclStmt(INFERRED_TYPE, StmtModifier.Final));
       literalFactory = variable(name);
@@ -2788,6 +2806,9 @@ var Identifiers = _Identifiers;
 (() => {
   _Identifiers.repeaterTrackByIdentity = { name: "\u0275\u0275repeaterTrackByIdentity", moduleName: CORE };
 })();
+(() => {
+  _Identifiers.componentInstance = { name: "\u0275\u0275componentInstance", moduleName: CORE };
+})();
 (() => {
   _Identifiers.text = { name: "\u0275\u0275text", moduleName: CORE };
 })();
@@ -6787,6 +6808,25 @@ function convertPropertyBinding(localResolver, implicitReceiver, expressionWitho
   }
   return new ConvertPropertyBindingResult(stmts, outputExpr);
 }
+function convertPureComponentScopeFunction(ast, localResolver, implicitReceiver, bindingId) {
+  const converted = convertPropertyBindingBuiltins({
+    createLiteralArrayConverter: () => (args) => literalArr(args),
+    createLiteralMapConverter: (keys) => (values) => literalMap(keys.map((key, index) => {
+      return {
+        key: key.key,
+        value: values[index],
+        quoted: key.quoted
+      };
+    })),
+    createPipeConverter: () => {
+      throw new Error("Illegal State: Pipes are not allowed in this context");
+    }
+  }, ast);
+  const visitor = new _AstToIrVisitor(localResolver, implicitReceiver, bindingId, false);
+  const statements = [];
+  flattenStatements(converted.visit(visitor, _Mode.Statement), statements);
+  return statements;
+}
 function convertUpdateArguments(localResolver, contextVariableExpression, expressionWithArgumentsToExtract, bindingId) {
   const visitor = new _AstToIrVisitor(localResolver, contextVariableExpression, bindingId, true);
   const outputExpr = visitor.visitInterpolation(expressionWithArgumentsToExtract, _Mode.Expression);
@@ -19433,7 +19473,10 @@ function validateSwitchBlock(ast) {
   const [primaryBlock, ...secondaryBlocks] = ast.blocks;
   const errors = [];
   let hasDefault = false;
-  if (primaryBlock.children.length > 0) {
+  const hasPrimary = primaryBlock.children.length > 0 && primaryBlock.children.some((child) => {
+    return !(child instanceof Text4) || child.value.trim().length > 0;
+  });
+  if (hasPrimary) {
     errors.push(new ParseError(primaryBlock.sourceSpan, 'Switch block can only contain "case" and "default" blocks'));
   }
   if (primaryBlock.parameters.length !== 1) {
@@ -20505,9 +20548,10 @@ function createComponentDefConsts() {
   };
 }
 var TemplateData = class {
-  constructor(name, index, visitor) {
+  constructor(name, index, scope, visitor) {
     this.name = name;
     this.index = index;
+    this.scope = scope;
     this.visitor = visitor;
   }
   getConstCount() {
@@ -20999,7 +21043,7 @@ var TemplateDefinitionBuilder = class {
         this._ngContentReservedSlots.push(...visitor._ngContentReservedSlots);
       }
     });
-    return new TemplateData(name, index, visitor);
+    return new TemplateData(name, index, visitor._bindingScope, visitor);
   }
   createEmbeddedTemplateFn(tagName, children, contextNameSuffix, sourceSpan, variables = [], attrsExprs, references, i18n2) {
     const data = this.prepareEmbeddedTemplateFn(children, contextNameSuffix, variables, i18n2);
@@ -21194,15 +21238,15 @@ var TemplateDefinitionBuilder = class {
     const dependencyExp = [];
     for (const deferredDep of deferredDeps) {
       if (deferredDep.isDeferrable) {
-        const innerFn = fn([new FnParam("m", DYNAMIC_TYPE)], [new ReturnStatement(variable("m").prop(deferredDep.symbolName))]);
+        const innerFn = arrowFn([new FnParam("m", DYNAMIC_TYPE)], variable("m").prop(deferredDep.symbolName));
         const importExpr2 = new DynamicImportExpr(deferredDep.importPath).prop("then").callFn([innerFn]);
         dependencyExp.push(importExpr2);
       } else {
         dependencyExp.push(deferredDep.type);
       }
     }
-    const depsFnExpr = fn([], [new ReturnStatement(literalArr(dependencyExp))], INFERRED_TYPE, null, name);
-    this.constantPool.statements.push(depsFnExpr.toDeclStmt(name));
+    const depsFnExpr = arrowFn([], literalArr(dependencyExp));
+    this.constantPool.statements.push(depsFnExpr.toDeclStmt(name, StmtModifier.Final));
     return variable(name);
   }
   createDeferTriggerInstructions(deferredIndex, triggers, prefetch) {
@@ -21236,55 +21280,95 @@ var TemplateDefinitionBuilder = class {
   }
   visitForLoopBlock(block) {
     const blockIndex = this.allocateDataSlot();
-    const templateVariables = this.createForLoopVariables(block);
-    const primaryData = this.prepareEmbeddedTemplateFn(block.children, "_For", templateVariables);
+    const primaryData = this.prepareEmbeddedTemplateFn(block.children, "_For", [
+      new Variable(block.itemName, "$implicit", block.sourceSpan, block.sourceSpan),
+      new Variable(getLoopLocalName(block, "$index"), "$index", block.sourceSpan, block.sourceSpan),
+      new Variable(getLoopLocalName(block, "$count"), "$count", block.sourceSpan, block.sourceSpan)
+    ]);
     const emptyData = block.empty === null ? null : this.prepareEmbeddedTemplateFn(block.empty.children, "_ForEmpty");
-    const trackByFn = this.createTrackByFunction(block);
+    const { expression: trackByExpression, usesComponentInstance: trackByUsesComponentInstance } = this.createTrackByFunction(block);
     const value = block.expression.visit(this._valueConverter);
     this.allocateBindingSlots(value);
+    this.registerComputedLoopVariables(block, primaryData.scope);
     this.creationInstruction(block.sourceSpan, Identifiers.repeaterCreate, () => {
       const params = [
         literal(blockIndex),
         variable(primaryData.name),
         literal(primaryData.getConstCount()),
         literal(primaryData.getVarCount()),
-        trackByFn
+        trackByExpression
       ];
       if (emptyData !== null) {
-        params.push(variable(emptyData.name), literal(emptyData.getConstCount()), literal(emptyData.getVarCount()));
+        params.push(literal(trackByUsesComponentInstance), variable(emptyData.name), literal(emptyData.getConstCount()), literal(emptyData.getVarCount()));
+      } else if (trackByUsesComponentInstance) {
+        params.push(literal(trackByUsesComponentInstance));
       }
       return params;
     });
     this.updateInstruction(block.sourceSpan, Identifiers.repeater, () => [literal(blockIndex), this.convertPropertyBinding(value)]);
   }
-  createForLoopVariables(block) {
+  registerComputedLoopVariables(block, bindingScope) {
     const indexLocalName = getLoopLocalName(block, "$index");
     const countLocalName = getLoopLocalName(block, "$count");
-    this._bindingScope.set(this.level, getLoopLocalName(block, "$odd"), (scope) => scope.get(indexLocalName).modulo(literal(2)).notIdentical(literal(0)));
-    this._bindingScope.set(this.level, getLoopLocalName(block, "$even"), (scope) => scope.get(indexLocalName).modulo(literal(2)).identical(literal(0)));
-    this._bindingScope.set(this.level, getLoopLocalName(block, "$first"), (scope) => scope.get(indexLocalName).identical(literal(0)));
-    this._bindingScope.set(this.level, getLoopLocalName(block, "$last"), (scope) => scope.get(indexLocalName).identical(scope.get(countLocalName).minus(literal(1))));
-    return [
-      new Variable(block.itemName, "$implicit", block.sourceSpan, block.sourceSpan),
-      new Variable(indexLocalName, "$index", block.sourceSpan, block.sourceSpan),
-      new Variable(countLocalName, "$count", block.sourceSpan, block.sourceSpan)
-    ];
+    const level = bindingScope.bindingLevel;
+    bindingScope.set(level, getLoopLocalName(block, "$odd"), (scope) => scope.get(indexLocalName).modulo(literal(2)).notIdentical(literal(0)));
+    bindingScope.set(level, getLoopLocalName(block, "$even"), (scope) => scope.get(indexLocalName).modulo(literal(2)).identical(literal(0)));
+    bindingScope.set(level, getLoopLocalName(block, "$first"), (scope) => scope.get(indexLocalName).identical(literal(0)));
+    bindingScope.set(level, getLoopLocalName(block, "$last"), (scope) => scope.get(indexLocalName).identical(scope.get(countLocalName).minus(literal(1))));
   }
-  createTrackByFunction(block) {
+  optimizeTrackByFunction(block) {
     const ast = block.trackBy.ast;
     if (ast instanceof PropertyRead && ast.receiver instanceof ImplicitReceiver && ast.name === getLoopLocalName(block, "$index")) {
-      return importExpr(Identifiers.repeaterTrackByIndex);
+      return { expression: importExpr(Identifiers.repeaterTrackByIndex), usesComponentInstance: false };
     }
     if (ast instanceof PropertyRead && ast.receiver instanceof ImplicitReceiver && ast.name === block.itemName) {
-      return importExpr(Identifiers.repeaterTrackByIdentity);
+      return { expression: importExpr(Identifiers.repeaterTrackByIdentity), usesComponentInstance: false };
     }
-    if (ast instanceof PropertyRead && ast.receiver instanceof PropertyRead && ast.receiver.receiver instanceof ImplicitReceiver && ast.receiver.name === block.itemName) {
-      const params = [getLoopLocalName(block, "$index"), block.itemName];
-      const scope = this._bindingScope.nestedScope(this.level + 1, new Set(params));
-      const binding = convertPropertyBinding(scope, variable(CONTEXT_NAME), block.trackBy, "trackBy");
-      return arrowFn(params.map((param) => new FnParam(param)), binding.currValExpr);
+    if (ast instanceof Call && ast.receiver instanceof PropertyRead && ast.receiver.receiver instanceof ImplicitReceiver && ast.args.length === 2) {
+      const firstIsIndex = ast.args[0] instanceof PropertyRead && ast.args[0].receiver instanceof ImplicitReceiver && ast.args[0].name === getLoopLocalName(block, "$index");
+      const secondIsItem = ast.args[1] instanceof PropertyRead && ast.args[1].receiver instanceof ImplicitReceiver && ast.args[1].name === block.itemName;
+      if (firstIsIndex && secondIsItem) {
+        const receiver = this.level === 0 ? variable(CONTEXT_NAME) : new ExternalExpr(Identifiers.componentInstance).callFn([]);
+        return { expression: receiver.prop(ast.receiver.name), usesComponentInstance: false };
+      }
+    }
+    return null;
+  }
+  createTrackByFunction(block) {
+    const optimizedFn = this.optimizeTrackByFunction(block);
+    if (optimizedFn !== null) {
+      return optimizedFn;
+    }
+    const bannedGlobals = /* @__PURE__ */ new Set([
+      getLoopLocalName(block, "$count"),
+      getLoopLocalName(block, "$first"),
+      getLoopLocalName(block, "$last"),
+      getLoopLocalName(block, "$even"),
+      getLoopLocalName(block, "$odd")
+    ]);
+    const scope = new TrackByBindingScope(this._bindingScope, {
+      [getLoopLocalName(block, "$index")]: "$index",
+      [block.itemName]: "$item"
+    }, bannedGlobals);
+    const params = [new FnParam("$index"), new FnParam("$item")];
+    const stmts = convertPureComponentScopeFunction(block.trackBy.ast, scope, variable(CONTEXT_NAME), "track");
+    const usesComponentInstance = scope.getComponentAccessCount() > 0;
+    let fn2;
+    if (!usesComponentInstance && stmts.length === 1 && stmts[0] instanceof ExpressionStatement) {
+      fn2 = arrowFn(params, stmts[0].expr);
+    } else {
+      if (stmts.length > 0) {
+        const lastStatement = stmts[stmts.length - 1];
+        if (lastStatement instanceof ExpressionStatement) {
+          stmts[stmts.length - 1] = new ReturnStatement(lastStatement.expr);
+        }
+      }
+      fn2 = fn(params, stmts);
     }
-    throw new Error("Unsupported track expression");
+    return {
+      expression: this.constantPool.getSharedFunctionReference(fn2, "_forTrack"),
+      usesComponentInstance
+    };
   }
   getConstCount() {
     return this._dataIndex;
@@ -21645,6 +21729,9 @@ var BindingScope = class {
     }
     return this.bindingLevel === 0 ? null : this.getComponentProperty(name);
   }
+  hasLocal(name) {
+    return this.map.has(name);
+  }
   set(retrievalLevel, name, lhs, priority = 0, declareLocalCallback, localRef) {
     if (this.map.has(name)) {
       if (localRef) {
@@ -21761,6 +21848,37 @@ var BindingScope = class {
     this.usesRestoredViewContext = true;
   }
 };
+var TrackByBindingScope = class extends BindingScope {
+  constructor(parentScope, globalAliases, bannedGlobals) {
+    super(parentScope.bindingLevel + 1, parentScope);
+    this.globalAliases = globalAliases;
+    this.bannedGlobals = bannedGlobals;
+    this.componentAccessCount = 0;
+  }
+  get(name) {
+    let current = this.parent;
+    while (current) {
+      if (current.hasLocal(name)) {
+        this.forbiddenAccessError(name);
+      }
+      current = current.parent;
+    }
+    if (this.bannedGlobals.has(name)) {
+      this.forbiddenAccessError(name);
+    }
+    if (this.globalAliases[name]) {
+      return variable(this.globalAliases[name]);
+    }
+    this.componentAccessCount++;
+    return variable("this").prop(name);
+  }
+  getComponentAccessCount() {
+    return this.componentAccessCount;
+  }
+  forbiddenAccessError(propertyName) {
+    throw new Error(`Accessing ${propertyName} inside of a track expression is not allowed. Tracking expressions can only access the item, $index and properties on the containing component.`);
+  }
+};
 function createCssSelector(elementName, attributes) {
   const cssSelector = new CssSelector();
   const elementNameNoNs = splitNsName(elementName)[1];
@@ -23125,7 +23243,7 @@ function publishFacade(global) {
 }
 
 // bazel-out/k8-fastbuild/bin/packages/compiler/src/version.mjs
-var VERSION2 = new Version("17.0.0-next.2");
+var VERSION2 = new Version("17.0.0-next.3");
 
 // bazel-out/k8-fastbuild/bin/packages/compiler/src/i18n/extractor_merger.mjs
 var _I18N_ATTR = "i18n";
@@ -24662,7 +24780,7 @@ var MINIMUM_PARTIAL_LINKER_VERSION = "12.0.0";
 function compileDeclareClassMetadata(metadata) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION));
-  definitionMap.set("version", literal("17.0.0-next.2"));
+  definitionMap.set("version", literal("17.0.0-next.3"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", metadata.type);
   definitionMap.set("decorators", metadata.decorators);
@@ -24733,7 +24851,7 @@ function createDirectiveDefinitionMap(meta) {
   const hasTransformFunctions = Object.values(meta.inputs).some((input) => input.transformFunction !== null);
   const minVersion = hasTransformFunctions ? MINIMUM_PARTIAL_LINKER_VERSION2 : "14.0.0";
   definitionMap.set("minVersion", literal(minVersion));
-  definitionMap.set("version", literal("17.0.0-next.2"));
+  definitionMap.set("version", literal("17.0.0-next.3"));
   definitionMap.set("type", meta.type.value);
   if (meta.isStandalone) {
     definitionMap.set("isStandalone", literal(meta.isStandalone));
@@ -24921,7 +25039,7 @@ var MINIMUM_PARTIAL_LINKER_VERSION3 = "12.0.0";
 function compileDeclareFactoryFunction(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION3));
-  definitionMap.set("version", literal("17.0.0-next.2"));
+  definitionMap.set("version", literal("17.0.0-next.3"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   definitionMap.set("deps", compileDependencies(meta.deps));
@@ -24944,7 +25062,7 @@ function compileDeclareInjectableFromMetadata(meta) {
 function createInjectableDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION4));
-  definitionMap.set("version", literal("17.0.0-next.2"));
+  definitionMap.set("version", literal("17.0.0-next.3"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   if (meta.providedIn !== void 0) {
@@ -24982,7 +25100,7 @@ function compileDeclareInjectorFromMetadata(meta) {
 function createInjectorDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION5));
-  definitionMap.set("version", literal("17.0.0-next.2"));
+  definitionMap.set("version", literal("17.0.0-next.3"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   definitionMap.set("providers", meta.providers);
@@ -25006,7 +25124,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_VERSION6));
-  definitionMap.set("version", literal("17.0.0-next.2"));
+  definitionMap.set("version", literal("17.0.0-next.3"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   if (meta.bootstrap.length > 0) {
@@ -25041,7 +25159,7 @@ function compileDeclarePipeFromMetadata(meta) {
 function createPipeDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION7));
-  definitionMap.set("version", literal("17.0.0-next.2"));
+  definitionMap.set("version", literal("17.0.0-next.3"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   if (meta.isStandalone) {
@@ -25058,7 +25176,7 @@ function createPipeDefinitionMap(meta) {
 publishFacade(_global);
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/version.mjs
-var VERSION3 = new Version("17.0.0-next.2");
+var VERSION3 = new Version("17.0.0-next.3");
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/transformers/api.mjs
 var EmitFlags;
@@ -25235,7 +25353,6 @@ var ErrorCode;
   ErrorCode2[ErrorCode2["NGMODULE_DECLARATION_IS_STANDALONE"] = 6008] = "NGMODULE_DECLARATION_IS_STANDALONE";
   ErrorCode2[ErrorCode2["NGMODULE_BOOTSTRAP_IS_STANDALONE"] = 6009] = "NGMODULE_BOOTSTRAP_IS_STANDALONE";
   ErrorCode2[ErrorCode2["WARN_NGMODULE_ID_UNNECESSARY"] = 6100] = "WARN_NGMODULE_ID_UNNECESSARY";
-  ErrorCode2[ErrorCode2["NGMODULE_VE_DEPENDENCY_ON_IVY_LIB"] = 6999] = "NGMODULE_VE_DEPENDENCY_ON_IVY_LIB";
   ErrorCode2[ErrorCode2["SCHEMA_INVALID_ELEMENT"] = 8001] = "SCHEMA_INVALID_ELEMENT";
   ErrorCode2[ErrorCode2["SCHEMA_INVALID_ATTRIBUTE"] = 8002] = "SCHEMA_INVALID_ATTRIBUTE";
   ErrorCode2[ErrorCode2["MISSING_REFERENCE_TARGET"] = 8003] = "MISSING_REFERENCE_TARGET";
@@ -33452,7 +33569,8 @@ function parseExtractedTemplate(template2, sourceStr, sourceParseRange, escapedS
     enableI18nLegacyMessageIdFormat: options.enableI18nLegacyMessageIdFormat,
     i18nNormalizeLineEndingsInICUs,
     leadingTriviaChars: [],
-    alwaysAttemptHtmlToR3AstConversion: options.usePoisonedData
+    alwaysAttemptHtmlToR3AstConversion: options.usePoisonedData,
+    enabledBlockTypes: options.enabledBlockTypes
   });
   return __spreadProps(__spreadValues({}, parsedTemplate), {
     diagNodes,
@@ -38324,18 +38442,18 @@ var TcbTemplateBodyOp = class extends TcbOp {
     return null;
   }
 };
-var TcbTextInterpolationOp = class extends TcbOp {
-  constructor(tcb, scope, binding) {
+var TcbExpressionOp = class extends TcbOp {
+  constructor(tcb, scope, expression) {
     super();
     this.tcb = tcb;
     this.scope = scope;
-    this.binding = binding;
+    this.expression = expression;
   }
   get optional() {
     return false;
   }
   execute() {
-    const expr = tcbExpression(this.binding.value, this.tcb, this.scope);
+    const expr = tcbExpression(this.expression, this.tcb, this.scope);
     this.scope.addStatement(import_typescript83.default.factory.createExpressionStatement(expr));
     return null;
   }
@@ -38912,9 +39030,7 @@ var Scope2 = class {
       this.elementOpMap.set(node, opIndex);
       this.appendDirectivesAndInputsOfNode(node);
       this.appendOutputsOfNode(node);
-      for (const child of node.children) {
-        this.appendNode(child);
-      }
+      this.appendChildren(node);
       this.checkAndAppendReferencesOfNode(node);
     } else if (node instanceof Template) {
       this.appendDirectivesAndInputsOfNode(node);
@@ -38927,12 +39043,35 @@ var Scope2 = class {
         this.appendDeepSchemaChecks(node.children);
       }
       this.checkAndAppendReferencesOfNode(node);
+    } else if (node instanceof DeferredBlock) {
+      node.triggers.when !== void 0 && this.opQueue.push(new TcbExpressionOp(this.tcb, this, node.triggers.when.value));
+      node.prefetchTriggers.when !== void 0 && this.opQueue.push(new TcbExpressionOp(this.tcb, this, node.prefetchTriggers.when.value));
+      this.appendChildren(node);
+      node.placeholder !== null && this.appendChildren(node.placeholder);
+      node.loading !== null && this.appendChildren(node.loading);
+      node.error !== null && this.appendChildren(node.error);
+    } else if (node instanceof IfBlock) {
+      for (const branch of node.branches) {
+        this.appendChildren(branch);
+      }
+    } else if (node instanceof SwitchBlock) {
+      for (const currentCase of node.cases) {
+        this.appendChildren(currentCase);
+      }
+    } else if (node instanceof ForLoopBlock) {
+      this.appendChildren(node);
+      node.empty && this.appendChildren(node.empty);
     } else if (node instanceof BoundText) {
-      this.opQueue.push(new TcbTextInterpolationOp(this.tcb, this, node));
+      this.opQueue.push(new TcbExpressionOp(this.tcb, this, node.value));
     } else if (node instanceof Icu) {
       this.appendIcuExpressions(node);
     }
   }
+  appendChildren(node) {
+    for (const child of node.children) {
+      this.appendNode(child);
+    }
+  }
   checkAndAppendReferencesOfNode(node) {
     for (const ref of node.references) {
       const target = this.tcb.boundTarget.getReferenceTarget(ref);
@@ -39033,11 +39172,11 @@ var Scope2 = class {
   }
   appendIcuExpressions(node) {
     for (const variable2 of Object.values(node.vars)) {
-      this.opQueue.push(new TcbTextInterpolationOp(this.tcb, this, variable2));
+      this.opQueue.push(new TcbExpressionOp(this.tcb, this, variable2.value));
     }
     for (const placeholder of Object.values(node.placeholders)) {
       if (placeholder instanceof BoundText) {
-        this.opQueue.push(new TcbTextInterpolationOp(this.tcb, this, placeholder));
+        this.opQueue.push(new TcbExpressionOp(this.tcb, this, placeholder.value));
       }
     }
   }