@angular-eslint/bundled-angular-compiler 22.1.1-alpha.1 → 22.1.1-alpha.2

package/dist/index.js

@@ -182,6 +182,7 @@ __export(index_exports, {
   TmplAstBoundText: () => BoundText,
   TmplAstComponent: () => Component$1,
   TmplAstContent: () => Content,
+  TmplAstContentBlock: () => ContentBlock,
   TmplAstDeferredBlock: () => DeferredBlock,
   TmplAstDeferredBlockError: () => DeferredBlockError,
   TmplAstDeferredBlockLoading: () => DeferredBlockLoading,
@@ -306,7 +307,7 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// ../../node_modules/.pnpm/@angular+compiler@22.0.5/node_modules/@angular/compiler/fesm2022/compiler.mjs
+// ../../node_modules/.pnpm/@angular+compiler@22.1.2/node_modules/@angular/compiler/fesm2022/compiler.mjs
 var _SELECTOR_REGEXP = new RegExp(`(\\:not\\()|(([\\.\\#]?)[-\\w]+)|(?:\\[([-.\\w*\\\\$]+)(?:=(["']?)([^\\]"']*)\\5)?\\])|(\\))|(\\s*,\\s*)`, "g");
 var CssSelector = class _CssSelector {
   static {
@@ -2749,10 +2750,8 @@ var ConstantPool = class {
   isClosureCompilerEnabled;
   statements = [];
   literals = /* @__PURE__ */ new Map();
-  literalFactories = /* @__PURE__ */ new Map();
   sharedConstants = /* @__PURE__ */ new Map();
   _claimedNames = /* @__PURE__ */ new Map();
-  nextNameIndex = 0;
   constructor(isClosureCompilerEnabled = false) {
     this.isClosureCompilerEnabled = isClosureCompilerEnabled;
   }
@@ -2899,6 +2898,18 @@ var Identifiers = class {
     name: "\u0275\u0275elementEnd",
     moduleName: CORE
   };
+  static foreignComponent = {
+    name: "\u0275\u0275foreignComponent",
+    moduleName: CORE
+  };
+  static foreignContent = {
+    name: "\u0275\u0275foreignContent",
+    moduleName: CORE
+  };
+  static foreignContentFn = {
+    name: "\u0275\u0275foreignContentFn",
+    moduleName: CORE
+  };
   static domElement = {
     name: "\u0275\u0275domElement",
     moduleName: CORE
@@ -3828,6 +3839,14 @@ function getJitStandaloneDefaultForVersion(version) {
   return true;
 }
 __name(getJitStandaloneDefaultForVersion, "getJitStandaloneDefaultForVersion");
+function namespaceCssVariable(varName) {
+  if (varName.startsWith("--global--")) {
+    return "--" + varName.substring("--global--".length);
+  } else {
+    return "--%NS%" + varName.substring("--".length);
+  }
+}
+__name(namespaceCssVariable, "namespaceCssVariable");
 var VERSION$1 = 3;
 var JS_B64_PREFIX = "# sourceMappingURL=data:application/json;base64,";
 var SourceMapGenerator = class {
@@ -4526,6 +4545,8 @@ function escapeIdentifier(input, alwaysQuote = true) {
 }
 __name(escapeIdentifier, "escapeIdentifier");
 var UNSAFE_OBJECT_KEY_NAME_REGEXP = /[-.]/;
+var IDENTIFIER_PATTERN = /^[$A-Z_][0-9A-Z_$]*$/i;
+var LET_PATTERN = /^let\s+([\S\s]*)/;
 function typeWithParameters(type, numParams) {
   if (numParams === 0) {
     return expressionType(type);
@@ -5896,6 +5917,25 @@ var DeferredBlockError = class extends BlockNode {
     return visitor.visitDeferredBlockError(this);
   }
 };
+var ContentBlock = class extends BlockNode {
+  static {
+    __name(this, "ContentBlock");
+  }
+  name;
+  variables;
+  children;
+  i18n;
+  constructor(name, variables, children, nameSpan, sourceSpan, startSourceSpan, endSourceSpan, i18n2) {
+    super(nameSpan, sourceSpan, startSourceSpan, endSourceSpan);
+    this.name = name;
+    this.variables = variables;
+    this.children = children;
+    this.i18n = i18n2;
+  }
+  visit(visitor) {
+    return visitor.visitContentBlock(this);
+  }
+};
 var DeferredBlock = class extends BlockNode {
   static {
     __name(this, "DeferredBlock");
@@ -6424,6 +6464,9 @@ var RecursiveVisitor$1 = class RecursiveVisitor {
   }
   visitLetDeclaration(decl) {
   }
+  visitContentBlock(block) {
+    visitAll$1(this, block.children);
+  }
 };
 function visitAll$1(visitor, nodes) {
   const result = [];
@@ -8397,6 +8440,16 @@ var COLON_IN_PLACEHOLDER = "%COLON_IN_PLACEHOLDER%";
 var _cssCommaInPlaceholderReGlobal = new RegExp(COMMA_IN_PLACEHOLDER, "g");
 var _cssSemiInPlaceholderReGlobal = new RegExp(SEMI_IN_PLACEHOLDER, "g");
 var _cssColonInPlaceholderReGlobal = new RegExp(COLON_IN_PLACEHOLDER, "g");
+var _cssVariableRe = /(var\(\s*)?(--(?:[a-zA-Z0-9_-]|[^\x00-\x7F])+)(\s*:)?/g;
+function namespaceCssVariables(cssText) {
+  return cssText.replace(_cssVariableRe, (match, leadingVar, varName, trailingColon) => {
+    if (!leadingVar && !trailingColon) {
+      return match;
+    }
+    return (leadingVar ?? "") + namespaceCssVariable(varName) + (trailingColon ?? "");
+  });
+}
+__name(namespaceCssVariables, "namespaceCssVariables");
 var CssRule = class {
   static {
     __name(this, "CssRule");
@@ -8558,61 +8611,63 @@ var OpKind;
   OpKind2[OpKind2["Variable"] = 2] = "Variable";
   OpKind2[OpKind2["ElementStart"] = 3] = "ElementStart";
   OpKind2[OpKind2["Element"] = 4] = "Element";
-  OpKind2[OpKind2["Template"] = 5] = "Template";
-  OpKind2[OpKind2["ElementEnd"] = 6] = "ElementEnd";
-  OpKind2[OpKind2["ContainerStart"] = 7] = "ContainerStart";
-  OpKind2[OpKind2["Container"] = 8] = "Container";
-  OpKind2[OpKind2["ContainerEnd"] = 9] = "ContainerEnd";
-  OpKind2[OpKind2["DisableBindings"] = 10] = "DisableBindings";
-  OpKind2[OpKind2["ConditionalCreate"] = 11] = "ConditionalCreate";
-  OpKind2[OpKind2["ConditionalBranchCreate"] = 12] = "ConditionalBranchCreate";
-  OpKind2[OpKind2["Conditional"] = 13] = "Conditional";
-  OpKind2[OpKind2["EnableBindings"] = 14] = "EnableBindings";
-  OpKind2[OpKind2["Text"] = 15] = "Text";
-  OpKind2[OpKind2["Listener"] = 16] = "Listener";
-  OpKind2[OpKind2["InterpolateText"] = 17] = "InterpolateText";
-  OpKind2[OpKind2["Binding"] = 18] = "Binding";
-  OpKind2[OpKind2["Property"] = 19] = "Property";
-  OpKind2[OpKind2["StyleProp"] = 20] = "StyleProp";
-  OpKind2[OpKind2["ClassProp"] = 21] = "ClassProp";
-  OpKind2[OpKind2["StyleMap"] = 22] = "StyleMap";
-  OpKind2[OpKind2["ClassMap"] = 23] = "ClassMap";
-  OpKind2[OpKind2["Advance"] = 24] = "Advance";
-  OpKind2[OpKind2["Pipe"] = 25] = "Pipe";
-  OpKind2[OpKind2["Attribute"] = 26] = "Attribute";
-  OpKind2[OpKind2["ExtractedAttribute"] = 27] = "ExtractedAttribute";
-  OpKind2[OpKind2["Defer"] = 28] = "Defer";
-  OpKind2[OpKind2["DeferOn"] = 29] = "DeferOn";
-  OpKind2[OpKind2["DeferWhen"] = 30] = "DeferWhen";
-  OpKind2[OpKind2["I18nMessage"] = 31] = "I18nMessage";
-  OpKind2[OpKind2["DomProperty"] = 32] = "DomProperty";
-  OpKind2[OpKind2["Namespace"] = 33] = "Namespace";
-  OpKind2[OpKind2["ProjectionDef"] = 34] = "ProjectionDef";
-  OpKind2[OpKind2["EnableIncrementalHydrationRuntime"] = 35] = "EnableIncrementalHydrationRuntime";
-  OpKind2[OpKind2["Projection"] = 36] = "Projection";
-  OpKind2[OpKind2["RepeaterCreate"] = 37] = "RepeaterCreate";
-  OpKind2[OpKind2["Repeater"] = 38] = "Repeater";
-  OpKind2[OpKind2["TwoWayProperty"] = 39] = "TwoWayProperty";
-  OpKind2[OpKind2["TwoWayListener"] = 40] = "TwoWayListener";
-  OpKind2[OpKind2["DeclareLet"] = 41] = "DeclareLet";
-  OpKind2[OpKind2["StoreLet"] = 42] = "StoreLet";
-  OpKind2[OpKind2["I18nStart"] = 43] = "I18nStart";
-  OpKind2[OpKind2["I18n"] = 44] = "I18n";
-  OpKind2[OpKind2["I18nEnd"] = 45] = "I18nEnd";
-  OpKind2[OpKind2["I18nExpression"] = 46] = "I18nExpression";
-  OpKind2[OpKind2["I18nApply"] = 47] = "I18nApply";
-  OpKind2[OpKind2["IcuStart"] = 48] = "IcuStart";
-  OpKind2[OpKind2["IcuEnd"] = 49] = "IcuEnd";
-  OpKind2[OpKind2["IcuPlaceholder"] = 50] = "IcuPlaceholder";
-  OpKind2[OpKind2["I18nContext"] = 51] = "I18nContext";
-  OpKind2[OpKind2["I18nAttributes"] = 52] = "I18nAttributes";
-  OpKind2[OpKind2["SourceLocation"] = 53] = "SourceLocation";
-  OpKind2[OpKind2["Animation"] = 54] = "Animation";
-  OpKind2[OpKind2["AnimationString"] = 55] = "AnimationString";
-  OpKind2[OpKind2["AnimationBinding"] = 56] = "AnimationBinding";
-  OpKind2[OpKind2["AnimationListener"] = 57] = "AnimationListener";
-  OpKind2[OpKind2["Control"] = 58] = "Control";
-  OpKind2[OpKind2["ControlCreate"] = 59] = "ControlCreate";
+  OpKind2[OpKind2["ForeignComponent"] = 5] = "ForeignComponent";
+  OpKind2[OpKind2["Template"] = 6] = "Template";
+  OpKind2[OpKind2["ElementEnd"] = 7] = "ElementEnd";
+  OpKind2[OpKind2["ContainerStart"] = 8] = "ContainerStart";
+  OpKind2[OpKind2["Container"] = 9] = "Container";
+  OpKind2[OpKind2["ContainerEnd"] = 10] = "ContainerEnd";
+  OpKind2[OpKind2["DisableBindings"] = 11] = "DisableBindings";
+  OpKind2[OpKind2["ConditionalCreate"] = 12] = "ConditionalCreate";
+  OpKind2[OpKind2["ConditionalBranchCreate"] = 13] = "ConditionalBranchCreate";
+  OpKind2[OpKind2["Conditional"] = 14] = "Conditional";
+  OpKind2[OpKind2["EnableBindings"] = 15] = "EnableBindings";
+  OpKind2[OpKind2["Text"] = 16] = "Text";
+  OpKind2[OpKind2["Listener"] = 17] = "Listener";
+  OpKind2[OpKind2["InterpolateText"] = 18] = "InterpolateText";
+  OpKind2[OpKind2["Binding"] = 19] = "Binding";
+  OpKind2[OpKind2["Property"] = 20] = "Property";
+  OpKind2[OpKind2["StyleProp"] = 21] = "StyleProp";
+  OpKind2[OpKind2["ClassProp"] = 22] = "ClassProp";
+  OpKind2[OpKind2["StyleMap"] = 23] = "StyleMap";
+  OpKind2[OpKind2["ClassMap"] = 24] = "ClassMap";
+  OpKind2[OpKind2["Advance"] = 25] = "Advance";
+  OpKind2[OpKind2["Pipe"] = 26] = "Pipe";
+  OpKind2[OpKind2["Attribute"] = 27] = "Attribute";
+  OpKind2[OpKind2["ExtractedAttribute"] = 28] = "ExtractedAttribute";
+  OpKind2[OpKind2["Defer"] = 29] = "Defer";
+  OpKind2[OpKind2["DeferOn"] = 30] = "DeferOn";
+  OpKind2[OpKind2["DeferWhen"] = 31] = "DeferWhen";
+  OpKind2[OpKind2["I18nMessage"] = 32] = "I18nMessage";
+  OpKind2[OpKind2["DomProperty"] = 33] = "DomProperty";
+  OpKind2[OpKind2["Namespace"] = 34] = "Namespace";
+  OpKind2[OpKind2["ProjectionDef"] = 35] = "ProjectionDef";
+  OpKind2[OpKind2["EnableIncrementalHydrationRuntime"] = 36] = "EnableIncrementalHydrationRuntime";
+  OpKind2[OpKind2["Projection"] = 37] = "Projection";
+  OpKind2[OpKind2["Content"] = 38] = "Content";
+  OpKind2[OpKind2["RepeaterCreate"] = 39] = "RepeaterCreate";
+  OpKind2[OpKind2["Repeater"] = 40] = "Repeater";
+  OpKind2[OpKind2["TwoWayProperty"] = 41] = "TwoWayProperty";
+  OpKind2[OpKind2["TwoWayListener"] = 42] = "TwoWayListener";
+  OpKind2[OpKind2["DeclareLet"] = 43] = "DeclareLet";
+  OpKind2[OpKind2["StoreLet"] = 44] = "StoreLet";
+  OpKind2[OpKind2["I18nStart"] = 45] = "I18nStart";
+  OpKind2[OpKind2["I18n"] = 46] = "I18n";
+  OpKind2[OpKind2["I18nEnd"] = 47] = "I18nEnd";
+  OpKind2[OpKind2["I18nExpression"] = 48] = "I18nExpression";
+  OpKind2[OpKind2["I18nApply"] = 49] = "I18nApply";
+  OpKind2[OpKind2["IcuStart"] = 50] = "IcuStart";
+  OpKind2[OpKind2["IcuEnd"] = 51] = "IcuEnd";
+  OpKind2[OpKind2["IcuPlaceholder"] = 52] = "IcuPlaceholder";
+  OpKind2[OpKind2["I18nContext"] = 53] = "I18nContext";
+  OpKind2[OpKind2["I18nAttributes"] = 54] = "I18nAttributes";
+  OpKind2[OpKind2["SourceLocation"] = 55] = "SourceLocation";
+  OpKind2[OpKind2["Animation"] = 56] = "Animation";
+  OpKind2[OpKind2["AnimationString"] = 57] = "AnimationString";
+  OpKind2[OpKind2["AnimationBinding"] = 58] = "AnimationBinding";
+  OpKind2[OpKind2["AnimationListener"] = 59] = "AnimationListener";
+  OpKind2[OpKind2["Control"] = 60] = "Control";
+  OpKind2[OpKind2["ControlCreate"] = 61] = "ControlCreate";
 })(OpKind || (OpKind = {}));
 var ExpressionKind;
 (function(ExpressionKind2) {
@@ -8642,7 +8697,8 @@ var ExpressionKind;
   ExpressionKind2[ExpressionKind2["ConditionalCase"] = 23] = "ConditionalCase";
   ExpressionKind2[ExpressionKind2["ConstCollected"] = 24] = "ConstCollected";
   ExpressionKind2[ExpressionKind2["TwoWayBindingSet"] = 25] = "TwoWayBindingSet";
-  ExpressionKind2[ExpressionKind2["ArrowFunction"] = 26] = "ArrowFunction";
+  ExpressionKind2[ExpressionKind2["ForeignContent"] = 26] = "ForeignContent";
+  ExpressionKind2[ExpressionKind2["ArrowFunction"] = 27] = "ArrowFunction";
 })(ExpressionKind || (ExpressionKind = {}));
 var VariableFlags;
 (function(VariableFlags2) {
@@ -9301,6 +9357,34 @@ var ReferenceExpr = class _ReferenceExpr extends ExpressionBase {
     return new _ReferenceExpr(this.target, this.targetSlot, this.offset);
   }
 };
+var ForeignContentExpr = class _ForeignContentExpr extends ExpressionBase {
+  static {
+    __name(this, "ForeignContentExpr");
+  }
+  childrenViewXref;
+  childrenViewHandle;
+  foreignComponentConstIndex;
+  kind = ExpressionKind.ForeignContent;
+  constructor(childrenViewXref, childrenViewHandle, foreignComponentConstIndex) {
+    super();
+    this.childrenViewXref = childrenViewXref;
+    this.childrenViewHandle = childrenViewHandle;
+    this.foreignComponentConstIndex = foreignComponentConstIndex;
+  }
+  visitExpression() {
+  }
+  isEquivalent(e) {
+    return e instanceof _ForeignContentExpr && e.childrenViewXref === this.childrenViewXref && e.foreignComponentConstIndex === this.foreignComponentConstIndex;
+  }
+  isConstant() {
+    return false;
+  }
+  transformInternalExpressions() {
+  }
+  clone() {
+    return new _ForeignContentExpr(this.childrenViewXref, this.childrenViewHandle, this.foreignComponentConstIndex);
+  }
+};
 var StoreLetExpr = class _StoreLetExpr extends ExpressionBase {
   static {
     __name(this, "StoreLetExpr");
@@ -10177,6 +10261,11 @@ function transformExpressionsInOp(op, transform2, flags) {
     case OpKind.StoreLet:
       op.value = transformExpressionsInExpression(op.value, transform2, flags);
       break;
+    case OpKind.ForeignComponent:
+      for (const [key, expr] of op.props) {
+        op.props.set(key, transformExpressionsInExpression(expr, transform2, flags));
+      }
+      break;
     case OpKind.Advance:
     case OpKind.Container:
     case OpKind.ContainerEnd:
@@ -10200,6 +10289,7 @@ function transformExpressionsInOp(op, transform2, flags) {
     case OpKind.ProjectionDef:
     case OpKind.EnableIncrementalHydrationRuntime:
     case OpKind.Template:
+    case OpKind.Content:
     case OpKind.Text:
     case OpKind.I18nAttributes:
     case OpKind.IcuPlaceholder:
@@ -10343,6 +10433,31 @@ function createElementStartOp(tag, xref, namespace, i18nPlaceholder, startSource
   };
 }
 __name(createElementStartOp, "createElementStartOp");
+function createForeignComponentOp(xref, constIndex, props, sourceSpan) {
+  return {
+    kind: OpKind.ForeignComponent,
+    xref,
+    handle: new SlotHandle(),
+    constIndex,
+    props,
+    sourceSpan,
+    ...TRAIT_CONSUMES_SLOT,
+    ...NEW_OP
+  };
+}
+__name(createForeignComponentOp, "createForeignComponentOp");
+function createContentOp(target, view, propertyName, startSourceSpan, sourceSpan) {
+  return {
+    kind: OpKind.Content,
+    target,
+    propertyName,
+    view,
+    startSourceSpan,
+    sourceSpan,
+    ...NEW_OP
+  };
+}
+__name(createContentOp, "createContentOp");
 function createTemplateOp(xref, templateKind, tag, functionNameSuffix, namespace, i18nPlaceholder, startSourceSpan, wholeSourceSpan) {
   return {
     kind: OpKind.Template,
@@ -10864,7 +10979,9 @@ var ComponentCompilationJob = class extends CompilationJob {
   allDeferrableDepsFn;
   relativeTemplatePath;
   enableDebugLocations;
-  constructor(componentName, pool, mode, relativeContextFilePath, i18nUseExternalIds, deferMeta, allDeferrableDepsFn, relativeTemplatePath, enableDebugLocations, legacyOptionalChaining) {
+  foreignImports;
+  foreignMatcher;
+  constructor(componentName, pool, mode, relativeContextFilePath, i18nUseExternalIds, deferMeta, allDeferrableDepsFn, relativeTemplatePath, enableDebugLocations, legacyOptionalChaining, foreignImports) {
     super(componentName, pool, mode, legacyOptionalChaining);
     this.relativeContextFilePath = relativeContextFilePath;
     this.i18nUseExternalIds = i18nUseExternalIds;
@@ -10872,8 +10989,25 @@ var ComponentCompilationJob = class extends CompilationJob {
     this.allDeferrableDepsFn = allDeferrableDepsFn;
     this.relativeTemplatePath = relativeTemplatePath;
     this.enableDebugLocations = enableDebugLocations;
+    this.foreignImports = foreignImports;
     this.root = new ViewCompilationUnit(this, this.allocateXrefId(), null);
     this.views.set(this.root.xref, this.root);
+    if (foreignImports && foreignImports.length > 0) {
+      const registry = /* @__PURE__ */ new Map();
+      for (const meta of foreignImports) {
+        registry.set(meta.name, [meta]);
+      }
+      this.foreignMatcher = new SelectorlessMatcher(registry);
+    } else {
+      this.foreignMatcher = null;
+    }
+  }
+  getForeignComponent(element2) {
+    if (this.foreignMatcher === null) {
+      return null;
+    }
+    const matches = this.foreignMatcher.match(element2.name);
+    return matches.length > 0 ? matches[0] : null;
   }
   kind = CompilationJobKind.Tmpl;
   fnSuffix = "Template";
@@ -11842,7 +11976,8 @@ function resolveDeferTargetNames(job) {
   }
   __name(getScopeForView2, "getScopeForView");
   function resolveTrigger(deferOwnerView, op, placeholderView) {
-    switch (op.trigger.kind) {
+    const triggerKind = op.trigger.kind;
+    switch (triggerKind) {
       case DeferTriggerKind.Idle:
       case DeferTriggerKind.Never:
       case DeferTriggerKind.Immediate:
@@ -11889,8 +12024,10 @@ function resolveDeferTargetNames(job) {
           step++;
         }
         break;
-      default:
-        throw new Error(`Trigger kind ${op.trigger.kind} not handled`);
+      default: {
+        const unhandledTriggerKind = triggerKind;
+        throw new Error(`Trigger kind ${unhandledTriggerKind} not handled`);
+      }
     }
   }
   __name(resolveTrigger, "resolveTrigger");
@@ -12386,6 +12523,7 @@ function recursivelyProcessView(view, parentScope) {
         break;
     }
   }
+  view.create.prepend(generateVariablesInScopeForView(view, scope, false));
   view.update.prepend(generateVariablesInScopeForView(view, scope, false));
   for (const expr of view.functions) {
     expr.ops.prepend(generateVariablesInScopeForView(view, getScopeForView(view, parentScope), true));
@@ -12463,7 +12601,14 @@ function generateVariablesInScopeForView(view, scope, isCallback) {
   const scopeView = view.job.views.get(scope.view);
   for (const [name, value] of scopeView.contextVariables) {
     const context = new ContextExpr(scope.view);
-    const variable2 = value === CTX_REF ? context : new ReadPropExpr(context, value);
+    let variable2;
+    if (value === CTX_REF) {
+      variable2 = context;
+    } else if (typeof value === "number") {
+      variable2 = new ReadKeyExpr(context, literal(value));
+    } else {
+      variable2 = new ReadPropExpr(context, value);
+    }
     newOps.push(createVariableOp(view.job.allocateXrefId(), scope.contextVariables.get(name), variable2, VariableFlags.None));
   }
   for (const alias of scopeView.aliases) {
@@ -12514,6 +12659,8 @@ function parseHostStyleProperties(job) {
       op.name = op.name.substring(STYLE_DOT.length);
       if (!isCssCustomProperty(op.name)) {
         op.name = hyphenate$1(op.name);
+      } else {
+        op.name = namespaceCssVariable(op.name);
       }
       const {
         property: property2,
@@ -15100,11 +15247,13 @@ var CharacterReferenceType;
   CharacterReferenceType2["HEX"] = "hexadecimal";
   CharacterReferenceType2["DEC"] = "decimal";
 })(CharacterReferenceType || (CharacterReferenceType = {}));
-var SUPPORTED_BLOCKS = ["@if", "@else", "@for", "@switch", "@case", "@default", "@empty", "@defer", "@placeholder", "@loading", "@error"];
+var SUPPORTED_BLOCKS = ["@if", "@else", "@for", "@switch", "@case", "@default", "@empty", "@defer", "@placeholder", "@loading", "@error", "@content"];
 var INTERPOLATION = {
   start: "{{",
   end: "}}"
 };
+var DEFAULT_NEVER_PATTERN = /^default[^\S\r\n]+never/;
+var ELSE_IF_PATTERN = /^else[^\S\r\n]+if/;
 var _Tokenizer = class {
   static {
     __name(this, "_Tokenizer");
@@ -15169,6 +15318,8 @@ var _Tokenizer = class {
             }
           } else if (this._attemptCharCode($SLASH)) {
             this._consumeTagClose(start);
+          } else if (this._attemptCharCode($QUESTION)) {
+            this._consumeProcessingInstruction(start);
           } else {
             this._consumeTagOpen(start);
           }
@@ -15185,7 +15336,7 @@ var _Tokenizer = class {
         this.handleError(e);
       }
     }
-    this._beginToken(42);
+    this._beginToken(43);
     this._endToken([]);
   }
   _getBlockName() {
@@ -15201,7 +15352,13 @@ var _Tokenizer = class {
       }
       return true;
     });
-    return this._cursor.getChars(nameCursor).trim();
+    let result = this._cursor.getChars(nameCursor).trim();
+    if (ELSE_IF_PATTERN.test(result)) {
+      result = "else if";
+    } else if (DEFAULT_NEVER_PATTERN.test(result)) {
+      result = "default never";
+    }
+    return result;
   }
   _consumeBlockStart(start) {
     this._requireCharCode($AT);
@@ -15314,23 +15471,7 @@ var _Tokenizer = class {
   _consumeLetDeclarationValue() {
     const start = this._cursor.clone();
     this._beginToken(31, start);
-    while (this._cursor.peek() !== $EOF) {
-      const char = this._cursor.peek();
-      if (char === $SEMICOLON) {
-        break;
-      }
-      if (isQuote(char)) {
-        this._cursor.advance();
-        this._attemptCharCodeUntilFn((inner) => {
-          if (inner === $BACKSLASH) {
-            this._cursor.advance();
-            return false;
-          }
-          return inner === char;
-        });
-      }
-      this._cursor.advance();
-    }
+    this._attemptUntilIgnoreQuotes((char) => char === $SEMICOLON);
     this._endToken([this._cursor.getChars(start)]);
   }
   _tokenizeExpansionForm() {
@@ -15459,6 +15600,25 @@ var _Tokenizer = class {
       this._cursor.advance();
     }
   }
+  _attemptUntilIgnoreQuotes(predicate) {
+    while (this._cursor.peek() !== $EOF) {
+      const char = this._cursor.peek();
+      if (predicate(char)) {
+        break;
+      }
+      if (isQuote(char)) {
+        this._cursor.advance();
+        this._attemptCharCodeUntilFn((inner) => {
+          if (inner === $BACKSLASH) {
+            this._cursor.advance();
+            return false;
+          }
+          return inner === char;
+        });
+      }
+      this._cursor.advance();
+    }
+  }
   _readChar() {
     const char = String.fromCodePoint(this._cursor.peek());
     this._cursor.advance();
@@ -15570,6 +15730,18 @@ var _Tokenizer = class {
     this._cursor.advance();
     this._endToken([content]);
   }
+  _consumeProcessingInstruction(start) {
+    this._beginToken(42, start);
+    const contentStart = this._cursor.clone();
+    this._attemptUntilIgnoreQuotes((char) => char === $QUESTION || char === $GT);
+    const endChar = this._cursor.peek();
+    const content = this._cursor.getChars(contentStart);
+    this._cursor.advance();
+    if (endChar === $QUESTION) {
+      this._requireCharCode($GT);
+    }
+    this._endToken([content]);
+  }
   _consumePrefixAndName(endPredicate) {
     const nameOrPrefixStart = this._cursor.clone();
     let prefix = "";
@@ -15996,7 +16168,7 @@ var _Tokenizer = class {
       const tmp = this._cursor.clone();
       tmp.advance();
       const code = tmp.peek();
-      if ($a <= code && code <= $z || $A <= code && code <= $Z || code === $SLASH || code === $BANG) {
+      if ($a <= code && code <= $z || $A <= code && code <= $Z || code === $SLASH || code === $BANG || code === $QUESTION) {
         return true;
       }
     }
@@ -16370,7 +16542,7 @@ var _TreeBuilder = class __TreeBuilder {
     this._advance();
   }
   build() {
-    while (this._peek.type !== 42) {
+    while (this._peek.type !== 43) {
       if (this._peek.type === 0 || this._peek.type === 4) {
         this._consumeElementStartTag(this._advance());
       } else if (this._peek.type === 3) {
@@ -16468,7 +16640,7 @@ var _TreeBuilder = class __TreeBuilder {
     if (!exp) return null;
     const end = this._advance();
     exp.push({
-      type: 42,
+      type: 43,
       parts: [],
       sourceSpan: end.sourceSpan
     });
@@ -16506,7 +16678,7 @@ var _TreeBuilder = class __TreeBuilder {
           return null;
         }
       }
-      if (this._peek.type === 42) {
+      if (this._peek.type === 43) {
         this.errors.push(TreeError.create(null, start.sourceSpan, `Invalid ICU message. Missing '}'.`));
         return null;
       }
@@ -18693,9 +18865,8 @@ var _ParseAST = class {
         const expression = this.parsePipe();
         if (expression instanceof EmptyExpr$1) {
           this.error("Template literal interpolation cannot be empty");
-        } else {
-          expressions.push(expression);
         }
+        expressions.push(expression);
         this.rbracesExpected--;
       } else {
         this.advance();
@@ -20768,6 +20939,7 @@ function mergeNextContextExpressions(job) {
         mergeNextContextsInOps(op.handlerOps);
       }
     }
+    mergeNextContextsInOps(unit.create);
     mergeNextContextsInOps(unit.update);
   }
 }
@@ -21009,7 +21181,7 @@ function processPipeBindingsInView(unit) {
       if (slotHandle == void 0) {
         throw new Error(`AssertionError: expected slot handle to be assigned for pipe creation`);
       }
-      addPipeToCreationBlock(unit, updateOp.target, expr);
+      addPipeToCreationBlock(unit, slotHandle, expr);
     });
   }
 }
@@ -21262,6 +21434,18 @@ function elementStart(slot, tag, constIndex, localRefIndex, sourceSpan) {
   return elementOrContainerBase(Identifiers.elementStart, slot, tag, constIndex, localRefIndex, sourceSpan);
 }
 __name(elementStart, "elementStart");
+function foreignComponent(slot, foreignComponentRef, props, sourceSpan) {
+  const args = [literal(slot), foreignComponentRef];
+  if (props !== null) {
+    args.push(props);
+  }
+  return call(Identifiers.foreignComponent, args, sourceSpan);
+}
+__name(foreignComponent, "foreignComponent");
+function foreignContent(slot, foreignComponentIndex, parameterized) {
+  return importExpr(parameterized ? Identifiers.foreignContentFn : Identifiers.foreignContent).callFn([literal(slot), literal(foreignComponentIndex)]);
+}
+__name(foreignContent, "foreignContent");
 function elementOrContainerBase(instruction, slot, tag, constIndex, localRefIndex, sourceSpan) {
   const args = [literal(slot)];
   if (tag !== null) {
@@ -21829,6 +22013,14 @@ function reifyCreateOperations(unit, ops) {
       case OpKind.Element:
         OpList.replace(op, unit.job.mode === TemplateCompilationMode.DomOnly ? domElement(op.handle.slot, op.tag, op.attributes, op.localRefs, op.wholeSourceSpan) : element(op.handle.slot, op.tag, op.attributes, op.localRefs, op.wholeSourceSpan));
         break;
+      case OpKind.ForeignComponent:
+        const propsExpr = op.props.size > 0 ? literalMap(Array.from(op.props.entries()).map(([key, value]) => ({
+          key,
+          value,
+          quoted: isUnsafeObjectKey(key)
+        }))) : null;
+        OpList.replace(op, foreignComponent(op.handle.slot, literal(op.constIndex), propsExpr, op.sourceSpan));
+        break;
       case OpKind.ElementEnd:
         OpList.replace(op, unit.job.mode === TemplateCompilationMode.DomOnly ? domElementEnd(op.sourceSpan) : elementEnd(op.sourceSpan));
         break;
@@ -21925,7 +22117,8 @@ function reifyCreateOperations(unit, ops) {
         break;
       case OpKind.DeferOn:
         let args = [];
-        switch (op.trigger.kind) {
+        const triggerKind = op.trigger.kind;
+        switch (triggerKind) {
           case DeferTriggerKind.Never:
           case DeferTriggerKind.Immediate:
             break;
@@ -21963,8 +22156,10 @@ function reifyCreateOperations(unit, ops) {
               }
             }
             break;
-          default:
-            throw new Error(`AssertionError: Unsupported reification of defer trigger kind ${op.trigger.kind}`);
+          default: {
+            const unhandledTriggerKind = triggerKind;
+            throw new Error(`AssertionError: Unsupported reification of defer trigger kind ${unhandledTriggerKind}`);
+          }
         }
         OpList.replace(op, deferOn(op.trigger.kind, args, op.modifier, op.sourceSpan));
         break;
@@ -22171,6 +22366,12 @@ function reifyIrExpression(unit, expr) {
       return nextContext(expr.steps);
     case ExpressionKind.Reference:
       return reference(expr.targetSlot.slot + 1 + expr.offset);
+    case ExpressionKind.ForeignContent:
+      if (!(unit instanceof ViewCompilationUnit)) {
+        throw new Error(`AssertionError: must be compiling a component`);
+      }
+      const parameterized = unit.job.views.get(expr.childrenViewXref).contextVariables.size > 0;
+      return foreignContent(expr.childrenViewHandle.slot, expr.foreignComponentConstIndex, parameterized);
     case ExpressionKind.LexicalRead:
       throw new Error(`AssertionError: unresolved LexicalRead of ${expr.name}`);
     case ExpressionKind.TwoWayBindingSet:
@@ -22446,6 +22647,31 @@ function transformDollarEvent(ops) {
   }
 }
 __name(transformDollarEvent, "transformDollarEvent");
+function resolveForeignContent(job) {
+  for (const unit of job.units) {
+    const foreignComponents = /* @__PURE__ */ new Map();
+    for (const op of unit.create) {
+      if (op.kind === OpKind.ForeignComponent) {
+        foreignComponents.set(op.xref, op);
+      }
+    }
+    for (const op of unit.create) {
+      if (op.kind !== OpKind.Content) {
+        continue;
+      }
+      const target = foreignComponents.get(op.target);
+      if (target === void 0) {
+        throw new Error(`AssertionError: ContentOp target not found`);
+      }
+      const templateName = op.propertyName.charAt(0).toUpperCase() + op.propertyName.slice(1);
+      const templateOp = createTemplateOp(op.view, TemplateKind.NgTemplate, null, templateName, Namespace.HTML, void 0, op.startSourceSpan, op.sourceSpan);
+      OpList.replace(op, templateOp);
+      const foreignContent2 = new ForeignContentExpr(templateOp.xref, templateOp.handle, target.constIndex);
+      target.props.set(op.propertyName, foreignContent2);
+    }
+  }
+}
+__name(resolveForeignContent, "resolveForeignContent");
 function resolveI18nElementPlaceholders(job) {
   const i18nContexts = /* @__PURE__ */ new Map();
   const elements = /* @__PURE__ */ new Map();
@@ -22877,7 +23103,7 @@ function resolveSanitizers(job) {
         case OpKind.DomProperty:
         case OpKind.TwoWayProperty:
           let sanitizerFn = null;
-          if (Array.isArray(op.securityContext) && op.securityContext.length === 2 && op.securityContext.includes(SecurityContext.URL) && op.securityContext.includes(SecurityContext.RESOURCE_URL)) {
+          if (Array.isArray(op.securityContext) && hasCompositeUrlSecurityContext(op.securityContext)) {
             sanitizerFn = Identifiers.sanitizeUrlOrResourceUrl;
           } else {
             sanitizerFn = sanitizerFns.get(getOnlySecurityContext(op.securityContext)) ?? null;
@@ -22889,14 +23115,40 @@ function resolveSanitizers(job) {
   }
 }
 __name(resolveSanitizers, "resolveSanitizers");
-function getOnlySecurityContext(securityContext) {
-  if (Array.isArray(securityContext)) {
-    if (securityContext.length > 1) {
-      throw Error(`AssertionError: Ambiguous security context`);
+function hasCompositeUrlSecurityContext(securityContext) {
+  let hasUrlContext = false;
+  let hasResourceUrlContext = false;
+  let hasNoneContext = false;
+  for (const context of securityContext) {
+    switch (context) {
+      case SecurityContext.URL:
+        hasUrlContext = true;
+        break;
+      case SecurityContext.RESOURCE_URL:
+        hasResourceUrlContext = true;
+        break;
+      case SecurityContext.NONE:
+        hasNoneContext = true;
+        break;
+      default:
+        return false;
     }
-    return securityContext[0] || SecurityContext.NONE;
   }
-  return securityContext;
+  return (hasUrlContext || hasResourceUrlContext) && hasNoneContext || hasUrlContext && hasResourceUrlContext;
+}
+__name(hasCompositeUrlSecurityContext, "hasCompositeUrlSecurityContext");
+function getOnlySecurityContext(securityContext) {
+  if (!Array.isArray(securityContext)) {
+    return securityContext;
+  }
+  if (securityContext.length < 2) {
+    return securityContext[0] ?? SecurityContext.NONE;
+  }
+  const nonNoneSecurityContexts = securityContext.filter((context) => context !== SecurityContext.NONE);
+  if (nonNoneSecurityContexts.length > 1) {
+    throw Error(`AssertionError: Ambiguous security context`);
+  }
+  return nonNoneSecurityContexts[0] ?? SecurityContext.NONE;
 }
 __name(getOnlySecurityContext, "getOnlySecurityContext");
 function removeSafeNavigationMigration(job) {
@@ -23585,7 +23837,7 @@ function collectOpInfo(op, predicate) {
     }
     if (expr.kind === ExpressionKind.ReadVariable) {
       variablesUsed.add(expr.xref);
-    } else {
+    } else if (!(flags & VisitorContextFlag.InChildOperation)) {
       fences |= fencesForIrExpression(expr);
     }
   });
@@ -23727,6 +23979,9 @@ function wrapI18nIcus(job) {
 }
 __name(wrapI18nIcus, "wrapI18nIcus");
 var phases = [{
+  kind: CompilationJobKind.Tmpl,
+  fn: resolveForeignContent
+}, {
   kind: CompilationJobKind.Tmpl,
   fn: removeContentSelectors
 }, {
@@ -24021,9 +24276,420 @@ function emitHostBindingFunction(job) {
   return fn([new FnParam(RENDER_FLAGS, NUMBER_TYPE), new FnParam(CONTEXT_NAME, DYNAMIC_TYPE)], [...createCond, ...updateCond], void 0, void 0, job.root.fnName);
 }
 __name(emitHostBindingFunction, "emitHostBindingFunction");
+var PROPERTY_PARTS_SEPARATOR = ".";
+var ATTRIBUTE_PREFIX = "attr";
+var ANIMATE_PREFIX$1 = "animate";
+var CLASS_PREFIX = "class";
+var STYLE_PREFIX = "style";
+var TEMPLATE_ATTR_PREFIX$1 = "*";
+var LEGACY_ANIMATE_PROP_PREFIX = "animate-";
+var BindingParser = class {
+  static {
+    __name(this, "BindingParser");
+  }
+  _exprParser;
+  _schemaRegistry;
+  errors;
+  constructor(_exprParser, _schemaRegistry, errors) {
+    this._exprParser = _exprParser;
+    this._schemaRegistry = _schemaRegistry;
+    this.errors = errors;
+  }
+  createBoundHostProperties(properties, sourceSpan) {
+    const boundProps = [];
+    for (const propName of Object.keys(properties)) {
+      const expression = properties[propName];
+      if (typeof expression === "string") {
+        this.parsePropertyBinding(propName, expression, true, false, sourceSpan, sourceSpan.start.offset, void 0, [], boundProps, sourceSpan);
+      } else {
+        this._reportError(`Value of the host property binding "${propName}" needs to be a string representing an expression but got "${expression}" (${typeof expression})`, sourceSpan);
+      }
+    }
+    return boundProps;
+  }
+  createDirectiveHostEventAsts(hostListeners, sourceSpan) {
+    const targetEvents = [];
+    for (const propName of Object.keys(hostListeners)) {
+      const expression = hostListeners[propName];
+      if (typeof expression === "string") {
+        this.parseEvent(propName, expression, false, sourceSpan, sourceSpan, [], targetEvents, sourceSpan);
+      } else {
+        this._reportError(`Value of the host listener "${propName}" needs to be a string representing an expression but got "${expression}" (${typeof expression})`, sourceSpan);
+      }
+    }
+    return targetEvents;
+  }
+  parseInterpolation(value, sourceSpan, interpolatedTokens) {
+    const absoluteOffset = sourceSpan.fullStart.offset;
+    try {
+      const ast = this._exprParser.parseInterpolation(value, sourceSpan, absoluteOffset, interpolatedTokens);
+      if (ast) {
+        this.errors.push(...ast.errors);
+      }
+      return ast;
+    } catch (e) {
+      this._reportError(`${e}`, sourceSpan);
+      return this._exprParser.wrapLiteralPrimitive("ERROR", sourceSpan, absoluteOffset);
+    }
+  }
+  parseInterpolationExpression(expression, sourceSpan) {
+    const absoluteOffset = sourceSpan.start.offset;
+    try {
+      const ast = this._exprParser.parseInterpolationExpression(expression, sourceSpan, absoluteOffset);
+      if (ast) {
+        this.errors.push(...ast.errors);
+      }
+      return ast;
+    } catch (e) {
+      this._reportError(`${e}`, sourceSpan);
+      return this._exprParser.wrapLiteralPrimitive("ERROR", sourceSpan, absoluteOffset);
+    }
+  }
+  parseInlineTemplateBinding(tplKey, tplValue, sourceSpan, absoluteValueOffset, targetMatchableAttrs, targetProps, targetVars, isIvyAst) {
+    const absoluteKeyOffset = sourceSpan.start.offset + TEMPLATE_ATTR_PREFIX$1.length;
+    const bindings = this._parseTemplateBindings(tplKey, tplValue, sourceSpan, absoluteKeyOffset, absoluteValueOffset);
+    for (const binding of bindings) {
+      const bindingSpan = moveParseSourceSpan(sourceSpan, binding.sourceSpan);
+      const key = binding.key.source;
+      const keySpan = moveParseSourceSpan(sourceSpan, binding.key.span);
+      if (binding instanceof VariableBinding) {
+        const value = binding.value ? binding.value.source : "$implicit";
+        const valueSpan = binding.value ? moveParseSourceSpan(sourceSpan, binding.value.span) : void 0;
+        targetVars.push(new ParsedVariable(key, value, bindingSpan, keySpan, valueSpan));
+      } else if (binding.value) {
+        const srcSpan = isIvyAst ? bindingSpan : sourceSpan;
+        const valueSpan = moveParseSourceSpan(sourceSpan, binding.value.ast.sourceSpan);
+        this._parsePropertyAst(key, binding.value, false, srcSpan, keySpan, valueSpan, targetMatchableAttrs, targetProps);
+      } else {
+        targetMatchableAttrs.push([key, ""]);
+        this.parseLiteralAttr(key, null, keySpan, absoluteValueOffset, void 0, targetMatchableAttrs, targetProps, keySpan);
+      }
+    }
+  }
+  _parseTemplateBindings(tplKey, tplValue, sourceSpan, absoluteKeyOffset, absoluteValueOffset) {
+    try {
+      const bindingsResult = this._exprParser.parseTemplateBindings(tplKey, tplValue, sourceSpan, absoluteKeyOffset, absoluteValueOffset);
+      bindingsResult.errors.forEach((e) => this.errors.push(e));
+      bindingsResult.warnings.forEach((warning) => {
+        this._reportError(warning, sourceSpan, ParseErrorLevel.WARNING);
+      });
+      return bindingsResult.templateBindings;
+    } catch (e) {
+      this._reportError(`${e}`, sourceSpan);
+      return [];
+    }
+  }
+  parseLiteralAttr(name, value, sourceSpan, absoluteOffset, valueSpan, targetMatchableAttrs, targetProps, keySpan) {
+    if (isLegacyAnimationLabel(name)) {
+      name = name.substring(1);
+      if (keySpan !== void 0) {
+        keySpan = moveParseSourceSpan(keySpan, new AbsoluteSourceSpan(keySpan.start.offset + 1, keySpan.end.offset));
+      }
+      if (value) {
+        this._reportError(`Assigning animation triggers via @prop="exp" attributes with an expression is invalid. Use property bindings (e.g. [@prop]="exp") or use an attribute without a value (e.g. @prop) instead.`, sourceSpan, ParseErrorLevel.ERROR);
+      }
+      this._parseLegacyAnimation(name, value, sourceSpan, absoluteOffset, keySpan, valueSpan, targetMatchableAttrs, targetProps);
+    } else {
+      targetProps.push(new ParsedProperty(name, this._exprParser.wrapLiteralPrimitive(value, "", absoluteOffset), ParsedPropertyType.LITERAL_ATTR, sourceSpan, keySpan, valueSpan));
+    }
+  }
+  parsePropertyBinding(name, expression, isHost, isPartOfAssignmentBinding, sourceSpan, absoluteOffset, valueSpan, targetMatchableAttrs, targetProps, keySpan) {
+    if (name.length === 0) {
+      this._reportError(`Property name is missing in binding`, sourceSpan);
+    }
+    let isLegacyAnimationProp = false;
+    if (name.startsWith(LEGACY_ANIMATE_PROP_PREFIX)) {
+      isLegacyAnimationProp = true;
+      name = name.substring(LEGACY_ANIMATE_PROP_PREFIX.length);
+      if (keySpan !== void 0) {
+        keySpan = moveParseSourceSpan(keySpan, new AbsoluteSourceSpan(keySpan.start.offset + LEGACY_ANIMATE_PROP_PREFIX.length, keySpan.end.offset));
+      }
+    } else if (isLegacyAnimationLabel(name)) {
+      isLegacyAnimationProp = true;
+      name = name.substring(1);
+      if (keySpan !== void 0) {
+        keySpan = moveParseSourceSpan(keySpan, new AbsoluteSourceSpan(keySpan.start.offset + 1, keySpan.end.offset));
+      }
+    }
+    if (isLegacyAnimationProp) {
+      this._parseLegacyAnimation(name, expression, sourceSpan, absoluteOffset, keySpan, valueSpan, targetMatchableAttrs, targetProps);
+    } else if (name.startsWith(`${ANIMATE_PREFIX$1}${PROPERTY_PARTS_SEPARATOR}`)) {
+      this._parseAnimation(name, this.parseBinding(expression, isHost, valueSpan || sourceSpan, absoluteOffset), sourceSpan, keySpan, valueSpan, targetMatchableAttrs, targetProps);
+    } else {
+      this._parsePropertyAst(name, this.parseBinding(expression, isHost, valueSpan || sourceSpan, absoluteOffset), isPartOfAssignmentBinding, sourceSpan, keySpan, valueSpan, targetMatchableAttrs, targetProps);
+    }
+  }
+  parsePropertyInterpolation(name, value, sourceSpan, valueSpan, targetMatchableAttrs, targetProps, keySpan, interpolatedTokens) {
+    const expr = this.parseInterpolation(value, valueSpan || sourceSpan, interpolatedTokens);
+    if (expr) {
+      this._parsePropertyAst(name, expr, false, sourceSpan, keySpan, valueSpan, targetMatchableAttrs, targetProps);
+      return true;
+    }
+    return false;
+  }
+  _parsePropertyAst(name, ast, isPartOfAssignmentBinding, sourceSpan, keySpan, valueSpan, targetMatchableAttrs, targetProps) {
+    targetMatchableAttrs.push([name, ast.source]);
+    targetProps.push(new ParsedProperty(name, ast, isPartOfAssignmentBinding ? ParsedPropertyType.TWO_WAY : ParsedPropertyType.DEFAULT, sourceSpan, keySpan, valueSpan));
+  }
+  _parseAnimation(name, ast, sourceSpan, keySpan, valueSpan, targetMatchableAttrs, targetProps) {
+    targetMatchableAttrs.push([name, ast.source]);
+    targetProps.push(new ParsedProperty(name, ast, ParsedPropertyType.ANIMATION, sourceSpan, keySpan, valueSpan));
+  }
+  _parseLegacyAnimation(name, expression, sourceSpan, absoluteOffset, keySpan, valueSpan, targetMatchableAttrs, targetProps) {
+    if (name.length === 0) {
+      this._reportError("Animation trigger is missing", sourceSpan);
+    }
+    const ast = this.parseBinding(expression || "undefined", false, valueSpan || sourceSpan, absoluteOffset);
+    targetMatchableAttrs.push([name, ast.source]);
+    targetProps.push(new ParsedProperty(name, ast, ParsedPropertyType.LEGACY_ANIMATION, sourceSpan, keySpan, valueSpan));
+  }
+  parseBinding(value, isHostBinding2, sourceSpan, absoluteOffset) {
+    try {
+      const ast = isHostBinding2 ? this._exprParser.parseSimpleBinding(value, sourceSpan, absoluteOffset) : this._exprParser.parseBinding(value, sourceSpan, absoluteOffset);
+      if (ast) {
+        this.errors.push(...ast.errors);
+      }
+      return ast;
+    } catch (e) {
+      this._reportError(`${e}`, sourceSpan);
+      return this._exprParser.wrapLiteralPrimitive("ERROR", sourceSpan, absoluteOffset);
+    }
+  }
+  createBoundElementProperty(elementSelector, boundProp, skipValidation = false, mapPropertyName = true) {
+    if (boundProp.isLegacyAnimation) {
+      return new BoundElementProperty(boundProp.name, BindingType.LegacyAnimation, SecurityContext.NONE, boundProp.expression, null, boundProp.sourceSpan, boundProp.keySpan, boundProp.valueSpan);
+    }
+    let unit = null;
+    let bindingType = void 0;
+    let boundPropertyName = null;
+    const parts = boundProp.name.split(PROPERTY_PARTS_SEPARATOR);
+    let securityContexts = void 0;
+    if (parts.length > 1) {
+      if (parts[0] == ATTRIBUTE_PREFIX) {
+        boundPropertyName = parts.slice(1).join(PROPERTY_PARTS_SEPARATOR);
+        if (!skipValidation) {
+          this._validatePropertyOrAttributeName(boundPropertyName, boundProp.sourceSpan, true);
+        }
+        securityContexts = calcPossibleSecurityContexts(this._schemaRegistry, elementSelector, boundPropertyName, true);
+        const nsSeparatorIdx = boundPropertyName.indexOf(":");
+        if (nsSeparatorIdx > -1) {
+          const ns = boundPropertyName.substring(0, nsSeparatorIdx);
+          const name = boundPropertyName.substring(nsSeparatorIdx + 1);
+          boundPropertyName = mergeNsAndName(ns, name);
+        }
+        bindingType = BindingType.Attribute;
+      } else if (parts[0] == CLASS_PREFIX) {
+        boundPropertyName = parts[1];
+        bindingType = BindingType.Class;
+        securityContexts = [SecurityContext.NONE];
+      } else if (parts[0] == STYLE_PREFIX) {
+        unit = parts.length > 2 ? parts[2] : null;
+        const boundName = parts[1];
+        if (!boundName.startsWith("--")) {
+          boundPropertyName = boundName;
+        } else {
+          try {
+            boundPropertyName = namespaceCssVariable(boundName);
+          } catch (e) {
+            this._reportError(e.message, boundProp.sourceSpan);
+          }
+        }
+        bindingType = BindingType.Style;
+        securityContexts = [SecurityContext.STYLE];
+      } else if (parts[0] == ANIMATE_PREFIX$1) {
+        boundPropertyName = boundProp.name;
+        bindingType = BindingType.Animation;
+        securityContexts = [SecurityContext.NONE];
+      }
+    }
+    if (boundPropertyName === null) {
+      const mappedPropName = this._schemaRegistry.getMappedPropName(boundProp.name);
+      boundPropertyName = mapPropertyName ? mappedPropName : boundProp.name;
+      securityContexts = calcPossibleSecurityContexts(this._schemaRegistry, elementSelector, mappedPropName, false);
+      bindingType = boundProp.type === ParsedPropertyType.TWO_WAY ? BindingType.TwoWay : BindingType.Property;
+      if (!skipValidation) {
+        this._validatePropertyOrAttributeName(mappedPropName, boundProp.sourceSpan, false);
+      }
+    }
+    return new BoundElementProperty(boundPropertyName, bindingType, securityContexts[0], boundProp.expression, unit, boundProp.sourceSpan, boundProp.keySpan, boundProp.valueSpan);
+  }
+  parseEvent(name, expression, isAssignmentEvent, sourceSpan, handlerSpan, targetMatchableAttrs, targetEvents, keySpan) {
+    if (name.length === 0) {
+      this._reportError(`Event name is missing in binding`, sourceSpan);
+    }
+    if (isLegacyAnimationLabel(name)) {
+      name = name.slice(1);
+      if (keySpan !== void 0) {
+        keySpan = moveParseSourceSpan(keySpan, new AbsoluteSourceSpan(keySpan.start.offset + 1, keySpan.end.offset));
+      }
+      this._parseLegacyAnimationEvent(name, expression, sourceSpan, handlerSpan, targetEvents, keySpan);
+    } else {
+      this._parseRegularEvent(name, expression, isAssignmentEvent, sourceSpan, handlerSpan, targetMatchableAttrs, targetEvents, keySpan);
+    }
+  }
+  calcPossibleSecurityContexts(selector, propName, isAttribute) {
+    const prop = this._schemaRegistry.getMappedPropName(propName);
+    return calcPossibleSecurityContexts(this._schemaRegistry, selector, prop, isAttribute);
+  }
+  parseEventListenerName(rawName) {
+    const [target, eventName] = splitAtColon(rawName, [null, rawName]);
+    return {
+      eventName,
+      target
+    };
+  }
+  parseLegacyAnimationEventName(rawName) {
+    const matches = splitAtPeriod(rawName, [rawName, null]);
+    return {
+      eventName: matches[0],
+      phase: matches[1] === null ? null : matches[1].toLowerCase()
+    };
+  }
+  _parseLegacyAnimationEvent(name, expression, sourceSpan, handlerSpan, targetEvents, keySpan) {
+    const {
+      eventName,
+      phase
+    } = this.parseLegacyAnimationEventName(name);
+    const ast = this._parseAction(expression, handlerSpan);
+    targetEvents.push(new ParsedEvent(eventName, phase, ParsedEventType.LegacyAnimation, ast, sourceSpan, handlerSpan, keySpan));
+    if (eventName.length === 0) {
+      this._reportError(`Animation event name is missing in binding`, sourceSpan);
+    }
+    if (phase) {
+      if (phase !== "start" && phase !== "done") {
+        this._reportError(`The provided animation output phase value "${phase}" for "@${eventName}" is not supported (use start or done)`, sourceSpan);
+      }
+    } else {
+      this._reportError(`The animation trigger output event (@${eventName}) is missing its phase value name (start or done are currently supported)`, sourceSpan);
+    }
+  }
+  _parseRegularEvent(name, expression, isAssignmentEvent, sourceSpan, handlerSpan, targetMatchableAttrs, targetEvents, keySpan) {
+    const {
+      eventName,
+      target
+    } = this.parseEventListenerName(name);
+    const prevErrorCount = this.errors.length;
+    const ast = this._parseAction(expression, handlerSpan);
+    const isValid = this.errors.length === prevErrorCount;
+    targetMatchableAttrs.push([name, ast.source]);
+    if (isAssignmentEvent && isValid && !this._isAllowedAssignmentEvent(ast)) {
+      this._reportError("Unsupported expression in a two-way binding", sourceSpan);
+    }
+    let eventType = ParsedEventType.Regular;
+    if (isAssignmentEvent) {
+      eventType = ParsedEventType.TwoWay;
+    }
+    if (name.startsWith(`${ANIMATE_PREFIX$1}${PROPERTY_PARTS_SEPARATOR}`)) {
+      eventType = ParsedEventType.Animation;
+    }
+    targetEvents.push(new ParsedEvent(eventName, target, eventType, ast, sourceSpan, handlerSpan, keySpan));
+  }
+  _parseAction(value, sourceSpan) {
+    const absoluteOffset = sourceSpan && sourceSpan.start ? sourceSpan.start.offset : 0;
+    try {
+      const ast = this._exprParser.parseAction(value, sourceSpan, absoluteOffset);
+      if (ast) {
+        this.errors.push(...ast.errors);
+      }
+      if (!ast || ast.ast instanceof EmptyExpr$1) {
+        this._reportError(`Empty expressions are not allowed`, sourceSpan);
+        return this._exprParser.wrapLiteralPrimitive("ERROR", sourceSpan, absoluteOffset);
+      }
+      return ast;
+    } catch (e) {
+      this._reportError(`${e}`, sourceSpan);
+      return this._exprParser.wrapLiteralPrimitive("ERROR", sourceSpan, absoluteOffset);
+    }
+  }
+  _reportError(message, sourceSpan, level = ParseErrorLevel.ERROR) {
+    this.errors.push(new ParseError(sourceSpan, message, level));
+  }
+  _validatePropertyOrAttributeName(propName, sourceSpan, isAttr) {
+    const report = isAttr ? this._schemaRegistry.validateAttribute(propName) : this._schemaRegistry.validateProperty(propName);
+    if (report.error) {
+      this._reportError(report.msg, sourceSpan, ParseErrorLevel.ERROR);
+    }
+  }
+  _isAllowedAssignmentEvent(ast) {
+    if (ast instanceof ASTWithSource) {
+      return this._isAllowedAssignmentEvent(ast.ast);
+    }
+    if (ast instanceof NonNullAssert) {
+      return this._isAllowedAssignmentEvent(ast.expression);
+    }
+    if (ast instanceof Call && ast.args.length === 1 && ast.receiver instanceof PropertyRead && ast.receiver.name === "$any" && ast.receiver.receiver instanceof ImplicitReceiver) {
+      return this._isAllowedAssignmentEvent(ast.args[0]);
+    }
+    if (ast instanceof PropertyRead || ast instanceof KeyedRead) {
+      if (!hasRecursiveSafeReceiver(ast)) {
+        return true;
+      }
+    }
+    return false;
+  }
+};
+function hasRecursiveSafeReceiver(ast) {
+  if (ast instanceof SafePropertyRead || ast instanceof SafeKeyedRead) {
+    return true;
+  }
+  if (ast instanceof ParenthesizedExpression) {
+    return hasRecursiveSafeReceiver(ast.expression);
+  }
+  if (ast instanceof PropertyRead || ast instanceof KeyedRead || ast instanceof Call) {
+    return hasRecursiveSafeReceiver(ast.receiver);
+  }
+  return false;
+}
+__name(hasRecursiveSafeReceiver, "hasRecursiveSafeReceiver");
+function isLegacyAnimationLabel(name) {
+  return name[0] == "@";
+}
+__name(isLegacyAnimationLabel, "isLegacyAnimationLabel");
+function calcPossibleSecurityContexts(registry, selector, propName, isAttribute) {
+  let ctxs;
+  const [namespaceKey, baseSelector] = selector ? splitNsName(selector, false) : [null, selector];
+  const nameToContext = /* @__PURE__ */ __name((elName) => {
+    const [nsStr, name] = splitNsName(elName, false);
+    const ns = nsStr ?? namespaceKey;
+    const fullName = ns ? `:${ns}:${name}` : name;
+    return registry.securityContext(fullName, propName, isAttribute);
+  }, "nameToContext");
+  const allKnownElements = registry.allKnownElementNames();
+  if (baseSelector === null) {
+    ctxs = allKnownElements.map(nameToContext);
+  } else {
+    ctxs = [];
+    CssSelector.parse(baseSelector).forEach((selector2) => {
+      let elementNames = selector2.element ? [selector2.element] : allKnownElements;
+      if (selector2.element && !registry.hasElement(selector2.element, [])) {
+        const svgElement = `:${SVG_NAMESPACE}:${selector2.element}`;
+        const mathElement = `:${MATH_ML_NAMESPACE}:${selector2.element}`;
+        if (registry.hasElement(svgElement, [])) {
+          elementNames = [svgElement];
+        } else if (registry.hasElement(mathElement, [])) {
+          elementNames = [mathElement];
+        }
+      }
+      const notElementNames = new Set(selector2.notSelectors.filter((selector3) => selector3.isElementSelector()).map((selector3) => selector3.element?.toLowerCase()));
+      const possibleElementNames = elementNames.filter((elName) => {
+        const elNameLowerCase = elName.toLowerCase();
+        return !notElementNames.has(elNameLowerCase) && !notElementNames.has(splitNsName(elNameLowerCase)[1]);
+      });
+      ctxs.push(...possibleElementNames.map(nameToContext));
+    });
+  }
+  return ctxs.length === 0 ? [SecurityContext.NONE] : Array.from(new Set(ctxs)).sort();
+}
+__name(calcPossibleSecurityContexts, "calcPossibleSecurityContexts");
+function moveParseSourceSpan(sourceSpan, absoluteSpan) {
+  const startDiff = absoluteSpan.start - sourceSpan.start.offset;
+  const endDiff = absoluteSpan.end - sourceSpan.end.offset;
+  return new ParseSourceSpan(sourceSpan.start.moveBy(startDiff), sourceSpan.end.moveBy(endDiff), sourceSpan.fullStart.moveBy(startDiff), sourceSpan.details);
+}
+__name(moveParseSourceSpan, "moveParseSourceSpan");
 var domSchema = new DomElementSchemaRegistry();
 var NG_TEMPLATE_TAG_NAME = "ng-template";
-var ANIMATE_PREFIX$1 = "animate.";
+var ANIMATE_PREFIX = "animate.";
 function isI18nRootNode(meta) {
   return meta instanceof Message;
 }
@@ -24032,8 +24698,8 @@ function isSingleI18nIcu(meta) {
   return isI18nRootNode(meta) && meta.nodes.length === 1 && meta.nodes[0] instanceof Icu2;
 }
 __name(isSingleI18nIcu, "isSingleI18nIcu");
-function ingestComponent(componentName, template2, constantPool, compilationMode, relativeContextFilePath, i18nUseExternalIds, deferMeta, allDeferrableDepsFn, relativeTemplatePath, enableDebugLocations, legacyOptionalChaining) {
-  const job = new ComponentCompilationJob(componentName, constantPool, compilationMode, relativeContextFilePath, i18nUseExternalIds, deferMeta, allDeferrableDepsFn, relativeTemplatePath, enableDebugLocations, legacyOptionalChaining);
+function ingestComponent(componentName, template2, constantPool, compilationMode, relativeContextFilePath, i18nUseExternalIds, deferMeta, allDeferrableDepsFn, relativeTemplatePath, enableDebugLocations, legacyOptionalChaining, foreignImports) {
+  const job = new ComponentCompilationJob(componentName, constantPool, compilationMode, relativeContextFilePath, i18nUseExternalIds, deferMeta, allDeferrableDepsFn, relativeTemplatePath, enableDebugLocations, legacyOptionalChaining, foreignImports);
   ingestNodes(job.root, template2);
   return job;
 }
@@ -24052,11 +24718,11 @@ function ingestHostBinding(input, bindingParser, constantPool) {
     if (property2.isAnimation) {
       bindingKind = BindingKind.Animation;
     }
-    const securityContexts = bindingParser.calcPossibleSecurityContexts(input.componentSelector, property2.name, bindingKind === BindingKind.Attribute).filter((context) => context !== SecurityContext.NONE);
+    const securityContexts = calcHostBindingSecurityContexts(bindingParser, input.componentSelector, property2.name, bindingKind === BindingKind.Attribute);
     ingestDomProperty(job, property2, bindingKind, securityContexts);
   }
   for (const [name, expr] of Object.entries(input.attributes) ?? []) {
-    const securityContexts = bindingParser.calcPossibleSecurityContexts(input.componentSelector, name, true).filter((context) => context !== SecurityContext.NONE);
+    const securityContexts = calcHostBindingSecurityContexts(bindingParser, input.componentSelector, name, true);
     ingestHostAttribute(job, name, expr, securityContexts);
   }
   for (const event of input.events ?? []) {
@@ -24065,6 +24731,21 @@ function ingestHostBinding(input, bindingParser, constantPool) {
   return job;
 }
 __name(ingestHostBinding, "ingestHostBinding");
+function calcHostBindingSecurityContexts(bindingParser, selector, name, isAttribute) {
+  const declaringSelectorContexts = bindingParser.calcPossibleSecurityContexts(selector, name, isAttribute);
+  const concreteHostContexts = calcPossibleSecurityContexts(domSchema, null, domSchema.getMappedPropName(name), isAttribute);
+  const concreteHostNonNoneContexts = concreteHostContexts.filter((context) => context !== SecurityContext.NONE);
+  const concreteHostNonNoneCount = concreteHostNonNoneContexts.length;
+  const hasConcreteHostNoneContext = concreteHostNonNoneCount !== concreteHostContexts.length;
+  if (hasConcreteHostNoneContext && concreteHostNonNoneCount > 0) {
+    return concreteHostContexts;
+  }
+  if (concreteHostNonNoneContexts.some((context) => !declaringSelectorContexts.includes(context))) {
+    return concreteHostContexts;
+  }
+  return declaringSelectorContexts.filter((context) => context !== SecurityContext.NONE);
+}
+__name(calcHostBindingSecurityContexts, "calcHostBindingSecurityContexts");
 function ingestDomProperty(job, property2, bindingKind, securityContexts) {
   let expression;
   const ast = property2.expression.ast;
@@ -24128,6 +24809,11 @@ function ingestElement(unit, element2) {
     throw Error(`Unhandled i18n metadata type for element: ${element2.i18n.constructor.name}`);
   }
   const id = unit.job.allocateXrefId();
+  const foreignComp = unit.job.getForeignComponent(element2);
+  if (foreignComp) {
+    ingestForeignComponent(unit, id, element2, foreignComp);
+    return;
+  }
   const [namespaceKey, elementName] = splitNsName(element2.name);
   const startOp = createElementStartOp(elementName, id, namespaceForKey(namespaceKey), element2.i18n instanceof TagPlaceholder ? element2.i18n : void 0, element2.startSourceSpan, element2.sourceSpan);
   unit.create.push(startOp);
@@ -24146,6 +24832,40 @@ function ingestElement(unit, element2) {
   }
 }
 __name(ingestElement, "ingestElement");
+function ingestForeignComponent(unit, id, element2, foreignComp) {
+  const props = /* @__PURE__ */ new Map();
+  for (const attr of element2.attributes) {
+    props.set(attr.name, literal(attr.value));
+  }
+  for (const input of element2.inputs) {
+    props.set(input.name, convertAst(input.value, unit.job, input.sourceSpan));
+  }
+  const contentBlocks = [];
+  const childNodes = [];
+  for (const child of element2.children) {
+    if (child instanceof ContentBlock) {
+      contentBlocks.push(child);
+    } else {
+      childNodes.push(child);
+    }
+  }
+  for (const block of contentBlocks) {
+    const blockView = unit.job.allocateView(unit.xref);
+    for (let i = 0; i < block.variables.length; i++) {
+      blockView.contextVariables.set(block.variables[i].name, i);
+    }
+    ingestNodes(blockView, block.children);
+    unit.create.push(createContentOp(id, blockView.xref, block.name, block.startSourceSpan, block.sourceSpan));
+  }
+  if (childNodes.length > 0) {
+    const childView = unit.job.allocateView(unit.xref);
+    ingestNodes(childView, childNodes);
+    unit.create.push(createContentOp(id, childView.xref, "children", element2.startSourceSpan, element2.sourceSpan));
+  }
+  const constIndex = unit.job.addConst(foreignComp.component);
+  unit.create.push(createForeignComponentOp(id, constIndex, props, element2.startSourceSpan));
+}
+__name(ingestForeignComponent, "ingestForeignComponent");
 function ingestTemplate(unit, tmpl) {
   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}`);
@@ -24819,7 +25539,7 @@ function ingestControlFlowInsertionPoint(unit, xref, node) {
     if (root !== null) {
       return null;
     }
-    if (child instanceof Element$1 || child instanceof Template && child.tagName !== null) {
+    if (child instanceof Element$1 && unit.job.getForeignComponent(child) === null || child instanceof Template && child.tagName !== null) {
       root = child;
     } else {
       return null;
@@ -24827,7 +25547,7 @@ function ingestControlFlowInsertionPoint(unit, xref, node) {
   }
   if (root !== null) {
     for (const attr of root.attributes) {
-      if (!attr.name.startsWith(ANIMATE_PREFIX$1)) {
+      if (!attr.name.startsWith(ANIMATE_PREFIX)) {
         const securityContext = domSchema.securityContext(NG_TEMPLATE_TAG_NAME, attr.name, true);
         unit.update.push(createBindingOp(xref, BindingKind.Attribute, attr.name, literal(attr.value), null, securityContext, true, false, null, asMessage(attr.i18n), attr.sourceSpan));
       }
@@ -25013,408 +25733,6 @@ var HtmlParser = class extends Parser$1 {
     return super.parse(source, url, options);
   }
 };
-var PROPERTY_PARTS_SEPARATOR = ".";
-var ATTRIBUTE_PREFIX = "attr";
-var ANIMATE_PREFIX = "animate";
-var CLASS_PREFIX = "class";
-var STYLE_PREFIX = "style";
-var TEMPLATE_ATTR_PREFIX$1 = "*";
-var LEGACY_ANIMATE_PROP_PREFIX = "animate-";
-var BindingParser = class {
-  static {
-    __name(this, "BindingParser");
-  }
-  _exprParser;
-  _schemaRegistry;
-  errors;
-  constructor(_exprParser, _schemaRegistry, errors) {
-    this._exprParser = _exprParser;
-    this._schemaRegistry = _schemaRegistry;
-    this.errors = errors;
-  }
-  createBoundHostProperties(properties, sourceSpan) {
-    const boundProps = [];
-    for (const propName of Object.keys(properties)) {
-      const expression = properties[propName];
-      if (typeof expression === "string") {
-        this.parsePropertyBinding(propName, expression, true, false, sourceSpan, sourceSpan.start.offset, void 0, [], boundProps, sourceSpan);
-      } else {
-        this._reportError(`Value of the host property binding "${propName}" needs to be a string representing an expression but got "${expression}" (${typeof expression})`, sourceSpan);
-      }
-    }
-    return boundProps;
-  }
-  createDirectiveHostEventAsts(hostListeners, sourceSpan) {
-    const targetEvents = [];
-    for (const propName of Object.keys(hostListeners)) {
-      const expression = hostListeners[propName];
-      if (typeof expression === "string") {
-        this.parseEvent(propName, expression, false, sourceSpan, sourceSpan, [], targetEvents, sourceSpan);
-      } else {
-        this._reportError(`Value of the host listener "${propName}" needs to be a string representing an expression but got "${expression}" (${typeof expression})`, sourceSpan);
-      }
-    }
-    return targetEvents;
-  }
-  parseInterpolation(value, sourceSpan, interpolatedTokens) {
-    const absoluteOffset = sourceSpan.fullStart.offset;
-    try {
-      const ast = this._exprParser.parseInterpolation(value, sourceSpan, absoluteOffset, interpolatedTokens);
-      if (ast) {
-        this.errors.push(...ast.errors);
-      }
-      return ast;
-    } catch (e) {
-      this._reportError(`${e}`, sourceSpan);
-      return this._exprParser.wrapLiteralPrimitive("ERROR", sourceSpan, absoluteOffset);
-    }
-  }
-  parseInterpolationExpression(expression, sourceSpan) {
-    const absoluteOffset = sourceSpan.start.offset;
-    try {
-      const ast = this._exprParser.parseInterpolationExpression(expression, sourceSpan, absoluteOffset);
-      if (ast) {
-        this.errors.push(...ast.errors);
-      }
-      return ast;
-    } catch (e) {
-      this._reportError(`${e}`, sourceSpan);
-      return this._exprParser.wrapLiteralPrimitive("ERROR", sourceSpan, absoluteOffset);
-    }
-  }
-  parseInlineTemplateBinding(tplKey, tplValue, sourceSpan, absoluteValueOffset, targetMatchableAttrs, targetProps, targetVars, isIvyAst) {
-    const absoluteKeyOffset = sourceSpan.start.offset + TEMPLATE_ATTR_PREFIX$1.length;
-    const bindings = this._parseTemplateBindings(tplKey, tplValue, sourceSpan, absoluteKeyOffset, absoluteValueOffset);
-    for (const binding of bindings) {
-      const bindingSpan = moveParseSourceSpan(sourceSpan, binding.sourceSpan);
-      const key = binding.key.source;
-      const keySpan = moveParseSourceSpan(sourceSpan, binding.key.span);
-      if (binding instanceof VariableBinding) {
-        const value = binding.value ? binding.value.source : "$implicit";
-        const valueSpan = binding.value ? moveParseSourceSpan(sourceSpan, binding.value.span) : void 0;
-        targetVars.push(new ParsedVariable(key, value, bindingSpan, keySpan, valueSpan));
-      } else if (binding.value) {
-        const srcSpan = isIvyAst ? bindingSpan : sourceSpan;
-        const valueSpan = moveParseSourceSpan(sourceSpan, binding.value.ast.sourceSpan);
-        this._parsePropertyAst(key, binding.value, false, srcSpan, keySpan, valueSpan, targetMatchableAttrs, targetProps);
-      } else {
-        targetMatchableAttrs.push([key, ""]);
-        this.parseLiteralAttr(key, null, keySpan, absoluteValueOffset, void 0, targetMatchableAttrs, targetProps, keySpan);
-      }
-    }
-  }
-  _parseTemplateBindings(tplKey, tplValue, sourceSpan, absoluteKeyOffset, absoluteValueOffset) {
-    try {
-      const bindingsResult = this._exprParser.parseTemplateBindings(tplKey, tplValue, sourceSpan, absoluteKeyOffset, absoluteValueOffset);
-      bindingsResult.errors.forEach((e) => this.errors.push(e));
-      bindingsResult.warnings.forEach((warning) => {
-        this._reportError(warning, sourceSpan, ParseErrorLevel.WARNING);
-      });
-      return bindingsResult.templateBindings;
-    } catch (e) {
-      this._reportError(`${e}`, sourceSpan);
-      return [];
-    }
-  }
-  parseLiteralAttr(name, value, sourceSpan, absoluteOffset, valueSpan, targetMatchableAttrs, targetProps, keySpan) {
-    if (isLegacyAnimationLabel(name)) {
-      name = name.substring(1);
-      if (keySpan !== void 0) {
-        keySpan = moveParseSourceSpan(keySpan, new AbsoluteSourceSpan(keySpan.start.offset + 1, keySpan.end.offset));
-      }
-      if (value) {
-        this._reportError(`Assigning animation triggers via @prop="exp" attributes with an expression is invalid. Use property bindings (e.g. [@prop]="exp") or use an attribute without a value (e.g. @prop) instead.`, sourceSpan, ParseErrorLevel.ERROR);
-      }
-      this._parseLegacyAnimation(name, value, sourceSpan, absoluteOffset, keySpan, valueSpan, targetMatchableAttrs, targetProps);
-    } else {
-      targetProps.push(new ParsedProperty(name, this._exprParser.wrapLiteralPrimitive(value, "", absoluteOffset), ParsedPropertyType.LITERAL_ATTR, sourceSpan, keySpan, valueSpan));
-    }
-  }
-  parsePropertyBinding(name, expression, isHost, isPartOfAssignmentBinding, sourceSpan, absoluteOffset, valueSpan, targetMatchableAttrs, targetProps, keySpan) {
-    if (name.length === 0) {
-      this._reportError(`Property name is missing in binding`, sourceSpan);
-    }
-    let isLegacyAnimationProp = false;
-    if (name.startsWith(LEGACY_ANIMATE_PROP_PREFIX)) {
-      isLegacyAnimationProp = true;
-      name = name.substring(LEGACY_ANIMATE_PROP_PREFIX.length);
-      if (keySpan !== void 0) {
-        keySpan = moveParseSourceSpan(keySpan, new AbsoluteSourceSpan(keySpan.start.offset + LEGACY_ANIMATE_PROP_PREFIX.length, keySpan.end.offset));
-      }
-    } else if (isLegacyAnimationLabel(name)) {
-      isLegacyAnimationProp = true;
-      name = name.substring(1);
-      if (keySpan !== void 0) {
-        keySpan = moveParseSourceSpan(keySpan, new AbsoluteSourceSpan(keySpan.start.offset + 1, keySpan.end.offset));
-      }
-    }
-    if (isLegacyAnimationProp) {
-      this._parseLegacyAnimation(name, expression, sourceSpan, absoluteOffset, keySpan, valueSpan, targetMatchableAttrs, targetProps);
-    } else if (name.startsWith(`${ANIMATE_PREFIX}${PROPERTY_PARTS_SEPARATOR}`)) {
-      this._parseAnimation(name, this.parseBinding(expression, isHost, valueSpan || sourceSpan, absoluteOffset), sourceSpan, keySpan, valueSpan, targetMatchableAttrs, targetProps);
-    } else {
-      this._parsePropertyAst(name, this.parseBinding(expression, isHost, valueSpan || sourceSpan, absoluteOffset), isPartOfAssignmentBinding, sourceSpan, keySpan, valueSpan, targetMatchableAttrs, targetProps);
-    }
-  }
-  parsePropertyInterpolation(name, value, sourceSpan, valueSpan, targetMatchableAttrs, targetProps, keySpan, interpolatedTokens) {
-    const expr = this.parseInterpolation(value, valueSpan || sourceSpan, interpolatedTokens);
-    if (expr) {
-      this._parsePropertyAst(name, expr, false, sourceSpan, keySpan, valueSpan, targetMatchableAttrs, targetProps);
-      return true;
-    }
-    return false;
-  }
-  _parsePropertyAst(name, ast, isPartOfAssignmentBinding, sourceSpan, keySpan, valueSpan, targetMatchableAttrs, targetProps) {
-    targetMatchableAttrs.push([name, ast.source]);
-    targetProps.push(new ParsedProperty(name, ast, isPartOfAssignmentBinding ? ParsedPropertyType.TWO_WAY : ParsedPropertyType.DEFAULT, sourceSpan, keySpan, valueSpan));
-  }
-  _parseAnimation(name, ast, sourceSpan, keySpan, valueSpan, targetMatchableAttrs, targetProps) {
-    targetMatchableAttrs.push([name, ast.source]);
-    targetProps.push(new ParsedProperty(name, ast, ParsedPropertyType.ANIMATION, sourceSpan, keySpan, valueSpan));
-  }
-  _parseLegacyAnimation(name, expression, sourceSpan, absoluteOffset, keySpan, valueSpan, targetMatchableAttrs, targetProps) {
-    if (name.length === 0) {
-      this._reportError("Animation trigger is missing", sourceSpan);
-    }
-    const ast = this.parseBinding(expression || "undefined", false, valueSpan || sourceSpan, absoluteOffset);
-    targetMatchableAttrs.push([name, ast.source]);
-    targetProps.push(new ParsedProperty(name, ast, ParsedPropertyType.LEGACY_ANIMATION, sourceSpan, keySpan, valueSpan));
-  }
-  parseBinding(value, isHostBinding2, sourceSpan, absoluteOffset) {
-    try {
-      const ast = isHostBinding2 ? this._exprParser.parseSimpleBinding(value, sourceSpan, absoluteOffset) : this._exprParser.parseBinding(value, sourceSpan, absoluteOffset);
-      if (ast) {
-        this.errors.push(...ast.errors);
-      }
-      return ast;
-    } catch (e) {
-      this._reportError(`${e}`, sourceSpan);
-      return this._exprParser.wrapLiteralPrimitive("ERROR", sourceSpan, absoluteOffset);
-    }
-  }
-  createBoundElementProperty(elementSelector, boundProp, skipValidation = false, mapPropertyName = true) {
-    if (boundProp.isLegacyAnimation) {
-      return new BoundElementProperty(boundProp.name, BindingType.LegacyAnimation, SecurityContext.NONE, boundProp.expression, null, boundProp.sourceSpan, boundProp.keySpan, boundProp.valueSpan);
-    }
-    let unit = null;
-    let bindingType = void 0;
-    let boundPropertyName = null;
-    const parts = boundProp.name.split(PROPERTY_PARTS_SEPARATOR);
-    let securityContexts = void 0;
-    if (parts.length > 1) {
-      if (parts[0] == ATTRIBUTE_PREFIX) {
-        boundPropertyName = parts.slice(1).join(PROPERTY_PARTS_SEPARATOR);
-        if (!skipValidation) {
-          this._validatePropertyOrAttributeName(boundPropertyName, boundProp.sourceSpan, true);
-        }
-        securityContexts = calcPossibleSecurityContexts(this._schemaRegistry, elementSelector, boundPropertyName, true);
-        const nsSeparatorIdx = boundPropertyName.indexOf(":");
-        if (nsSeparatorIdx > -1) {
-          const ns = boundPropertyName.substring(0, nsSeparatorIdx);
-          const name = boundPropertyName.substring(nsSeparatorIdx + 1);
-          boundPropertyName = mergeNsAndName(ns, name);
-        }
-        bindingType = BindingType.Attribute;
-      } else if (parts[0] == CLASS_PREFIX) {
-        boundPropertyName = parts[1];
-        bindingType = BindingType.Class;
-        securityContexts = [SecurityContext.NONE];
-      } else if (parts[0] == STYLE_PREFIX) {
-        unit = parts.length > 2 ? parts[2] : null;
-        boundPropertyName = parts[1];
-        bindingType = BindingType.Style;
-        securityContexts = [SecurityContext.STYLE];
-      } else if (parts[0] == ANIMATE_PREFIX) {
-        boundPropertyName = boundProp.name;
-        bindingType = BindingType.Animation;
-        securityContexts = [SecurityContext.NONE];
-      }
-    }
-    if (boundPropertyName === null) {
-      const mappedPropName = this._schemaRegistry.getMappedPropName(boundProp.name);
-      boundPropertyName = mapPropertyName ? mappedPropName : boundProp.name;
-      securityContexts = calcPossibleSecurityContexts(this._schemaRegistry, elementSelector, mappedPropName, false);
-      bindingType = boundProp.type === ParsedPropertyType.TWO_WAY ? BindingType.TwoWay : BindingType.Property;
-      if (!skipValidation) {
-        this._validatePropertyOrAttributeName(mappedPropName, boundProp.sourceSpan, false);
-      }
-    }
-    return new BoundElementProperty(boundPropertyName, bindingType, securityContexts[0], boundProp.expression, unit, boundProp.sourceSpan, boundProp.keySpan, boundProp.valueSpan);
-  }
-  parseEvent(name, expression, isAssignmentEvent, sourceSpan, handlerSpan, targetMatchableAttrs, targetEvents, keySpan) {
-    if (name.length === 0) {
-      this._reportError(`Event name is missing in binding`, sourceSpan);
-    }
-    if (isLegacyAnimationLabel(name)) {
-      name = name.slice(1);
-      if (keySpan !== void 0) {
-        keySpan = moveParseSourceSpan(keySpan, new AbsoluteSourceSpan(keySpan.start.offset + 1, keySpan.end.offset));
-      }
-      this._parseLegacyAnimationEvent(name, expression, sourceSpan, handlerSpan, targetEvents, keySpan);
-    } else {
-      this._parseRegularEvent(name, expression, isAssignmentEvent, sourceSpan, handlerSpan, targetMatchableAttrs, targetEvents, keySpan);
-    }
-  }
-  calcPossibleSecurityContexts(selector, propName, isAttribute) {
-    const prop = this._schemaRegistry.getMappedPropName(propName);
-    return calcPossibleSecurityContexts(this._schemaRegistry, selector, prop, isAttribute);
-  }
-  parseEventListenerName(rawName) {
-    const [target, eventName] = splitAtColon(rawName, [null, rawName]);
-    return {
-      eventName,
-      target
-    };
-  }
-  parseLegacyAnimationEventName(rawName) {
-    const matches = splitAtPeriod(rawName, [rawName, null]);
-    return {
-      eventName: matches[0],
-      phase: matches[1] === null ? null : matches[1].toLowerCase()
-    };
-  }
-  _parseLegacyAnimationEvent(name, expression, sourceSpan, handlerSpan, targetEvents, keySpan) {
-    const {
-      eventName,
-      phase
-    } = this.parseLegacyAnimationEventName(name);
-    const ast = this._parseAction(expression, handlerSpan);
-    targetEvents.push(new ParsedEvent(eventName, phase, ParsedEventType.LegacyAnimation, ast, sourceSpan, handlerSpan, keySpan));
-    if (eventName.length === 0) {
-      this._reportError(`Animation event name is missing in binding`, sourceSpan);
-    }
-    if (phase) {
-      if (phase !== "start" && phase !== "done") {
-        this._reportError(`The provided animation output phase value "${phase}" for "@${eventName}" is not supported (use start or done)`, sourceSpan);
-      }
-    } else {
-      this._reportError(`The animation trigger output event (@${eventName}) is missing its phase value name (start or done are currently supported)`, sourceSpan);
-    }
-  }
-  _parseRegularEvent(name, expression, isAssignmentEvent, sourceSpan, handlerSpan, targetMatchableAttrs, targetEvents, keySpan) {
-    const {
-      eventName,
-      target
-    } = this.parseEventListenerName(name);
-    const prevErrorCount = this.errors.length;
-    const ast = this._parseAction(expression, handlerSpan);
-    const isValid = this.errors.length === prevErrorCount;
-    targetMatchableAttrs.push([name, ast.source]);
-    if (isAssignmentEvent && isValid && !this._isAllowedAssignmentEvent(ast)) {
-      this._reportError("Unsupported expression in a two-way binding", sourceSpan);
-    }
-    let eventType = ParsedEventType.Regular;
-    if (isAssignmentEvent) {
-      eventType = ParsedEventType.TwoWay;
-    }
-    if (name.startsWith(`${ANIMATE_PREFIX}${PROPERTY_PARTS_SEPARATOR}`)) {
-      eventType = ParsedEventType.Animation;
-    }
-    targetEvents.push(new ParsedEvent(eventName, target, eventType, ast, sourceSpan, handlerSpan, keySpan));
-  }
-  _parseAction(value, sourceSpan) {
-    const absoluteOffset = sourceSpan && sourceSpan.start ? sourceSpan.start.offset : 0;
-    try {
-      const ast = this._exprParser.parseAction(value, sourceSpan, absoluteOffset);
-      if (ast) {
-        this.errors.push(...ast.errors);
-      }
-      if (!ast || ast.ast instanceof EmptyExpr$1) {
-        this._reportError(`Empty expressions are not allowed`, sourceSpan);
-        return this._exprParser.wrapLiteralPrimitive("ERROR", sourceSpan, absoluteOffset);
-      }
-      return ast;
-    } catch (e) {
-      this._reportError(`${e}`, sourceSpan);
-      return this._exprParser.wrapLiteralPrimitive("ERROR", sourceSpan, absoluteOffset);
-    }
-  }
-  _reportError(message, sourceSpan, level = ParseErrorLevel.ERROR) {
-    this.errors.push(new ParseError(sourceSpan, message, level));
-  }
-  _validatePropertyOrAttributeName(propName, sourceSpan, isAttr) {
-    const report = isAttr ? this._schemaRegistry.validateAttribute(propName) : this._schemaRegistry.validateProperty(propName);
-    if (report.error) {
-      this._reportError(report.msg, sourceSpan, ParseErrorLevel.ERROR);
-    }
-  }
-  _isAllowedAssignmentEvent(ast) {
-    if (ast instanceof ASTWithSource) {
-      return this._isAllowedAssignmentEvent(ast.ast);
-    }
-    if (ast instanceof NonNullAssert) {
-      return this._isAllowedAssignmentEvent(ast.expression);
-    }
-    if (ast instanceof Call && ast.args.length === 1 && ast.receiver instanceof PropertyRead && ast.receiver.name === "$any" && ast.receiver.receiver instanceof ImplicitReceiver) {
-      return this._isAllowedAssignmentEvent(ast.args[0]);
-    }
-    if (ast instanceof PropertyRead || ast instanceof KeyedRead) {
-      if (!hasRecursiveSafeReceiver(ast)) {
-        return true;
-      }
-    }
-    return false;
-  }
-};
-function hasRecursiveSafeReceiver(ast) {
-  if (ast instanceof SafePropertyRead || ast instanceof SafeKeyedRead) {
-    return true;
-  }
-  if (ast instanceof ParenthesizedExpression) {
-    return hasRecursiveSafeReceiver(ast.expression);
-  }
-  if (ast instanceof PropertyRead || ast instanceof KeyedRead || ast instanceof Call) {
-    return hasRecursiveSafeReceiver(ast.receiver);
-  }
-  return false;
-}
-__name(hasRecursiveSafeReceiver, "hasRecursiveSafeReceiver");
-function isLegacyAnimationLabel(name) {
-  return name[0] == "@";
-}
-__name(isLegacyAnimationLabel, "isLegacyAnimationLabel");
-function calcPossibleSecurityContexts(registry, selector, propName, isAttribute) {
-  let ctxs;
-  const [namespaceKey, baseSelector] = selector ? splitNsName(selector, false) : [null, selector];
-  const nameToContext = /* @__PURE__ */ __name((elName) => {
-    const [nsStr, name] = splitNsName(elName, false);
-    const ns = nsStr ?? namespaceKey;
-    const fullName = ns ? `:${ns}:${name}` : name;
-    return registry.securityContext(fullName, propName, isAttribute);
-  }, "nameToContext");
-  const allKnownElements = registry.allKnownElementNames();
-  if (baseSelector === null) {
-    ctxs = allKnownElements.map(nameToContext);
-  } else {
-    ctxs = [];
-    CssSelector.parse(baseSelector).forEach((selector2) => {
-      let elementNames = selector2.element ? [selector2.element] : allKnownElements;
-      if (selector2.element && !registry.hasElement(selector2.element, [])) {
-        const svgElement = `:${SVG_NAMESPACE}:${selector2.element}`;
-        const mathElement = `:${MATH_ML_NAMESPACE}:${selector2.element}`;
-        if (registry.hasElement(svgElement, [])) {
-          elementNames = [svgElement];
-        } else if (registry.hasElement(mathElement, [])) {
-          elementNames = [mathElement];
-        }
-      }
-      const notElementNames = new Set(selector2.notSelectors.filter((selector3) => selector3.isElementSelector()).map((selector3) => selector3.element?.toLowerCase()));
-      const possibleElementNames = elementNames.filter((elName) => {
-        const elNameLowerCase = elName.toLowerCase();
-        return !notElementNames.has(elNameLowerCase) && !notElementNames.has(splitNsName(elNameLowerCase)[1]);
-      });
-      ctxs.push(...possibleElementNames.map(nameToContext));
-    });
-  }
-  return ctxs.length === 0 ? [SecurityContext.NONE] : Array.from(new Set(ctxs)).sort();
-}
-__name(calcPossibleSecurityContexts, "calcPossibleSecurityContexts");
-function moveParseSourceSpan(sourceSpan, absoluteSpan) {
-  const startDiff = absoluteSpan.start - sourceSpan.start.offset;
-  const endDiff = absoluteSpan.end - sourceSpan.end.offset;
-  return new ParseSourceSpan(sourceSpan.start.moveBy(startDiff), sourceSpan.end.moveBy(endDiff), sourceSpan.fullStart.moveBy(startDiff), sourceSpan.details);
-}
-__name(moveParseSourceSpan, "moveParseSourceSpan");
 function isStyleUrlResolvable(url) {
   if (url == null || url.length === 0 || url[0] == "/") return false;
   const schemeMatch = url.match(URL_WITH_SCHEMA_REGEXP);
@@ -25428,7 +25746,7 @@ var LINK_STYLE_REL_ATTR = "rel";
 var LINK_STYLE_HREF_ATTR = "href";
 var LINK_STYLE_REL_VALUE = "stylesheet";
 var STYLE_ELEMENT = "style";
-var SCRIPT_ELEMENTS = /* @__PURE__ */ new Set([":svg:script", "script"]);
+var SCRIPT_ELEMENTS = /* @__PURE__ */ new Set([":math:script", ":svg:script", "script"]);
 var NG_NON_BINDABLE_ATTR = "ngNonBindable";
 var NG_PROJECT_AS = "ngProjectAs";
 function preparseElement(ast) {
@@ -25493,12 +25811,99 @@ var PreparsedElement = class {
     this.projectAs = projectAs;
   }
 };
+function createContentBlock(ast, visitor) {
+  const errors = [];
+  if (ast.parameters.length < 1 || ast.parameters.length > 2) {
+    errors.push(new ParseError(ast.startSourceSpan, '@content block must have one or two parameters, e.g. "@content(header)" or "@content(items; let item, index)"'));
+    return {
+      node: null,
+      errors
+    };
+  }
+  const nameParam = ast.parameters[0];
+  const name = nameParam.expression.trim();
+  if (name.includes(",")) {
+    errors.push(new ParseError(ast.startSourceSpan, "@content block must have exactly one name parameter"));
+    return {
+      node: null,
+      errors
+    };
+  }
+  if (!IDENTIFIER_PATTERN.test(name)) {
+    errors.push(new ParseError(nameParam.sourceSpan, "@content name must be a valid JavaScript identifier"));
+    return {
+      node: null,
+      errors
+    };
+  }
+  const variables = parseContentBlockVariables(ast, errors);
+  if (variables === null) {
+    return {
+      node: null,
+      errors
+    };
+  }
+  const node = new ContentBlock(name, variables, visitAll(visitor, ast.children, ast.children), ast.nameSpan, ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan, ast.i18n);
+  return {
+    node,
+    errors
+  };
+}
+__name(createContentBlock, "createContentBlock");
+function parseContentBlockVariables(ast, errors) {
+  const variables = [];
+  if (ast.parameters.length < 2) {
+    return variables;
+  }
+  const varsParam = ast.parameters[1];
+  const varsExpr = varsParam.expression.trim();
+  const letMatch = varsExpr.match(LET_PATTERN);
+  if (!letMatch) {
+    errors.push(new ParseError(varsParam.sourceSpan, '@content block variables must start with "let", e.g. "let item, index"'));
+    return null;
+  }
+  const varNames = letMatch[1].split(",").map((v) => v.trim());
+  const variablesRawString = letMatch[1];
+  const variablesStartOffset = varsParam.expression.indexOf(variablesRawString);
+  const variablesStartLocation = varsParam.sourceSpan.start.moveBy(variablesStartOffset);
+  let searchIndex = 0;
+  for (let varName of varNames) {
+    if (varName === "") {
+      errors.push(new ParseError(varsParam.sourceSpan, "Invalid variable name in @content block"));
+      continue;
+    }
+    let varSpan;
+    const index = variablesRawString.indexOf(varName, searchIndex);
+    const varStart = variablesStartLocation.moveBy(index);
+    if (varName.includes("=")) {
+      const eqIndex = varName.indexOf("=");
+      const namePart = varName.substring(0, eqIndex).trim();
+      const fullVarSpan = new ParseSourceSpan(varStart, varStart.moveBy(varName.length));
+      errors.push(new ParseError(fullVarSpan, `@content block variables cannot be assigned a value`));
+      varName = namePart;
+      varSpan = new ParseSourceSpan(varStart, varStart.moveBy(varName.length));
+    } else {
+      varSpan = new ParseSourceSpan(varStart, varStart.moveBy(varName.length));
+    }
+    if (!IDENTIFIER_PATTERN.test(varName)) {
+      errors.push(new ParseError(varSpan, `Variable name "${varName}" must be a valid JavaScript identifier`));
+      searchIndex = index + varName.length;
+      continue;
+    }
+    if (variables.some((v) => v.name === varName)) {
+      errors.push(new ParseError(varSpan, `Duplicate variable name "${varName}" in @content block`));
+      searchIndex = index + varName.length;
+      continue;
+    }
+    variables.push(new Variable(varName, "", varSpan, varSpan));
+    searchIndex = index + varName.length;
+  }
+  return variables;
+}
+__name(parseContentBlockVariables, "parseContentBlockVariables");
 var FOR_LOOP_EXPRESSION_PATTERN = /^\s*([0-9A-Za-z_$]*)\s+of\s+([\S\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+([\S\s]*)/;
-var IDENTIFIER_PATTERN = /^[$A-Z_][0-9A-Z_$]*$/i;
 var CHARACTERS_IN_SURROUNDING_WHITESPACE_PATTERN = /(\s*)(\S+)(\s*)/;
 var ALLOWED_FOR_LOOP_LET_VARIABLES = /* @__PURE__ */ new Set(["$index", "$first", "$last", "$even", "$odd", "$count"]);
 function isConnectedForLoopBlock(name) {
@@ -25506,7 +25911,7 @@ function isConnectedForLoopBlock(name) {
 }
 __name(isConnectedForLoopBlock, "isConnectedForLoopBlock");
 function isConnectedIfLoopBlock(name) {
-  return name === "else" || ELSE_IF_PATTERN.test(name);
+  return name === "else" || name === "else if";
 }
 __name(isConnectedIfLoopBlock, "isConnectedIfLoopBlock");
 function createIfBlock(ast, connectedBlocks, visitor, bindingParser) {
@@ -25517,7 +25922,7 @@ function createIfBlock(ast, connectedBlocks, visitor, bindingParser) {
     branches.push(new IfBlockBranch(mainBlockParams.expression, visitAll(visitor, ast.children, ast.children), mainBlockParams.expressionAlias, ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan, ast.nameSpan, ast.i18n));
   }
   for (const block of connectedBlocks) {
-    if (ELSE_IF_PATTERN.test(block.name)) {
+    if (block.name === "else if") {
       const params = parseConditionalBlockParameters(block, errors, bindingParser);
       if (params !== null) {
         const children = visitAll(visitor, block.children, block.children);
@@ -25670,7 +26075,7 @@ function parseForLoopParameters(block, errors, bindingParser) {
     })
   };
   for (const param of secondaryParams) {
-    const letMatch = param.expression.match(FOR_LOOP_LET_PATTERN);
+    const letMatch = param.expression.match(LET_PATTERN);
     if (letMatch !== null) {
       const variablesSpan = new ParseSourceSpan(param.sourceSpan.start.moveBy(letMatch[0].length - letMatch[1].length), param.sourceSpan.end);
       parseLetParameter(param.sourceSpan, letMatch[1], variablesSpan, itemName, result.context, errors);
@@ -25750,7 +26155,7 @@ function validateIfConnectedBlocks(connectedBlocks) {
         errors.push(new ParseError(block.startSourceSpan, "@else block cannot have parameters"));
       }
       hasElse = true;
-    } else if (!ELSE_IF_PATTERN.test(block.name)) {
+    } else if (block.name !== "else if") {
       errors.push(new ParseError(block.startSourceSpan, `Unrecognized conditional block @${block.name}`));
     }
   }
@@ -25816,7 +26221,7 @@ function parseConditionalBlockParameters(block, errors, bindingParser) {
     const aliasMatch = param.expression.match(CONDITIONAL_ALIAS_PATTERN);
     if (aliasMatch === null) {
       errors.push(new ParseError(param.sourceSpan, `Unrecognized conditional parameter "${param.expression}"`));
-    } else if (block.name !== "if" && !ELSE_IF_PATTERN.test(block.name)) {
+    } else if (block.name !== "if" && block.name !== "else if") {
       errors.push(new ParseError(param.sourceSpan, '"as" expression is only allowed on `@if` and `@else if` blocks'));
     } else if (expressionAlias !== null) {
       errors.push(new ParseError(param.sourceSpan, 'Conditional can only have one "as" expression'));
@@ -26703,6 +27108,9 @@ var HtmlAstToIvyAst = class {
       case "switch":
         result = createSwitchBlock(block, this, this.bindingParser);
         break;
+      case "content":
+        result = createContentBlock(block, this);
+        break;
       case "for":
         result = createForLoop(block, this.findConnectedBlocks(index, context, isConnectedForLoopBlock), this, this.bindingParser);
         break;
@@ -27248,7 +27656,7 @@ function compileComponentFromMetadata(meta, constantPool, bindingParser) {
     allDeferrableDepsFn = variable(fnName);
   }
   const compilationMode = meta.isStandalone && !meta.hasDirectiveDependencies ? TemplateCompilationMode.DomOnly : TemplateCompilationMode.Full;
-  const tpl = ingestComponent(meta.name, meta.template.nodes, constantPool, compilationMode, meta.relativeContextFilePath, meta.i18nUseExternalIds, meta.defer, allDeferrableDepsFn, meta.relativeTemplatePath, getTemplateSourceLocationsEnabled(), meta.legacyOptionalChaining);
+  const tpl = ingestComponent(meta.name, meta.template.nodes, constantPool, compilationMode, meta.relativeContextFilePath, meta.i18nUseExternalIds, meta.defer, allDeferrableDepsFn, meta.relativeTemplatePath, getTemplateSourceLocationsEnabled(), meta.legacyOptionalChaining, meta.foreignImports);
   transform(tpl, CompilationJobKind.Tmpl);
   const templateFn = emitTemplateFn(tpl, constantPool);
   if (tpl.contentSelectors !== null) {
@@ -27278,7 +27686,8 @@ function compileComponentFromMetadata(meta, constantPool, bindingParser) {
   }
   let hasStyles = !!meta.externalStyles?.length;
   if (meta.styles && meta.styles.length) {
-    const styleValues = meta.encapsulation == ViewEncapsulation$1.Emulated ? compileStyles(meta.styles, CONTENT_ATTR, HOST_ATTR) : meta.styles;
+    const namespacedStyles = meta.styles.map((s) => namespaceCssVariables(s));
+    const styleValues = meta.encapsulation == ViewEncapsulation$1.Emulated ? compileStyles(namespacedStyles, CONTENT_ATTR, HOST_ATTR) : namespacedStyles;
     const styleNodes = styleValues.reduce((result, style) => {
       if (style.trim().length > 0) {
         result.push(constantPool.getConstLiteral(literal(style)));
@@ -27648,6 +28057,9 @@ var CombinedRecursiveAstVisitor = class extends RecursiveAstVisitor2 {
   visitContent(content) {
     this.visitAllTemplateNodes(content.children);
   }
+  visitContentBlock(block) {
+    this.visitAllTemplateNodes(block.children);
+  }
   visitBoundAttribute(attribute2) {
     this.visit(attribute2.value);
   }
@@ -27884,14 +28296,17 @@ var R3TargetBinder = class {
     __name(this, "R3TargetBinder");
   }
   directiveMatcher;
-  constructor(directiveMatcher) {
+  foreignComponentMatcher;
+  constructor(directiveMatcher, foreignComponentMatcher = null) {
     this.directiveMatcher = directiveMatcher;
+    this.foreignComponentMatcher = foreignComponentMatcher;
   }
   bind(target) {
     if (!target.template && !target.host) {
       throw new Error("Empty bound targets are not supported");
     }
     const directives = /* @__PURE__ */ new Map();
+    const foreignComponents = /* @__PURE__ */ new Map();
     const eagerDirectives = [];
     const missingDirectives = /* @__PURE__ */ new Set();
     const bindings = /* @__PURE__ */ new Map();
@@ -27907,14 +28322,14 @@ var R3TargetBinder = class {
     if (target.template) {
       const scope = Scope$1.apply(target.template);
       extractScopedNodeEntities(scope, scopedNodeEntities);
-      DirectiveBinder.apply(target.template, this.directiveMatcher, directives, eagerDirectives, missingDirectives, bindings, references, conflictingHostDirectiveBindings);
+      DirectiveBinder.apply(target.template, this.directiveMatcher, this.foreignComponentMatcher, directives, foreignComponents, eagerDirectives, missingDirectives, bindings, references, conflictingHostDirectiveBindings);
       TemplateBinder.applyWithScope(target.template, scope, expressions, symbols, nestingLevel, usedPipes, eagerPipes, deferBlocks);
     }
     if (target.host) {
       directives.set(target.host.node, target.host.directives);
       TemplateBinder.applyWithScope(target.host.node, Scope$1.apply(target.host.node), expressions, symbols, nestingLevel, usedPipes, eagerPipes, deferBlocks);
     }
-    return new R3BoundTarget(target, directives, eagerDirectives, missingDirectives, bindings, references, expressions, symbols, nestingLevel, scopedNodeEntities, usedPipes, eagerPipes, deferBlocks, conflictingHostDirectiveBindings);
+    return new R3BoundTarget(target, directives, foreignComponents, eagerDirectives, missingDirectives, bindings, references, expressions, symbols, nestingLevel, scopedNodeEntities, usedPipes, eagerPipes, deferBlocks, conflictingHostDirectiveBindings);
   }
 };
 var Scope$1 = class Scope2 {
@@ -27953,7 +28368,7 @@ var Scope$1 = class Scope2 {
       this.visitVariable(nodeOrNodes.item);
       nodeOrNodes.contextVariables.forEach((v) => this.visitVariable(v));
       nodeOrNodes.children.forEach((node) => node.visit(this));
-    } else if (nodeOrNodes instanceof SwitchBlockCaseGroup || nodeOrNodes instanceof ForLoopBlockEmpty || nodeOrNodes instanceof DeferredBlock || nodeOrNodes instanceof DeferredBlockError || nodeOrNodes instanceof DeferredBlockPlaceholder || nodeOrNodes instanceof DeferredBlockLoading || nodeOrNodes instanceof Content) {
+    } else if (nodeOrNodes instanceof SwitchBlockCaseGroup || nodeOrNodes instanceof ForLoopBlockEmpty || nodeOrNodes instanceof DeferredBlock || nodeOrNodes instanceof DeferredBlockError || nodeOrNodes instanceof DeferredBlockPlaceholder || nodeOrNodes instanceof DeferredBlockLoading || nodeOrNodes instanceof ContentBlock || nodeOrNodes instanceof Content) {
       nodeOrNodes.children.forEach((node) => node.visit(this));
     } else if (!(nodeOrNodes instanceof HostElement)) {
       nodeOrNodes.forEach((node) => node.visit(this));
@@ -28014,6 +28429,9 @@ var Scope$1 = class Scope2 {
   visitContent(content) {
     this.ingestScopedNode(content);
   }
+  visitContentBlock(block) {
+    this.ingestScopedNode(block);
+  }
   visitLetDeclaration(decl) {
     this.maybeDeclare(decl);
   }
@@ -28077,24 +28495,28 @@ var DirectiveBinder = class _DirectiveBinder {
     __name(this, "DirectiveBinder");
   }
   directiveMatcher;
+  foreignMatcher;
   directives;
+  foreignComponents;
   eagerDirectives;
   missingDirectives;
   bindings;
   references;
   conflictingHostDirectiveBindings;
   isInDeferBlock = false;
-  constructor(directiveMatcher, directives, eagerDirectives, missingDirectives, bindings, references, conflictingHostDirectiveBindings) {
+  constructor(directiveMatcher, foreignMatcher, directives, foreignComponents, eagerDirectives, missingDirectives, bindings, references, conflictingHostDirectiveBindings) {
     this.directiveMatcher = directiveMatcher;
+    this.foreignMatcher = foreignMatcher;
     this.directives = directives;
+    this.foreignComponents = foreignComponents;
     this.eagerDirectives = eagerDirectives;
     this.missingDirectives = missingDirectives;
     this.bindings = bindings;
     this.references = references;
     this.conflictingHostDirectiveBindings = conflictingHostDirectiveBindings;
   }
-  static apply(template2, directiveMatcher, directives, eagerDirectives, missingDirectives, bindings, references, conflictingHostDirectiveBindings) {
-    const matcher = new _DirectiveBinder(directiveMatcher, directives, eagerDirectives, missingDirectives, bindings, references, conflictingHostDirectiveBindings);
+  static apply(template2, directiveMatcher, foreignMatcher, directives, foreignComponents, eagerDirectives, missingDirectives, bindings, references, conflictingHostDirectiveBindings) {
+    const matcher = new _DirectiveBinder(directiveMatcher, foreignMatcher, directives, foreignComponents, eagerDirectives, missingDirectives, bindings, references, conflictingHostDirectiveBindings);
     matcher.ingest(template2);
   }
   ingest(template2) {
@@ -28153,6 +28575,9 @@ var DirectiveBinder = class _DirectiveBinder {
   visitContent(content) {
     content.children.forEach((child) => child.visit(this));
   }
+  visitContentBlock(block) {
+    block.children.forEach((child) => child.visit(this));
+  }
   visitComponent(node) {
     if (this.directiveMatcher instanceof SelectorlessMatcher) {
       const componentMatches = this.directiveMatcher.match(node.componentName);
@@ -28176,11 +28601,11 @@ var DirectiveBinder = class _DirectiveBinder {
     }
   }
   visitElementOrTemplate(node) {
+    const matchedDirectives = [];
     if (this.directiveMatcher instanceof SelectorMatcher) {
-      const directives = [];
       const cssSelector = createCssSelectorFromNode(node);
-      this.directiveMatcher.match(cssSelector, (_, results) => directives.push(...results));
-      this.trackSelectorBasedBindingsAndDirectives(node, directives);
+      this.directiveMatcher.match(cssSelector, (_, results) => matchedDirectives.push(...results));
+      this.trackSelectorBasedBindingsAndDirectives(node, matchedDirectives);
     } else {
       node.references.forEach((ref) => {
         if (ref.value.trim() === "") {
@@ -28188,6 +28613,15 @@ var DirectiveBinder = class _DirectiveBinder {
         }
       });
     }
+    if (this.foreignMatcher && node instanceof Element$1) {
+      const foreignMatches = this.foreignMatcher.match(node.name);
+      if (foreignMatches.length > 0) {
+        if (matchedDirectives.length > 0) {
+          throw new Error(`Conflict: Element '${node.name}' matches both an Angular directive and a foreign component.`);
+        }
+        this.foreignComponents.set(node, foreignMatches[0]);
+      }
+    }
     node.directives.forEach((directive) => directive.visit(this));
     node.children.forEach((child) => child.visit(this));
   }
@@ -28407,7 +28841,7 @@ var TemplateBinder = class _TemplateBinder extends CombinedRecursiveAstVisitor {
       this.deferBlocks.push([nodeOrNodes, this.scope]);
       nodeOrNodes.children.forEach((node) => node.visit(this));
       this.nestingLevel.set(nodeOrNodes, this.level);
-    } else if (nodeOrNodes instanceof SwitchBlockCaseGroup || nodeOrNodes instanceof ForLoopBlockEmpty || nodeOrNodes instanceof DeferredBlockError || nodeOrNodes instanceof DeferredBlockPlaceholder || nodeOrNodes instanceof DeferredBlockLoading || nodeOrNodes instanceof Content) {
+    } else if (nodeOrNodes instanceof SwitchBlockCaseGroup || nodeOrNodes instanceof ForLoopBlockEmpty || nodeOrNodes instanceof DeferredBlockError || nodeOrNodes instanceof DeferredBlockPlaceholder || nodeOrNodes instanceof DeferredBlockLoading || nodeOrNodes instanceof ContentBlock || nodeOrNodes instanceof Content) {
       nodeOrNodes.children.forEach((node) => node.visit(this));
       this.nestingLevel.set(nodeOrNodes, this.level);
     } else if (nodeOrNodes instanceof HostElement) {
@@ -28478,6 +28912,9 @@ var TemplateBinder = class _TemplateBinder extends CombinedRecursiveAstVisitor {
   visitContent(content) {
     this.ingestScopedNode(content);
   }
+  visitContentBlock(block) {
+    this.ingestScopedNode(block);
+  }
   visitLetDeclaration(decl) {
     super.visitLetDeclaration(decl);
     if (this.rootNode !== null) {
@@ -28520,6 +28957,7 @@ var R3BoundTarget = class {
   }
   target;
   directives;
+  foreignComponents;
   eagerDirectives;
   missingDirectives;
   bindings;
@@ -28533,9 +28971,10 @@ var R3BoundTarget = class {
   conflictingHostDirectiveBindings;
   deferredBlocks;
   deferredScopes;
-  constructor(target, directives, eagerDirectives, missingDirectives, bindings, references, exprTargets, symbols, nestingLevel, scopedNodeEntities, usedPipes, eagerPipes, rawDeferred, conflictingHostDirectiveBindings) {
+  constructor(target, directives, foreignComponents, eagerDirectives, missingDirectives, bindings, references, exprTargets, symbols, nestingLevel, scopedNodeEntities, usedPipes, eagerPipes, rawDeferred, conflictingHostDirectiveBindings) {
     this.target = target;
     this.directives = directives;
+    this.foreignComponents = foreignComponents;
     this.eagerDirectives = eagerDirectives;
     this.missingDirectives = missingDirectives;
     this.bindings = bindings;
@@ -28556,6 +28995,9 @@ var R3BoundTarget = class {
   getDirectivesOfNode(node) {
     return this.directives.get(node) || null;
   }
+  getForeignComponent(element2) {
+    return this.foreignComponents.get(element2) || null;
+  }
   getReferenceTarget(ref) {
     return this.references.get(ref) || null;
   }
@@ -28875,7 +29317,8 @@ var CompilerFacadeImpl = class {
       viewProviders: facade.viewProviders != null ? new WrappedNodeExpr(facade.viewProviders) : null,
       relativeContextFilePath: "",
       i18nUseExternalIds: true,
-      relativeTemplatePath: null
+      relativeTemplatePath: null,
+      foreignImports: null
     };
     const jitExpressionSourceMap = `ng:///${facade.name}.js`;
     return this.compileComponentFromMeta(angularCoreEnv, jitExpressionSourceMap, meta);
@@ -29114,7 +29557,8 @@ function convertDeclareComponentFacadeToMetadata(decl, typeSourceSpan, sourceMap
     i18nUseExternalIds: true,
     relativeTemplatePath: null,
     hasDirectiveDependencies,
-    legacyOptionalChaining: decl.legacyOptionalChaining ?? LEGACY_OPTIONAL_CHAINING_DEFAULT
+    legacyOptionalChaining: decl.legacyOptionalChaining ?? LEGACY_OPTIONAL_CHAINING_DEFAULT,
+    foreignImports: null
   };
 }
 __name(convertDeclareComponentFacadeToMetadata, "convertDeclareComponentFacadeToMetadata");
@@ -29515,7 +29959,7 @@ var _Visitor3 = class {
     if (!this._inI18nNode && !this._inIcu) {
       if (!this._inI18nBlock) {
         if (isOpening) {
-          if (!i18nCommentsWarned && console && console.warn) {
+          if (!i18nCommentsWarned && typeof console?.warn === "function") {
             i18nCommentsWarned = true;
             const details = comment.sourceSpan.details ? `, ${comment.sourceSpan.details}` : "";
             console.warn(`I18n comments are deprecated, use an <ng-container> element instead (${comment.sourceSpan.start}${details})`);
@@ -31075,7 +31519,7 @@ var MINIMUM_PARTIAL_LINKER_DEFER_SUPPORT_VERSION = "18.0.0";
 function compileDeclareClassMetadata(metadata) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION$6));
-  definitionMap.set("version", literal("22.0.5"));
+  definitionMap.set("version", literal("22.1.2"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", metadata.type);
   definitionMap.set("decorators", metadata.decorators);
@@ -31094,7 +31538,7 @@ function compileComponentDeclareClassMetadata(metadata, dependencies) {
   callbackReturnDefinitionMap.set("ctorParameters", metadata.ctorParameters ?? literal(null));
   callbackReturnDefinitionMap.set("propDecorators", metadata.propDecorators ?? literal(null));
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_DEFER_SUPPORT_VERSION));
-  definitionMap.set("version", literal("22.0.5"));
+  definitionMap.set("version", literal("22.1.2"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", metadata.type);
   definitionMap.set("resolveDeferredDeps", compileComponentMetadataAsyncResolver(dependencies));
@@ -31171,7 +31615,7 @@ function createDirectiveDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   const minVersion = getMinimumVersionForPartialOutput(meta);
   definitionMap.set("minVersion", literal(minVersion));
-  definitionMap.set("version", literal("22.0.5"));
+  definitionMap.set("version", literal("22.1.2"));
   definitionMap.set("type", meta.type.value);
   if (meta.isStandalone !== void 0) {
     definitionMap.set("isStandalone", literal(meta.isStandalone));
@@ -31527,7 +31971,7 @@ var MINIMUM_PARTIAL_LINKER_VERSION$5 = "12.0.0";
 function compileDeclareFactoryFunction(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION$5));
-  definitionMap.set("version", literal("22.0.5"));
+  definitionMap.set("version", literal("22.1.2"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   definitionMap.set("deps", compileDependencies(meta.deps));
@@ -31554,7 +31998,7 @@ __name(compileDeclareInjectableFromMetadata, "compileDeclareInjectableFromMetada
 function createInjectableDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION$4));
-  definitionMap.set("version", literal("22.0.5"));
+  definitionMap.set("version", literal("22.1.2"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   if (meta.providedIn !== void 0) {
@@ -31596,7 +32040,7 @@ __name(compileDeclareServiceFromMetadata, "compileDeclareServiceFromMetadata");
 function createServiceDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION$3));
-  definitionMap.set("version", literal("22.0.5"));
+  definitionMap.set("version", literal("22.1.2"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   if (meta.autoProvided === false) {
@@ -31623,7 +32067,7 @@ __name(compileDeclareInjectorFromMetadata, "compileDeclareInjectorFromMetadata")
 function createInjectorDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION$2));
-  definitionMap.set("version", literal("22.0.5"));
+  definitionMap.set("version", literal("22.1.2"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   definitionMap.set("providers", meta.providers);
@@ -31654,7 +32098,7 @@ function createNgModuleDefinitionMap(meta) {
     throw new Error("Invalid path! Isolated compilation mode should not get into the partial compilation path");
   }
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION$1));
-  definitionMap.set("version", literal("22.0.5"));
+  definitionMap.set("version", literal("22.1.2"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   if (meta.bootstrap.length > 0) {
@@ -31693,7 +32137,7 @@ __name(compileDeclarePipeFromMetadata, "compileDeclarePipeFromMetadata");
 function createPipeDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION));
-  definitionMap.set("version", literal("22.0.5"));
+  definitionMap.set("version", literal("22.1.2"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   if (meta.isStandalone !== void 0) {
@@ -31768,7 +32212,7 @@ function compileHmrUpdateCallback(definitions, constantStatements, meta) {
   return new DeclareFunctionStmt(`${meta.className}_UpdateMetadata`, params, body, null, StmtModifier.Final);
 }
 __name(compileHmrUpdateCallback, "compileHmrUpdateCallback");
-var VERSION = new Version("22.0.5");
+var VERSION = new Version("22.1.2");
 var HOST_BINDING_GUARD_COMMENT_TEXT = "hostBindingsBlockGuard";
 function createHostElement(type, selector, nameSpan, hostObjectLiteralBindings, hostBindingDecorators, hostListenerDecorators) {
   const bindings = [];
@@ -32186,7 +32630,10 @@ var TcbExprTranslator = class {
     return new TcbExpr(`"" + ${exprs.join(" + ")}`);
   }
   visitKeyedRead(ast) {
-    const receiver = this.translate(ast.receiver).wrapForTypeChecker();
+    const receiver = this.translate(ast.receiver);
+    if (!this.isStrictSafeNavigationChain(ast.receiver)) {
+      receiver.wrapForTypeChecker();
+    }
     const key = this.translate(ast.key);
     return new TcbExpr(`${receiver.print()}[${key.print()}]`).addParseSpanInfo(ast.sourceSpan);
   }
@@ -32261,7 +32708,10 @@ var TcbExprTranslator = class {
     return new TcbExpr(`void ${expression.print()}`).addParseSpanInfo(ast.sourceSpan);
   }
   visitPropertyRead(ast) {
-    const receiver = this.translate(ast.receiver).wrapForTypeChecker();
+    const receiver = this.translate(ast.receiver);
+    if (!this.isStrictSafeNavigationChain(ast.receiver)) {
+      receiver.wrapForTypeChecker();
+    }
     return new TcbExpr(`${receiver.print()}.${ast.name}`).addParseSpanInfo(ast.nameSpan).wrapForTypeChecker().addParseSpanInfo(ast.sourceSpan);
   }
   visitSafePropertyRead(ast) {
@@ -32300,7 +32750,10 @@ var TcbExprTranslator = class {
       if (resolved !== null) {
         expr = resolved;
       } else {
-        const propertyReceiver = this.translate(receiver.receiver).wrapForTypeChecker();
+        const propertyReceiver = this.translate(receiver.receiver);
+        if (!this.isStrictSafeNavigationChain(receiver.receiver)) {
+          propertyReceiver.wrapForTypeChecker();
+        }
         expr = new TcbExpr(`${propertyReceiver.print()}.${receiver.name}`).addParseSpanInfo(receiver.nameSpan);
       }
     } else {
@@ -32382,7 +32835,7 @@ var TcbExprTranslator = class {
     const expr = exprNode.print();
     const args = argNodes.map((node) => node.print()).join(", ");
     if (this.config.strictSafeNavigationTypes) {
-      return new TcbExpr(`(0 as any ? ${expr}!(${args}) : undefined)`);
+      return new TcbExpr(`(${expr}?.(${args}))`);
     }
     if (VeSafeLhsInferenceBugDetector.veWillInferAnyFor(ast)) {
       return new TcbExpr(`(${expr} as any)(${args})`);
@@ -32392,6 +32845,9 @@ var TcbExprTranslator = class {
   escapeTemplateLiteral(value) {
     return value.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\${/g, "$\\{");
   }
+  isStrictSafeNavigationChain(ast) {
+    return this.config.strictSafeNavigationTypes && (ast instanceof SafePropertyRead || ast instanceof SafeKeyedRead || ast instanceof SafeCall);
+  }
 };
 var VeSafeLhsInferenceBugDetector = class _VeSafeLhsInferenceBugDetector {
   static {
@@ -34463,7 +34919,11 @@ var Scope3 = class _Scope {
     const directives = this.tcb.boundTarget.getDirectivesOfNode(node);
     if (directives === null || directives.length === 0) {
       if (node instanceof Element$1) {
-        this.opQueue.push(new TcbUnclaimedInputsOp(this.tcb, this, node.inputs, node, claimedInputs), new TcbDomSchemaCheckerOp(this.tcb, node, true, claimedInputs));
+        this.opQueue.push(new TcbUnclaimedInputsOp(this.tcb, this, node.inputs, node, claimedInputs));
+        const isForeign = this.tcb.boundTarget.getForeignComponent(node) !== null;
+        if (!isForeign) {
+          this.opQueue.push(new TcbDomSchemaCheckerOp(this.tcb, node, true, claimedInputs));
+        }
       }
       return;
     }
@@ -34632,7 +35092,10 @@ var Scope3 = class _Scope {
             }
           }
         }
-        this.opQueue.push(new TcbDomSchemaCheckerOp(this.tcb, node, !hasDirectives, claimedInputs));
+        const isForeign = this.tcb.boundTarget.getForeignComponent(node) !== null;
+        if (!isForeign) {
+          this.opQueue.push(new TcbDomSchemaCheckerOp(this.tcb, node, !hasDirectives, claimedInputs));
+        }
       }
       this.appendDeepSchemaChecks(node.children);
     }
@@ -34966,6 +35429,7 @@ publishFacade(_global);
   TmplAstBoundText,
   TmplAstComponent,
   TmplAstContent,
+  TmplAstContentBlock,
   TmplAstDeferredBlock,
   TmplAstDeferredBlockError,
   TmplAstDeferredBlockLoading,
@@ -35092,7 +35556,7 @@ publishFacade(_global);
 
 @angular/compiler/fesm2022/compiler.mjs:
   (**
-   * @license Angular v22.0.5
+   * @license Angular v22.1.2
    * (c) 2010-2026 Google LLC. https://angular.dev/
    * License: MIT
    *)