@angular/core 17.0.0-next.7 → 17.0.0-rc.0

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

@@ -2181,6 +2181,9 @@ var Identifiers = _Identifiers;
 (() => {
   _Identifiers.deferPrefetchOnViewport = { name: "\u0275\u0275deferPrefetchOnViewport", moduleName: CORE };
 })();
+(() => {
+  _Identifiers.deferEnableTimerScheduling = { name: "\u0275\u0275deferEnableTimerScheduling", moduleName: CORE };
+})();
 (() => {
   _Identifiers.conditional = { name: "\u0275\u0275conditional", moduleName: CORE };
 })();
@@ -2508,6 +2511,9 @@ var Identifiers = _Identifiers;
 (() => {
   _Identifiers.setClassMetadataAsync = { name: "\u0275setClassMetadataAsync", moduleName: CORE };
 })();
+(() => {
+  _Identifiers.setClassDebugInfo = { name: "\u0275setClassDebugInfo", moduleName: CORE };
+})();
 (() => {
   _Identifiers.queryRefresh = { name: "\u0275\u0275queryRefresh", moduleName: CORE };
 })();
@@ -3673,12 +3679,13 @@ var DeferredBlockError = class {
   }
 };
 var DeferredBlock = class {
-  constructor(children, triggers, prefetchTriggers, placeholder, loading, error2, sourceSpan, startSourceSpan, endSourceSpan) {
+  constructor(children, triggers, prefetchTriggers, placeholder, loading, error2, sourceSpan, mainBlockSpan, startSourceSpan, endSourceSpan) {
     this.children = children;
     this.placeholder = placeholder;
     this.loading = loading;
     this.error = error2;
     this.sourceSpan = sourceSpan;
+    this.mainBlockSpan = mainBlockSpan;
     this.startSourceSpan = startSourceSpan;
     this.endSourceSpan = endSourceSpan;
     this.triggers = triggers;
@@ -3693,20 +3700,18 @@ var DeferredBlock = class {
     this.visitTriggers(this.definedTriggers, this.triggers, visitor);
     this.visitTriggers(this.definedPrefetchTriggers, this.prefetchTriggers, visitor);
     visitAll(visitor, this.children);
-    this.placeholder && visitor.visitDeferredBlockPlaceholder(this.placeholder);
-    this.loading && visitor.visitDeferredBlockLoading(this.loading);
-    this.error && visitor.visitDeferredBlockError(this.error);
+    const remainingBlocks = [this.placeholder, this.loading, this.error].filter((x) => x !== null);
+    visitAll(visitor, remainingBlocks);
   }
   visitTriggers(keys, triggers, visitor) {
-    for (const key of keys) {
-      visitor.visitDeferredTrigger(triggers[key]);
-    }
+    visitAll(visitor, keys.map((k) => triggers[k]));
   }
 };
 var SwitchBlock = class {
-  constructor(expression, cases, sourceSpan, startSourceSpan, endSourceSpan) {
+  constructor(expression, cases, unknownBlocks, sourceSpan, startSourceSpan, endSourceSpan) {
     this.expression = expression;
     this.cases = cases;
+    this.unknownBlocks = unknownBlocks;
     this.sourceSpan = sourceSpan;
     this.startSourceSpan = startSourceSpan;
     this.endSourceSpan = endSourceSpan;
@@ -3716,18 +3721,19 @@ var SwitchBlock = class {
   }
 };
 var SwitchBlockCase = class {
-  constructor(expression, children, sourceSpan, startSourceSpan) {
+  constructor(expression, children, sourceSpan, startSourceSpan, endSourceSpan) {
     this.expression = expression;
     this.children = children;
     this.sourceSpan = sourceSpan;
     this.startSourceSpan = startSourceSpan;
+    this.endSourceSpan = endSourceSpan;
   }
   visit(visitor) {
     return visitor.visitSwitchBlockCase(this);
   }
 };
 var ForLoopBlock = class {
-  constructor(item, expression, trackBy, contextVariables, children, empty, sourceSpan, startSourceSpan, endSourceSpan) {
+  constructor(item, expression, trackBy, contextVariables, children, empty, sourceSpan, mainBlockSpan, startSourceSpan, endSourceSpan) {
     this.item = item;
     this.expression = expression;
     this.trackBy = trackBy;
@@ -3735,6 +3741,7 @@ var ForLoopBlock = class {
     this.children = children;
     this.empty = empty;
     this.sourceSpan = sourceSpan;
+    this.mainBlockSpan = mainBlockSpan;
     this.startSourceSpan = startSourceSpan;
     this.endSourceSpan = endSourceSpan;
   }
@@ -3743,10 +3750,11 @@ var ForLoopBlock = class {
   }
 };
 var ForLoopBlockEmpty = class {
-  constructor(children, sourceSpan, startSourceSpan) {
+  constructor(children, sourceSpan, startSourceSpan, endSourceSpan) {
     this.children = children;
     this.sourceSpan = sourceSpan;
     this.startSourceSpan = startSourceSpan;
+    this.endSourceSpan = endSourceSpan;
   }
   visit(visitor) {
     return visitor.visitForLoopBlockEmpty(this);
@@ -3764,17 +3772,27 @@ var IfBlock = class {
   }
 };
 var IfBlockBranch = class {
-  constructor(expression, children, expressionAlias, sourceSpan, startSourceSpan) {
+  constructor(expression, children, expressionAlias, sourceSpan, startSourceSpan, endSourceSpan) {
     this.expression = expression;
     this.children = children;
     this.expressionAlias = expressionAlias;
     this.sourceSpan = sourceSpan;
     this.startSourceSpan = startSourceSpan;
+    this.endSourceSpan = endSourceSpan;
   }
   visit(visitor) {
     return visitor.visitIfBlockBranch(this);
   }
 };
+var UnknownBlock = class {
+  constructor(name, sourceSpan) {
+    this.name = name;
+    this.sourceSpan = sourceSpan;
+  }
+  visit(visitor) {
+    return visitor.visitUnknownBlock(this);
+  }
+};
 var Template = class {
   constructor(tagName, attributes, inputs, outputs, templateAttrs, children, references, variables, sourceSpan, startSourceSpan, endSourceSpan, i18n2) {
     this.tagName = tagName;
@@ -6724,7 +6742,7 @@ var ShadowCss = class {
     while ((res = sep.exec(selector)) !== null) {
       const separator = res[1];
       const part2 = selector.slice(startIndex, res.index).trim();
-      if (part2.match(_placeholderRe) && ((_a2 = selector[res.index + 1]) == null ? void 0 : _a2.match(/[a-fA-F\d]/))) {
+      if (part2.match(/__esc-ph-(\d+)__/) && ((_a2 = selector[res.index + 1]) == null ? void 0 : _a2.match(/[a-fA-F\d]/))) {
         continue;
       }
       shouldScope = shouldScope || part2.indexOf(_polyfillHostNoCombinator) > -1;
@@ -6746,7 +6764,12 @@ var SafeSelector = class {
     this.placeholders = [];
     this.index = 0;
     selector = this._escapeRegexMatches(selector, /(\[[^\]]*\])/g);
-    selector = this._escapeRegexMatches(selector, /(\\.)/g);
+    selector = selector.replace(/(\\.)/g, (_, keep) => {
+      const replaceBy = `__esc-ph-${this.index}__`;
+      this.placeholders.push(keep);
+      this.index++;
+      return replaceBy;
+    });
     this._content = selector.replace(/(:nth-[-\w]+)(\([^)]+\))/g, (_, pseudo, exp) => {
       const replaceBy = `__ph-${this.index}__`;
       this.placeholders.push(exp);
@@ -6755,7 +6778,7 @@ var SafeSelector = class {
     });
   }
   restore(content) {
-    return content.replace(_placeholderRe, (_ph, index) => this.placeholders[+index]);
+    return content.replace(/__(?:ph|esc-ph)-(\d+)__/g, (_ph, index) => this.placeholders[+index]);
   }
   content() {
     return this._content;
@@ -6796,7 +6819,6 @@ var _commentRe = /\/\*[\s\S]*?\*\//g;
 var _commentWithHashRe = /\/\*\s*#\s*source(Mapping)?URL=/g;
 var COMMENT_PLACEHOLDER = "%COMMENT%";
 var _commentWithHashPlaceHolderRe = new RegExp(COMMENT_PLACEHOLDER, "g");
-var _placeholderRe = /__ph-(\d+)__/g;
 var BLOCK_PLACEHOLDER = "%BLOCK%";
 var _ruleRe = new RegExp(`(\\s*(?:${COMMENT_PLACEHOLDER}\\s*)*)([^;\\{\\}]+?)(\\s*)((?:{%BLOCK%}?\\s*;?)|(?:\\s*;))`, "g");
 var CONTENT_PAIRS = /* @__PURE__ */ new Map([["{", "}"]]);
@@ -6986,6 +7008,8 @@ var OpKind;
   OpKind2[OpKind2["I18nEnd"] = 36] = "I18nEnd";
   OpKind2[OpKind2["I18nExpression"] = 37] = "I18nExpression";
   OpKind2[OpKind2["I18nApply"] = 38] = "I18nApply";
+  OpKind2[OpKind2["Icu"] = 39] = "Icu";
+  OpKind2[OpKind2["IcuUpdate"] = 40] = "IcuUpdate";
 })(OpKind || (OpKind = {}));
 var ExpressionKind;
 (function(ExpressionKind2) {
@@ -7048,6 +7072,11 @@ var BindingKind;
   BindingKind2[BindingKind2["I18n"] = 5] = "I18n";
   BindingKind2[BindingKind2["Animation"] = 6] = "Animation";
 })(BindingKind || (BindingKind = {}));
+var I18nParamResolutionTime;
+(function(I18nParamResolutionTime2) {
+  I18nParamResolutionTime2[I18nParamResolutionTime2["Creation"] = 0] = "Creation";
+  I18nParamResolutionTime2[I18nParamResolutionTime2["Postproccessing"] = 1] = "Postproccessing";
+})(I18nParamResolutionTime || (I18nParamResolutionTime = {}));
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/template/pipeline/ir/src/traits.mjs
 var ConsumesSlot = Symbol("ConsumesSlot");
@@ -7228,12 +7257,14 @@ function createConditionalOp(target, test, conditions, sourceSpan) {
     contextValue: null
   }, NEW_OP), TRAIT_USES_SLOT_INDEX), TRAIT_DEPENDS_ON_SLOT_CONTEXT), TRAIT_CONSUMES_VARS);
 }
-function createI18nExpressionOp(target, expression, i18nPlaceholder, sourceSpan) {
+function createI18nExpressionOp(owner, expression, i18nPlaceholder, resolutionTime, sourceSpan) {
   return __spreadValues(__spreadValues(__spreadValues({
     kind: OpKind.I18nExpression,
-    target,
+    owner,
+    target: owner,
     expression,
     i18nPlaceholder,
+    resolutionTime,
     sourceSpan
   }, NEW_OP), TRAIT_CONSUMES_VARS), TRAIT_DEPENDS_ON_SLOT_CONTEXT);
 }
@@ -7244,6 +7275,13 @@ function createI18nApplyOp(target, sourceSpan) {
     sourceSpan
   }, NEW_OP), TRAIT_USES_SLOT_INDEX);
 }
+function createIcuUpdateOp(xref, sourceSpan) {
+  return __spreadValues({
+    kind: OpKind.IcuUpdate,
+    xref,
+    sourceSpan
+  }, NEW_OP);
+}
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/template/pipeline/ir/src/expression.mjs
 var _a;
@@ -7952,6 +7990,8 @@ function transformExpressionsInOp(op, transform2, flags) {
     case OpKind.Advance:
     case OpKind.Namespace:
     case OpKind.I18nApply:
+    case OpKind.Icu:
+    case OpKind.IcuUpdate:
       break;
     default:
       throw new Error(`AssertionError: transformExpressionsInOp doesn't handle ${OpKind[op.kind]}`);
@@ -8249,7 +8289,7 @@ function createElementStartOp(tag, xref, namespace, i18nPlaceholder, sourceSpan)
     sourceSpan
   }, TRAIT_CONSUMES_SLOT), NEW_OP);
 }
-function createTemplateOp(xref, tag, namespace, generatedInBlock, i18n2, sourceSpan) {
+function createTemplateOp(xref, tag, namespace, generatedInBlock, i18nPlaceholder, sourceSpan) {
   return __spreadValues(__spreadValues({
     kind: OpKind.Template,
     xref,
@@ -8261,6 +8301,7 @@ function createTemplateOp(xref, tag, namespace, generatedInBlock, i18n2, sourceS
     localRefs: [],
     nonBindable: false,
     namespace,
+    i18nPlaceholder,
     sourceSpan
   }, TRAIT_CONSUMES_SLOT), NEW_OP);
 }
@@ -8388,13 +8429,17 @@ function createExtractedMessageOp(owner, expression, statements) {
     statements
   }, NEW_OP);
 }
-function createI18nStartOp(xref, message) {
+function createI18nStartOp(xref, message, root) {
   return __spreadValues(__spreadValues({
     kind: OpKind.I18nStart,
     xref,
+    root: root != null ? root : xref,
     message,
     params: /* @__PURE__ */ new Map(),
-    messageIndex: null
+    postprocessingParams: /* @__PURE__ */ new Map(),
+    messageIndex: null,
+    subTemplateIndex: null,
+    needsPostprocessing: false
   }, NEW_OP), TRAIT_CONSUMES_SLOT);
 }
 function createI18nEndOp(xref) {
@@ -8403,6 +8448,14 @@ function createI18nEndOp(xref) {
     xref
   }, NEW_OP);
 }
+function createIcuOp(xref, message, sourceSpan) {
+  return __spreadValues({
+    kind: OpKind.Icu,
+    xref,
+    message,
+    sourceSpan
+  }, NEW_OP);
+}
 function literalOrArrayLiteral(value) {
   if (Array.isArray(value)) {
     return literalArr(value.map(literalOrArrayLiteral));
@@ -8652,7 +8705,7 @@ function phaseApplyI18nExpressions(job) {
   for (const unit of job.units) {
     for (const op of unit.update) {
       if (op.kind === OpKind.I18nExpression && needsApplication(op)) {
-        OpList.insertAfter(createI18nApplyOp(op.target, null), op);
+        OpList.insertAfter(createI18nApplyOp(op.owner, null), op);
       }
     }
   }
@@ -8662,12 +8715,33 @@ function needsApplication(op) {
   if (((_a2 = op.next) == null ? void 0 : _a2.kind) !== OpKind.I18nExpression) {
     return true;
   }
-  if (op.next.target !== op.target) {
+  if (op.next.owner !== op.owner) {
     return true;
   }
   return false;
 }
 
+// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/assign_i18n_slot_dependencies.mjs
+function phaseAssignI18nSlotDependencies(job) {
+  const i18nLastSlotConsumers = /* @__PURE__ */ new Map();
+  let lastSlotConsumer = null;
+  for (const unit of job.units) {
+    for (const op of unit.create) {
+      if (op.kind === OpKind.I18nEnd) {
+        i18nLastSlotConsumers.set(op.xref, lastSlotConsumer);
+      }
+      if (hasConsumesSlotTrait(op)) {
+        lastSlotConsumer = op.xref;
+      }
+    }
+    for (const op of unit.update) {
+      if (op.kind === OpKind.I18nExpression) {
+        op.target = i18nLastSlotConsumers.get(op.owner);
+      }
+    }
+  }
+}
+
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/template/pipeline/src/util/elements.mjs
 function getElementsByXrefId(unit) {
   const elements = /* @__PURE__ */ new Map();
@@ -9283,24 +9357,12 @@ function ternaryTransform(e) {
 function phaseGenerateAdvance(job) {
   for (const unit of job.units) {
     const slotMap = /* @__PURE__ */ new Map();
-    let lastSlotOp = null;
     for (const op of unit.create) {
-      if (op.kind === OpKind.I18nEnd) {
-        if (lastSlotOp === null) {
-          throw Error("Expected to have encountered an op prior to i18nEnd that consumes a slot");
-        }
-        let lastSlot = lastSlotOp.slot;
-        if (lastSlotOp.kind === OpKind.I18nStart && job.compatibility) {
-          lastSlot++;
-        }
-        slotMap.set(op.xref, lastSlot);
-      }
       if (!hasConsumesSlotTrait(op)) {
         continue;
       } else if (op.slot === null) {
         throw new Error(`AssertionError: expected slots to have been allocated before generating advance() calls`);
       }
-      lastSlotOp = op;
       slotMap.set(op.xref, op.slot);
     }
     let slotContext = 0;
@@ -9387,7 +9449,6 @@ function getScopeForView(view, parent) {
   }
   for (const op of view.create) {
     switch (op.kind) {
-      case OpKind.Element:
       case OpKind.ElementStart:
       case OpKind.Template:
         if (!Array.isArray(op.localRefs)) {
@@ -9521,8 +9582,8 @@ function phaseI18nConstCollection(job) {
   }
   for (const unit of job.units) {
     for (const op of unit.create) {
-      if ((op.kind === OpKind.I18nStart || op.kind === OpKind.I18n) && messageConstIndices[op.xref] !== void 0) {
-        op.messageIndex = messageConstIndices[op.xref];
+      if (op.kind === OpKind.I18nStart) {
+        op.messageIndex = messageConstIndices[op.root];
       }
     }
   }
@@ -11364,7 +11425,7 @@ function getHtmlTagDefinition(tagName) {
   var _a2, _b2;
   if (!TAG_DEFINITIONS) {
     DEFAULT_TAG_DEFINITION = new HtmlTagDefinition({ canSelfClose: true });
-    TAG_DEFINITIONS = {
+    TAG_DEFINITIONS = Object.assign(/* @__PURE__ */ Object.create(null), {
       "base": new HtmlTagDefinition({ isVoid: true }),
       "meta": new HtmlTagDefinition({ isVoid: true }),
       "area": new HtmlTagDefinition({ isVoid: true }),
@@ -11439,9 +11500,9 @@ function getHtmlTagDefinition(tagName) {
         contentType: { default: TagContentType.ESCAPABLE_RAW_TEXT, svg: TagContentType.PARSABLE_DATA }
       }),
       "textarea": new HtmlTagDefinition({ contentType: TagContentType.ESCAPABLE_RAW_TEXT, ignoreFirstLf: true })
-    };
+    });
     new DomElementSchemaRegistry().allKnownElementNames().forEach((knownTagName) => {
-      if (!TAG_DEFINITIONS.hasOwnProperty(knownTagName) && getNsPrefix(knownTagName) === null) {
+      if (!TAG_DEFINITIONS[knownTagName] && getNsPrefix(knownTagName) === null) {
         TAG_DEFINITIONS[knownTagName] = new HtmlTagDefinition({ canSelfClose: false });
       }
     });
@@ -13943,7 +14004,7 @@ var _Tokenizer = class {
         this.handleError(e);
       }
     }
-    this._beginToken(28);
+    this._beginToken(29);
     this._endToken([]);
   }
   _getBlockName() {
@@ -13963,17 +14024,24 @@ var _Tokenizer = class {
   }
   _consumeBlockStart(start) {
     this._beginToken(24, start);
-    this._endToken([this._getBlockName()]);
+    const startToken = this._endToken([this._getBlockName()]);
     if (this._cursor.peek() === $LPAREN) {
       this._cursor.advance();
       this._consumeBlockParameters();
       this._attemptCharCodeUntilFn(isNotWhitespace);
-      this._requireCharCode($RPAREN);
-      this._attemptCharCodeUntilFn(isNotWhitespace);
+      if (this._attemptCharCode($RPAREN)) {
+        this._attemptCharCodeUntilFn(isNotWhitespace);
+      } else {
+        startToken.type = 28;
+        return;
+      }
+    }
+    if (this._attemptCharCode($LBRACE)) {
+      this._beginToken(25);
+      this._endToken([]);
+    } else {
+      startToken.type = 28;
     }
-    this._beginToken(25);
-    this._requireCharCode($LBRACE);
-    this._endToken([]);
   }
   _consumeBlockEnd(start) {
     this._beginToken(26, start);
@@ -14805,7 +14873,7 @@ var _TreeBuilder = class {
     this._advance();
   }
   build() {
-    while (this._peek.type !== 28) {
+    while (this._peek.type !== 29) {
       if (this._peek.type === 0 || this._peek.type === 4) {
         this._consumeStartTag(this._advance());
       } else if (this._peek.type === 3) {
@@ -14827,6 +14895,9 @@ var _TreeBuilder = class {
       } else if (this._peek.type === 26) {
         this._closeVoidElement();
         this._consumeBlockClose(this._advance());
+      } else if (this._peek.type === 28) {
+        this._closeVoidElement();
+        this._consumeIncompleteBlock(this._advance());
       } else {
         this._advance();
       }
@@ -14891,7 +14962,7 @@ var _TreeBuilder = class {
     if (!exp)
       return null;
     const end = this._advance();
-    exp.push({ type: 28, parts: [], sourceSpan: end.sourceSpan });
+    exp.push({ type: 29, parts: [], sourceSpan: end.sourceSpan });
     const expansionCaseParser = new _TreeBuilder(exp, this.getTagDefinition);
     expansionCaseParser.build();
     if (expansionCaseParser.errors.length > 0) {
@@ -14927,7 +14998,7 @@ var _TreeBuilder = class {
           return null;
         }
       }
-      if (this._peek.type === 28) {
+      if (this._peek.type === 29) {
         this.errors.push(TreeError.create(null, start.sourceSpan, `Invalid ICU message. Missing '}'.`));
         return null;
       }
@@ -15079,15 +15150,26 @@ var _TreeBuilder = class {
     const startSpan = new ParseSourceSpan(token.sourceSpan.start, end, token.sourceSpan.fullStart);
     const block = new Block(token.parts[0], parameters, [], span, startSpan);
     this._pushContainer(block, false);
-    return block;
   }
   _consumeBlockClose(token) {
-    const previousContainer = this._getContainer();
     if (!this._popContainer(null, Block, token.sourceSpan)) {
-      const context = previousContainer instanceof Element2 ? `There is an unclosed "${previousContainer.name}" HTML tag that may have to be closed first.` : `The block may have been closed earlier.`;
-      this.errors.push(TreeError.create(null, token.sourceSpan, `Unexpected closing block. ${context}`));
+      this.errors.push(TreeError.create(null, token.sourceSpan, `Unexpected closing block. The block may have been closed earlier. If you meant to write the } character, you should use the "}" HTML entity instead.`));
     }
   }
+  _consumeIncompleteBlock(token) {
+    const parameters = [];
+    while (this._peek.type === 27) {
+      const paramToken = this._advance();
+      parameters.push(new BlockParameter(paramToken.parts[0], paramToken.sourceSpan));
+    }
+    const end = this._peek.sourceSpan.fullStart;
+    const span = new ParseSourceSpan(token.sourceSpan.start, end, token.sourceSpan.fullStart);
+    const startSpan = new ParseSourceSpan(token.sourceSpan.start, end, token.sourceSpan.fullStart);
+    const block = new Block(token.parts[0], parameters, [], span, startSpan);
+    this._pushContainer(block, false);
+    this._popContainer(null, Block, null);
+    this.errors.push(TreeError.create(token.parts[0], span, `Incomplete block "${token.parts[0]}". If you meant to write the @ character, you should use the "@" HTML entity instead.`));
+  }
   _getContainer() {
     return this._containerStack.length > 0 ? this._containerStack[this._containerStack.length - 1] : null;
   }
@@ -15446,12 +15528,22 @@ function phaseI18nMessageExtraction(job) {
   const fileBasedI18nSuffix = job.relativeContextFilePath.replace(/[^A-Za-z0-9]/g, "_").toUpperCase() + "_";
   for (const unit of job.units) {
     for (const op of unit.create) {
-      if (op.kind === OpKind.I18nStart || op.kind === OpKind.I18n) {
-        const params = new Map([...op.params.entries()].sort());
-        const mainVar = variable(job.pool.uniqueName(TRANSLATION_VAR_PREFIX2));
-        const closureVar = i18nGenerateClosureVar(job.pool, op.message.id, fileBasedI18nSuffix, job.i18nUseExternalIds);
-        const statements = getTranslationDeclStmts(op.message, mainVar, closureVar, params, void 0);
-        unit.create.push(createExtractedMessageOp(op.xref, mainVar, statements));
+      if (op.kind === OpKind.I18nStart) {
+        if (op.xref === op.root) {
+          const params = new Map([...op.params.entries()].sort());
+          const mainVar = variable(job.pool.uniqueName(TRANSLATION_VAR_PREFIX2));
+          const closureVar = i18nGenerateClosureVar(job.pool, op.message.id, fileBasedI18nSuffix, job.i18nUseExternalIds);
+          let transformFn = void 0;
+          if (op.needsPostprocessing) {
+            const extraTransformFnParams = [];
+            if (op.postprocessingParams.size > 0) {
+              extraTransformFnParams.push(literalMap([...op.postprocessingParams.entries()].map(([key, value]) => ({ key, value, quoted: true }))));
+            }
+            transformFn = (expr) => importExpr(Identifiers.i18nPostprocess).callFn([expr, ...extraTransformFnParams]);
+          }
+          const statements = getTranslationDeclStmts(op.message, mainVar, closureVar, params, transformFn);
+          unit.create.push(createExtractedMessageOp(op.xref, mainVar, statements));
+        }
       }
     }
   }
@@ -15517,7 +15609,7 @@ function phaseI18nTextExtraction(job) {
           for (let i = 0; i < op.interpolation.expressions.length; i++) {
             const expr = op.interpolation.expressions[i];
             const placeholder = op.i18nPlaceholders[i];
-            ops.push(createI18nExpressionOp(i18nBlockId, expr, placeholder, (_a2 = expr.sourceSpan) != null ? _a2 : op.sourceSpan));
+            ops.push(createI18nExpressionOp(i18nBlockId, expr, placeholder.name, I18nParamResolutionTime.Creation, (_a2 = expr.sourceSpan) != null ? _a2 : op.sourceSpan));
           }
           if (ops.length > 0) {
           }
@@ -15528,13 +15620,52 @@ function phaseI18nTextExtraction(job) {
   }
 }
 
+// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/icu_extraction.mjs
+function phaseIcuExtraction(job) {
+  for (const unit of job.units) {
+    const icus = /* @__PURE__ */ new Map();
+    let currentI18nId = null;
+    for (const op of unit.create) {
+      switch (op.kind) {
+        case OpKind.I18nStart:
+          currentI18nId = op.xref;
+          break;
+        case OpKind.I18nEnd:
+          currentI18nId = null;
+          break;
+        case OpKind.Icu:
+          if (currentI18nId === null) {
+            throw Error("Unexpected ICU outside of an i18n block.");
+          }
+          icus.set(op.xref, { message: op.message, i18nBlockId: currentI18nId });
+          OpList.remove(op);
+          break;
+      }
+    }
+    for (const op of unit.update) {
+      switch (op.kind) {
+        case OpKind.IcuUpdate:
+          const { message, i18nBlockId } = icus.get(op.xref);
+          const icuNode = message.nodes.find((n) => n instanceof Icu2);
+          if (icuNode === void 0) {
+            throw Error("Could not find ICU in i18n AST");
+          }
+          if (icuNode.expressionPlaceholder === void 0) {
+            throw Error("ICU is missing an i18n placeholder");
+          }
+          OpList.replace(op, createI18nExpressionOp(i18nBlockId, new LexicalReadExpr(icuNode.expression), icuNode.expressionPlaceholder, I18nParamResolutionTime.Postproccessing, null));
+          break;
+      }
+    }
+  }
+}
+
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/local_refs.mjs
 function phaseLocalRefs(job) {
   for (const unit of job.units) {
     for (const op of unit.create) {
       switch (op.kind) {
         case OpKind.ElementStart:
-        case OpKind.Element:
         case OpKind.Template:
           if (!Array.isArray(op.localRefs)) {
             throw new Error(`AssertionError: expected localRefs to be an array still`);
@@ -15564,7 +15695,7 @@ function phaseNamespace(job) {
   for (const unit of job.units) {
     let activeNamespace = Namespace.HTML;
     for (const op of unit.create) {
-      if (op.kind !== OpKind.Element && op.kind !== OpKind.ElementStart) {
+      if (op.kind !== OpKind.ElementStart) {
         continue;
       }
       if (op.namespace !== activeNamespace) {
@@ -15683,7 +15814,8 @@ function addNamesToView(unit, baseName, state, compatibility) {
         if (op.slot === null) {
           throw new Error(`Expected slot to be assigned`);
         }
-        addNamesToView(childView, `${baseName}_${prefixWithNamespace(op.tag, op.namespace)}_${op.slot}`, state, compatibility);
+        const tagToken = op.tag === null ? "" : "_" + prefixWithNamespace(op.tag, op.namespace);
+        addNamesToView(childView, `${baseName}${tagToken}_${op.slot}`, state, compatibility);
         break;
       case OpKind.StyleProp:
         op.name = normalizeStylePropName(op.name);
@@ -15789,10 +15921,6 @@ function phaseNgContainer(job) {
   for (const unit of job.units) {
     const updatedElementXrefs = /* @__PURE__ */ new Set();
     for (const op of unit.create) {
-      if (op.kind === OpKind.Element && op.tag === CONTAINER_TAG) {
-        op.kind = OpKind.Container;
-        updatedElementXrefs.add(op.xref);
-      }
       if (op.kind === OpKind.ElementStart && op.tag === CONTAINER_TAG) {
         op.kind = OpKind.ContainerStart;
         updatedElementXrefs.add(op.xref);
@@ -16027,6 +16155,43 @@ function phasePipeVariadic(job) {
   }
 }
 
+// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/propagate_i18n_blocks.mjs
+function phasePropagateI18nBlocks(job) {
+  propagateI18nBlocksToTemplates(job.root, 0);
+}
+function propagateI18nBlocksToTemplates(unit, subTemplateIndex) {
+  let i18nBlock = null;
+  for (const op of unit.create) {
+    switch (op.kind) {
+      case OpKind.I18nStart:
+        op.subTemplateIndex = subTemplateIndex === 0 ? null : subTemplateIndex;
+        i18nBlock = op;
+        break;
+      case OpKind.I18nEnd:
+        i18nBlock = null;
+        break;
+      case OpKind.Template:
+        const templateView = unit.job.views.get(op.xref);
+        if (op.i18nPlaceholder !== void 0) {
+          if (i18nBlock === null) {
+            throw Error("Expected template with i18n placeholder to be in an i18n block.");
+          }
+          subTemplateIndex++;
+          wrapTemplateWithI18n(templateView, i18nBlock);
+        }
+        propagateI18nBlocksToTemplates(templateView, subTemplateIndex);
+    }
+  }
+}
+function wrapTemplateWithI18n(unit, parentI18n) {
+  var _a2;
+  if (((_a2 = unit.create.head.next) == null ? void 0 : _a2.kind) !== OpKind.I18nStart) {
+    const id = unit.job.allocateXrefId();
+    OpList.insertAfter(createI18nStartOp(id, parentI18n.message, parentI18n.root), unit.create.head);
+    OpList.insertBefore(createI18nEndOp(id), unit.create.tail);
+  }
+}
+
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/pure_function_extraction.mjs
 function phasePureFunctionExtraction(job) {
   for (const view of job.units) {
@@ -16152,7 +16317,7 @@ function elementContainerEnd() {
 }
 function template(slot, templateFnRef, decls, vars, tag, constIndex, sourceSpan) {
   const args = [literal(slot), templateFnRef, literal(decls), literal(vars)];
-  if (tag !== null) {
+  if (tag !== null || constIndex !== null) {
     args.push(literal(tag));
     if (constIndex !== null) {
       args.push(literal(constIndex));
@@ -16258,11 +16423,19 @@ function projection(slot, projectionSlotIndex, attributes) {
   }
   return call(Identifiers.projection, args, null);
 }
-function i18nStart(slot, constIndex) {
-  return call(Identifiers.i18nStart, [literal(slot), literal(constIndex)], null);
+function i18nStart(slot, constIndex, subTemplateIndex) {
+  const args = [literal(slot), literal(constIndex)];
+  if (subTemplateIndex !== null) {
+    args.push(literal(subTemplateIndex));
+  }
+  return call(Identifiers.i18nStart, args, null);
 }
-function i18n(slot, constIndex) {
-  return call(Identifiers.i18n, [literal(slot), literal(constIndex)], null);
+function i18n(slot, constIndex, subTemplateIndex) {
+  const args = [literal(slot), literal(constIndex)];
+  if (subTemplateIndex) {
+    args.push(literal(subTemplateIndex));
+  }
+  return call(Identifiers.i18n, args, null);
 }
 function i18nEnd() {
   return call(Identifiers.i18nEnd, [], null);
@@ -16605,13 +16778,13 @@ function reifyCreateOperations(unit, ops) {
         OpList.replace(op, elementContainerEnd());
         break;
       case OpKind.I18nStart:
-        OpList.replace(op, i18nStart(op.slot, op.messageIndex));
+        OpList.replace(op, i18nStart(op.slot, op.messageIndex, op.subTemplateIndex));
         break;
       case OpKind.I18nEnd:
         OpList.replace(op, i18nEnd());
         break;
       case OpKind.I18n:
-        OpList.replace(op, i18n(op.slot, op.messageIndex));
+        OpList.replace(op, i18n(op.slot, op.messageIndex, op.subTemplateIndex));
         break;
       case OpKind.Template:
         if (!(unit instanceof ViewCompilationUnit)) {
@@ -16917,45 +17090,149 @@ function resolveDollarEvent(unit, ops) {
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/resolve_i18n_placeholders.mjs
 var ESCAPE = "\uFFFD";
+var ELEMENT_MARKER = "#";
+var TEMPLATE_MARKER = "*";
+var TAG_CLOSE_MARKER = "/";
+var CONTEXT_MARKER = ":";
+var LIST_START_MARKER = "[";
+var LIST_END_MARKER = "]";
+var LIST_DELIMITER = "|";
+var I18nParamValueFlags;
+(function(I18nParamValueFlags2) {
+  I18nParamValueFlags2[I18nParamValueFlags2["None"] = 0] = "None";
+  I18nParamValueFlags2[I18nParamValueFlags2["ElementTag"] = 1] = "ElementTag";
+  I18nParamValueFlags2[I18nParamValueFlags2["TemplateTag"] = 2] = "TemplateTag";
+  I18nParamValueFlags2[I18nParamValueFlags2["OpenTag"] = 4] = "OpenTag";
+  I18nParamValueFlags2[I18nParamValueFlags2["CloseTag"] = 8] = "CloseTag";
+})(I18nParamValueFlags || (I18nParamValueFlags = {}));
+var I18nPlaceholderParams = class {
+  constructor() {
+    this.values = /* @__PURE__ */ new Map();
+  }
+  addValue(placeholder, value, subTemplateIndex, resolutionTime, flags) {
+    var _a2;
+    const placeholderValues = (_a2 = this.values.get(placeholder)) != null ? _a2 : [];
+    placeholderValues.push({ value, subTemplateIndex, resolutionTime, flags });
+    this.values.set(placeholder, placeholderValues);
+  }
+  saveToOp(op) {
+    for (const [placeholder, placeholderValues] of this.values) {
+      const creationValues = placeholderValues.filter(({ resolutionTime }) => resolutionTime === I18nParamResolutionTime.Creation);
+      if (creationValues.length > 1) {
+        op.needsPostprocessing = true;
+      }
+      const serializedCreationValues = this.serializeValues(creationValues);
+      if (serializedCreationValues !== null) {
+        op.params.set(placeholder, literal(serializedCreationValues));
+      }
+      const serializedPostprocessingValues = this.serializeValues(placeholderValues.filter(({ resolutionTime }) => resolutionTime === I18nParamResolutionTime.Postproccessing));
+      if (serializedPostprocessingValues !== null) {
+        op.needsPostprocessing = true;
+        op.postprocessingParams.set(placeholder, literal(serializedPostprocessingValues));
+      }
+    }
+  }
+  merge(other) {
+    for (const [placeholder, otherValues] of other.values) {
+      const currentValues = this.values.get(placeholder) || [];
+      const flags = otherValues[0].flags;
+      if (flags & I18nParamValueFlags.CloseTag && !(flags & I18nParamValueFlags.OpenTag)) {
+        this.values.set(placeholder, [...otherValues, ...currentValues]);
+      } else {
+        this.values.set(placeholder, [...currentValues, ...otherValues]);
+      }
+    }
+  }
+  serializeValues(values) {
+    if (values.length === 0) {
+      return null;
+    }
+    const serializedValues = values.map((value) => this.serializeValue(value));
+    return serializedValues.length === 1 ? serializedValues[0] : `${LIST_START_MARKER}${serializedValues.join(LIST_DELIMITER)}${LIST_END_MARKER}`;
+  }
+  serializeValue(value) {
+    let tagMarker = "";
+    let closeMarker = "";
+    if (value.flags & I18nParamValueFlags.ElementTag) {
+      tagMarker = ELEMENT_MARKER;
+    } else if (value.flags & I18nParamValueFlags.TemplateTag) {
+      tagMarker = TEMPLATE_MARKER;
+    }
+    if (tagMarker !== "") {
+      closeMarker = value.flags & I18nParamValueFlags.CloseTag ? TAG_CLOSE_MARKER : "";
+    }
+    const context = value.subTemplateIndex === null ? "" : `${CONTEXT_MARKER}${value.subTemplateIndex}`;
+    if (value.flags & I18nParamValueFlags.OpenTag && value.flags & I18nParamValueFlags.CloseTag) {
+      return `${ESCAPE}${tagMarker}${value.value}${context}${ESCAPE}${ESCAPE}${closeMarker}${tagMarker}${value.value}${context}${ESCAPE}`;
+    }
+    return `${ESCAPE}${closeMarker}${tagMarker}${value.value}${context}${ESCAPE}`;
+  }
+};
 function phaseResolveI18nPlaceholders(job) {
+  const params = /* @__PURE__ */ new Map();
+  const i18nOps = /* @__PURE__ */ new Map();
+  resolvePlaceholders(job, params, i18nOps);
+  propagatePlaceholders(params, i18nOps);
+  for (const [xref, i18nOpParams] of params) {
+    i18nOpParams.saveToOp(i18nOps.get(xref));
+  }
+  for (const op of i18nOps.values()) {
+    if (op.xref === op.root) {
+      for (const placeholder in op.message.placeholders) {
+        if (!op.params.has(placeholder) && !op.postprocessingParams.has(placeholder)) {
+          throw Error(`Failed to resolve i18n placeholder: ${placeholder}`);
+        }
+      }
+    }
+  }
+}
+function resolvePlaceholders(job, params, i18nOps) {
   for (const unit of job.units) {
-    const i18nOps = /* @__PURE__ */ new Map();
-    let startTagSlots = /* @__PURE__ */ new Map();
-    let closeTagSlots = /* @__PURE__ */ new Map();
+    const elements = /* @__PURE__ */ new Map();
     let currentI18nOp = null;
     for (const op of unit.create) {
       switch (op.kind) {
         case OpKind.I18nStart:
-        case OpKind.I18n:
           i18nOps.set(op.xref, op);
           currentI18nOp = op.kind === OpKind.I18nStart ? op : null;
-          startTagSlots = /* @__PURE__ */ new Map();
-          closeTagSlots = /* @__PURE__ */ new Map();
           break;
         case OpKind.I18nEnd:
-          if (currentI18nOp === null) {
-            throw Error("Missing corresponding i18n start op for i18n end op");
-          }
-          for (const [placeholder, slots] of startTagSlots) {
-            currentI18nOp.params.set(placeholder, serializeSlots(slots, true));
-          }
-          for (const [placeholder, slots] of closeTagSlots) {
-            currentI18nOp.params.set(placeholder, serializeSlots(slots, false));
-          }
           currentI18nOp = null;
           break;
-        case OpKind.Element:
         case OpKind.ElementStart:
-          if (op.i18nPlaceholder != void 0) {
+          if (op.i18nPlaceholder !== void 0) {
             if (currentI18nOp === null) {
               throw Error("i18n tag placeholder should only occur inside an i18n block");
             }
-            if (!op.slot) {
-              throw Error("Slots should be allocated before i18n placeholder resolution");
-            }
+            elements.set(op.xref, op);
             const { startName, closeName } = op.i18nPlaceholder;
-            addTagSlot(startTagSlots, startName, op.slot);
-            addTagSlot(closeTagSlots, closeName, op.slot);
+            let flags = I18nParamValueFlags.ElementTag | I18nParamValueFlags.OpenTag;
+            if (closeName === "") {
+              flags |= I18nParamValueFlags.CloseTag;
+            }
+            addParam(params, currentI18nOp, startName, op.slot, currentI18nOp.subTemplateIndex, I18nParamResolutionTime.Creation, flags);
+          }
+          break;
+        case OpKind.ElementEnd:
+          const startOp = elements.get(op.xref);
+          if (startOp && startOp.i18nPlaceholder !== void 0) {
+            if (currentI18nOp === null) {
+              throw Error("i18n tag placeholder should only occur inside an i18n block");
+            }
+            const { closeName } = startOp.i18nPlaceholder;
+            if (closeName !== "") {
+              addParam(params, currentI18nOp, closeName, startOp.slot, currentI18nOp.subTemplateIndex, I18nParamResolutionTime.Creation, I18nParamValueFlags.ElementTag | I18nParamValueFlags.CloseTag);
+            }
+          }
+          break;
+        case OpKind.Template:
+          if (op.i18nPlaceholder !== void 0) {
+            if (currentI18nOp === null) {
+              throw Error("i18n tag placeholder should only occur inside an i18n block");
+            }
+            const subTemplateIndex = getSubTemplateIndexForTemplateTag(job, currentI18nOp, op);
+            addParam(params, currentI18nOp, op.i18nPlaceholder.startName, op.slot, subTemplateIndex, I18nParamResolutionTime.Creation, I18nParamValueFlags.TemplateTag);
+            addParam(params, currentI18nOp, op.i18nPlaceholder.closeName, op.slot, subTemplateIndex, I18nParamResolutionTime.Creation, I18nParamValueFlags.TemplateTag | I18nParamValueFlags.CloseTag);
           }
           break;
       }
@@ -16963,35 +17240,38 @@ function phaseResolveI18nPlaceholders(job) {
     const i18nBlockPlaceholderIndices = /* @__PURE__ */ new Map();
     for (const op of unit.update) {
       if (op.kind === OpKind.I18nExpression) {
-        const i18nOp = i18nOps.get(op.target);
-        let index = i18nBlockPlaceholderIndices.get(op.target) || 0;
+        const i18nOp = i18nOps.get(op.owner);
+        let index = i18nBlockPlaceholderIndices.get(op.owner) || 0;
         if (!i18nOp) {
           throw Error("Cannot find corresponding i18nStart for i18nExpr");
         }
-        i18nOp.params.set(op.i18nPlaceholder.name, literal(`${ESCAPE}${index++}${ESCAPE}`));
-        i18nBlockPlaceholderIndices.set(op.target, index);
-      }
-    }
-    for (const op of i18nOps.values()) {
-      for (const placeholder in op.message.placeholders) {
-        if (!op.params.has(placeholder)) {
-          throw Error(`Failed to resolve i18n placeholder: ${placeholder}`);
-        }
+        addParam(params, i18nOp, op.i18nPlaceholder, index++, i18nOp.subTemplateIndex, op.resolutionTime);
+        i18nBlockPlaceholderIndices.set(op.owner, index);
       }
     }
   }
 }
-function addTagSlot(tagSlots, placeholder, slot) {
-  const slots = tagSlots.get(placeholder) || [];
-  slots.push(slot);
-  tagSlots.set(placeholder, slots);
+function addParam(params, i18nOp, placeholder, value, subTemplateIndex, resolutionTime, flags = I18nParamValueFlags.None) {
+  const i18nOpParams = params.get(i18nOp.xref) || new I18nPlaceholderParams();
+  i18nOpParams.addValue(placeholder, value, subTemplateIndex, resolutionTime, flags);
+  params.set(i18nOp.xref, i18nOpParams);
 }
-function serializeSlots(slots, start) {
-  const slotStrings = slots.map((slot) => `${ESCAPE}${start ? "" : "/"}#${slot}${ESCAPE}`);
-  if (slotStrings.length === 1) {
-    return literal(slotStrings[0]);
+function getSubTemplateIndexForTemplateTag(job, i18nOp, op) {
+  for (const childOp of job.views.get(op.xref).create) {
+    if (childOp.kind === OpKind.I18nStart) {
+      return childOp.subTemplateIndex;
+    }
+  }
+  return i18nOp.subTemplateIndex;
+}
+function propagatePlaceholders(params, i18nOps) {
+  for (const [xref, opParams] of params) {
+    const op = i18nOps.get(xref);
+    if (op.xref !== op.root) {
+      const rootParams = params.get(op.root) || new I18nPlaceholderParams();
+      rootParams.merge(opParams);
+    }
   }
-  return literal(`[${slotStrings.join("|")}]`);
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/resolve_names.mjs
@@ -17090,7 +17370,8 @@ function phaseResolveSanitizers(job) {
   }
 }
 function isIframeElement(op) {
-  return (op.kind === OpKind.Element || op.kind === OpKind.ElementStart) && op.tag.toLowerCase() === "iframe";
+  var _a2;
+  return op.kind === OpKind.ElementStart && ((_a2 = op.tag) == null ? void 0 : _a2.toLowerCase()) === "iframe";
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/save_restore_view.mjs
@@ -17482,6 +17763,30 @@ function allowConservativeInlining(decl, target) {
   }
 }
 
+// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/wrap_icus.mjs
+function phaseWrapIcus(job) {
+  for (const unit of job.units) {
+    let currentI18nOp = null;
+    for (const op of unit.create) {
+      switch (op.kind) {
+        case OpKind.I18nStart:
+          currentI18nOp = op;
+          break;
+        case OpKind.I18nEnd:
+          currentI18nOp = null;
+          break;
+        case OpKind.Icu:
+          if (currentI18nOp === null) {
+            const id = job.allocateXrefId();
+            OpList.insertBefore(createI18nStartOp(id, op.message), op);
+            OpList.insertAfter(createI18nEndOp(id), op);
+          }
+          break;
+      }
+    }
+  }
+}
+
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/template/pipeline/src/emit.mjs
 var phases = [
   { kind: CompilationJobKind.Tmpl, fn: phaseRemoveContentSelectors },
@@ -17489,12 +17794,15 @@ var phases = [
   { kind: CompilationJobKind.Tmpl, fn: phaseNamespace },
   { kind: CompilationJobKind.Both, fn: phaseStyleBindingSpecialization },
   { kind: CompilationJobKind.Both, fn: phaseBindingSpecialization },
+  { kind: CompilationJobKind.Tmpl, fn: phasePropagateI18nBlocks },
+  { kind: CompilationJobKind.Tmpl, fn: phaseWrapIcus },
   { kind: CompilationJobKind.Both, fn: phaseAttributeExtraction },
   { kind: CompilationJobKind.Both, fn: phaseParseExtractedStyles },
   { kind: CompilationJobKind.Tmpl, fn: phaseRemoveEmptyBindings },
   { kind: CompilationJobKind.Tmpl, fn: phaseConditionals },
   { kind: CompilationJobKind.Tmpl, fn: phasePipeCreation },
   { kind: CompilationJobKind.Tmpl, fn: phaseI18nTextExtraction },
+  { kind: CompilationJobKind.Tmpl, fn: phaseIcuExtraction },
   { kind: CompilationJobKind.Tmpl, fn: phaseApplyI18nExpressions },
   { kind: CompilationJobKind.Tmpl, fn: phasePipeVariadic },
   { kind: CompilationJobKind.Both, fn: phasePureLiteralStructures },
@@ -17516,6 +17824,7 @@ var phases = [
   { kind: CompilationJobKind.Tmpl, fn: phaseI18nConstCollection },
   { kind: CompilationJobKind.Tmpl, fn: phaseConstTraitCollection },
   { kind: CompilationJobKind.Both, fn: phaseConstCollection },
+  { kind: CompilationJobKind.Tmpl, fn: phaseAssignI18nSlotDependencies },
   { kind: CompilationJobKind.Both, fn: phaseVarCounting },
   { kind: CompilationJobKind.Tmpl, fn: phaseGenerateAdvance },
   { kind: CompilationJobKind.Both, fn: phaseVariableOptimization },
@@ -17708,6 +18017,8 @@ function ingestNodes(unit, template2) {
       ingestSwitchBlock(unit, node);
     } else if (node instanceof DeferredBlock) {
       ingestDeferBlock(unit, node);
+    } else if (node instanceof Icu) {
+      ingestIcu(unit, node);
     } else {
       throw new Error(`Unsupported template node: ${node.constructor.name}`);
     }
@@ -17737,7 +18048,7 @@ function ingestElement(unit, element2) {
   }
 }
 function ingestTemplate(unit, tmpl) {
-  if (tmpl.i18n !== void 0 && !(tmpl.i18n instanceof Message)) {
+  if (tmpl.i18n !== void 0 && !(tmpl.i18n instanceof Message || tmpl.i18n instanceof TagPlaceholder)) {
     throw Error(`Unhandled i18n metadata type for template: ${tmpl.i18n.constructor.name}`);
   }
   const childView = unit.job.allocateView(unit.xref);
@@ -17746,7 +18057,8 @@ function ingestTemplate(unit, tmpl) {
   if (tmpl.tagName) {
     [namespacePrefix, tagNameWithoutNamespace] = splitNsName(tmpl.tagName);
   }
-  const tplOp = createTemplateOp(childView.xref, tagNameWithoutNamespace != null ? tagNameWithoutNamespace : "ng-template", namespaceForKey(namespacePrefix), false, void 0, tmpl.startSourceSpan);
+  const i18nPlaceholder = tmpl.i18n instanceof TagPlaceholder ? tmpl.i18n : void 0;
+  const tplOp = createTemplateOp(childView.xref, tagNameWithoutNamespace, namespaceForKey(namespacePrefix), false, i18nPlaceholder, tmpl.startSourceSpan);
   unit.create.push(tplOp);
   ingestBindings(unit, tplOp, tmpl);
   ingestReferences(tplOp, tmpl);
@@ -17754,7 +18066,7 @@ function ingestTemplate(unit, tmpl) {
   for (const { name, value } of tmpl.variables) {
     childView.contextVariables.set(name, value);
   }
-  if (tmpl.i18n instanceof Message) {
+  if (isPlainTemplate(tmpl) && tmpl.i18n instanceof Message) {
     const id = unit.job.allocateXrefId();
     OpList.insertAfter(createI18nStartOp(id, tmpl.i18n), childView.create.head);
     OpList.insertBefore(createI18nEndOp(id), childView.create.tail);
@@ -17771,6 +18083,7 @@ function ingestText(unit, text2) {
   unit.create.push(createTextOp(unit.job.allocateXrefId(), text2.value, text2.sourceSpan));
 }
 function ingestBoundText(unit, text2) {
+  var _a2;
   let value = text2.value;
   if (value instanceof ASTWithSource) {
     value = value.ast;
@@ -17779,7 +18092,7 @@ function ingestBoundText(unit, text2) {
     throw new Error(`AssertionError: expected Interpolation for BoundText node, got ${value.constructor.name}`);
   }
   if (text2.i18n !== void 0 && !(text2.i18n instanceof Container)) {
-    throw Error(`Unhandled i18n metadata type for text interpolation: ${text2.i18n.constructor.name}`);
+    throw Error(`Unhandled i18n metadata type for text interpolation: ${(_a2 = text2.i18n) == null ? void 0 : _a2.constructor.name}`);
   }
   const i18nPlaceholders = text2.i18n instanceof Container ? text2.i18n.children.filter((node) => node instanceof Placeholder) : [];
   const textXref = unit.job.allocateXrefId();
@@ -17863,6 +18176,16 @@ function ingestDeferBlock(unit, deferBlock) {
   const deferOnOp = createDeferOnOp(unit.job.allocateXrefId(), null);
   unit.create.push(deferOnOp);
 }
+function ingestIcu(unit, icu) {
+  var _a2;
+  if (icu.i18n instanceof Message) {
+    const xref = unit.job.allocateXrefId();
+    unit.create.push(createIcuOp(xref, icu.i18n, null));
+    unit.update.push(createIcuUpdateOp(xref, null));
+  } else {
+    throw Error(`Unhandled i18n metadata type for ICU: ${(_a2 = icu.i18n) == null ? void 0 : _a2.constructor.name}`);
+  }
+}
 function convertAst(ast, job, baseSourceSpan) {
   if (ast instanceof ASTWithSource) {
     return convertAst(ast.ast, job, baseSourceSpan);
@@ -17925,13 +18248,15 @@ function convertAst(ast, job, baseSourceSpan) {
     throw new Error(`Unhandled expression type: ${ast.constructor.name}`);
   }
 }
-function ingestBindings(unit, op, element2) {
+function isPlainTemplate(tmpl) {
   var _a2;
+  return splitNsName((_a2 = tmpl.tagName) != null ? _a2 : "")[1] === "ng-template";
+}
+function ingestBindings(unit, op, element2) {
   let flags = BindingFlags.None;
-  const isPlainTemplate = element2 instanceof Template && splitNsName((_a2 = element2.tagName) != null ? _a2 : "")[1] === "ng-template";
   if (element2 instanceof Template) {
     flags |= BindingFlags.OnNgTemplateElement;
-    if (isPlainTemplate) {
+    if (element2 instanceof Template && isPlainTemplate(element2)) {
       flags |= BindingFlags.BindingTargetsTemplate;
     }
     const templateAttrFlags = flags | BindingFlags.BindingTargetsTemplate | BindingFlags.IsStructuralTemplateAttribute;
@@ -17956,7 +18281,7 @@ function ingestBindings(unit, op, element2) {
         throw Error("Animation listener should have a phase");
       }
     }
-    if (element2 instanceof Template && !isPlainTemplate) {
+    if (element2 instanceof Template && !isPlainTemplate(element2)) {
       unit.create.push(createExtractedAttributeOp(op.xref, BindingKind.Property, output.name, null));
       continue;
     }
@@ -18855,10 +19180,10 @@ function normalizeNgContentSelect(selectAttr) {
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/render3/r3_control_flow.mjs
 var FOR_LOOP_EXPRESSION_PATTERN = /^\s*([0-9A-Za-z_$]*)\s+of\s+(.*)/;
-var FOR_LOOP_TRACK_PATTERN = /^track\s+(.*)/;
+var FOR_LOOP_TRACK_PATTERN = /^track\s+([\S\s]*)/;
 var CONDITIONAL_ALIAS_PATTERN = /^as\s+(.*)/;
 var ELSE_IF_PATTERN = /^else[^\S\r\n]+if/;
-var FOR_LOOP_LET_PATTERN = /^let\s+(.*)/;
+var FOR_LOOP_LET_PATTERN = /^let\s+([\S\s]*)/;
 var ALLOWED_FOR_LOOP_LET_VARIABLES = /* @__PURE__ */ new Set(["$index", "$first", "$last", "$even", "$odd", "$count"]);
 function isConnectedForLoopBlock(name) {
   return name === "empty";
@@ -18869,30 +19194,36 @@ function isConnectedIfLoopBlock(name) {
 function createIfBlock(ast, connectedBlocks, visitor, bindingParser) {
   const errors = validateIfConnectedBlocks(connectedBlocks);
   const branches = [];
-  if (errors.length > 0) {
-    return { node: null, errors };
-  }
   const mainBlockParams = parseConditionalBlockParameters(ast, errors, bindingParser);
   if (mainBlockParams !== null) {
-    branches.push(new IfBlockBranch(mainBlockParams.expression, visitAll2(visitor, ast.children, ast.children), mainBlockParams.expressionAlias, ast.sourceSpan, ast.startSourceSpan));
+    branches.push(new IfBlockBranch(mainBlockParams.expression, visitAll2(visitor, ast.children, ast.children), mainBlockParams.expressionAlias, ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan));
   }
   for (const block of connectedBlocks) {
-    const children = visitAll2(visitor, block.children, block.children);
     if (ELSE_IF_PATTERN.test(block.name)) {
       const params = parseConditionalBlockParameters(block, errors, bindingParser);
       if (params !== null) {
-        branches.push(new IfBlockBranch(params.expression, children, params.expressionAlias, block.sourceSpan, block.startSourceSpan));
+        const children = visitAll2(visitor, block.children, block.children);
+        branches.push(new IfBlockBranch(params.expression, children, params.expressionAlias, block.sourceSpan, block.startSourceSpan, block.endSourceSpan));
       }
     } else if (block.name === "else") {
-      branches.push(new IfBlockBranch(null, children, null, block.sourceSpan, block.startSourceSpan));
+      const children = visitAll2(visitor, block.children, block.children);
+      branches.push(new IfBlockBranch(null, children, null, block.sourceSpan, block.startSourceSpan, block.endSourceSpan));
     }
   }
+  const ifBlockStartSourceSpan = branches.length > 0 ? branches[0].startSourceSpan : ast.startSourceSpan;
+  const ifBlockEndSourceSpan = branches.length > 0 ? branches[branches.length - 1].endSourceSpan : ast.endSourceSpan;
+  let wholeSourceSpan = ast.sourceSpan;
+  const lastBranch = branches[branches.length - 1];
+  if (lastBranch !== void 0) {
+    wholeSourceSpan = new ParseSourceSpan(ifBlockStartSourceSpan.start, lastBranch.sourceSpan.end);
+  }
   return {
-    node: new IfBlock(branches, ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan),
+    node: new IfBlock(branches, wholeSourceSpan, ast.startSourceSpan, ifBlockEndSourceSpan),
     errors
   };
 }
 function createForLoop(ast, connectedBlocks, visitor, bindingParser) {
+  var _a2, _b2;
   const errors = [];
   const params = parseForLoopParameters(ast, errors, bindingParser);
   let node = null;
@@ -18904,7 +19235,7 @@ function createForLoop(ast, connectedBlocks, visitor, bindingParser) {
       } else if (block.parameters.length > 0) {
         errors.push(new ParseError(block.sourceSpan, "@empty block cannot have parameters"));
       } else {
-        empty = new ForLoopBlockEmpty(visitAll2(visitor, block.children, block.children), block.sourceSpan, block.startSourceSpan);
+        empty = new ForLoopBlockEmpty(visitAll2(visitor, block.children, block.children), block.sourceSpan, block.startSourceSpan, block.endSourceSpan);
       }
     } else {
       errors.push(new ParseError(block.sourceSpan, `Unrecognized @for loop block "${block.name}"`));
@@ -18914,25 +19245,29 @@ function createForLoop(ast, connectedBlocks, visitor, bindingParser) {
     if (params.trackBy === null) {
       errors.push(new ParseError(ast.sourceSpan, '@for loop must have a "track" expression'));
     } else {
-      node = new ForLoopBlock(params.itemName, params.expression, params.trackBy, params.context, visitAll2(visitor, ast.children, ast.children), empty, ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan);
+      const endSpan = (_a2 = empty == null ? void 0 : empty.endSourceSpan) != null ? _a2 : ast.endSourceSpan;
+      const sourceSpan = new ParseSourceSpan(ast.sourceSpan.start, (_b2 = endSpan == null ? void 0 : endSpan.end) != null ? _b2 : ast.sourceSpan.end);
+      node = new ForLoopBlock(params.itemName, params.expression, params.trackBy, params.context, visitAll2(visitor, ast.children, ast.children), empty, sourceSpan, ast.sourceSpan, ast.startSourceSpan, endSpan);
     }
   }
   return { node, errors };
 }
 function createSwitchBlock(ast, visitor, bindingParser) {
   const errors = validateSwitchBlock(ast);
-  if (errors.length > 0) {
-    return { node: null, errors };
-  }
-  const primaryExpression = parseBlockParameterToBinding(ast.parameters[0], bindingParser);
+  const primaryExpression = ast.parameters.length > 0 ? parseBlockParameterToBinding(ast.parameters[0], bindingParser) : bindingParser.parseBinding("", false, ast.sourceSpan, 0);
   const cases = [];
+  const unknownBlocks = [];
   let defaultCase = null;
   for (const node of ast.children) {
     if (!(node instanceof Block)) {
       continue;
     }
+    if ((node.name !== "case" || node.parameters.length === 0) && node.name !== "default") {
+      unknownBlocks.push(new UnknownBlock(node.name, node.sourceSpan));
+      continue;
+    }
     const expression = node.name === "case" ? parseBlockParameterToBinding(node.parameters[0], bindingParser) : null;
-    const ast2 = new SwitchBlockCase(expression, visitAll2(visitor, node.children, node.children), node.sourceSpan, node.startSourceSpan);
+    const ast2 = new SwitchBlockCase(expression, visitAll2(visitor, node.children, node.children), node.sourceSpan, node.startSourceSpan, node.endSourceSpan);
     if (expression === null) {
       defaultCase = ast2;
     } else {
@@ -18943,7 +19278,7 @@ function createSwitchBlock(ast, visitor, bindingParser) {
     cases.push(defaultCase);
   }
   return {
-    node: new SwitchBlock(primaryExpression, cases, ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan),
+    node: new SwitchBlock(primaryExpression, cases, unknownBlocks, ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan),
     errors
   };
 }
@@ -18985,7 +19320,8 @@ function parseForLoopParameters(block, errors, bindingParser) {
   }
   for (const variableName of ALLOWED_FOR_LOOP_LET_VARIABLES) {
     if (!result.context.hasOwnProperty(variableName)) {
-      result.context[variableName] = new Variable(variableName, variableName, block.startSourceSpan, block.startSourceSpan);
+      const emptySpanAfterForBlockStart = new ParseSourceSpan(block.startSourceSpan.end, block.startSourceSpan.end);
+      result.context[variableName] = new Variable(variableName, variableName, emptySpanAfterForBlockStart, emptySpanAfterForBlockStart);
     }
   }
   return result;
@@ -19393,7 +19729,15 @@ function createDeferredBlock(ast, connectedBlocks, visitor, bindingParser) {
   const errors = [];
   const { placeholder, loading, error: error2 } = parseConnectedBlocks(connectedBlocks, errors, visitor);
   const { triggers, prefetchTriggers } = parsePrimaryTriggers(ast.parameters, bindingParser, errors, placeholder);
-  const node = new DeferredBlock(visitAll2(visitor, ast.children, ast.children), triggers, prefetchTriggers, placeholder, loading, error2, ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan);
+  let lastEndSourceSpan = ast.endSourceSpan;
+  let endOfLastSourceSpan = ast.sourceSpan.end;
+  if (connectedBlocks.length > 0) {
+    const lastConnectedBlock = connectedBlocks[connectedBlocks.length - 1];
+    lastEndSourceSpan = lastConnectedBlock.endSourceSpan;
+    endOfLastSourceSpan = lastConnectedBlock.sourceSpan.end;
+  }
+  const mainDeferredSourceSpan = new ParseSourceSpan(ast.sourceSpan.start, endOfLastSourceSpan);
+  const node = new DeferredBlock(visitAll2(visitor, ast.children, ast.children), triggers, prefetchTriggers, placeholder, loading, error2, mainDeferredSourceSpan, ast.sourceSpan, ast.startSourceSpan, lastEndSourceSpan);
   return { node, errors };
 }
 function parseConnectedBlocks(connectedBlocks, errors, visitor) {
@@ -19723,7 +20067,10 @@ var HtmlAstToIvyAst = class {
         } else {
           errorMessage = `Unrecognized block @${block.name}.`;
         }
-        result = { node: null, errors: [new ParseError(block.sourceSpan, errorMessage)] };
+        result = {
+          node: new UnknownBlock(block.name, block.sourceSpan),
+          errors: [new ParseError(block.sourceSpan, errorMessage)]
+        };
         break;
     }
     this.errors.push(...result.errors);
@@ -19934,9 +20281,6 @@ function textContents(node) {
   }
 }
 
-// bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/render3/view/block_syntax_switch.mjs
-var BLOCK_SYNTAX_ENABLED_DEFAULT = true;
-
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/render3/view/i18n/context.mjs
 var TagType;
 (function(TagType2) {
@@ -20184,6 +20528,7 @@ var TemplateDefinitionBuilder = class {
     this.visitIfBlockBranch = invalid;
     this.visitSwitchBlockCase = invalid;
     this.visitForLoopBlockEmpty = invalid;
+    this.visitUnknownBlock = invalid;
     this._bindingScope = parentBindingScope.nestedScope(level);
     this.fileBasedI18nSuffix = relativeContextFilePath.replace(/[^A-Za-z0-9]/g, "_") + "_";
     this._valueConverter = new ValueConverter(constantPool, () => this.allocateDataSlot(), (numSlots) => this.allocatePureFunctionSlots(numSlots), (name, localName, slot, value) => {
@@ -20724,13 +21069,10 @@ var TemplateDefinitionBuilder = class {
   visitIfBlock(block) {
     this.allocateBindingSlots(null);
     const branchData = block.branches.map(({ expression, expressionAlias, children, sourceSpan }) => {
-      const processedExpression = expression === null ? null : expression.visit(this._valueConverter);
       const variables = expressionAlias !== null ? [new Variable(expressionAlias.name, DIRECT_CONTEXT_REFERENCE, expressionAlias.sourceSpan, expressionAlias.keySpan)] : void 0;
-      return {
-        index: this.createEmbeddedTemplateFn(null, children, "_Conditional", sourceSpan, variables),
-        expression: processedExpression,
-        alias: expressionAlias
-      };
+      const index = this.createEmbeddedTemplateFn(null, children, "_Conditional", sourceSpan, variables);
+      const processedExpression = expression === null ? null : expression.visit(this._valueConverter);
+      return { index, expression: processedExpression, alias: expressionAlias };
     });
     const containerIndex = branchData[0].index;
     const paramsCallback = () => {
@@ -20761,15 +21103,14 @@ var TemplateDefinitionBuilder = class {
     this.updateInstructionWithAdvance(containerIndex, block.branches[0].sourceSpan, Identifiers.conditional, paramsCallback);
   }
   visitSwitchBlock(block) {
-    const blockExpression = block.expression.visit(this._valueConverter);
-    this.allocateBindingSlots(null);
     const caseData = block.cases.map((currentCase) => {
-      return {
-        index: this.createEmbeddedTemplateFn(null, currentCase.children, "_Case", currentCase.sourceSpan),
-        expression: currentCase.expression === null ? null : currentCase.expression.visit(this._valueConverter)
-      };
+      const index = this.createEmbeddedTemplateFn(null, currentCase.children, "_Case", currentCase.sourceSpan);
+      const expression = currentCase.expression === null ? null : currentCase.expression.visit(this._valueConverter);
+      return { index, expression };
     });
     const containerIndex = caseData[0].index;
+    const blockExpression = block.expression.visit(this._valueConverter);
+    this.allocateBindingSlots(null);
     this.updateInstructionWithAdvance(containerIndex, block.sourceSpan, Identifiers.conditional, () => {
       const generateCases = (caseIndex) => {
         if (caseIndex > caseData.length - 1) {
@@ -20807,11 +21148,12 @@ var TemplateDefinitionBuilder = class {
       literal(placeholderIndex),
       literal(errorIndex),
       (loadingConsts == null ? void 0 : loadingConsts.length) ? this.addToConsts(literalArr(loadingConsts)) : TYPED_NULL_EXPR,
-      placeholderConsts ? this.addToConsts(placeholderConsts) : TYPED_NULL_EXPR
+      placeholderConsts ? this.addToConsts(placeholderConsts) : TYPED_NULL_EXPR,
+      (loadingConsts == null ? void 0 : loadingConsts.length) || placeholderConsts ? importExpr(Identifiers.deferEnableTimerScheduling) : TYPED_NULL_EXPR
     ]));
+    this.allocateDataSlot();
     this.createDeferTriggerInstructions(deferredIndex, triggers, metadata, false);
     this.createDeferTriggerInstructions(deferredIndex, prefetchTriggers, metadata, true);
-    this.allocateDataSlot();
   }
   createDeferredDepsFunction(name, metadata) {
     if (metadata.deps.length === 0) {
@@ -20881,10 +21223,12 @@ var TemplateDefinitionBuilder = class {
   visitForLoopBlock(block) {
     const blockIndex = this.allocateDataSlot();
     const primaryData = this.prepareEmbeddedTemplateFn(block.children, "_For", [block.item, block.contextVariables.$index, block.contextVariables.$count]);
-    const emptyData = block.empty === null ? null : this.prepareEmbeddedTemplateFn(block.empty.children, "_ForEmpty");
     const { expression: trackByExpression, usesComponentInstance: trackByUsesComponentInstance } = this.createTrackByFunction(block);
-    const value = block.expression.visit(this._valueConverter);
-    this.allocateBindingSlots(value);
+    let emptyData = null;
+    if (block.empty !== null) {
+      emptyData = this.prepareEmbeddedTemplateFn(block.empty.children, "_ForEmpty");
+      this.allocateBindingSlots(null);
+    }
     this.registerComputedLoopVariables(block, primaryData.scope);
     this.creationInstruction(block.sourceSpan, Identifiers.repeaterCreate, () => {
       const params = [
@@ -20901,6 +21245,7 @@ var TemplateDefinitionBuilder = class {
       }
       return params;
     });
+    const value = block.expression.visit(this._valueConverter);
     this.updateInstruction(block.sourceSpan, Identifiers.repeater, () => [literal(blockIndex), this.convertPropertyBinding(value)]);
   }
   registerComputedLoopVariables(block, bindingScope) {
@@ -21567,7 +21912,7 @@ function parseTemplate(template2, templateUrl, options = {}) {
     leadingTriviaChars: LEADING_TRIVIA_CHARS
   }, options), {
     tokenizeExpansionForms: true,
-    tokenizeBlocks: (_a2 = options.enableBlockSyntax) != null ? _a2 : BLOCK_SYNTAX_ENABLED_DEFAULT
+    tokenizeBlocks: (_a2 = options.enableBlockSyntax) != null ? _a2 : true
   }));
   if (!options.alwaysAttemptHtmlToR3AstConversion && parseResult.errors && parseResult.errors.length > 0) {
     const parsedTemplate2 = {
@@ -22420,6 +22765,8 @@ var Scope = class {
   }
   visitDeferredTrigger(trigger) {
   }
+  visitUnknownBlock(block) {
+  }
   maybeDeclare(thing) {
     if (!this.namedEntities.has(thing.name)) {
       this.namedEntities.set(thing.name, thing);
@@ -22578,6 +22925,8 @@ var DirectiveBinder = class {
   }
   visitDeferredTrigger(trigger) {
   }
+  visitUnknownBlock(block) {
+  }
 };
 var TemplateBinder = class extends RecursiveAstVisitor {
   constructor(bindings, symbols, usedPipes, eagerPipes, deferBlocks, nestingLevel, scope, rootNode, level) {
@@ -22665,6 +23014,10 @@ var TemplateBinder = class extends RecursiveAstVisitor {
   }
   visitTextAttribute(attribute2) {
   }
+  visitUnknownBlock(block) {
+  }
+  visitDeferredTrigger() {
+  }
   visitIcu(icu) {
     Object.keys(icu.vars).forEach((key) => icu.vars[key].visit(this));
     Object.keys(icu.placeholders).forEach((key) => icu.placeholders[key].visit(this));
@@ -22676,17 +23029,15 @@ var TemplateBinder = class extends RecursiveAstVisitor {
     event.handler.visit(this);
   }
   visitDeferredBlock(deferred) {
+    var _a2, _b2;
     this.deferBlocks.add(deferred);
     this.ingestScopedNode(deferred);
+    (_a2 = deferred.triggers.when) == null ? void 0 : _a2.value.visit(this);
+    (_b2 = deferred.prefetchTriggers.when) == null ? void 0 : _b2.value.visit(this);
     deferred.placeholder && this.visitNode(deferred.placeholder);
     deferred.loading && this.visitNode(deferred.loading);
     deferred.error && this.visitNode(deferred.error);
   }
-  visitDeferredTrigger(trigger) {
-    if (trigger instanceof BoundDeferredTrigger) {
-      trigger.value.visit(this);
-    }
-  }
   visitDeferredBlockPlaceholder(block) {
     this.ingestScopedNode(block);
   }
@@ -23446,7 +23797,7 @@ function publishFacade(global) {
 }
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/version.mjs
-var VERSION2 = new Version("17.0.0-next.7");
+var VERSION2 = new Version("17.0.0-rc.0");
 
 // bazel-out/darwin_arm64-fastbuild/bin/packages/compiler/src/i18n/extractor_merger.mjs
 var _VisitorMode;
@@ -23497,6 +23848,7 @@ var REPLACEMENTS2 = {
   "@": "&#64;",
   "}": "&#125;"
 };
+var CONTROL_FLOW_CHARS_PATTERN = /@|}/;
 var AnalyzedFile = class {
   constructor() {
     __publicField(this, "ranges", []);
@@ -23546,30 +23898,36 @@ function analyze(sourceFile, analyzedFiles) {
   }
 }
 function migrateTemplate(template2) {
+  if (!CONTROL_FLOW_CHARS_PATTERN.test(template2)) {
+    return null;
+  }
+  let rootNodes = null;
   try {
     const parsed = new HtmlParser().parse(template2, "", {
       tokenizeExpansionForms: true,
       tokenizeBlocks: false
     });
-    if (parsed.errors && parsed.errors.length > 0) {
-      return null;
-    }
-    let result = template2;
-    const visitor = new TextRangeCollector();
-    visitAll2(visitor, parsed.rootNodes);
-    const sortedRanges = visitor.textRanges.sort(([aStart], [bStart]) => bStart - aStart);
-    for (const [start, end] of sortedRanges) {
-      const text2 = result.slice(start, end);
-      let replaced = "";
-      for (const char of text2) {
-        replaced += REPLACEMENTS2[char] || char;
-      }
-      result = result.slice(0, start) + replaced + result.slice(end);
+    if (parsed.errors.length === 0) {
+      rootNodes = parsed.rootNodes;
     }
-    return result;
   } catch (e) {
+  }
+  if (rootNodes === null) {
     return null;
   }
+  let result = template2;
+  const visitor = new TextRangeCollector();
+  visitAll2(visitor, rootNodes);
+  const sortedRanges = visitor.textRanges.sort(([aStart], [bStart]) => bStart - aStart);
+  for (const [start, end] of sortedRanges) {
+    const text2 = result.slice(start, end);
+    let replaced = "";
+    for (const char of text2) {
+      replaced += REPLACEMENTS2[char] || char;
+    }
+    result = result.slice(0, start) + replaced + result.slice(end);
+  }
+  return result;
 }
 var TextRangeCollector = class extends RecursiveVisitor {
   constructor() {
@@ -23610,6 +23968,9 @@ function runBlockTemplateEntitiesMigration(tree, tsconfigPath, basePath) {
   for (const [path2, file] of analysis) {
     const ranges = file.getSortedRanges();
     const relativePath = (0, import_path3.relative)(basePath, path2);
+    if (!tree.exists(relativePath)) {
+      continue;
+    }
     const content = tree.readText(relativePath);
     const update = tree.beginUpdate(relativePath);
     for (const [start, end] of ranges) {
@@ -23626,13 +23987,6 @@ function runBlockTemplateEntitiesMigration(tree, tsconfigPath, basePath) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {});
-/*!
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.