@angular/core 16.2.0-next.1 → 16.2.0-next.3

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

@@ -418,9 +418,9 @@ var CssSelector = class {
           current.setElement(tag);
         }
       }
-      const attribute = match[4];
-      if (attribute) {
-        current.addAttribute(current.unescapeAttribute(attribute), match[6]);
+      const attribute2 = match[4];
+      if (attribute2) {
+        current.addAttribute(current.unescapeAttribute(attribute2), match[6]);
       }
       if (match[7]) {
         inNot = false;
@@ -758,6 +758,7 @@ __export(output_ast_exports, {
   DYNAMIC_TYPE: () => DYNAMIC_TYPE,
   DeclareFunctionStmt: () => DeclareFunctionStmt,
   DeclareVarStmt: () => DeclareVarStmt,
+  DynamicImportExpr: () => DynamicImportExpr,
   Expression: () => Expression,
   ExpressionStatement: () => ExpressionStatement,
   ExpressionType: () => ExpressionType,
@@ -1516,6 +1517,9 @@ var InvokeFunctionExpr = class extends Expression {
     this.args = args;
     this.pure = pure;
   }
+  get receiver() {
+    return this.fn;
+  }
   isEquivalent(e) {
     return e instanceof InvokeFunctionExpr && this.fn.isEquivalent(e.fn) && areAllEquivalent(this.args, e.args) && this.pure === e.pure;
   }
@@ -1741,6 +1745,24 @@ var ConditionalExpr = class extends Expression {
     return new ConditionalExpr(this.condition.clone(), this.trueCase.clone(), (_a2 = this.falseCase) == null ? void 0 : _a2.clone(), this.type, this.sourceSpan);
   }
 };
+var DynamicImportExpr = class extends Expression {
+  constructor(url, sourceSpan) {
+    super(null, sourceSpan);
+    this.url = url;
+  }
+  isEquivalent(e) {
+    return e instanceof DynamicImportExpr && this.url === e.url;
+  }
+  isConstant() {
+    return false;
+  }
+  visitExpression(visitor, context) {
+    return visitor.visitDynamicImportExpr(this, context);
+  }
+  clone() {
+    return new DynamicImportExpr(this.url, this.sourceSpan);
+  }
+};
 var NotExpr = class extends Expression {
   constructor(condition, sourceSpan) {
     super(BOOL_TYPE, sourceSpan);
@@ -1841,6 +1863,9 @@ var ReadPropExpr = class extends Expression {
     this.receiver = receiver;
     this.name = name;
   }
+  get index() {
+    return this.name;
+  }
   isEquivalent(e) {
     return e instanceof ReadPropExpr && this.receiver.isEquivalent(e.receiver) && this.name === e.name;
   }
@@ -2115,6 +2140,9 @@ var RecursiveAstVisitor = class {
     ast.value.visitExpression(this, context);
     return this.visitExpression(ast, context);
   }
+  visitDynamicImportExpr(ast, context) {
+    return this.visitExpression(ast, context);
+  }
   visitInvokeFunctionExpr(ast, context) {
     ast.fn.visitExpression(this, context);
     this.visitAllExpressions(ast.args, context);
@@ -3110,7 +3138,7 @@ var Version = class {
     this.patch = splits.slice(2).join(".");
   }
 };
-var _global = /* @__PURE__ */ (() => typeof global !== "undefined" && global || typeof window !== "undefined" && window || typeof self !== "undefined" && typeof WorkerGlobalScope !== "undefined" && self instanceof WorkerGlobalScope && self)();
+var _global = globalThis;
 function partitionArray(arr, conditionFn) {
   const truthy = [];
   const falsy = [];
@@ -3544,6 +3572,9 @@ var AbstractEmitterVisitor = class {
     ctx.print(ast, `)`);
     return null;
   }
+  visitDynamicImportExpr(ast, ctx) {
+    ctx.print(ast, `import(${ast.url})`);
+  }
   visitNotExpr(ast, ctx) {
     ctx.print(ast, "!");
     ast.condition.visitExpression(this, ctx);
@@ -4041,6 +4072,96 @@ var Element = class {
     return visitor.visitElement(this);
   }
 };
+var DeferredTrigger = class {
+  constructor(sourceSpan) {
+    this.sourceSpan = sourceSpan;
+  }
+  visit(visitor) {
+    return visitor.visitDeferredTrigger(this);
+  }
+};
+var BoundDeferredTrigger = class extends DeferredTrigger {
+  constructor(value, sourceSpan) {
+    super(sourceSpan);
+    this.value = value;
+  }
+};
+var IdleDeferredTrigger = class extends DeferredTrigger {
+};
+var ImmediateDeferredTrigger = class extends DeferredTrigger {
+};
+var HoverDeferredTrigger = class extends DeferredTrigger {
+};
+var TimerDeferredTrigger = class extends DeferredTrigger {
+  constructor(delay, sourceSpan) {
+    super(sourceSpan);
+    this.delay = delay;
+  }
+};
+var InteractionDeferredTrigger = class extends DeferredTrigger {
+  constructor(reference2, sourceSpan) {
+    super(sourceSpan);
+    this.reference = reference2;
+  }
+};
+var ViewportDeferredTrigger = class extends DeferredTrigger {
+  constructor(reference2, sourceSpan) {
+    super(sourceSpan);
+    this.reference = reference2;
+  }
+};
+var DeferredBlockPlaceholder = class {
+  constructor(children, minimumTime, sourceSpan, startSourceSpan, endSourceSpan) {
+    this.children = children;
+    this.minimumTime = minimumTime;
+    this.sourceSpan = sourceSpan;
+    this.startSourceSpan = startSourceSpan;
+    this.endSourceSpan = endSourceSpan;
+  }
+  visit(visitor) {
+    return visitor.visitDeferredBlockPlaceholder(this);
+  }
+};
+var DeferredBlockLoading = class {
+  constructor(children, afterTime, minimumTime, sourceSpan, startSourceSpan, endSourceSpan) {
+    this.children = children;
+    this.afterTime = afterTime;
+    this.minimumTime = minimumTime;
+    this.sourceSpan = sourceSpan;
+    this.startSourceSpan = startSourceSpan;
+    this.endSourceSpan = endSourceSpan;
+  }
+  visit(visitor) {
+    return visitor.visitDeferredBlockLoading(this);
+  }
+};
+var DeferredBlockError = class {
+  constructor(children, sourceSpan, startSourceSpan, endSourceSpan) {
+    this.children = children;
+    this.sourceSpan = sourceSpan;
+    this.startSourceSpan = startSourceSpan;
+    this.endSourceSpan = endSourceSpan;
+  }
+  visit(visitor) {
+    return visitor.visitDeferredBlockError(this);
+  }
+};
+var DeferredBlock = class {
+  constructor(children, triggers, prefetchTriggers, placeholder, loading, error2, sourceSpan, startSourceSpan, endSourceSpan) {
+    this.children = children;
+    this.triggers = triggers;
+    this.prefetchTriggers = prefetchTriggers;
+    this.placeholder = placeholder;
+    this.loading = loading;
+    this.error = error2;
+    this.sourceSpan = sourceSpan;
+    this.startSourceSpan = startSourceSpan;
+    this.endSourceSpan = endSourceSpan;
+  }
+  visit(visitor) {
+    return visitor.visitDeferredBlock(this);
+  }
+};
 var Template = class {
   constructor(tagName, attributes, inputs, outputs, templateAttrs, children, references, variables, sourceSpan, startSourceSpan, endSourceSpan, i18n) {
     this.tagName = tagName;
@@ -4123,17 +4244,35 @@ var RecursiveVisitor = class {
     visitAll(this, template2.references);
     visitAll(this, template2.variables);
   }
+  visitDeferredBlock(deferred) {
+    var _a2, _b2, _c2;
+    visitAll(this, deferred.triggers);
+    visitAll(this, deferred.prefetchTriggers);
+    visitAll(this, deferred.children);
+    (_a2 = deferred.placeholder) == null ? void 0 : _a2.visit(this);
+    (_b2 = deferred.loading) == null ? void 0 : _b2.visit(this);
+    (_c2 = deferred.error) == null ? void 0 : _c2.visit(this);
+  }
+  visitDeferredBlockPlaceholder(block) {
+    visitAll(this, block.children);
+  }
+  visitDeferredBlockError(block) {
+    visitAll(this, block.children);
+  }
+  visitDeferredBlockLoading(block) {
+    visitAll(this, block.children);
+  }
   visitContent(content) {
   }
   visitVariable(variable2) {
   }
   visitReference(reference2) {
   }
-  visitTextAttribute(attribute) {
+  visitTextAttribute(attribute2) {
   }
-  visitBoundAttribute(attribute) {
+  visitBoundAttribute(attribute2) {
   }
-  visitBoundEvent(attribute) {
+  visitBoundEvent(attribute2) {
   }
   visitText(text2) {
   }
@@ -4141,6 +4280,8 @@ var RecursiveVisitor = class {
   }
   visitIcu(icu) {
   }
+  visitDeferredTrigger(trigger) {
+  }
 };
 function visitAll(visitor, nodes) {
   const result = [];
@@ -5516,37 +5657,47 @@ var R3SelectorScopeMode;
   R3SelectorScopeMode2[R3SelectorScopeMode2["SideEffect"] = 1] = "SideEffect";
   R3SelectorScopeMode2[R3SelectorScopeMode2["Omit"] = 2] = "Omit";
 })(R3SelectorScopeMode || (R3SelectorScopeMode = {}));
+var R3NgModuleMetadataKind;
+(function(R3NgModuleMetadataKind2) {
+  R3NgModuleMetadataKind2[R3NgModuleMetadataKind2["Global"] = 0] = "Global";
+  R3NgModuleMetadataKind2[R3NgModuleMetadataKind2["Local"] = 1] = "Local";
+})(R3NgModuleMetadataKind || (R3NgModuleMetadataKind = {}));
 function compileNgModule(meta) {
-  const { type: moduleType, bootstrap, declarations, imports, exports, schemas, containsForwardDecls, selectorScopeMode, id } = meta;
   const statements = [];
   const definitionMap = new DefinitionMap();
-  definitionMap.set("type", moduleType.value);
-  if (bootstrap.length > 0) {
-    definitionMap.set("bootstrap", refsToArray(bootstrap, containsForwardDecls));
+  definitionMap.set("type", meta.type.value);
+  if (meta.kind === R3NgModuleMetadataKind.Global) {
+    if (meta.bootstrap.length > 0) {
+      definitionMap.set("bootstrap", refsToArray(meta.bootstrap, meta.containsForwardDecls));
+    }
+  } else {
+    if (meta.bootstrapExpression) {
+      definitionMap.set("bootstrap", meta.bootstrapExpression);
+    }
   }
-  if (selectorScopeMode === R3SelectorScopeMode.Inline) {
-    if (declarations.length > 0) {
-      definitionMap.set("declarations", refsToArray(declarations, containsForwardDecls));
+  if (meta.selectorScopeMode === R3SelectorScopeMode.Inline) {
+    if (meta.declarations.length > 0) {
+      definitionMap.set("declarations", refsToArray(meta.declarations, meta.containsForwardDecls));
     }
-    if (imports.length > 0) {
-      definitionMap.set("imports", refsToArray(imports, containsForwardDecls));
+    if (meta.imports.length > 0) {
+      definitionMap.set("imports", refsToArray(meta.imports, meta.containsForwardDecls));
     }
-    if (exports.length > 0) {
-      definitionMap.set("exports", refsToArray(exports, containsForwardDecls));
+    if (meta.exports.length > 0) {
+      definitionMap.set("exports", refsToArray(meta.exports, meta.containsForwardDecls));
     }
-  } else if (selectorScopeMode === R3SelectorScopeMode.SideEffect) {
+  } else if (meta.selectorScopeMode === R3SelectorScopeMode.SideEffect) {
     const setNgModuleScopeCall = generateSetNgModuleScopeCall(meta);
     if (setNgModuleScopeCall !== null) {
       statements.push(setNgModuleScopeCall);
     }
   } else {
   }
-  if (schemas !== null && schemas.length > 0) {
-    definitionMap.set("schemas", literalArr(schemas.map((ref) => ref.value)));
+  if (meta.schemas !== null && meta.schemas.length > 0) {
+    definitionMap.set("schemas", literalArr(meta.schemas.map((ref) => ref.value)));
   }
-  if (id !== null) {
-    definitionMap.set("id", id);
-    statements.push(importExpr(Identifiers.registerNgModuleType).callFn([moduleType.value, id]).toStmt());
+  if (meta.id !== null) {
+    definitionMap.set("id", meta.id);
+    statements.push(importExpr(Identifiers.registerNgModuleType).callFn([meta.type.value, meta.id]).toStmt());
   }
   const expression = importExpr(Identifiers.defineNgModule).callFn([definitionMap.toLiteralMap()], void 0, true);
   const type = createNgModuleType(meta);
@@ -5575,7 +5726,11 @@ function compileNgModuleDeclarationExpression(meta) {
   }
   return importExpr(Identifiers.defineNgModule).callFn([definitionMap.toLiteralMap()]);
 }
-function createNgModuleType({ type: moduleType, declarations, exports, imports, includeImportTypes, publicDeclarationTypes }) {
+function createNgModuleType(meta) {
+  if (meta.kind === R3NgModuleMetadataKind.Local) {
+    return new ExpressionType(meta.type.value);
+  }
+  const { type: moduleType, declarations, exports, imports, includeImportTypes, publicDeclarationTypes } = meta;
   return new ExpressionType(importExpr(Identifiers.NgModuleDeclaration, [
     new ExpressionType(moduleType.type),
     publicDeclarationTypes === null ? tupleTypeOf(declarations) : tupleOfTypes(publicDeclarationTypes),
@@ -5584,23 +5739,40 @@ function createNgModuleType({ type: moduleType, declarations, exports, imports,
   ]));
 }
 function generateSetNgModuleScopeCall(meta) {
-  const { type: moduleType, declarations, imports, exports, containsForwardDecls } = meta;
   const scopeMap = new DefinitionMap();
-  if (declarations.length > 0) {
-    scopeMap.set("declarations", refsToArray(declarations, containsForwardDecls));
+  if (meta.kind === R3NgModuleMetadataKind.Global) {
+    if (meta.declarations.length > 0) {
+      scopeMap.set("declarations", refsToArray(meta.declarations, meta.containsForwardDecls));
+    }
+  } else {
+    if (meta.declarationsExpression) {
+      scopeMap.set("declarations", meta.declarationsExpression);
+    }
   }
-  if (imports.length > 0) {
-    scopeMap.set("imports", refsToArray(imports, containsForwardDecls));
+  if (meta.kind === R3NgModuleMetadataKind.Global) {
+    if (meta.imports.length > 0) {
+      scopeMap.set("imports", refsToArray(meta.imports, meta.containsForwardDecls));
+    }
+  } else {
+    if (meta.importsExpression) {
+      scopeMap.set("imports", meta.importsExpression);
+    }
   }
-  if (exports.length > 0) {
-    scopeMap.set("exports", refsToArray(exports, containsForwardDecls));
+  if (meta.kind === R3NgModuleMetadataKind.Global) {
+    if (meta.exports.length > 0) {
+      scopeMap.set("exports", refsToArray(meta.exports, meta.containsForwardDecls));
+    }
+  } else {
+    if (meta.exportsExpression) {
+      scopeMap.set("exports", meta.exportsExpression);
+    }
   }
   if (Object.keys(scopeMap.values).length === 0) {
     return null;
   }
   const fnCall = new InvokeFunctionExpr(
     importExpr(Identifiers.setNgModuleScope),
-    [moduleType.value, scopeMap.toLiteralMap()]
+    [meta.type.value, scopeMap.toLiteralMap()]
   );
   const guardedCall = jitOnlyGuardedExpression(fnCall);
   const iife = new FunctionExpr(
@@ -7161,7 +7333,7 @@ var ShadowCss = class {
       let content = rule.content;
       if (rule.selector[0] !== "@") {
         selector = this._scopeSelector(rule.selector, scopeSelector, hostSelector);
-      } else if (rule.selector.startsWith("@media") || rule.selector.startsWith("@supports") || rule.selector.startsWith("@document") || rule.selector.startsWith("@layer") || rule.selector.startsWith("@container")) {
+      } else if (rule.selector.startsWith("@media") || rule.selector.startsWith("@supports") || rule.selector.startsWith("@document") || rule.selector.startsWith("@layer") || rule.selector.startsWith("@container") || rule.selector.startsWith("@scope")) {
         content = this._scopeSelectors(rule.content, scopeSelector, hostSelector);
       } else if (rule.selector.startsWith("@font-face") || rule.selector.startsWith("@page")) {
         content = this._stripScopingSelectors(rule.content);
@@ -7595,13 +7767,17 @@ var OpKind;
   OpKind2[OpKind2["InterpolateText"] = 12] = "InterpolateText";
   OpKind2[OpKind2["Property"] = 13] = "Property";
   OpKind2[OpKind2["StyleProp"] = 14] = "StyleProp";
-  OpKind2[OpKind2["StyleMap"] = 15] = "StyleMap";
-  OpKind2[OpKind2["InterpolateProperty"] = 16] = "InterpolateProperty";
-  OpKind2[OpKind2["InterpolateStyleProp"] = 17] = "InterpolateStyleProp";
-  OpKind2[OpKind2["InterpolateStyleMap"] = 18] = "InterpolateStyleMap";
-  OpKind2[OpKind2["Advance"] = 19] = "Advance";
-  OpKind2[OpKind2["Pipe"] = 20] = "Pipe";
-  OpKind2[OpKind2["Attribute"] = 21] = "Attribute";
+  OpKind2[OpKind2["ClassProp"] = 15] = "ClassProp";
+  OpKind2[OpKind2["StyleMap"] = 16] = "StyleMap";
+  OpKind2[OpKind2["ClassMap"] = 17] = "ClassMap";
+  OpKind2[OpKind2["InterpolateProperty"] = 18] = "InterpolateProperty";
+  OpKind2[OpKind2["InterpolateStyleProp"] = 19] = "InterpolateStyleProp";
+  OpKind2[OpKind2["InterpolateStyleMap"] = 20] = "InterpolateStyleMap";
+  OpKind2[OpKind2["InterpolateClassMap"] = 21] = "InterpolateClassMap";
+  OpKind2[OpKind2["Advance"] = 22] = "Advance";
+  OpKind2[OpKind2["Pipe"] = 23] = "Pipe";
+  OpKind2[OpKind2["Attribute"] = 24] = "Attribute";
+  OpKind2[OpKind2["InterpolateAttribute"] = 25] = "InterpolateAttribute";
 })(OpKind || (OpKind = {}));
 var ExpressionKind;
 (function(ExpressionKind2) {
@@ -7622,6 +7798,8 @@ var ExpressionKind;
   ExpressionKind2[ExpressionKind2["SafeInvokeFunction"] = 14] = "SafeInvokeFunction";
   ExpressionKind2[ExpressionKind2["SafeTernaryExpr"] = 15] = "SafeTernaryExpr";
   ExpressionKind2[ExpressionKind2["EmptyExpr"] = 16] = "EmptyExpr";
+  ExpressionKind2[ExpressionKind2["AssignTemporaryExpr"] = 17] = "AssignTemporaryExpr";
+  ExpressionKind2[ExpressionKind2["ReadTemporaryExpr"] = 18] = "ReadTemporaryExpr";
 })(ExpressionKind || (ExpressionKind = {}));
 var SemanticVariableKind;
 (function(SemanticVariableKind2) {
@@ -8030,7 +8208,11 @@ var SafePropertyReadExpr = class extends ExpressionBase {
     this.name = name;
     this.kind = ExpressionKind.SafePropertyRead;
   }
+  get index() {
+    return this.name;
+  }
   visitExpression(visitor, context) {
+    this.receiver.visitExpression(visitor, context);
   }
   isEquivalent() {
     return false;
@@ -8053,6 +8235,8 @@ var SafeKeyedReadExpr = class extends ExpressionBase {
     this.kind = ExpressionKind.SafeKeyedRead;
   }
   visitExpression(visitor, context) {
+    this.receiver.visitExpression(visitor, context);
+    this.index.visitExpression(visitor, context);
   }
   isEquivalent() {
     return false;
@@ -8076,6 +8260,10 @@ var SafeInvokeFunctionExpr = class extends ExpressionBase {
     this.kind = ExpressionKind.SafeInvokeFunction;
   }
   visitExpression(visitor, context) {
+    this.receiver.visitExpression(visitor, context);
+    for (const a of this.args) {
+      a.visitExpression(visitor, context);
+    }
   }
   isEquivalent() {
     return false;
@@ -8101,6 +8289,8 @@ var SafeTernaryExpr = class extends ExpressionBase {
     this.kind = ExpressionKind.SafeTernaryExpr;
   }
   visitExpression(visitor, context) {
+    this.guard.visitExpression(visitor, context);
+    this.expr.visitExpression(visitor, context);
   }
   isEquivalent() {
     return false;
@@ -8135,6 +8325,55 @@ var EmptyExpr2 = class extends ExpressionBase {
   transformInternalExpressions() {
   }
 };
+var AssignTemporaryExpr = class extends ExpressionBase {
+  constructor(expr, xref) {
+    super();
+    this.expr = expr;
+    this.xref = xref;
+    this.kind = ExpressionKind.AssignTemporaryExpr;
+    this.name = null;
+  }
+  visitExpression(visitor, context) {
+    this.expr.visitExpression(visitor, context);
+  }
+  isEquivalent() {
+    return false;
+  }
+  isConstant() {
+    return false;
+  }
+  transformInternalExpressions(transform, flags) {
+    this.expr = transformExpressionsInExpression(this.expr, transform, flags);
+  }
+  clone() {
+    const a = new AssignTemporaryExpr(this.expr, this.xref);
+    a.name = this.name;
+    return a;
+  }
+};
+var ReadTemporaryExpr = class extends ExpressionBase {
+  constructor(xref) {
+    super();
+    this.xref = xref;
+    this.kind = ExpressionKind.ReadTemporaryExpr;
+    this.name = null;
+  }
+  visitExpression(visitor, context) {
+  }
+  isEquivalent() {
+    return this.xref === this.xref;
+  }
+  isConstant() {
+    return false;
+  }
+  transformInternalExpressions(transform, flags) {
+  }
+  clone() {
+    const r = new ReadTemporaryExpr(this.xref);
+    r.name = this.name;
+    return r;
+  }
+};
 function visitExpressionsInOp(op, visitor) {
   transformExpressionsInOp(op, (expr, flags) => {
     visitor(expr, flags);
@@ -8151,11 +8390,14 @@ function transformExpressionsInOp(op, transform, flags) {
     case OpKind.Property:
     case OpKind.StyleProp:
     case OpKind.StyleMap:
+    case OpKind.ClassProp:
+    case OpKind.ClassMap:
       op.expression = transformExpressionsInExpression(op.expression, transform, flags);
       break;
     case OpKind.InterpolateProperty:
     case OpKind.InterpolateStyleProp:
     case OpKind.InterpolateStyleMap:
+    case OpKind.InterpolateClassMap:
     case OpKind.InterpolateText:
       for (let i = 0; i < op.expressions.length; i++) {
         op.expressions[i] = transformExpressionsInExpression(op.expressions[i], transform, flags);
@@ -8166,7 +8408,12 @@ function transformExpressionsInOp(op, transform, flags) {
       break;
     case OpKind.Attribute:
       if (op.value) {
-        transformExpressionsInExpression(op.value, transform, flags);
+        op.value = transformExpressionsInExpression(op.value, transform, flags);
+      }
+      break;
+    case OpKind.InterpolateAttribute:
+      for (let i = 0; i < op.expressions.length; i++) {
+        op.expressions[i] = transformExpressionsInExpression(op.expressions[i], transform, flags);
       }
       break;
     case OpKind.Variable:
@@ -8240,6 +8487,10 @@ function transformExpressionsInStatement(stmt, transform, flags) {
     stmt.expr = transformExpressionsInExpression(stmt.expr, transform, flags);
   } else if (stmt instanceof ReturnStatement) {
     stmt.value = transformExpressionsInExpression(stmt.value, transform, flags);
+  } else if (stmt instanceof DeclareVarStmt) {
+    if (stmt.value !== void 0) {
+      stmt.value = transformExpressionsInExpression(stmt.value, transform, flags);
+    }
   } else {
     throw new Error(`Unhandled statement kind: ${stmt.constructor.name}`);
   }
@@ -8521,6 +8772,14 @@ function createStylePropOp(xref, name, expression, unit) {
     unit
   }, TRAIT_DEPENDS_ON_SLOT_CONTEXT), TRAIT_CONSUMES_VARS), NEW_OP);
 }
+function createClassPropOp(xref, name, expression) {
+  return __spreadValues(__spreadValues(__spreadValues({
+    kind: OpKind.ClassProp,
+    target: xref,
+    name,
+    expression
+  }, TRAIT_DEPENDS_ON_SLOT_CONTEXT), TRAIT_CONSUMES_VARS), NEW_OP);
+}
 function createStyleMapOp(xref, expression) {
   return __spreadValues(__spreadValues(__spreadValues({
     kind: OpKind.StyleMap,
@@ -8528,14 +8787,21 @@ function createStyleMapOp(xref, expression) {
     expression
   }, TRAIT_DEPENDS_ON_SLOT_CONTEXT), TRAIT_CONSUMES_VARS), NEW_OP);
 }
+function createClassMapOp(xref, expression) {
+  return __spreadValues(__spreadValues(__spreadValues({
+    kind: OpKind.ClassMap,
+    target: xref,
+    expression
+  }, TRAIT_DEPENDS_ON_SLOT_CONTEXT), TRAIT_CONSUMES_VARS), NEW_OP);
+}
 function createAttributeOp(target, attributeKind, name, value) {
-  return __spreadValues({
+  return __spreadValues(__spreadValues(__spreadValues({
     kind: OpKind.Attribute,
     target,
     attributeKind,
     name,
     value
-  }, NEW_OP);
+  }, TRAIT_DEPENDS_ON_SLOT_CONTEXT), TRAIT_CONSUMES_VARS), NEW_OP);
 }
 function createInterpolatePropertyOp(xref, bindingKind, name, strings, expressions) {
   return __spreadValues(__spreadValues(__spreadValues({
@@ -8547,6 +8813,16 @@ function createInterpolatePropertyOp(xref, bindingKind, name, strings, expressio
     expressions
   }, TRAIT_DEPENDS_ON_SLOT_CONTEXT), TRAIT_CONSUMES_VARS), NEW_OP);
 }
+function createInterpolateAttributeOp(target, attributeKind, name, strings, expressions) {
+  return __spreadValues(__spreadValues(__spreadValues({
+    kind: OpKind.InterpolateAttribute,
+    target,
+    attributeKind,
+    name,
+    strings,
+    expressions
+  }, TRAIT_DEPENDS_ON_SLOT_CONTEXT), TRAIT_CONSUMES_VARS), NEW_OP);
+}
 function createInterpolateStylePropOp(xref, name, strings, expressions, unit) {
   return __spreadValues(__spreadValues(__spreadValues({
     kind: OpKind.InterpolateStyleProp,
@@ -8565,6 +8841,14 @@ function createInterpolateStyleMapOp(xref, strings, expressions) {
     expressions
   }, TRAIT_DEPENDS_ON_SLOT_CONTEXT), TRAIT_CONSUMES_VARS), NEW_OP);
 }
+function createInterpolateClassMapOp(xref, strings, expressions) {
+  return __spreadValues(__spreadValues(__spreadValues({
+    kind: OpKind.InterpolateClassMap,
+    target: xref,
+    strings,
+    expressions
+  }, TRAIT_DEPENDS_ON_SLOT_CONTEXT), TRAIT_CONSUMES_VARS), NEW_OP);
+}
 function createAdvanceOp(delta) {
   return __spreadValues({
     kind: OpKind.Advance,
@@ -8607,15 +8891,23 @@ function phaseVarCounting(cpl) {
 function varsUsedByOp(op) {
   switch (op.kind) {
     case OpKind.Property:
+    case OpKind.Attribute:
+      return 1;
     case OpKind.StyleProp:
+    case OpKind.ClassProp:
     case OpKind.StyleMap:
-      return 1;
+    case OpKind.ClassMap:
+      return 2;
     case OpKind.InterpolateText:
       return op.expressions.length;
     case OpKind.InterpolateProperty:
+      return 1 + op.expressions.length;
+    case OpKind.InterpolateAttribute:
+      return 1 + op.expressions.length;
     case OpKind.InterpolateStyleProp:
     case OpKind.InterpolateStyleMap:
-      return 1 + op.expressions.length;
+    case OpKind.InterpolateClassMap:
+      return 2 + op.expressions.length;
     default:
       throw new Error(`Unhandled op: ${OpKind[op.kind]}`);
   }
@@ -8706,6 +8998,7 @@ function populateElementAttributes(view, compatibility) {
         ownerOp.attributes.add(op.bindingKind, op.name, null);
         break;
       case OpKind.StyleProp:
+      case OpKind.ClassProp:
         ownerOp = lookupElement(elements, op.target);
         assertIsElementAttributes(ownerOp.attributes);
         if (removeIfExpressionIsEmpty(op, op.expression) && compatibility) {
@@ -8730,6 +9023,17 @@ var CHAINABLE = /* @__PURE__ */ new Set([
   Identifiers.elementEnd,
   Identifiers.property,
   Identifiers.styleProp,
+  Identifiers.attribute,
+  Identifiers.stylePropInterpolate1,
+  Identifiers.stylePropInterpolate2,
+  Identifiers.stylePropInterpolate3,
+  Identifiers.stylePropInterpolate4,
+  Identifiers.stylePropInterpolate5,
+  Identifiers.stylePropInterpolate6,
+  Identifiers.stylePropInterpolate7,
+  Identifiers.stylePropInterpolate8,
+  Identifiers.stylePropInterpolateV,
+  Identifiers.classProp,
   Identifiers.elementContainerStart,
   Identifiers.elementContainerEnd,
   Identifiers.elementContainer
@@ -8833,6 +9137,138 @@ function phaseEmptyElements(cpl) {
   }
 }
 
+// bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/expand_safe_reads.mjs
+function phaseExpandSafeReads(cpl, compatibility) {
+  for (const [_, view] of cpl.views) {
+    for (const op of view.ops()) {
+      transformExpressionsInOp(op, (e) => safeTransform(e, { cpl, compatibility }), VisitorContextFlag.None);
+      transformExpressionsInOp(op, ternaryTransform, VisitorContextFlag.None);
+    }
+  }
+}
+var requiresTemporary = [
+  InvokeFunctionExpr,
+  LiteralArrayExpr,
+  LiteralMapExpr,
+  SafeInvokeFunctionExpr,
+  PipeBindingExpr
+].map((e) => e.constructor.name);
+function needsTemporaryInSafeAccess(e) {
+  if (e instanceof UnaryOperatorExpr) {
+    return needsTemporaryInSafeAccess(e.expr);
+  } else if (e instanceof BinaryOperatorExpr) {
+    return needsTemporaryInSafeAccess(e.lhs) || needsTemporaryInSafeAccess(e.rhs);
+  } else if (e instanceof ConditionalExpr) {
+    if (e.falseCase && needsTemporaryInSafeAccess(e.falseCase))
+      return true;
+    return needsTemporaryInSafeAccess(e.condition) || needsTemporaryInSafeAccess(e.trueCase);
+  } else if (e instanceof NotExpr) {
+    return needsTemporaryInSafeAccess(e.condition);
+  } else if (e instanceof AssignTemporaryExpr) {
+    return needsTemporaryInSafeAccess(e.expr);
+  } else if (e instanceof ReadPropExpr) {
+    return needsTemporaryInSafeAccess(e.receiver);
+  } else if (e instanceof ReadKeyExpr) {
+    return needsTemporaryInSafeAccess(e.receiver) || needsTemporaryInSafeAccess(e.index);
+  }
+  return e instanceof InvokeFunctionExpr || e instanceof LiteralArrayExpr || e instanceof LiteralMapExpr || e instanceof SafeInvokeFunctionExpr || e instanceof PipeBindingExpr;
+}
+function temporariesIn(e) {
+  const temporaries = /* @__PURE__ */ new Set();
+  transformExpressionsInExpression(e, (e2) => {
+    if (e2 instanceof AssignTemporaryExpr) {
+      temporaries.add(e2.xref);
+    }
+    return e2;
+  }, VisitorContextFlag.None);
+  return temporaries;
+}
+function eliminateTemporaryAssignments(e, tmps, ctx) {
+  transformExpressionsInExpression(e, (e2) => {
+    if (e2 instanceof AssignTemporaryExpr && tmps.has(e2.xref)) {
+      const read = new ReadTemporaryExpr(e2.xref);
+      return ctx.compatibility ? new AssignTemporaryExpr(read, read.xref) : read;
+    }
+    return e2;
+  }, VisitorContextFlag.None);
+  return e;
+}
+function safeTernaryWithTemporary(guard, body, ctx) {
+  let result;
+  if (needsTemporaryInSafeAccess(guard)) {
+    const xref = ctx.cpl.allocateXrefId();
+    result = [new AssignTemporaryExpr(guard, xref), new ReadTemporaryExpr(xref)];
+  } else {
+    result = [guard, guard.clone()];
+    eliminateTemporaryAssignments(result[1], temporariesIn(result[0]), ctx);
+  }
+  return new SafeTernaryExpr(result[0], body(result[1]));
+}
+function isSafeAccessExpression(e) {
+  return e instanceof SafePropertyReadExpr || e instanceof SafeKeyedReadExpr;
+}
+function isUnsafeAccessExpression(e) {
+  return e instanceof ReadPropExpr || e instanceof ReadKeyExpr || e instanceof InvokeFunctionExpr;
+}
+function isAccessExpression(e) {
+  return isSafeAccessExpression(e) || isUnsafeAccessExpression(e);
+}
+function deepestSafeTernary(e) {
+  if (isAccessExpression(e) && e.receiver instanceof SafeTernaryExpr) {
+    let st = e.receiver;
+    while (st.expr instanceof SafeTernaryExpr) {
+      st = st.expr;
+    }
+    return st;
+  }
+  return null;
+}
+function safeTransform(e, ctx) {
+  if (e instanceof SafeInvokeFunctionExpr) {
+    return new InvokeFunctionExpr(e.receiver, e.args);
+  }
+  if (!isAccessExpression(e)) {
+    return e;
+  }
+  const dst = deepestSafeTernary(e);
+  if (dst) {
+    if (e instanceof InvokeFunctionExpr) {
+      dst.expr = dst.expr.callFn(e.args);
+      return e.receiver;
+    }
+    if (e instanceof ReadPropExpr) {
+      dst.expr = dst.expr.prop(e.name);
+      return e.receiver;
+    }
+    if (e instanceof ReadKeyExpr) {
+      dst.expr = dst.expr.key(e.index);
+      return e.receiver;
+    }
+    if (e instanceof SafePropertyReadExpr) {
+      dst.expr = safeTernaryWithTemporary(dst.expr, (r) => r.prop(e.name), ctx);
+      return e.receiver;
+    }
+    if (e instanceof SafeKeyedReadExpr) {
+      dst.expr = safeTernaryWithTemporary(dst.expr, (r) => r.key(e.index), ctx);
+      return e.receiver;
+    }
+  } else {
+    if (e instanceof SafePropertyReadExpr) {
+      return safeTernaryWithTemporary(e.receiver, (r) => r.prop(e.name), ctx);
+    }
+    if (e instanceof SafeKeyedReadExpr) {
+      return safeTernaryWithTemporary(e.receiver, (r) => r.key(e.index), ctx);
+    }
+  }
+  return e;
+}
+function ternaryTransform(e) {
+  if (!(e instanceof SafeTernaryExpr)) {
+    return e;
+  }
+  return new ConditionalExpr(new BinaryOperatorExpr(BinaryOperator.Equals, e.guard, NULL_EXPR), NULL_EXPR, e.expr);
+}
+
 // bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/generate_advance.mjs
 function phaseGenerateAdvance(cpl) {
   for (const [_, view] of cpl.views) {
@@ -8865,28 +9301,12 @@ function phaseGenerateAdvance(cpl) {
   }
 }
 
-// bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/nullish_coalescing.mjs
-function phaseNullishCoalescing(cpl) {
-  for (const view of cpl.views.values()) {
-    for (const op of view.ops()) {
-      transformExpressionsInOp(op, (expr) => {
-        if (!(expr instanceof BinaryOperatorExpr) || expr.operator !== BinaryOperator.NullishCoalesce) {
-          return expr;
-        }
-        return new ConditionalExpr(new BinaryOperatorExpr(BinaryOperator.And, new BinaryOperatorExpr(BinaryOperator.NotIdentical, expr.lhs, NULL_EXPR), new BinaryOperatorExpr(BinaryOperator.NotIdentical, expr.lhs, new LiteralExpr(void 0))), expr.lhs, expr.rhs);
-      }, VisitorContextFlag.None);
-    }
-  }
-}
-
 // bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/generate_variables.mjs
 function phaseGenerateVariables(cpl) {
   recursivelyProcessView(cpl.root, null);
 }
 function recursivelyProcessView(view, parentScope) {
   const scope = getScopeForView(view, parentScope);
-  if (view.parent !== null) {
-  }
   for (const op of view.create) {
     switch (op.kind) {
       case OpKind.Template:
@@ -8992,13 +9412,74 @@ function serializeLocalRefs(refs) {
   return literalArr(constRefs);
 }
 
+// bazel-out/k8-fastbuild/bin/packages/compiler/src/render3/view/style_parser.mjs
+function parse(value) {
+  const styles = [];
+  let i = 0;
+  let parenDepth = 0;
+  let quote = 0;
+  let valueStart = 0;
+  let propStart = 0;
+  let currentProp = null;
+  while (i < value.length) {
+    const token = value.charCodeAt(i++);
+    switch (token) {
+      case 40:
+        parenDepth++;
+        break;
+      case 41:
+        parenDepth--;
+        break;
+      case 39:
+        if (quote === 0) {
+          quote = 39;
+        } else if (quote === 39 && value.charCodeAt(i - 1) !== 92) {
+          quote = 0;
+        }
+        break;
+      case 34:
+        if (quote === 0) {
+          quote = 34;
+        } else if (quote === 34 && value.charCodeAt(i - 1) !== 92) {
+          quote = 0;
+        }
+        break;
+      case 58:
+        if (!currentProp && parenDepth === 0 && quote === 0) {
+          currentProp = hyphenate(value.substring(propStart, i - 1).trim());
+          valueStart = i;
+        }
+        break;
+      case 59:
+        if (currentProp && valueStart > 0 && parenDepth === 0 && quote === 0) {
+          const styleVal = value.substring(valueStart, i - 1).trim();
+          styles.push(currentProp, styleVal);
+          propStart = i;
+          valueStart = 0;
+          currentProp = null;
+        }
+        break;
+    }
+  }
+  if (currentProp && valueStart) {
+    const styleVal = value.slice(valueStart).trim();
+    styles.push(currentProp, styleVal);
+  }
+  return styles;
+}
+function hyphenate(value) {
+  return value.replace(/[a-z][A-Z]/g, (v) => {
+    return v.charAt(0) + "-" + v.charAt(1);
+  }).toLowerCase();
+}
+
 // bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/naming.mjs
-function phaseNaming(cpl) {
-  addNamesToView(cpl.root, cpl.componentName, { index: 0 });
+function phaseNaming(cpl, compatibility) {
+  addNamesToView(cpl.root, cpl.componentName, { index: 0 }, compatibility);
 }
-function addNamesToView(view, baseName, state) {
+function addNamesToView(view, baseName, state, compatibility) {
   if (view.fnName === null) {
-    view.fnName = `${baseName}_Template`;
+    view.fnName = sanitizeIdentifier(`${baseName}_Template`);
   }
   const varNames = /* @__PURE__ */ new Map();
   for (const op of view.ops()) {
@@ -9008,7 +9489,7 @@ function addNamesToView(view, baseName, state) {
           if (op.slot === null) {
             throw new Error(`Expected a slot to be assigned`);
           }
-          op.handlerFnName = `${view.fnName}_${op.tag}_${op.name}_${op.slot}_listener`;
+          op.handlerFnName = sanitizeIdentifier(`${view.fnName}_${op.tag}_${op.name}_${op.slot}_listener`);
         }
         break;
       case OpKind.Variable:
@@ -9019,8 +9500,19 @@ function addNamesToView(view, baseName, state) {
         if (op.slot === null) {
           throw new Error(`Expected slot to be assigned`);
         }
-        const safeTagName = op.tag.replace("-", "_");
-        addNamesToView(childView, `${baseName}_${safeTagName}_${op.slot}`, state);
+        addNamesToView(childView, `${baseName}_${op.tag}_${op.slot}`, state, compatibility);
+        break;
+      case OpKind.StyleProp:
+      case OpKind.InterpolateStyleProp:
+        op.name = normalizeStylePropName(op.name);
+        if (compatibility) {
+          op.name = stripImportant(op.name);
+        }
+        break;
+      case OpKind.ClassProp:
+        if (compatibility) {
+          op.name = stripImportant(op.name);
+        }
         break;
     }
   }
@@ -9049,6 +9541,16 @@ function getVariableName(variable2, state) {
   }
   return variable2.name;
 }
+function normalizeStylePropName(name) {
+  return name.startsWith("--") ? name : hyphenate(name);
+}
+function stripImportant(name) {
+  const importantIndex = name.indexOf("!important");
+  if (importantIndex > -1) {
+    return name.substring(0, importantIndex);
+  }
+  return name;
+}
 
 // bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/next_context_merging.mjs
 function phaseMergeNextContext(cpl) {
@@ -9112,6 +9614,22 @@ function phaseNgContainer(cpl) {
   }
 }
 
+// bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/nullish_coalescing.mjs
+function phaseNullishCoalescing(cpl) {
+  for (const view of cpl.views.values()) {
+    for (const op of view.ops()) {
+      transformExpressionsInOp(op, (expr) => {
+        if (!(expr instanceof BinaryOperatorExpr) || expr.operator !== BinaryOperator.NullishCoalesce) {
+          return expr;
+        }
+        const assignment = new AssignTemporaryExpr(expr.lhs.clone(), cpl.allocateXrefId());
+        const read = new ReadTemporaryExpr(assignment.xref);
+        return new ConditionalExpr(new BinaryOperatorExpr(BinaryOperator.And, new BinaryOperatorExpr(BinaryOperator.NotIdentical, assignment, NULL_EXPR), new BinaryOperatorExpr(BinaryOperator.NotIdentical, read, new LiteralExpr(void 0))), read.clone(), expr.rhs);
+      }, VisitorContextFlag.None);
+    }
+  }
+}
+
 // bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/pipe_creation.mjs
 function phasePipeCreation(cpl) {
   for (const view of cpl.views.values()) {
@@ -9172,6 +9690,51 @@ function phasePipeVariadic(cpl) {
   }
 }
 
+// bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/property_ordering.mjs
+var ORDERING = [
+  { kinds: /* @__PURE__ */ new Set([OpKind.StyleMap, OpKind.InterpolateStyleMap]), transform: keepLast },
+  { kinds: /* @__PURE__ */ new Set([OpKind.ClassMap, OpKind.InterpolateClassMap]), transform: keepLast },
+  { kinds: /* @__PURE__ */ new Set([OpKind.StyleProp, OpKind.InterpolateStyleProp]) },
+  { kinds: /* @__PURE__ */ new Set([OpKind.ClassProp]) },
+  { kinds: /* @__PURE__ */ new Set([OpKind.InterpolateProperty]) },
+  { kinds: /* @__PURE__ */ new Set([OpKind.Property]) },
+  { kinds: /* @__PURE__ */ new Set([OpKind.Attribute, OpKind.InterpolateAttribute]) }
+];
+var handledOpKinds = new Set(ORDERING.flatMap((group) => [...group.kinds]));
+function phasePropertyOrdering(cpl) {
+  for (const [_, view] of cpl.views) {
+    let opsToOrder = [];
+    for (const op of view.update) {
+      if (handledOpKinds.has(op.kind)) {
+        opsToOrder.push(op);
+        OpList.remove(op);
+      } else {
+        for (const orderedOp of reorder(opsToOrder)) {
+          OpList.insertBefore(orderedOp, op);
+        }
+        opsToOrder = [];
+      }
+    }
+    for (const orderedOp of reorder(opsToOrder)) {
+      view.update.push(orderedOp);
+    }
+  }
+}
+function reorder(ops) {
+  const groups = Array.from(ORDERING, () => new Array());
+  for (const op of ops) {
+    const groupIndex = ORDERING.findIndex((o) => o.kinds.has(op.kind));
+    groups[groupIndex].push(op);
+  }
+  return groups.flatMap((group, i) => {
+    const transform = ORDERING[i].transform;
+    return transform ? transform(group) : group;
+  });
+}
+function keepLast(ops) {
+  return ops.slice(ops.length - 1);
+}
+
 // bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/pure_function_extraction.mjs
 function phasePureFunctionExtraction(cpl) {
   for (const view of cpl.views.values()) {
@@ -9356,6 +9919,9 @@ function property(name, expression) {
     expression
   ]);
 }
+function attribute(name, expression) {
+  return call(Identifiers.attribute, [literal(name), expression]);
+}
 function styleProp(name, expression, unit) {
   const args = [literal(name), expression];
   if (unit !== null) {
@@ -9363,9 +9929,15 @@ function styleProp(name, expression, unit) {
   }
   return call(Identifiers.styleProp, args);
 }
+function classProp(name, expression) {
+  return call(Identifiers.classProp, [literal(name), expression]);
+}
 function styleMap(expression) {
   return call(Identifiers.styleMap, [expression]);
 }
+function classMap(expression) {
+  return call(Identifiers.classMap, [expression]);
+}
 var PIPE_BINDINGS = [
   Identifiers.pipeBind1,
   Identifiers.pipeBind2,
@@ -9410,6 +9982,10 @@ function propertyInterpolate(name, strings, expressions) {
   const interpolationArgs = collateInterpolationArgs(strings, expressions);
   return callVariadicInstruction(PROPERTY_INTERPOLATE_CONFIG, [literal(name)], interpolationArgs);
 }
+function attributeInterpolate(name, strings, expressions) {
+  const interpolationArgs = collateInterpolationArgs(strings, expressions);
+  return callVariadicInstruction(ATTRIBUTE_INTERPOLATE_CONFIG, [literal(name)], interpolationArgs);
+}
 function stylePropInterpolate(name, strings, expressions, unit) {
   const interpolationArgs = collateInterpolationArgs(strings, expressions);
   const extraArgs = [];
@@ -9422,6 +9998,10 @@ function styleMapInterpolate(strings, expressions) {
   const interpolationArgs = collateInterpolationArgs(strings, expressions);
   return callVariadicInstruction(STYLE_MAP_INTERPOLATE_CONFIG, [], interpolationArgs);
 }
+function classMapInterpolate(strings, expressions) {
+  const interpolationArgs = collateInterpolationArgs(strings, expressions);
+  return callVariadicInstruction(CLASS_MAP_INTERPOLATE_CONFIG, [], interpolationArgs);
+}
 function pureFunction(varOffset, fn2, args) {
   return callVariadicInstructionExpr(PURE_FUNCTION_CONFIG, [
     literal(varOffset),
@@ -9489,7 +10069,7 @@ var PROPERTY_INTERPOLATE_CONFIG = {
 };
 var STYLE_PROP_INTERPOLATE_CONFIG = {
   constant: [
-    null,
+    Identifiers.styleProp,
     Identifiers.stylePropInterpolate1,
     Identifiers.stylePropInterpolate2,
     Identifiers.stylePropInterpolate3,
@@ -9504,15 +10084,32 @@ var STYLE_PROP_INTERPOLATE_CONFIG = {
     if (n % 2 === 0) {
       throw new Error(`Expected odd number of arguments`);
     }
-    if (n < 3) {
-      throw new Error(`Expected at least 3 arguments`);
+    return (n - 1) / 2;
+  }
+};
+var ATTRIBUTE_INTERPOLATE_CONFIG = {
+  constant: [
+    Identifiers.attribute,
+    Identifiers.attributeInterpolate1,
+    Identifiers.attributeInterpolate2,
+    Identifiers.attributeInterpolate3,
+    Identifiers.attributeInterpolate4,
+    Identifiers.attributeInterpolate5,
+    Identifiers.attributeInterpolate6,
+    Identifiers.attributeInterpolate7,
+    Identifiers.attributeInterpolate8
+  ],
+  variable: Identifiers.attributeInterpolateV,
+  mapping: (n) => {
+    if (n % 2 === 0) {
+      throw new Error(`Expected odd number of arguments`);
     }
     return (n - 1) / 2;
   }
 };
 var STYLE_MAP_INTERPOLATE_CONFIG = {
   constant: [
-    null,
+    Identifiers.styleMap,
     Identifiers.styleMapInterpolate1,
     Identifiers.styleMapInterpolate2,
     Identifiers.styleMapInterpolate3,
@@ -9527,8 +10124,25 @@ var STYLE_MAP_INTERPOLATE_CONFIG = {
     if (n % 2 === 0) {
       throw new Error(`Expected odd number of arguments`);
     }
-    if (n < 3) {
-      throw new Error(`Expected at least 3 arguments`);
+    return (n - 1) / 2;
+  }
+};
+var CLASS_MAP_INTERPOLATE_CONFIG = {
+  constant: [
+    Identifiers.classMap,
+    Identifiers.classMapInterpolate1,
+    Identifiers.classMapInterpolate2,
+    Identifiers.classMapInterpolate3,
+    Identifiers.classMapInterpolate4,
+    Identifiers.classMapInterpolate5,
+    Identifiers.classMapInterpolate6,
+    Identifiers.classMapInterpolate7,
+    Identifiers.classMapInterpolate8
+  ],
+  variable: Identifiers.classMapInterpolateV,
+  mapping: (n) => {
+    if (n % 2 === 0) {
+      throw new Error(`Expected odd number of arguments`);
     }
     return (n - 1) / 2;
   }
@@ -9639,9 +10253,15 @@ function reifyUpdateOperations(_view, ops) {
       case OpKind.StyleProp:
         OpList.replace(op, styleProp(op.name, op.expression, op.unit));
         break;
+      case OpKind.ClassProp:
+        OpList.replace(op, classProp(op.name, op.expression));
+        break;
       case OpKind.StyleMap:
         OpList.replace(op, styleMap(op.expression));
         break;
+      case OpKind.ClassMap:
+        OpList.replace(op, classMap(op.expression));
+        break;
       case OpKind.InterpolateProperty:
         OpList.replace(op, propertyInterpolate(op.name, op.strings, op.expressions));
         break;
@@ -9651,9 +10271,18 @@ function reifyUpdateOperations(_view, ops) {
       case OpKind.InterpolateStyleMap:
         OpList.replace(op, styleMapInterpolate(op.strings, op.expressions));
         break;
+      case OpKind.InterpolateClassMap:
+        OpList.replace(op, classMapInterpolate(op.strings, op.expressions));
+        break;
       case OpKind.InterpolateText:
         OpList.replace(op, textInterpolate(op.strings, op.expressions));
         break;
+      case OpKind.Attribute:
+        OpList.replace(op, attribute(op.name, op.value));
+        break;
+      case OpKind.InterpolateAttribute:
+        OpList.replace(op, attributeInterpolate(op.name, op.strings, op.expressions));
+        break;
       case OpKind.Variable:
         if (op.variable.name === null) {
           throw new Error(`AssertionError: unnamed variable ${op.xref}`);
@@ -9692,6 +10321,16 @@ function reifyIrExpression(expr) {
         throw new Error(`Read of unnamed variable ${expr.xref}`);
       }
       return variable(expr.name);
+    case ExpressionKind.ReadTemporaryExpr:
+      if (expr.name === null) {
+        throw new Error(`Read of unnamed temporary ${expr.xref}`);
+      }
+      return variable(expr.name);
+    case ExpressionKind.AssignTemporaryExpr:
+      if (expr.name === null) {
+        throw new Error(`Assign of unnamed temporary ${expr.xref}`);
+      }
+      return variable(expr.name).set(expr.expr);
     case ExpressionKind.PureFunctionExpr:
       if (expr.fn === null) {
         throw new Error(`AssertionError: expected PureFunctions to have been extracted`);
@@ -9825,14 +10464,18 @@ function processLexicalScope2(view, ops, savedView) {
       }
     }, VisitorContextFlag.None);
   }
+  for (const op of ops) {
+    visitExpressionsInOp(op, (expr) => {
+      if (expr instanceof LexicalReadExpr) {
+        throw new Error(`AssertionError: no lexical reads should remain, but found read of ${expr.name}`);
+      }
+    });
+  }
 }
 
 // bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/save_restore_view.mjs
 function phaseSaveRestoreView(cpl) {
   for (const view of cpl.views.values()) {
-    if (view === cpl.root) {
-      continue;
-    }
     view.create.prepend([
       createVariableOp(view.tpl.allocateXrefId(), {
         kind: SemanticVariableKind.SavedView,
@@ -9844,18 +10487,33 @@ function phaseSaveRestoreView(cpl) {
       if (op.kind !== OpKind.Listener) {
         continue;
       }
-      op.handlerOps.prepend([
-        createVariableOp(view.tpl.allocateXrefId(), {
-          kind: SemanticVariableKind.Context,
-          name: null,
-          view: view.xref
-        }, new RestoreViewExpr(view.xref))
-      ]);
-      for (const handlerOp of op.handlerOps) {
-        if (handlerOp.kind === OpKind.Statement && handlerOp.statement instanceof ReturnStatement) {
-          handlerOp.statement.value = new ResetViewExpr(handlerOp.statement.value);
+      let needsRestoreView = view !== cpl.root;
+      if (!needsRestoreView) {
+        for (const handlerOp of op.handlerOps) {
+          visitExpressionsInOp(handlerOp, (expr) => {
+            if (expr instanceof ReferenceExpr) {
+              needsRestoreView = true;
+            }
+          });
         }
       }
+      if (needsRestoreView) {
+        addSaveRestoreViewOperationToListener(view, op);
+      }
+    }
+  }
+}
+function addSaveRestoreViewOperationToListener(view, op) {
+  op.handlerOps.prepend([
+    createVariableOp(view.tpl.allocateXrefId(), {
+      kind: SemanticVariableKind.Context,
+      name: null,
+      view: view.xref
+    }, new RestoreViewExpr(view.xref))
+  ]);
+  for (const handlerOp of op.handlerOps) {
+    if (handlerOp.kind === OpKind.Statement && handlerOp.statement instanceof ReturnStatement) {
+      handlerOp.statement.value = new ResetViewExpr(handlerOp.statement.value);
     }
   }
 }
@@ -9903,6 +10561,39 @@ function phaseSlotAllocation(cpl) {
   }
 }
 
+// bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/temporary_variables.mjs
+function phaseTemporaryVariables(cpl) {
+  for (const view of cpl.views.values()) {
+    let opCount = 0;
+    let generatedStatements = [];
+    for (const op of view.ops()) {
+      let count = 0;
+      let xrefs = /* @__PURE__ */ new Set();
+      let defs = /* @__PURE__ */ new Map();
+      visitExpressionsInOp(op, (expr) => {
+        if (expr instanceof ReadTemporaryExpr || expr instanceof AssignTemporaryExpr) {
+          xrefs.add(expr.xref);
+        }
+      });
+      for (const xref of xrefs) {
+        defs.set(xref, `tmp_${opCount}_${count++}`);
+      }
+      visitExpressionsInOp(op, (expr) => {
+        if (expr instanceof ReadTemporaryExpr || expr instanceof AssignTemporaryExpr) {
+          const name = defs.get(expr.xref);
+          if (name === void 0) {
+            throw new Error("Found xref with unassigned name");
+          }
+          expr.name = name;
+        }
+      });
+      generatedStatements.push(...Array.from(defs.values()).map((name) => createStatementOp(new DeclareVarStmt(name))));
+      opCount++;
+    }
+    view.update.prepend(generatedStatements);
+  }
+}
+
 // bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/variable_optimization.mjs
 function phaseVariableOptimization(cpl, options) {
   for (const [_, view] of cpl.views) {
@@ -10113,76 +10804,6 @@ function allowConservativeInlining(decl, target) {
   }
 }
 
-// bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/phases/expand_safe_reads.mjs
-function phaseExpandSafeReads(cpl) {
-  for (const [_, view] of cpl.views) {
-    for (const op of view.ops()) {
-      transformExpressionsInOp(op, safeTransform, VisitorContextFlag.None);
-      transformExpressionsInOp(op, ternaryTransform, VisitorContextFlag.None);
-    }
-  }
-}
-function isSafeAccessExpression(e) {
-  return e instanceof SafePropertyReadExpr || e instanceof SafeKeyedReadExpr;
-}
-function isUnsafeAccessExpression(e) {
-  return e instanceof ReadPropExpr || e instanceof ReadKeyExpr;
-}
-function isAccessExpression(e) {
-  return isSafeAccessExpression(e) || isUnsafeAccessExpression(e);
-}
-function deepestSafeTernary(e) {
-  if (isAccessExpression(e) && e.receiver instanceof SafeTernaryExpr) {
-    let st = e.receiver;
-    while (st.expr instanceof SafeTernaryExpr) {
-      st = st.expr;
-    }
-    return st;
-  }
-  return null;
-}
-function safeTransform(e) {
-  if (e instanceof SafeInvokeFunctionExpr) {
-    return new InvokeFunctionExpr(e.receiver, e.args);
-  }
-  if (!isAccessExpression(e)) {
-    return e;
-  }
-  const dst = deepestSafeTernary(e);
-  if (dst) {
-    if (e instanceof ReadPropExpr) {
-      dst.expr = dst.expr.prop(e.name);
-      return e.receiver;
-    }
-    if (e instanceof ReadKeyExpr) {
-      dst.expr = dst.expr.key(e.index);
-      return e.receiver;
-    }
-    if (e instanceof SafePropertyReadExpr) {
-      dst.expr = new SafeTernaryExpr(dst.expr.clone(), dst.expr.prop(e.name));
-      return e.receiver;
-    }
-    if (e instanceof SafeKeyedReadExpr) {
-      dst.expr = new SafeTernaryExpr(dst.expr.clone(), dst.expr.key(e.index));
-      return e.receiver;
-    }
-  } else {
-    if (e instanceof SafePropertyReadExpr) {
-      return new SafeTernaryExpr(e.receiver.clone(), e.receiver.prop(e.name));
-    }
-    if (e instanceof SafeKeyedReadExpr) {
-      return new SafeTernaryExpr(e.receiver.clone(), e.receiver.key(e.index));
-    }
-  }
-  return e;
-}
-function ternaryTransform(e) {
-  if (!(e instanceof SafeTernaryExpr)) {
-    return e;
-  }
-  return new ConditionalExpr(new BinaryOperatorExpr(BinaryOperator.Equals, e.guard, NULL_EXPR), NULL_EXPR, e.expr);
-}
-
 // bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/src/emit.mjs
 function transformTemplate(cpl) {
   phaseAttributeExtraction(cpl, true);
@@ -10196,17 +10817,19 @@ function transformTemplate(cpl) {
   phaseLocalRefs(cpl);
   phaseConstCollection(cpl);
   phaseNullishCoalescing(cpl);
-  phaseExpandSafeReads(cpl);
+  phaseExpandSafeReads(cpl, true);
+  phaseTemporaryVariables(cpl);
   phaseSlotAllocation(cpl);
   phaseVarCounting(cpl);
   phaseGenerateAdvance(cpl);
-  phaseNaming(cpl);
+  phaseNaming(cpl, true);
   phaseVariableOptimization(cpl, { conservative: true });
   phaseMergeNextContext(cpl);
   phaseNgContainer(cpl);
   phaseEmptyElements(cpl);
   phasePureFunctionExtraction(cpl);
   phaseAlignPipeVariadicVarOffset(cpl);
+  phasePropertyOrdering(cpl);
   phaseReify(cpl);
   phaseChaining(cpl);
 }
@@ -10523,6 +11146,11 @@ function ingestPropertyBinding(view, xref, bindingKind, { name, value, type, uni
             throw Error("Unexpected style binding on ng-template");
           }
           view.update.push(createInterpolateStyleMapOp(xref, value.strings, value.expressions.map((expr) => convertAst(expr, view.tpl))));
+        } else if (name === "class") {
+          if (bindingKind !== ElementAttributeKind.Binding) {
+            throw Error("Unexpected class binding on ng-template");
+          }
+          view.update.push(createInterpolateClassMapOp(xref, value.strings, value.expressions.map((expr) => convertAst(expr, view.tpl))));
         } else {
           view.update.push(createInterpolatePropertyOp(xref, bindingKind, name, value.strings, value.expressions.map((expr) => convertAst(expr, view.tpl))));
         }
@@ -10533,6 +11161,16 @@ function ingestPropertyBinding(view, xref, bindingKind, { name, value, type, uni
         }
         view.update.push(createInterpolateStylePropOp(xref, name, value.strings, value.expressions.map((expr) => convertAst(expr, view.tpl)), unit));
         break;
+      case 1:
+        if (bindingKind !== ElementAttributeKind.Binding) {
+          throw new Error("Attribute bindings on templates are not expected to be valid");
+        }
+        const attributeInterpolate2 = createInterpolateAttributeOp(xref, bindingKind, name, value.strings, value.expressions.map((expr) => convertAst(expr, view.tpl)));
+        view.update.push(attributeInterpolate2);
+        break;
+      case 2:
+        throw Error("Unexpected interpolation in class property binding");
+      case 4:
       default:
         throw Error(`Interpolated property binding type not handled: ${type}`);
     }
@@ -10544,6 +11182,11 @@ function ingestPropertyBinding(view, xref, bindingKind, { name, value, type, uni
             throw Error("Unexpected style binding on ng-template");
           }
           view.update.push(createStyleMapOp(xref, convertAst(value, view.tpl)));
+        } else if (name === "class") {
+          if (bindingKind !== ElementAttributeKind.Binding) {
+            throw Error("Unexpected class binding on ng-template");
+          }
+          view.update.push(createClassMapOp(xref, convertAst(value, view.tpl)));
         } else {
           view.update.push(createPropertyOp(xref, bindingKind, name, convertAst(value, view.tpl)));
         }
@@ -10554,6 +11197,20 @@ function ingestPropertyBinding(view, xref, bindingKind, { name, value, type, uni
         }
         view.update.push(createStylePropOp(xref, name, convertAst(value, view.tpl), unit));
         break;
+      case 1:
+        if (bindingKind !== ElementAttributeKind.Binding) {
+          throw new Error("Attribute bindings on templates are not expected to be valid");
+        }
+        const attrOp = createAttributeOp(xref, bindingKind, name, convertAst(value, view.tpl));
+        view.update.push(attrOp);
+        break;
+      case 2:
+        if (bindingKind !== ElementAttributeKind.Binding) {
+          throw Error("Unexpected class binding on ng-template");
+        }
+        view.update.push(createClassPropOp(xref, name, convertAst(value, view.tpl)));
+        break;
+      case 4:
       default:
         throw Error(`Property binding type not handled: ${type}`);
     }
@@ -10577,67 +11234,6 @@ function assertIsArray(value) {
 // bazel-out/k8-fastbuild/bin/packages/compiler/src/template/pipeline/switch/index.mjs
 var USE_TEMPLATE_PIPELINE = false;
 
-// bazel-out/k8-fastbuild/bin/packages/compiler/src/render3/view/style_parser.mjs
-function parse(value) {
-  const styles = [];
-  let i = 0;
-  let parenDepth = 0;
-  let quote = 0;
-  let valueStart = 0;
-  let propStart = 0;
-  let currentProp = null;
-  while (i < value.length) {
-    const token = value.charCodeAt(i++);
-    switch (token) {
-      case 40:
-        parenDepth++;
-        break;
-      case 41:
-        parenDepth--;
-        break;
-      case 39:
-        if (quote === 0) {
-          quote = 39;
-        } else if (quote === 39 && value.charCodeAt(i - 1) !== 92) {
-          quote = 0;
-        }
-        break;
-      case 34:
-        if (quote === 0) {
-          quote = 34;
-        } else if (quote === 34 && value.charCodeAt(i - 1) !== 92) {
-          quote = 0;
-        }
-        break;
-      case 58:
-        if (!currentProp && parenDepth === 0 && quote === 0) {
-          currentProp = hyphenate(value.substring(propStart, i - 1).trim());
-          valueStart = i;
-        }
-        break;
-      case 59:
-        if (currentProp && valueStart > 0 && parenDepth === 0 && quote === 0) {
-          const styleVal = value.substring(valueStart, i - 1).trim();
-          styles.push(currentProp, styleVal);
-          propStart = i;
-          valueStart = 0;
-          currentProp = null;
-        }
-        break;
-    }
-  }
-  if (currentProp && valueStart) {
-    const styleVal = value.slice(valueStart).trim();
-    styles.push(currentProp, styleVal);
-  }
-  return styles;
-}
-function hyphenate(value) {
-  return value.replace(/[a-z][A-Z]/g, (v) => {
-    return v.charAt(0) + "-" + v.charAt(1);
-  }).toLowerCase();
-}
-
 // bazel-out/k8-fastbuild/bin/packages/compiler/src/render3/view/styling_builder.mjs
 var IMPORTANT_FLAG = "!important";
 var MIN_STYLING_BINDING_SLOTS_REQUIRED = 2;
@@ -12302,6 +12898,39 @@ var Comment2 = class {
     return visitor.visitComment(this, context);
   }
 };
+var BlockGroup = class {
+  constructor(blocks, sourceSpan, startSourceSpan, endSourceSpan = null) {
+    this.blocks = blocks;
+    this.sourceSpan = sourceSpan;
+    this.startSourceSpan = startSourceSpan;
+    this.endSourceSpan = endSourceSpan;
+  }
+  visit(visitor, context) {
+    return visitor.visitBlockGroup(this, context);
+  }
+};
+var Block = class {
+  constructor(name, parameters, children, sourceSpan, startSourceSpan, endSourceSpan = null) {
+    this.name = name;
+    this.parameters = parameters;
+    this.children = children;
+    this.sourceSpan = sourceSpan;
+    this.startSourceSpan = startSourceSpan;
+    this.endSourceSpan = endSourceSpan;
+  }
+  visit(visitor, context) {
+    return visitor.visitBlock(this, context);
+  }
+};
+var BlockParameter = class {
+  constructor(expression, sourceSpan) {
+    this.expression = expression;
+    this.sourceSpan = sourceSpan;
+  }
+  visit(visitor, context) {
+    return visitor.visitBlockParameter(this, context);
+  }
+};
 function visitAll2(visitor, nodes, context = null) {
   const result = [];
   const visit2 = visitor.visit ? (ast) => visitor.visit(ast, context) || ast.visit(visitor, context) : (ast) => ast.visit(visitor, context);
@@ -14976,8 +15605,8 @@ var _Tokenizer = class {
     const range = options.range || { endPos: _file.content.length, startPos: 0, startLine: 0, startCol: 0 };
     this._cursor = options.escapedString ? new EscapedCharacterCursor(_file, range) : new PlainCharacterCursor(_file, range);
     this._preserveLineEndings = options.preserveLineEndings || false;
-    this._escapedString = options.escapedString || false;
     this._i18nNormalizeLineEndingsInICUs = options.i18nNormalizeLineEndingsInICUs || false;
+    this._tokenizeBlocks = options.tokenizeBlocks || false;
     try {
       this._cursor.init();
     } catch (e) {
@@ -15008,6 +15637,12 @@ var _Tokenizer = class {
           } else {
             this._consumeTagOpen(start);
           }
+        } else if (this._tokenizeBlocks && this._attemptStr("{#")) {
+          this._consumeBlockGroupOpen(start);
+        } else if (this._tokenizeBlocks && this._attemptStr("{/")) {
+          this._consumeBlockGroupClose(start);
+        } else if (this._tokenizeBlocks && this._attemptStr("{:")) {
+          this._consumeBlock(start);
         } else if (!(this._tokenizeIcu && this._tokenizeExpansionForm())) {
           this._consumeWithInterpolation(5, 8, () => this._isTextEnd(), () => this._isTagStart());
         }
@@ -15018,6 +15653,55 @@ var _Tokenizer = class {
     this._beginToken(24);
     this._endToken([]);
   }
+  _consumeBlockGroupOpen(start) {
+    this._beginToken(25, start);
+    const nameCursor = this._cursor.clone();
+    this._attemptCharCodeUntilFn((code) => !isBlockNameChar(code));
+    this._endToken([this._cursor.getChars(nameCursor)]);
+    this._consumeBlockParameters();
+    this._beginToken(26);
+    this._requireCharCode($RBRACE);
+    this._endToken([]);
+  }
+  _consumeBlockGroupClose(start) {
+    this._beginToken(27, start);
+    const nameCursor = this._cursor.clone();
+    this._attemptCharCodeUntilFn((code) => !isBlockNameChar(code));
+    const name = this._cursor.getChars(nameCursor);
+    this._requireCharCode($RBRACE);
+    this._endToken([name]);
+  }
+  _consumeBlock(start) {
+    this._beginToken(29, start);
+    const nameCursor = this._cursor.clone();
+    this._attemptCharCodeUntilFn((code) => !isBlockNameChar(code));
+    this._endToken([this._cursor.getChars(nameCursor)]);
+    this._consumeBlockParameters();
+    this._beginToken(30);
+    this._requireCharCode($RBRACE);
+    this._endToken([]);
+  }
+  _consumeBlockParameters() {
+    this._attemptCharCodeUntilFn(isBlockParameterChar);
+    while (this._cursor.peek() !== $RBRACE && this._cursor.peek() !== $EOF) {
+      this._beginToken(28);
+      const start = this._cursor.clone();
+      let inQuote = null;
+      while (this._cursor.peek() !== $SEMICOLON && this._cursor.peek() !== $RBRACE && this._cursor.peek() !== $EOF || inQuote !== null) {
+        const char = this._cursor.peek();
+        if (char === $BACKSLASH) {
+          this._cursor.advance();
+        } else if (char === inQuote) {
+          inQuote = null;
+        } else if (inQuote === null && isQuote(char)) {
+          inQuote = char;
+        }
+        this._cursor.advance();
+      }
+      this._endToken([this._cursor.getChars(start)]);
+      this._attemptCharCodeUntilFn(isBlockParameterChar);
+    }
+  }
   _tokenizeExpansionForm() {
     if (this.isExpansionFormStart()) {
       this._consumeExpansionFormStart();
@@ -15326,7 +16010,6 @@ var _Tokenizer = class {
     this._endToken(prefixAndName);
   }
   _consumeAttributeValue() {
-    let value;
     if (this._cursor.peek() === $SQ || this._cursor.peek() === $DQ) {
       const quoteChar = this._cursor.peek();
       this._consumeQuote(quoteChar);
@@ -15469,7 +16152,7 @@ var _Tokenizer = class {
     return this._processCarriageReturns(end.getChars(start));
   }
   _isTextEnd() {
-    if (this._isTagStart() || this._cursor.peek() === $EOF) {
+    if (this._isTagStart() || this._isBlockStart() || this._cursor.peek() === $EOF) {
       return true;
     }
     if (this._tokenizeIcu && !this._inInterpolation) {
@@ -15493,6 +16176,21 @@ var _Tokenizer = class {
     }
     return false;
   }
+  _isBlockStart() {
+    if (this._tokenizeBlocks && this._cursor.peek() === $LBRACE) {
+      const tmp = this._cursor.clone();
+      tmp.advance();
+      const next = tmp.peek();
+      if (next !== $BANG && next !== $SLASH && next !== $COLON) {
+        return false;
+      }
+      tmp.advance();
+      if (isBlockNameChar(tmp.peek())) {
+        return true;
+      }
+    }
+    return false;
+  }
   _readUntil(char) {
     const start = this._cursor.clone();
     this._attemptUntilChar(char);
@@ -15541,6 +16239,12 @@ function compareCharCodeCaseInsensitive(code1, code2) {
 function toUpperCaseCharCode(code) {
   return code >= $a && code <= $z ? code - $a + $A : code;
 }
+function isBlockNameChar(code) {
+  return isAsciiLetter(code) || isDigit(code) || code === $_;
+}
+function isBlockParameterChar(code) {
+  return code !== $SEMICOLON && isNotWhitespace(code);
+}
 function mergeTextTokens(srcTokens) {
   const dstTokens = [];
   let lastDstToken = void 0;
@@ -15787,7 +16491,7 @@ var _TreeBuilder = class {
     this.tokens = tokens;
     this.getTagDefinition = getTagDefinition;
     this._index = -1;
-    this._elementStack = [];
+    this._containerStack = [];
     this.rootNodes = [];
     this.errors = [];
     this._advance();
@@ -15809,6 +16513,15 @@ var _TreeBuilder = class {
         this._consumeText(this._advance());
       } else if (this._peek.type === 19) {
         this._consumeExpansion(this._advance());
+      } else if (this._peek.type === 25) {
+        this._closeVoidElement();
+        this._consumeBlockGroupOpen(this._advance());
+      } else if (this._peek.type === 29) {
+        this._closeVoidElement();
+        this._consumeBlock(this._advance(), 30);
+      } else if (this._peek.type === 27) {
+        this._closeVoidElement();
+        this._consumeBlockGroupClose(this._advance());
       } else {
         this._advance();
       }
@@ -15915,7 +16628,11 @@ var _TreeBuilder = class {
     const startSpan = token.sourceSpan;
     let text2 = token.parts[0];
     if (text2.length > 0 && text2[0] === "\n") {
-      const parent = this._getParentElement();
+      const parent = this._getContainer();
+      if (parent instanceof BlockGroup) {
+        this.errors.push(TreeError.create(null, startSpan, "Text cannot be placed directly inside of a block group."));
+        return null;
+      }
       if (parent != null && parent.children.length === 0 && this.getTagDefinition(parent.name).ignoreFirstLf) {
         text2 = text2.substring(1);
         tokens[0] = { type: token.type, sourceSpan: token.sourceSpan, parts: [text2] };
@@ -15938,9 +16655,9 @@ var _TreeBuilder = class {
     }
   }
   _closeVoidElement() {
-    const el = this._getParentElement();
-    if (el && this.getTagDefinition(el.name).isVoid) {
-      this._elementStack.pop();
+    const el = this._getContainer();
+    if (el instanceof Element2 && this.getTagDefinition(el.name).isVoid) {
+      this._containerStack.pop();
     }
   }
   _consumeStartTag(startTagToken) {
@@ -15949,7 +16666,7 @@ var _TreeBuilder = class {
     while (this._peek.type === 14) {
       attrs.push(this._consumeAttr(this._advance()));
     }
-    const fullName = this._getElementFullName(prefix, name, this._getParentElement());
+    const fullName = this._getElementFullName(prefix, name, this._getClosestParentElement());
     let selfClosing = false;
     if (this._peek.type === 2) {
       this._advance();
@@ -15966,42 +16683,44 @@ var _TreeBuilder = class {
     const span = new ParseSourceSpan(startTagToken.sourceSpan.start, end, startTagToken.sourceSpan.fullStart);
     const startSpan = new ParseSourceSpan(startTagToken.sourceSpan.start, end, startTagToken.sourceSpan.fullStart);
     const el = new Element2(fullName, attrs, [], span, startSpan, void 0);
-    this._pushElement(el);
+    const parentEl = this._getContainer();
+    this._pushContainer(el, parentEl instanceof Element2 && this.getTagDefinition(parentEl.name).isClosedByChild(el.name));
     if (selfClosing) {
-      this._popElement(fullName, span);
+      this._popContainer(fullName, Element2, span);
     } else if (startTagToken.type === 4) {
-      this._popElement(fullName, null);
+      this._popContainer(fullName, Element2, null);
       this.errors.push(TreeError.create(fullName, span, `Opening tag "${fullName}" not terminated.`));
     }
   }
-  _pushElement(el) {
-    const parentEl = this._getParentElement();
-    if (parentEl && this.getTagDefinition(parentEl.name).isClosedByChild(el.name)) {
-      this._elementStack.pop();
+  _pushContainer(node, isClosedByChild) {
+    if (isClosedByChild) {
+      this._containerStack.pop();
     }
-    this._addToParent(el);
-    this._elementStack.push(el);
+    this._addToParent(node);
+    this._containerStack.push(node);
   }
   _consumeEndTag(endTagToken) {
-    const fullName = this._getElementFullName(endTagToken.parts[0], endTagToken.parts[1], this._getParentElement());
+    const fullName = this._getElementFullName(endTagToken.parts[0], endTagToken.parts[1], this._getClosestParentElement());
     if (this.getTagDefinition(fullName).isVoid) {
       this.errors.push(TreeError.create(fullName, endTagToken.sourceSpan, `Void elements do not have end tags "${endTagToken.parts[1]}"`));
-    } else if (!this._popElement(fullName, endTagToken.sourceSpan)) {
+    } else if (!this._popContainer(fullName, Element2, endTagToken.sourceSpan)) {
       const errMsg = `Unexpected closing tag "${fullName}". It may happen when the tag has already been closed by another tag. For more info see https://www.w3.org/TR/html5/syntax.html#closing-elements-that-have-implied-end-tags`;
       this.errors.push(TreeError.create(fullName, endTagToken.sourceSpan, errMsg));
     }
   }
-  _popElement(fullName, endSourceSpan) {
+  _popContainer(fullName, expectedType, endSourceSpan) {
+    var _a2;
     let unexpectedCloseTagDetected = false;
-    for (let stackIndex = this._elementStack.length - 1; stackIndex >= 0; stackIndex--) {
-      const el = this._elementStack[stackIndex];
-      if (el.name === fullName) {
-        el.endSourceSpan = endSourceSpan;
-        el.sourceSpan.end = endSourceSpan !== null ? endSourceSpan.end : el.sourceSpan.end;
-        this._elementStack.splice(stackIndex, this._elementStack.length - stackIndex);
+    for (let stackIndex = this._containerStack.length - 1; stackIndex >= 0; stackIndex--) {
+      const node = this._containerStack[stackIndex];
+      const name = node instanceof BlockGroup ? (_a2 = node.blocks[0]) == null ? void 0 : _a2.name : node.name;
+      if (name === fullName && node instanceof expectedType) {
+        node.endSourceSpan = endSourceSpan;
+        node.sourceSpan.end = endSourceSpan !== null ? endSourceSpan.end : node.sourceSpan.end;
+        this._containerStack.splice(stackIndex, this._containerStack.length - stackIndex);
         return !unexpectedCloseTagDetected;
       }
-      if (!this.getTagDefinition(el.name).closedByParent) {
+      if (node instanceof BlockGroup || node instanceof Element2 && !this.getTagDefinition(node.name).closedByParent) {
         unexpectedCloseTagDetected = true;
       }
     }
@@ -16041,15 +16760,74 @@ var _TreeBuilder = class {
     const valueSpan = valueStartSpan && valueEnd && new ParseSourceSpan(valueStartSpan.start, valueEnd, valueStartSpan.fullStart);
     return new Attribute(fullName, value, new ParseSourceSpan(attrName.sourceSpan.start, attrEnd, attrName.sourceSpan.fullStart), attrName.sourceSpan, valueSpan, valueTokens.length > 0 ? valueTokens : void 0, void 0);
   }
-  _getParentElement() {
-    return this._elementStack.length > 0 ? this._elementStack[this._elementStack.length - 1] : null;
+  _consumeBlockGroupOpen(token) {
+    const end = this._peek.sourceSpan.fullStart;
+    const span = new ParseSourceSpan(token.sourceSpan.start, end, token.sourceSpan.fullStart);
+    const startSpan = new ParseSourceSpan(token.sourceSpan.start, end, token.sourceSpan.fullStart);
+    const blockGroup = new BlockGroup([], span, startSpan, null);
+    this._pushContainer(blockGroup, false);
+    const implicitBlock = this._consumeBlock(token, 26);
+    startSpan.end = implicitBlock.startSourceSpan.end;
+  }
+  _consumeBlock(token, closeToken) {
+    this._conditionallyClosePreviousBlock();
+    const parameters = [];
+    while (this._peek.type === 28) {
+      const paramToken = this._advance();
+      parameters.push(new BlockParameter(paramToken.parts[0], paramToken.sourceSpan));
+    }
+    if (this._peek.type === closeToken) {
+      this._advance();
+    }
+    const end = this._peek.sourceSpan.fullStart;
+    const span = new ParseSourceSpan(token.sourceSpan.start, end, token.sourceSpan.fullStart);
+    const startSpan = new ParseSourceSpan(token.sourceSpan.start, end, token.sourceSpan.fullStart);
+    const block = new Block(token.parts[0], parameters, [], span, startSpan);
+    const parent = this._getContainer();
+    if (!(parent instanceof BlockGroup)) {
+      this.errors.push(TreeError.create(block.name, block.sourceSpan, "Blocks can only be placed inside of block groups."));
+    } else {
+      parent.blocks.push(block);
+      this._containerStack.push(block);
+    }
+    return block;
+  }
+  _consumeBlockGroupClose(token) {
+    const name = token.parts[0];
+    const previousContainer = this._getContainer();
+    this._conditionallyClosePreviousBlock();
+    if (!this._popContainer(name, BlockGroup, token.sourceSpan)) {
+      const context = previousContainer instanceof Element2 ? `There is an unclosed "${previousContainer.name}" HTML tag named that may have to be closed first.` : `The block may have been closed earlier.`;
+      this.errors.push(TreeError.create(name, token.sourceSpan, `Unexpected closing block "${name}". ${context}`));
+    }
+  }
+  _conditionallyClosePreviousBlock() {
+    const container = this._getContainer();
+    if (container instanceof Block) {
+      const lastChild = container.children.length ? container.children[container.children.length - 1] : null;
+      const endSpan = lastChild === null ? null : new ParseSourceSpan(lastChild.sourceSpan.end, lastChild.sourceSpan.end);
+      this._popContainer(container.name, Block, endSpan);
+    }
+  }
+  _getContainer() {
+    return this._containerStack.length > 0 ? this._containerStack[this._containerStack.length - 1] : null;
+  }
+  _getClosestParentElement() {
+    for (let i = this._containerStack.length - 1; i > -1; i--) {
+      if (this._containerStack[i] instanceof Element2) {
+        return this._containerStack[i];
+      }
+    }
+    return null;
   }
   _addToParent(node) {
-    const parent = this._getParentElement();
-    if (parent != null) {
-      parent.children.push(node);
-    } else {
+    const parent = this._getContainer();
+    if (parent === null) {
       this.rootNodes.push(node);
+    } else if (parent instanceof BlockGroup) {
+      this.errors.push(TreeError.create(null, node.sourceSpan, "Block groups can only contain blocks."));
+    } else {
+      parent.children.push(node);
     }
   }
   _getElementFullName(prefix, localName, parentElement) {
@@ -16111,8 +16889,8 @@ var WhitespaceVisitor = class {
     }
     return new Element2(element2.name, element2.attrs, visitAllWithSiblings(this, element2.children), element2.sourceSpan, element2.startSourceSpan, element2.endSourceSpan, element2.i18n);
   }
-  visitAttribute(attribute, context) {
-    return attribute.name !== PRESERVE_WS_ATTR_NAME ? attribute : null;
+  visitAttribute(attribute2, context) {
+    return attribute2.name !== PRESERVE_WS_ATTR_NAME ? attribute2 : null;
   }
   visitText(text2, context) {
     const isNotBlank = text2.value.match(NO_WS_REGEXP);
@@ -16133,6 +16911,15 @@ var WhitespaceVisitor = class {
   visitExpansionCase(expansionCase, context) {
     return expansionCase;
   }
+  visitBlockGroup(group, context) {
+    return new BlockGroup(visitAllWithSiblings(this, group.blocks), group.sourceSpan, group.startSourceSpan, group.endSourceSpan);
+  }
+  visitBlock(block, context) {
+    return new Block(block.name, block.parameters, visitAllWithSiblings(this, block.children), block.sourceSpan, block.startSourceSpan);
+  }
+  visitBlockParameter(parameter, context) {
+    return parameter;
+  }
 };
 function createWhitespaceProcessedTextToken({ type, parts, sourceSpan }) {
   return { type, parts: [processWhitespace(parts[0])], sourceSpan };
@@ -16323,7 +17110,7 @@ var BindingParser = class {
     if (isAnimationProp) {
       this._parseAnimation(name, expression, sourceSpan, absoluteOffset, keySpan, valueSpan, targetMatchableAttrs, targetProps);
     } else {
-      this._parsePropertyAst(name, this._parseBinding(expression, isHost, valueSpan || sourceSpan, absoluteOffset), sourceSpan, keySpan, valueSpan, targetMatchableAttrs, targetProps);
+      this._parsePropertyAst(name, this.parseBinding(expression, isHost, valueSpan || sourceSpan, absoluteOffset), sourceSpan, keySpan, valueSpan, targetMatchableAttrs, targetProps);
     }
   }
   parsePropertyInterpolation(name, value, sourceSpan, valueSpan, targetMatchableAttrs, targetProps, keySpan, interpolatedTokens) {
@@ -16342,11 +17129,11 @@ var BindingParser = class {
     if (name.length === 0) {
       this._reportError("Animation trigger is missing", sourceSpan);
     }
-    const ast = this._parseBinding(expression || "undefined", false, valueSpan || sourceSpan, absoluteOffset);
+    const ast = this.parseBinding(expression || "undefined", false, valueSpan || sourceSpan, absoluteOffset);
     targetMatchableAttrs.push([name, ast.source]);
     targetProps.push(new ParsedProperty(name, ast, ParsedPropertyType.ANIMATION, sourceSpan, keySpan, valueSpan));
   }
-  _parseBinding(value, isHostBinding2, sourceSpan, absoluteOffset) {
+  parseBinding(value, isHostBinding2, sourceSpan, absoluteOffset) {
     const sourceInfo = (sourceSpan && sourceSpan.start || "(unknown)").toString();
     try {
       const ast = isHostBinding2 ? this._exprParser.parseSimpleBinding(value, sourceInfo, absoluteOffset, this._interpolationConfig) : this._exprParser.parseBinding(value, sourceInfo, absoluteOffset, this._interpolationConfig);
@@ -16575,6 +17362,360 @@ function normalizeNgContentSelect(selectAttr) {
   return selectAttr;
 }
 
+// bazel-out/k8-fastbuild/bin/packages/compiler/src/render3/r3_deferred_triggers.mjs
+var TIME_PATTERN = /^\d+(ms|s)?$/;
+var SEPARATOR_PATTERN = /^\s$/;
+var COMMA_DELIMITED_SYNTAX = /* @__PURE__ */ new Map([
+  [$LBRACE, $RBRACE],
+  [$LBRACKET, $RBRACKET],
+  [$LPAREN, $RPAREN]
+]);
+var OnTriggerType;
+(function(OnTriggerType2) {
+  OnTriggerType2["IDLE"] = "idle";
+  OnTriggerType2["TIMER"] = "timer";
+  OnTriggerType2["INTERACTION"] = "interaction";
+  OnTriggerType2["IMMEDIATE"] = "immediate";
+  OnTriggerType2["HOVER"] = "hover";
+  OnTriggerType2["VIEWPORT"] = "viewport";
+})(OnTriggerType || (OnTriggerType = {}));
+function parseWhenTrigger({ expression, sourceSpan }, bindingParser, errors) {
+  const whenIndex = expression.indexOf("when");
+  if (whenIndex === -1) {
+    errors.push(new ParseError(sourceSpan, `Could not find "when" keyword in expression`));
+    return null;
+  }
+  const start = getTriggerParametersStart(expression, whenIndex + 1);
+  const parsed = bindingParser.parseBinding(expression.slice(start), false, sourceSpan, sourceSpan.start.offset + start);
+  return new BoundDeferredTrigger(parsed, sourceSpan);
+}
+function parseOnTrigger({ expression, sourceSpan }, errors) {
+  const onIndex = expression.indexOf("on");
+  if (onIndex === -1) {
+    errors.push(new ParseError(sourceSpan, `Could not find "on" keyword in expression`));
+    return [];
+  }
+  const start = getTriggerParametersStart(expression, onIndex + 1);
+  return new OnTriggerParser(expression, start, sourceSpan, errors).parse();
+}
+var OnTriggerParser = class {
+  constructor(expression, start, span, errors) {
+    this.expression = expression;
+    this.start = start;
+    this.span = span;
+    this.errors = errors;
+    this.index = 0;
+    this.triggers = [];
+    this.tokens = new Lexer().tokenize(expression.slice(start));
+  }
+  parse() {
+    while (this.tokens.length > 0 && this.index < this.tokens.length) {
+      const token = this.token();
+      if (!token.isIdentifier()) {
+        this.unexpectedToken(token);
+        break;
+      }
+      if (this.isFollowedByOrLast($COMMA)) {
+        this.consumeTrigger(token, []);
+        this.advance();
+      } else if (this.isFollowedByOrLast($LPAREN)) {
+        this.advance();
+        const prevErrors = this.errors.length;
+        const parameters = this.consumeParameters();
+        if (this.errors.length !== prevErrors) {
+          break;
+        }
+        this.consumeTrigger(token, parameters);
+        this.advance();
+      } else if (this.index < this.tokens.length - 1) {
+        this.unexpectedToken(this.tokens[this.index + 1]);
+      }
+      this.advance();
+    }
+    return this.triggers;
+  }
+  advance() {
+    this.index++;
+  }
+  isFollowedByOrLast(char) {
+    if (this.index === this.tokens.length - 1) {
+      return true;
+    }
+    return this.tokens[this.index + 1].isCharacter(char);
+  }
+  token() {
+    return this.tokens[Math.min(this.index, this.tokens.length - 1)];
+  }
+  consumeTrigger(identifier, parameters) {
+    const startSpan = this.span.start.moveBy(this.start + identifier.index - this.tokens[0].index);
+    const endSpan = startSpan.moveBy(this.token().end - identifier.index);
+    const sourceSpan = new ParseSourceSpan(startSpan, endSpan);
+    try {
+      switch (identifier.toString()) {
+        case OnTriggerType.IDLE:
+          this.triggers.push(createIdleTrigger(parameters, sourceSpan));
+          break;
+        case OnTriggerType.TIMER:
+          this.triggers.push(createTimerTrigger(parameters, sourceSpan));
+          break;
+        case OnTriggerType.INTERACTION:
+          this.triggers.push(createInteractionTrigger(parameters, sourceSpan));
+          break;
+        case OnTriggerType.IMMEDIATE:
+          this.triggers.push(createImmediateTrigger(parameters, sourceSpan));
+          break;
+        case OnTriggerType.HOVER:
+          this.triggers.push(createHoverTrigger(parameters, sourceSpan));
+          break;
+        case OnTriggerType.VIEWPORT:
+          this.triggers.push(createViewportTrigger(parameters, sourceSpan));
+          break;
+        default:
+          throw new Error(`Unrecognized trigger type "${identifier}"`);
+      }
+    } catch (e) {
+      this.error(identifier, e.message);
+    }
+  }
+  consumeParameters() {
+    const parameters = [];
+    if (!this.token().isCharacter($LPAREN)) {
+      this.unexpectedToken(this.token());
+      return parameters;
+    }
+    this.advance();
+    const commaDelimStack = [];
+    let current = "";
+    while (this.index < this.tokens.length) {
+      const token = this.token();
+      if (token.isCharacter($RPAREN) && commaDelimStack.length === 0) {
+        if (current.length) {
+          parameters.push(current);
+        }
+        break;
+      }
+      if (token.type === TokenType.Character && COMMA_DELIMITED_SYNTAX.has(token.numValue)) {
+        commaDelimStack.push(COMMA_DELIMITED_SYNTAX.get(token.numValue));
+      }
+      if (commaDelimStack.length > 0 && token.isCharacter(commaDelimStack[commaDelimStack.length - 1])) {
+        commaDelimStack.pop();
+      }
+      if (commaDelimStack.length === 0 && token.isCharacter($COMMA) && current.length > 0) {
+        parameters.push(current);
+        current = "";
+        this.advance();
+        continue;
+      }
+      current += this.tokenText();
+      this.advance();
+    }
+    if (!this.token().isCharacter($RPAREN) || commaDelimStack.length > 0) {
+      this.error(this.token(), "Unexpected end of expression");
+    }
+    if (this.index < this.tokens.length - 1 && !this.tokens[this.index + 1].isCharacter($COMMA)) {
+      this.unexpectedToken(this.tokens[this.index + 1]);
+    }
+    return parameters;
+  }
+  tokenText() {
+    return this.expression.slice(this.start + this.token().index, this.start + this.token().end);
+  }
+  error(token, message) {
+    const newStart = this.span.start.moveBy(this.start + token.index);
+    const newEnd = newStart.moveBy(token.end - token.index);
+    this.errors.push(new ParseError(new ParseSourceSpan(newStart, newEnd), message));
+  }
+  unexpectedToken(token) {
+    this.error(token, `Unexpected token "${token}"`);
+  }
+};
+function createIdleTrigger(parameters, sourceSpan) {
+  if (parameters.length > 0) {
+    throw new Error(`"${OnTriggerType.IDLE}" trigger cannot have parameters`);
+  }
+  return new IdleDeferredTrigger(sourceSpan);
+}
+function createTimerTrigger(parameters, sourceSpan) {
+  if (parameters.length !== 1) {
+    throw new Error(`"${OnTriggerType.TIMER}" trigger must have exactly one parameter`);
+  }
+  const delay = parseDeferredTime(parameters[0]);
+  if (delay === null) {
+    throw new Error(`Could not parse time value of trigger "${OnTriggerType.TIMER}"`);
+  }
+  return new TimerDeferredTrigger(delay, sourceSpan);
+}
+function createInteractionTrigger(parameters, sourceSpan) {
+  var _a2;
+  if (parameters.length > 1) {
+    throw new Error(`"${OnTriggerType.INTERACTION}" trigger can only have zero or one parameters`);
+  }
+  return new InteractionDeferredTrigger((_a2 = parameters[0]) != null ? _a2 : null, sourceSpan);
+}
+function createImmediateTrigger(parameters, sourceSpan) {
+  if (parameters.length > 0) {
+    throw new Error(`"${OnTriggerType.IMMEDIATE}" trigger cannot have parameters`);
+  }
+  return new ImmediateDeferredTrigger(sourceSpan);
+}
+function createHoverTrigger(parameters, sourceSpan) {
+  if (parameters.length > 0) {
+    throw new Error(`"${OnTriggerType.HOVER}" trigger cannot have parameters`);
+  }
+  return new HoverDeferredTrigger(sourceSpan);
+}
+function createViewportTrigger(parameters, sourceSpan) {
+  var _a2;
+  if (parameters.length > 1) {
+    throw new Error(`"${OnTriggerType.VIEWPORT}" trigger can only have zero or one parameters`);
+  }
+  return new ViewportDeferredTrigger((_a2 = parameters[0]) != null ? _a2 : null, sourceSpan);
+}
+function getTriggerParametersStart(value, startPosition = 0) {
+  let hasFoundSeparator = false;
+  for (let i = startPosition; i < value.length; i++) {
+    if (SEPARATOR_PATTERN.test(value[i])) {
+      hasFoundSeparator = true;
+    } else if (hasFoundSeparator) {
+      return i;
+    }
+  }
+  return -1;
+}
+function parseDeferredTime(value) {
+  const match = value.match(TIME_PATTERN);
+  if (!match) {
+    return null;
+  }
+  const [time, units] = match;
+  return parseInt(time) * (units === "s" ? 1e3 : 1);
+}
+
+// bazel-out/k8-fastbuild/bin/packages/compiler/src/render3/r3_deferred_blocks.mjs
+var PREFETCH_WHEN_PATTERN = /^prefetch\s+when\s/;
+var PREFETCH_ON_PATTERN = /^prefetch\s+on\s/;
+var MINIMUM_PARAMETER_PATTERN = /^minimum\s/;
+var AFTER_PARAMETER_PATTERN = /^after\s/;
+var WHEN_PARAMETER_PATTERN = /^when\s/;
+var ON_PARAMETER_PATTERN = /^on\s/;
+var SecondaryDeferredBlockType;
+(function(SecondaryDeferredBlockType2) {
+  SecondaryDeferredBlockType2["PLACEHOLDER"] = "placeholder";
+  SecondaryDeferredBlockType2["LOADING"] = "loading";
+  SecondaryDeferredBlockType2["ERROR"] = "error";
+})(SecondaryDeferredBlockType || (SecondaryDeferredBlockType = {}));
+function createDeferredBlock(ast, visitor, bindingParser) {
+  const errors = [];
+  const [primaryBlock, ...secondaryBlocks] = ast.blocks;
+  const { triggers, prefetchTriggers } = parsePrimaryTriggers(primaryBlock.parameters, bindingParser, errors);
+  const { placeholder, loading, error: error2 } = parseSecondaryBlocks(secondaryBlocks, errors, visitor);
+  return {
+    node: new DeferredBlock(visitAll2(visitor, primaryBlock.children), triggers, prefetchTriggers, placeholder, loading, error2, ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan),
+    errors
+  };
+}
+function parseSecondaryBlocks(blocks, errors, visitor) {
+  let placeholder = null;
+  let loading = null;
+  let error2 = null;
+  for (const block of blocks) {
+    try {
+      switch (block.name) {
+        case SecondaryDeferredBlockType.PLACEHOLDER:
+          if (placeholder !== null) {
+            errors.push(new ParseError(block.startSourceSpan, `"defer" block can only have one "${SecondaryDeferredBlockType.PLACEHOLDER}" block`));
+          } else {
+            placeholder = parsePlaceholderBlock(block, visitor);
+          }
+          break;
+        case SecondaryDeferredBlockType.LOADING:
+          if (loading !== null) {
+            errors.push(new ParseError(block.startSourceSpan, `"defer" block can only have one "${SecondaryDeferredBlockType.LOADING}" block`));
+          } else {
+            loading = parseLoadingBlock(block, visitor);
+          }
+          break;
+        case SecondaryDeferredBlockType.ERROR:
+          if (error2 !== null) {
+            errors.push(new ParseError(block.startSourceSpan, `"defer" block can only have one "${SecondaryDeferredBlockType.ERROR}" block`));
+          } else {
+            error2 = parseErrorBlock(block, visitor);
+          }
+          break;
+        default:
+          errors.push(new ParseError(block.startSourceSpan, `Unrecognized block "${block.name}"`));
+          break;
+      }
+    } catch (e) {
+      errors.push(new ParseError(block.startSourceSpan, e.message));
+    }
+  }
+  return { placeholder, loading, error: error2 };
+}
+function parsePlaceholderBlock(ast, visitor) {
+  let minimumTime = null;
+  for (const param of ast.parameters) {
+    if (MINIMUM_PARAMETER_PATTERN.test(param.expression)) {
+      const parsedTime = parseDeferredTime(param.expression.slice(getTriggerParametersStart(param.expression)));
+      if (parsedTime === null) {
+        throw new Error(`Could not parse time value of parameter "minimum"`);
+      }
+      minimumTime = parsedTime;
+    } else {
+      throw new Error(`Unrecognized parameter in "${SecondaryDeferredBlockType.PLACEHOLDER}" block: "${param.expression}"`);
+    }
+  }
+  return new DeferredBlockPlaceholder(visitAll2(visitor, ast.children), minimumTime, ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan);
+}
+function parseLoadingBlock(ast, visitor) {
+  let afterTime = null;
+  let minimumTime = null;
+  for (const param of ast.parameters) {
+    if (AFTER_PARAMETER_PATTERN.test(param.expression)) {
+      const parsedTime = parseDeferredTime(param.expression.slice(getTriggerParametersStart(param.expression)));
+      if (parsedTime === null) {
+        throw new Error(`Could not parse time value of parameter "after"`);
+      }
+      afterTime = parsedTime;
+    } else if (MINIMUM_PARAMETER_PATTERN.test(param.expression)) {
+      const parsedTime = parseDeferredTime(param.expression.slice(getTriggerParametersStart(param.expression)));
+      if (parsedTime === null) {
+        throw new Error(`Could not parse time value of parameter "minimum"`);
+      }
+      minimumTime = parsedTime;
+    } else {
+      throw new Error(`Unrecognized parameter in "${SecondaryDeferredBlockType.LOADING}" block: "${param.expression}"`);
+    }
+  }
+  return new DeferredBlockLoading(visitAll2(visitor, ast.children), afterTime, minimumTime, ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan);
+}
+function parseErrorBlock(ast, visitor) {
+  if (ast.parameters.length > 0) {
+    throw new Error(`"${SecondaryDeferredBlockType.ERROR}" block cannot have parameters`);
+  }
+  return new DeferredBlockError(visitAll2(visitor, ast.children), ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan);
+}
+function parsePrimaryTriggers(params, bindingParser, errors) {
+  const triggers = [];
+  const prefetchTriggers = [];
+  for (const param of params) {
+    if (WHEN_PARAMETER_PATTERN.test(param.expression)) {
+      const result = parseWhenTrigger(param, bindingParser, errors);
+      result !== null && triggers.push(result);
+    } else if (ON_PARAMETER_PATTERN.test(param.expression)) {
+      triggers.push(...parseOnTrigger(param, errors));
+    } else if (PREFETCH_WHEN_PATTERN.test(param.expression)) {
+      const result = parseWhenTrigger(param, bindingParser, errors);
+      result !== null && prefetchTriggers.push(result);
+    } else if (PREFETCH_ON_PATTERN.test(param.expression)) {
+      prefetchTriggers.push(...parseOnTrigger(param, errors));
+    } else {
+      errors.push(new ParseError(param.sourceSpan, "Unrecognized trigger"));
+    }
+  }
+  return { triggers, prefetchTriggers };
+}
+
 // bazel-out/k8-fastbuild/bin/packages/compiler/src/render3/r3_template_transform.mjs
 var BIND_NAME_REGEXP = /^(?:(bind-)|(let-)|(ref-|#)|(on-)|(bindon-)|(@))(.*)$/;
 var KW_BIND_IDX = 1;
@@ -16648,33 +17789,38 @@ var HtmlAstToIvyAst = class {
     const templateParsedProperties = [];
     const templateVariables = [];
     let elementHasInlineTemplate = false;
-    for (const attribute of element2.attrs) {
+    for (const attribute2 of element2.attrs) {
       let hasBinding = false;
-      const normalizedName = normalizeAttributeName(attribute.name);
+      const normalizedName = normalizeAttributeName(attribute2.name);
       let isTemplateBinding = false;
-      if (attribute.i18n) {
-        i18nAttrsMeta[attribute.name] = attribute.i18n;
+      if (attribute2.i18n) {
+        i18nAttrsMeta[attribute2.name] = attribute2.i18n;
       }
       if (normalizedName.startsWith(TEMPLATE_ATTR_PREFIX2)) {
         if (elementHasInlineTemplate) {
-          this.reportError(`Can't have multiple template bindings on one element. Use only one attribute prefixed with *`, attribute.sourceSpan);
+          this.reportError(`Can't have multiple template bindings on one element. Use only one attribute prefixed with *`, attribute2.sourceSpan);
         }
         isTemplateBinding = true;
         elementHasInlineTemplate = true;
-        const templateValue = attribute.value;
+        const templateValue = attribute2.value;
         const templateKey = normalizedName.substring(TEMPLATE_ATTR_PREFIX2.length);
         const parsedVariables = [];
-        const absoluteValueOffset = attribute.valueSpan ? attribute.valueSpan.start.offset : attribute.sourceSpan.start.offset + attribute.name.length;
-        this.bindingParser.parseInlineTemplateBinding(templateKey, templateValue, attribute.sourceSpan, absoluteValueOffset, [], templateParsedProperties, parsedVariables, true);
+        const absoluteValueOffset = attribute2.valueSpan ? attribute2.valueSpan.start.offset : attribute2.sourceSpan.start.offset + attribute2.name.length;
+        this.bindingParser.parseInlineTemplateBinding(templateKey, templateValue, attribute2.sourceSpan, absoluteValueOffset, [], templateParsedProperties, parsedVariables, true);
         templateVariables.push(...parsedVariables.map((v) => new Variable(v.name, v.value, v.sourceSpan, v.keySpan, v.valueSpan)));
       } else {
-        hasBinding = this.parseAttribute(isTemplateElement, attribute, [], parsedProperties, boundEvents, variables, references);
+        hasBinding = this.parseAttribute(isTemplateElement, attribute2, [], parsedProperties, boundEvents, variables, references);
       }
       if (!hasBinding && !isTemplateBinding) {
-        attributes.push(this.visitAttribute(attribute));
+        attributes.push(this.visitAttribute(attribute2));
       }
     }
-    const children = visitAll2(preparsedElement.nonBindable ? NON_BINDABLE_VISITOR : this, element2.children);
+    let children;
+    if (preparsedElement.nonBindable) {
+      children = visitAll2(NON_BINDABLE_VISITOR, element2.children).flat(Infinity);
+    } else {
+      children = visitAll2(this, element2.children);
+    }
     let parsedElement;
     if (preparsedElement.type === PreparsedElementType.NG_CONTENT) {
       if (element2.children && !element2.children.every((node) => isEmptyTextNode(node) || isCommentNode(node))) {
@@ -16710,8 +17856,8 @@ var HtmlAstToIvyAst = class {
     }
     return parsedElement;
   }
-  visitAttribute(attribute) {
-    return new TextAttribute(attribute.name, attribute.value, attribute.sourceSpan, attribute.keySpan, attribute.valueSpan, attribute.i18n);
+  visitAttribute(attribute2) {
+    return new TextAttribute(attribute2.name, attribute2.value, attribute2.sourceSpan, attribute2.keySpan, attribute2.valueSpan, attribute2.i18n);
   }
   visitText(text2) {
     return this._visitTextWithInterpolation(text2.value, text2.sourceSpan, text2.tokens, text2.i18n);
@@ -16747,6 +17893,24 @@ var HtmlAstToIvyAst = class {
     }
     return null;
   }
+  visitBlockGroup(group, context) {
+    const primaryBlock = group.blocks[0];
+    if (!primaryBlock) {
+      this.reportError("Block group must have at least one block.", group.sourceSpan);
+      return null;
+    }
+    if (primaryBlock.name === "defer" && this.options.enabledBlockTypes.has(primaryBlock.name)) {
+      const { node, errors } = createDeferredBlock(group, this, this.bindingParser);
+      this.errors.push(...errors);
+      return node;
+    }
+    this.reportError(`Unrecognized block "${primaryBlock.name}".`, primaryBlock.sourceSpan);
+    return null;
+  }
+  visitBlock(block, context) {
+  }
+  visitBlockParameter(parameter, context) {
+  }
   extractAttributes(elementName, properties, i18nPropsMeta) {
     const bound = [];
     const literal3 = [];
@@ -16761,14 +17925,14 @@ var HtmlAstToIvyAst = class {
     });
     return { bound, literal: literal3 };
   }
-  parseAttribute(isTemplateElement, attribute, matchableAttributes, parsedProperties, boundEvents, variables, references) {
+  parseAttribute(isTemplateElement, attribute2, matchableAttributes, parsedProperties, boundEvents, variables, references) {
     var _a2;
-    const name = normalizeAttributeName(attribute.name);
-    const value = attribute.value;
-    const srcSpan = attribute.sourceSpan;
-    const absoluteOffset = attribute.valueSpan ? attribute.valueSpan.start.offset : srcSpan.start.offset;
+    const name = normalizeAttributeName(attribute2.name);
+    const value = attribute2.value;
+    const srcSpan = attribute2.sourceSpan;
+    const absoluteOffset = attribute2.valueSpan ? attribute2.valueSpan.start.offset : srcSpan.start.offset;
     function createKeySpan(srcSpan2, prefix, identifier) {
-      const normalizationAdjustment = attribute.name.length - name.length;
+      const normalizationAdjustment = attribute2.name.length - name.length;
       const keySpanStart = srcSpan2.start.moveBy(prefix.length + normalizationAdjustment);
       const keySpanEnd = keySpanStart.moveBy(identifier.length);
       return new ParseSourceSpan(keySpanStart, keySpanEnd, keySpanStart, identifier);
@@ -16778,33 +17942,33 @@ var HtmlAstToIvyAst = class {
       if (bindParts[KW_BIND_IDX] != null) {
         const identifier = bindParts[IDENT_KW_IDX];
         const keySpan2 = createKeySpan(srcSpan, bindParts[KW_BIND_IDX], identifier);
-        this.bindingParser.parsePropertyBinding(identifier, value, false, srcSpan, absoluteOffset, attribute.valueSpan, matchableAttributes, parsedProperties, keySpan2);
+        this.bindingParser.parsePropertyBinding(identifier, value, false, srcSpan, absoluteOffset, attribute2.valueSpan, matchableAttributes, parsedProperties, keySpan2);
       } else if (bindParts[KW_LET_IDX]) {
         if (isTemplateElement) {
           const identifier = bindParts[IDENT_KW_IDX];
           const keySpan2 = createKeySpan(srcSpan, bindParts[KW_LET_IDX], identifier);
-          this.parseVariable(identifier, value, srcSpan, keySpan2, attribute.valueSpan, variables);
+          this.parseVariable(identifier, value, srcSpan, keySpan2, attribute2.valueSpan, variables);
         } else {
           this.reportError(`"let-" is only supported on ng-template elements.`, srcSpan);
         }
       } else if (bindParts[KW_REF_IDX]) {
         const identifier = bindParts[IDENT_KW_IDX];
         const keySpan2 = createKeySpan(srcSpan, bindParts[KW_REF_IDX], identifier);
-        this.parseReference(identifier, value, srcSpan, keySpan2, attribute.valueSpan, references);
+        this.parseReference(identifier, value, srcSpan, keySpan2, attribute2.valueSpan, references);
       } else if (bindParts[KW_ON_IDX]) {
         const events = [];
         const identifier = bindParts[IDENT_KW_IDX];
         const keySpan2 = createKeySpan(srcSpan, bindParts[KW_ON_IDX], identifier);
-        this.bindingParser.parseEvent(identifier, value, false, srcSpan, attribute.valueSpan || srcSpan, matchableAttributes, events, keySpan2);
+        this.bindingParser.parseEvent(identifier, value, false, srcSpan, attribute2.valueSpan || srcSpan, matchableAttributes, events, keySpan2);
         addEvents(events, boundEvents);
       } else if (bindParts[KW_BINDON_IDX]) {
         const identifier = bindParts[IDENT_KW_IDX];
         const keySpan2 = createKeySpan(srcSpan, bindParts[KW_BINDON_IDX], identifier);
-        this.bindingParser.parsePropertyBinding(identifier, value, false, srcSpan, absoluteOffset, attribute.valueSpan, matchableAttributes, parsedProperties, keySpan2);
-        this.parseAssignmentEvent(identifier, value, srcSpan, attribute.valueSpan, matchableAttributes, boundEvents, keySpan2);
+        this.bindingParser.parsePropertyBinding(identifier, value, false, srcSpan, absoluteOffset, attribute2.valueSpan, matchableAttributes, parsedProperties, keySpan2);
+        this.parseAssignmentEvent(identifier, value, srcSpan, attribute2.valueSpan, matchableAttributes, boundEvents, keySpan2);
       } else if (bindParts[KW_AT_IDX]) {
         const keySpan2 = createKeySpan(srcSpan, "", name);
-        this.bindingParser.parseLiteralAttr(name, value, srcSpan, absoluteOffset, attribute.valueSpan, matchableAttributes, parsedProperties, keySpan2);
+        this.bindingParser.parseLiteralAttr(name, value, srcSpan, absoluteOffset, attribute2.valueSpan, matchableAttributes, parsedProperties, keySpan2);
       }
       return true;
     }
@@ -16820,19 +17984,19 @@ var HtmlAstToIvyAst = class {
       const identifier = name.substring(delims.start.length, name.length - delims.end.length);
       const keySpan2 = createKeySpan(srcSpan, delims.start, identifier);
       if (delims.start === BINDING_DELIMS.BANANA_BOX.start) {
-        this.bindingParser.parsePropertyBinding(identifier, value, false, srcSpan, absoluteOffset, attribute.valueSpan, matchableAttributes, parsedProperties, keySpan2);
-        this.parseAssignmentEvent(identifier, value, srcSpan, attribute.valueSpan, matchableAttributes, boundEvents, keySpan2);
+        this.bindingParser.parsePropertyBinding(identifier, value, false, srcSpan, absoluteOffset, attribute2.valueSpan, matchableAttributes, parsedProperties, keySpan2);
+        this.parseAssignmentEvent(identifier, value, srcSpan, attribute2.valueSpan, matchableAttributes, boundEvents, keySpan2);
       } else if (delims.start === BINDING_DELIMS.PROPERTY.start) {
-        this.bindingParser.parsePropertyBinding(identifier, value, false, srcSpan, absoluteOffset, attribute.valueSpan, matchableAttributes, parsedProperties, keySpan2);
+        this.bindingParser.parsePropertyBinding(identifier, value, false, srcSpan, absoluteOffset, attribute2.valueSpan, matchableAttributes, parsedProperties, keySpan2);
       } else {
         const events = [];
-        this.bindingParser.parseEvent(identifier, value, false, srcSpan, attribute.valueSpan || srcSpan, matchableAttributes, events, keySpan2);
+        this.bindingParser.parseEvent(identifier, value, false, srcSpan, attribute2.valueSpan || srcSpan, matchableAttributes, events, keySpan2);
         addEvents(events, boundEvents);
       }
       return true;
     }
     const keySpan = createKeySpan(srcSpan, "", name);
-    const hasBinding = this.bindingParser.parsePropertyInterpolation(name, value, srcSpan, attribute.valueSpan, matchableAttributes, parsedProperties, keySpan, (_a2 = attribute.valueTokens) != null ? _a2 : null);
+    const hasBinding = this.bindingParser.parsePropertyInterpolation(name, value, srcSpan, attribute2.valueSpan, matchableAttributes, parsedProperties, keySpan, (_a2 = attribute2.valueTokens) != null ? _a2 : null);
     return hasBinding;
   }
   _visitTextWithInterpolation(value, sourceSpan, interpolatedTokens, i18n) {
@@ -16889,8 +18053,8 @@ var NonBindableVisitor = class {
   visitComment(comment) {
     return null;
   }
-  visitAttribute(attribute) {
-    return new TextAttribute(attribute.name, attribute.value, attribute.sourceSpan, attribute.keySpan, attribute.valueSpan, attribute.i18n);
+  visitAttribute(attribute2) {
+    return new TextAttribute(attribute2.name, attribute2.value, attribute2.sourceSpan, attribute2.keySpan, attribute2.valueSpan, attribute2.i18n);
   }
   visitText(text2) {
     return new Text(text2.value, text2.sourceSpan);
@@ -16901,6 +18065,22 @@ var NonBindableVisitor = class {
   visitExpansionCase(expansionCase) {
     return null;
   }
+  visitBlockGroup(group, context) {
+    const nodes = visitAll2(this, group.blocks);
+    if (group.endSourceSpan !== null) {
+      nodes.push(new Text(group.endSourceSpan.toString(), group.endSourceSpan));
+    }
+    return nodes;
+  }
+  visitBlock(block, context) {
+    return [
+      new Text(block.startSourceSpan.toString(), block.startSourceSpan),
+      ...visitAll2(this, block.children)
+    ];
+  }
+  visitBlockParameter(parameter, context) {
+    return null;
+  }
 };
 var NON_BINDABLE_VISITOR = new NonBindableVisitor();
 function normalizeAttributeName(attrName) {
@@ -17233,9 +18413,9 @@ var _I18nVisitor = class {
     const node = new TagPlaceholder(el.name, attrs, startPhName, closePhName, children, isVoid, el.sourceSpan, el.startSourceSpan, el.endSourceSpan);
     return context.visitNodeFn(el, node);
   }
-  visitAttribute(attribute, context) {
-    const node = attribute.valueTokens === void 0 || attribute.valueTokens.length === 1 ? new Text2(attribute.value, attribute.valueSpan || attribute.sourceSpan) : this._visitTextWithInterpolation(attribute.valueTokens, attribute.valueSpan || attribute.sourceSpan, context, attribute.i18n);
-    return context.visitNodeFn(attribute, node);
+  visitAttribute(attribute2, context) {
+    const node = attribute2.valueTokens === void 0 || attribute2.valueTokens.length === 1 ? new Text2(attribute2.value, attribute2.valueSpan || attribute2.sourceSpan) : this._visitTextWithInterpolation(attribute2.valueTokens, attribute2.valueSpan || attribute2.sourceSpan, context, attribute2.i18n);
+    return context.visitNodeFn(attribute2, node);
   }
   visitText(text2, context) {
     const node = text2.tokens.length === 1 ? new Text2(text2.value, text2.sourceSpan) : this._visitTextWithInterpolation(text2.tokens, text2.sourceSpan, context, text2.i18n);
@@ -17269,6 +18449,18 @@ var _I18nVisitor = class {
   visitExpansionCase(_icuCase, _context) {
     throw new Error("Unreachable code");
   }
+  visitBlockGroup(group, context) {
+    const children = visitAll2(this, group.blocks, context);
+    const node = new Container(children, group.sourceSpan);
+    return context.visitNodeFn(group, node);
+  }
+  visitBlock(block, context) {
+    const children = visitAll2(this, block.children, context);
+    const node = new Container(children, block.sourceSpan);
+    return context.visitNodeFn(block, node);
+  }
+  visitBlockParameter(_parameter, _context) {
+  }
   _visitTextWithInterpolation(tokens, sourceSpan, context, previousI18n) {
     const nodes = [];
     let hasInterpolation = false;
@@ -17436,8 +18628,8 @@ var I18nMetaVisitor = class {
   visitText(text2) {
     return text2;
   }
-  visitAttribute(attribute) {
-    return attribute;
+  visitAttribute(attribute2) {
+    return attribute2;
   }
   visitComment(comment) {
     return comment;
@@ -17445,6 +18637,17 @@ var I18nMetaVisitor = class {
   visitExpansionCase(expansionCase) {
     return expansionCase;
   }
+  visitBlockGroup(group, context) {
+    visitAll2(this, group.blocks, context);
+    return group;
+  }
+  visitBlock(block, context) {
+    visitAll2(this, block.children, context);
+    return block;
+  }
+  visitBlockParameter(parameter, context) {
+    return parameter;
+  }
   _parseMetadata(meta) {
     return typeof meta === "string" ? parseI18nMeta(meta) : meta instanceof Message ? meta : {};
   }
@@ -18233,6 +19436,16 @@ var TemplateDefinitionBuilder = class {
     }
     return null;
   }
+  visitDeferredBlock(deferred) {
+  }
+  visitDeferredTrigger(trigger) {
+  }
+  visitDeferredBlockPlaceholder(block) {
+  }
+  visitDeferredBlockError(block) {
+  }
+  visitDeferredBlockLoading(block) {
+  }
   allocateDataSlot() {
     return this._dataIndex++;
   }
@@ -18717,8 +19930,8 @@ function createCssSelector(elementName, attributes) {
   });
   return cssSelector;
 }
-function getNgProjectAsLiteral(attribute) {
-  const parsedR3Selector = parseSelectorToR3Selector(attribute.value)[0];
+function getNgProjectAsLiteral(attribute2) {
+  const parsedR3Selector = parseSelectorToR3Selector(attribute2.value)[0];
   return [literal(5), asLiteral(parsedR3Selector)];
 }
 function getPropertyInterpolationExpression(interpolation) {
@@ -18795,7 +20008,12 @@ function parseTemplate(template2, templateUrl, options = {}) {
   const { interpolationConfig, preserveWhitespaces, enableI18nLegacyMessageIdFormat } = options;
   const bindingParser = makeBindingParser(interpolationConfig);
   const htmlParser = new HtmlParser();
-  const parseResult = htmlParser.parse(template2, templateUrl, __spreadProps(__spreadValues({ leadingTriviaChars: LEADING_TRIVIA_CHARS }, options), { tokenizeExpansionForms: true }));
+  const parseResult = htmlParser.parse(template2, templateUrl, __spreadProps(__spreadValues({
+    leadingTriviaChars: LEADING_TRIVIA_CHARS
+  }, options), {
+    tokenizeExpansionForms: true,
+    tokenizeBlocks: options.enabledBlockTypes != null && options.enabledBlockTypes.size > 0
+  }));
   if (!options.alwaysAttemptHtmlToR3AstConversion && parseResult.errors && parseResult.errors.length > 0) {
     const parsedTemplate2 = {
       interpolationConfig,
@@ -18836,7 +20054,10 @@ function parseTemplate(template2, templateUrl, options = {}) {
       rootNodes = visitAll2(new I18nMetaVisitor(interpolationConfig, false), rootNodes);
     }
   }
-  const { nodes, errors, styleUrls, styles, ngContentSelectors, commentNodes } = htmlAstToRender3Ast(rootNodes, bindingParser, { collectCommentNodes: !!options.collectCommentNodes });
+  const { nodes, errors, styleUrls, styles, ngContentSelectors, commentNodes } = htmlAstToRender3Ast(rootNodes, bindingParser, {
+    collectCommentNodes: !!options.collectCommentNodes,
+    enabledBlockTypes: options.enabledBlockTypes || /* @__PURE__ */ new Set()
+  });
   errors.push(...parseResult.errors, ...i18nMetaResult.errors);
   const parsedTemplate = {
     interpolationConfig,
@@ -19570,6 +20791,7 @@ var CompilerFacadeImpl = class {
   }
   compileNgModule(angularCoreEnv, sourceMapUrl, facade) {
     const meta = {
+      kind: R3NgModuleMetadataKind.Global,
       type: wrapReference(facade.type),
       bootstrap: facade.bootstrap.map(wrapReference),
       declarations: facade.declarations.map(wrapReference),
@@ -19861,7 +21083,11 @@ function convertPipeDeclarationToMetadata(pipe2) {
 }
 function parseJitTemplate(template2, typeName, sourceMapUrl, preserveWhitespaces, interpolation) {
   const interpolationConfig = interpolation ? InterpolationConfig.fromArray(interpolation) : DEFAULT_INTERPOLATION_CONFIG;
-  const parsed = parseTemplate(template2, sourceMapUrl, { preserveWhitespaces, interpolationConfig });
+  const parsed = parseTemplate(template2, sourceMapUrl, {
+    preserveWhitespaces,
+    interpolationConfig,
+    enabledBlockTypes: /* @__PURE__ */ new Set()
+  });
   if (parsed.errors !== null) {
     const errors = parsed.errors.map((err) => err.toString()).join(", ");
     throw new Error(`Errors during JIT compilation of template for ${typeName}: ${errors}`);
@@ -19901,9 +21127,9 @@ function convertR3DeclareDependencyMetadata(facade) {
   const token = facade.token === null ? null : new WrappedNodeExpr(facade.token);
   return createR3DependencyMetadata(token, isAttributeDep, (_b2 = facade.host) != null ? _b2 : false, (_c2 = facade.optional) != null ? _c2 : false, (_d2 = facade.self) != null ? _d2 : false, (_e2 = facade.skipSelf) != null ? _e2 : false);
 }
-function createR3DependencyMetadata(token, isAttributeDep, host, optional, self2, skipSelf) {
+function createR3DependencyMetadata(token, isAttributeDep, host, optional, self, skipSelf) {
   const attributeNameType = isAttributeDep ? literal("unknown") : null;
-  return { token, attributeNameType, host, optional, self: self2, skipSelf };
+  return { token, attributeNameType, host, optional, self, skipSelf };
 }
 function extractHostBindings(propMetadata, sourceSpan, host) {
   const bindings = parseHostBindings(host || {});
@@ -20009,13 +21235,13 @@ function convertDeclareInjectorFacadeToMetadata(declaration) {
     imports: declaration.imports !== void 0 ? declaration.imports.map((i) => new WrappedNodeExpr(i)) : []
   };
 }
-function publishFacade(global2) {
-  const ng = global2.ng || (global2.ng = {});
+function publishFacade(global) {
+  const ng = global.ng || (global.ng = {});
   ng.\u0275compilerFacade = new CompilerFacadeImpl();
 }
 
 // bazel-out/k8-fastbuild/bin/packages/compiler/src/version.mjs
-var VERSION2 = new Version("16.2.0-next.1");
+var VERSION2 = new Version("16.2.0-next.3");
 
 // bazel-out/k8-fastbuild/bin/packages/compiler/src/i18n/extractor_merger.mjs
 var _I18N_ATTR = "i18n";
@@ -20184,9 +21410,17 @@ var _Visitor3 = class {
     }
     return null;
   }
-  visitAttribute(attribute, context) {
+  visitAttribute(attribute2, context) {
     throw new Error("unreachable code");
   }
+  visitBlockGroup(group, context) {
+    visitAll2(this, group.blocks, context);
+  }
+  visitBlock(block, context) {
+    visitAll2(this, block.children, context);
+  }
+  visitBlockParameter(parameter, context) {
+  }
   _init(mode, interpolationConfig) {
     this._mode = mode;
     this._inI18nBlock = false;
@@ -20351,8 +21585,8 @@ var XmlParser = class extends Parser2 {
   constructor() {
     super(getXmlTagDefinition);
   }
-  parse(source, url, options) {
-    return super.parse(source, url, options);
+  parse(source, url, options = {}) {
+    return super.parse(source, url, __spreadProps(__spreadValues({}, options), { tokenizeBlocks: false }));
   }
 };
 
@@ -20522,7 +21756,7 @@ var XliffParser = class {
         visitAll2(this, element2.children, null);
     }
   }
-  visitAttribute(attribute, context) {
+  visitAttribute(attribute2, context) {
   }
   visitText(text2, context) {
   }
@@ -20532,6 +21766,12 @@ var XliffParser = class {
   }
   visitExpansionCase(expansionCase, context) {
   }
+  visitBlockGroup(group, context) {
+  }
+  visitBlock(block, context) {
+  }
+  visitBlockParameter(parameter, context) {
+  }
   _addError(node, message) {
     this._errors.push(new I18nError(node.sourceSpan, message));
   }
@@ -20579,7 +21819,13 @@ var XmlToI18n = class {
   }
   visitComment(comment, context) {
   }
-  visitAttribute(attribute, context) {
+  visitAttribute(attribute2, context) {
+  }
+  visitBlockGroup(group, context) {
+  }
+  visitBlock(block, context) {
+  }
+  visitBlockParameter(parameter, context) {
   }
   _addError(node, message) {
     this._errors.push(new I18nError(node.sourceSpan, message));
@@ -20793,7 +22039,7 @@ var Xliff2Parser = class {
         visitAll2(this, element2.children, null);
     }
   }
-  visitAttribute(attribute, context) {
+  visitAttribute(attribute2, context) {
   }
   visitText(text2, context) {
   }
@@ -20803,6 +22049,12 @@ var Xliff2Parser = class {
   }
   visitExpansionCase(expansionCase, context) {
   }
+  visitBlockGroup(group, context) {
+  }
+  visitBlock(block, context) {
+  }
+  visitBlockParameter(parameter, context) {
+  }
   _addError(node, message) {
     this._errors.push(new I18nError(node.sourceSpan, message));
   }
@@ -20865,7 +22117,13 @@ var XmlToI18n2 = class {
   }
   visitComment(comment, context) {
   }
-  visitAttribute(attribute, context) {
+  visitAttribute(attribute2, context) {
+  }
+  visitBlockGroup(group, context) {
+  }
+  visitBlock(block, context) {
+  }
+  visitBlockParameter(parameter, context) {
   }
   _addError(node, message) {
     this._errors.push(new I18nError(node.sourceSpan, message));
@@ -21019,6 +22277,22 @@ var Scope = class {
   visitReference(reference2) {
     this.maybeDeclare(reference2);
   }
+  visitDeferredBlock(deferred) {
+    var _a2, _b2, _c2;
+    deferred.children.forEach((node) => node.visit(this));
+    (_a2 = deferred.placeholder) == null ? void 0 : _a2.visit(this);
+    (_b2 = deferred.loading) == null ? void 0 : _b2.visit(this);
+    (_c2 = deferred.error) == null ? void 0 : _c2.visit(this);
+  }
+  visitDeferredBlockPlaceholder(block) {
+    block.children.forEach((node) => node.visit(this));
+  }
+  visitDeferredBlockError(block) {
+    block.children.forEach((node) => node.visit(this));
+  }
+  visitDeferredBlockLoading(block) {
+    block.children.forEach((node) => node.visit(this));
+  }
   visitContent(content) {
   }
   visitBoundAttribute(attr) {
@@ -21033,6 +22307,8 @@ var Scope = class {
   }
   visitIcu(icu) {
   }
+  visitDeferredTrigger(trigger) {
+  }
   maybeDeclare(thing) {
     if (!this.namedEntities.has(thing.name)) {
       this.namedEntities.set(thing.name, thing);
@@ -21102,10 +22378,10 @@ var DirectiveBinder = class {
         this.references.set(ref, node);
       }
     });
-    const setAttributeBinding = (attribute, ioType) => {
-      const dir = directives.find((dir2) => dir2[ioType].hasBindingPropertyName(attribute.name));
+    const setAttributeBinding = (attribute2, ioType) => {
+      const dir = directives.find((dir2) => dir2[ioType].hasBindingPropertyName(attribute2.name));
       const binding = dir !== void 0 ? dir : node;
-      this.bindings.set(attribute, binding);
+      this.bindings.set(attribute2, binding);
     };
     node.inputs.forEach((input) => setAttributeBinding(input, "inputs"));
     node.attributes.forEach((attr) => setAttributeBinding(attr, "inputs"));
@@ -21115,17 +22391,33 @@ var DirectiveBinder = class {
     node.outputs.forEach((output) => setAttributeBinding(output, "outputs"));
     node.children.forEach((child) => child.visit(this));
   }
+  visitDeferredBlock(deferred) {
+    var _a2, _b2, _c2;
+    deferred.children.forEach((child) => child.visit(this));
+    (_a2 = deferred.placeholder) == null ? void 0 : _a2.visit(this);
+    (_b2 = deferred.loading) == null ? void 0 : _b2.visit(this);
+    (_c2 = deferred.error) == null ? void 0 : _c2.visit(this);
+  }
+  visitDeferredBlockPlaceholder(block) {
+    block.children.forEach((child) => child.visit(this));
+  }
+  visitDeferredBlockError(block) {
+    block.children.forEach((child) => child.visit(this));
+  }
+  visitDeferredBlockLoading(block) {
+    block.children.forEach((child) => child.visit(this));
+  }
   visitContent(content) {
   }
   visitVariable(variable2) {
   }
   visitReference(reference2) {
   }
-  visitTextAttribute(attribute) {
+  visitTextAttribute(attribute2) {
   }
-  visitBoundAttribute(attribute) {
+  visitBoundAttribute(attribute2) {
   }
-  visitBoundEvent(attribute) {
+  visitBoundEvent(attribute2) {
   }
   visitBoundAttributeOrEvent(node) {
   }
@@ -21135,6 +22427,8 @@ var DirectiveBinder = class {
   }
   visitIcu(icu) {
   }
+  visitDeferredTrigger(trigger) {
+  }
 };
 var TemplateBinder = class extends RecursiveAstVisitor2 {
   constructor(bindings, symbols, usedPipes, nestingLevel, scope, template2, level) {
@@ -21155,13 +22449,14 @@ var TemplateBinder = class extends RecursiveAstVisitor2 {
       node.visit(this);
     }
   }
-  static applyWithScope(template2, scope) {
+  static applyWithScope(nodes, scope) {
     const expressions = /* @__PURE__ */ new Map();
     const symbols = /* @__PURE__ */ new Map();
     const nestingLevel = /* @__PURE__ */ new Map();
     const usedPipes = /* @__PURE__ */ new Set();
-    const binder = new TemplateBinder(expressions, symbols, usedPipes, nestingLevel, scope, template2 instanceof Template ? template2 : null, 0);
-    binder.ingest(template2);
+    const template2 = nodes instanceof Template ? nodes : null;
+    const binder = new TemplateBinder(expressions, symbols, usedPipes, nestingLevel, scope, template2, 0);
+    binder.ingest(nodes);
     return { expressions, symbols, nestingLevel, usedPipes };
   }
   ingest(template2) {
@@ -21201,18 +22496,40 @@ var TemplateBinder = class extends RecursiveAstVisitor2 {
   }
   visitContent(content) {
   }
-  visitTextAttribute(attribute) {
+  visitTextAttribute(attribute2) {
   }
   visitIcu(icu) {
     Object.keys(icu.vars).forEach((key) => icu.vars[key].visit(this));
     Object.keys(icu.placeholders).forEach((key) => icu.placeholders[key].visit(this));
   }
-  visitBoundAttribute(attribute) {
-    attribute.value.visit(this);
+  visitBoundAttribute(attribute2) {
+    attribute2.value.visit(this);
   }
   visitBoundEvent(event) {
     event.handler.visit(this);
   }
+  visitDeferredBlock(deferred) {
+    deferred.triggers.forEach(this.visitNode);
+    deferred.prefetchTriggers.forEach(this.visitNode);
+    deferred.children.forEach(this.visitNode);
+    deferred.placeholder && this.visitNode(deferred.placeholder);
+    deferred.loading && this.visitNode(deferred.loading);
+    deferred.error && this.visitNode(deferred.error);
+  }
+  visitDeferredTrigger(trigger) {
+    if (trigger instanceof BoundDeferredTrigger) {
+      trigger.value.visit(this);
+    }
+  }
+  visitDeferredBlockPlaceholder(block) {
+    block.children.forEach(this.visitNode);
+  }
+  visitDeferredBlockError(block) {
+    block.children.forEach(this.visitNode);
+  }
+  visitDeferredBlockLoading(block) {
+    block.children.forEach(this.visitNode);
+  }
   visitBoundText(text2) {
     text2.value.visit(this);
   }
@@ -21334,7 +22651,7 @@ var MINIMUM_PARTIAL_LINKER_VERSION = "12.0.0";
 function compileDeclareClassMetadata(metadata) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION));
-  definitionMap.set("version", literal("16.2.0-next.1"));
+  definitionMap.set("version", literal("16.2.0-next.3"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", metadata.type);
   definitionMap.set("decorators", metadata.decorators);
@@ -21403,7 +22720,7 @@ function createDirectiveDefinitionMap(meta) {
   var _a2;
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION2));
-  definitionMap.set("version", literal("16.2.0-next.1"));
+  definitionMap.set("version", literal("16.2.0-next.3"));
   definitionMap.set("type", meta.type.value);
   if (meta.isStandalone) {
     definitionMap.set("isStandalone", literal(meta.isStandalone));
@@ -21588,7 +22905,7 @@ var MINIMUM_PARTIAL_LINKER_VERSION3 = "12.0.0";
 function compileDeclareFactoryFunction(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION3));
-  definitionMap.set("version", literal("16.2.0-next.1"));
+  definitionMap.set("version", literal("16.2.0-next.3"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   definitionMap.set("deps", compileDependencies(meta.deps));
@@ -21611,7 +22928,7 @@ function compileDeclareInjectableFromMetadata(meta) {
 function createInjectableDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION4));
-  definitionMap.set("version", literal("16.2.0-next.1"));
+  definitionMap.set("version", literal("16.2.0-next.3"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   if (meta.providedIn !== void 0) {
@@ -21649,7 +22966,7 @@ function compileDeclareInjectorFromMetadata(meta) {
 function createInjectorDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION5));
-  definitionMap.set("version", literal("16.2.0-next.1"));
+  definitionMap.set("version", literal("16.2.0-next.3"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   definitionMap.set("providers", meta.providers);
@@ -21669,8 +22986,11 @@ function compileDeclareNgModuleFromMetadata(meta) {
 }
 function createNgModuleDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
+  if (meta.kind === R3NgModuleMetadataKind.Local) {
+    throw new Error("Invalid path! Local compilation mode should not get into the partial compilation path");
+  }
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION6));
-  definitionMap.set("version", literal("16.2.0-next.1"));
+  definitionMap.set("version", literal("16.2.0-next.3"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   if (meta.bootstrap.length > 0) {
@@ -21705,7 +23025,7 @@ function compileDeclarePipeFromMetadata(meta) {
 function createPipeDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION7));
-  definitionMap.set("version", literal("16.2.0-next.1"));
+  definitionMap.set("version", literal("16.2.0-next.3"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   if (meta.isStandalone) {
@@ -21722,7 +23042,7 @@ function createPipeDefinitionMap(meta) {
 publishFacade(_global);
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/version.mjs
-var VERSION3 = new Version("16.2.0-next.1");
+var VERSION3 = new Version("16.2.0-next.3");
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/transformers/api.mjs
 var EmitFlags;
@@ -22902,7 +24222,7 @@ function getConstructorDependencies(clazz, reflector, isCore) {
   ctorParams.forEach((param, idx) => {
     let token = valueReferenceToExpression(param.typeValueReference);
     let attributeNameType = null;
-    let optional = false, self2 = false, skipSelf = false, host = false;
+    let optional = false, self = false, skipSelf = false, host = false;
     (param.decorators || []).filter((dec) => isCore || isAngularCore(dec)).forEach((dec) => {
       const name = isCore || dec.import === null ? dec.name : dec.import.name;
       if (name === "Inject") {
@@ -22915,7 +24235,7 @@ function getConstructorDependencies(clazz, reflector, isCore) {
       } else if (name === "SkipSelf") {
         skipSelf = true;
       } else if (name === "Self") {
-        self2 = true;
+        self = true;
       } else if (name === "Host") {
         host = true;
       } else if (name === "Attribute") {
@@ -22943,7 +24263,7 @@ function getConstructorDependencies(clazz, reflector, isCore) {
         reason: param.typeValueReference.reason
       });
     } else {
-      deps.push({ token, attributeNameType, optional, self: self2, skipSelf, host });
+      deps.push({ token, attributeNameType, optional, self, skipSelf, host });
     }
   });
   if (errors.length === 0) {
@@ -26795,7 +28115,7 @@ var TraitCompiler = class {
       return void 0;
     }
     const promises = [];
-    const priorWork = this.incrementalBuild.priorAnalysisFor(sf);
+    const priorWork = this.compilationMode !== CompilationMode.LOCAL ? this.incrementalBuild.priorAnalysisFor(sf) : null;
     if (priorWork !== null) {
       this.perf.eventCount(PerfEvent.SourceFileReuseAnalysis);
       if (priorWork.length > 0) {
@@ -26991,13 +28311,16 @@ var TraitCompiler = class {
       }
     }
     const symbol = this.makeSymbolForTrait(trait.handler, clazz, (_a2 = result.analysis) != null ? _a2 : null);
-    if (result.analysis !== void 0 && trait.handler.register !== void 0) {
+    if (this.compilationMode !== CompilationMode.LOCAL && result.analysis !== void 0 && trait.handler.register !== void 0) {
       trait.handler.register(clazz, result.analysis);
     }
     trait = trait.toAnalyzed((_b2 = result.analysis) != null ? _b2 : null, (_c2 = result.diagnostics) != null ? _c2 : null, symbol);
   }
   resolve() {
     var _a2, _b2;
+    if (this.compilationMode === CompilationMode.LOCAL) {
+      return;
+    }
     const classes = this.classes.keys();
     for (const clazz of classes) {
       const record = this.classes.get(clazz);
@@ -27062,6 +28385,9 @@ var TraitCompiler = class {
     }
   }
   extendedTemplateCheck(sf, extendedTemplateChecker) {
+    if (this.compilationMode === CompilationMode.LOCAL) {
+      return [];
+    }
     const classes = this.fileToClasses.get(sf);
     if (classes === void 0) {
       return [];
@@ -27112,7 +28438,7 @@ var TraitCompiler = class {
     }
   }
   updateResources(clazz) {
-    if (!this.reflector.isClass(clazz) || !this.classes.has(clazz)) {
+    if (this.compilationMode === CompilationMode.LOCAL || !this.reflector.isClass(clazz) || !this.classes.has(clazz)) {
       return;
     }
     const record = this.classes.get(clazz);
@@ -27131,14 +28457,21 @@ var TraitCompiler = class {
     const record = this.classes.get(original);
     let res = [];
     for (const trait of record.traits) {
-      if (trait.state !== TraitState.Resolved || containsErrors(trait.analysisDiagnostics) || containsErrors(trait.resolveDiagnostics)) {
-        continue;
-      }
       let compileRes;
-      if (this.compilationMode === CompilationMode.PARTIAL && trait.handler.compilePartial !== void 0) {
-        compileRes = trait.handler.compilePartial(clazz, trait.analysis, trait.resolution);
+      if (this.compilationMode === CompilationMode.LOCAL) {
+        if (trait.state !== TraitState.Analyzed || trait.analysis === null || containsErrors(trait.analysisDiagnostics)) {
+          continue;
+        }
+        compileRes = trait.handler.compileLocal(clazz, trait.analysis, constantPool);
       } else {
-        compileRes = trait.handler.compileFull(clazz, trait.analysis, trait.resolution, constantPool);
+        if (trait.state !== TraitState.Resolved || containsErrors(trait.analysisDiagnostics) || containsErrors(trait.resolveDiagnostics)) {
+          continue;
+        }
+        if (this.compilationMode === CompilationMode.PARTIAL && trait.handler.compilePartial !== void 0) {
+          compileRes = trait.handler.compilePartial(clazz, trait.analysis, trait.resolution);
+        } else {
+          compileRes = trait.handler.compileFull(clazz, trait.analysis, trait.resolution, constantPool);
+        }
       }
       const compileMatchRes = compileRes;
       if (Array.isArray(compileMatchRes)) {
@@ -27162,7 +28495,7 @@ var TraitCompiler = class {
     const record = this.classes.get(original);
     const decorators = [];
     for (const trait of record.traits) {
-      if (trait.state !== TraitState.Resolved) {
+      if (this.compilationMode !== CompilationMode.LOCAL && trait.state !== TraitState.Resolved) {
         continue;
       }
       if (trait.detected.trigger !== null && import_typescript37.default.isDecorator(trait.detected.trigger)) {
@@ -27400,6 +28733,9 @@ var ExpressionTranslatorVisitor = class {
     }
     return this.factory.createConditional(cond, ast.trueCase.visitExpression(this, context), ast.falseCase.visitExpression(this, context));
   }
+  visitDynamicImportExpr(ast, context) {
+    return this.factory.createDynamicImport(ast.url);
+  }
   visitNotExpr(ast, context) {
     return this.factory.createUnaryExpression("!", ast.condition.visitExpression(this, context));
   }
@@ -27591,6 +28927,9 @@ var TypeTranslatorVisitor = class {
   visitConditionalExpr(ast, context) {
     throw new Error("Method not implemented.");
   }
+  visitDynamicImportExpr(ast, context) {
+    throw new Error("Method not implemented.");
+  }
   visitNotExpr(ast, context) {
     throw new Error("Method not implemented.");
   }
@@ -27771,6 +29110,13 @@ var TypeScriptAstFactory = class {
   createConditional(condition, whenTrue, whenFalse) {
     return import_typescript41.default.factory.createConditionalExpression(condition, void 0, whenTrue, void 0, whenFalse);
   }
+  createDynamicImport(url) {
+    return import_typescript41.default.factory.createCallExpression(
+      import_typescript41.default.factory.createToken(import_typescript41.default.SyntaxKind.ImportKeyword),
+      void 0,
+      [import_typescript41.default.factory.createStringLiteral(url)]
+    );
+  }
   createFunctionDeclaration(functionName, parameters, body) {
     if (!import_typescript41.default.isBlock(body)) {
       throw new Error(`Invalid syntax, expected a block, but got ${import_typescript41.default.SyntaxKind[body.kind]}.`);
@@ -29140,6 +30486,13 @@ var DirectiveDecoratorHandler = class {
     const classMetadata = analysis.classMetadata !== null ? compileDeclareClassMetadata(analysis.classMetadata).toStmt() : null;
     return compileResults(fac, def, classMetadata, "\u0275dir", inputTransformFields);
   }
+  compileLocal(node, analysis, pool) {
+    const fac = compileNgFactoryDefField(toFactoryMetadata(analysis.meta, FactoryTarget.Directive));
+    const def = compileDirectiveFromMetadata(analysis.meta, pool, makeBindingParser());
+    const inputTransformFields = compileInputTransformFields(analysis.inputs);
+    const classMetadata = analysis.classMetadata !== null ? compileClassMetadata(analysis.classMetadata).toStmt() : null;
+    return compileResults(fac, def, classMetadata, "\u0275dir", inputTransformFields);
+  }
   findClassFieldWithAngularFeatures(node) {
     return this.reflector.getMembersOfClass(node).find((member) => {
       if (!member.isStatic && member.kind === ClassMemberKind.Method && LIFECYCLE_HOOKS.has(member.name)) {
@@ -29290,7 +30643,7 @@ var NgModuleSymbol = class extends SemanticSymbol {
   }
 };
 var NgModuleDecoratorHandler = class {
-  constructor(reflector, evaluator, metaReader, metaRegistry, scopeRegistry, referencesRegistry, exportedProviderStatusResolver, semanticDepGraphUpdater, isCore, refEmitter, annotateForClosureCompiler, onlyPublishPublicTypings, injectableRegistry, perf, includeClassMetadata) {
+  constructor(reflector, evaluator, metaReader, metaRegistry, scopeRegistry, referencesRegistry, exportedProviderStatusResolver, semanticDepGraphUpdater, isCore, refEmitter, annotateForClosureCompiler, onlyPublishPublicTypings, injectableRegistry, perf, includeClassMetadata, includeSelectorScope, compilationMode) {
     this.reflector = reflector;
     this.evaluator = evaluator;
     this.metaReader = metaReader;
@@ -29306,6 +30659,8 @@ var NgModuleDecoratorHandler = class {
     this.injectableRegistry = injectableRegistry;
     this.perf = perf;
     this.includeClassMetadata = includeClassMetadata;
+    this.includeSelectorScope = includeSelectorScope;
+    this.compilationMode = compilationMode;
     this.precedence = HandlerPrecedence.PRIMARY;
     this.name = "NgModuleDecoratorHandler";
   }
@@ -29325,7 +30680,7 @@ var NgModuleDecoratorHandler = class {
     }
   }
   analyze(node, decorator) {
-    var _a2;
+    var _a2, _b2, _c2, _d2, _e2;
     this.perf.eventCount(PerfEvent.AnalyzeNgModule);
     const name = node.name.text;
     if (decorator.args === null || decorator.args.length > 1) {
@@ -29345,9 +30700,8 @@ var NgModuleDecoratorHandler = class {
     ]);
     const diagnostics = [];
     let declarationRefs = [];
-    let rawDeclarations = null;
-    if (ngModule.has("declarations")) {
-      rawDeclarations = ngModule.get("declarations");
+    const rawDeclarations = (_a2 = ngModule.get("declarations")) != null ? _a2 : null;
+    if (this.compilationMode !== CompilationMode.LOCAL && rawDeclarations !== null) {
       const declarationMeta = this.evaluator.evaluate(rawDeclarations, forwardRefResolver);
       declarationRefs = this.resolveTypeList(rawDeclarations, declarationMeta, name, "declarations", 0).references;
       for (const ref of declarationRefs) {
@@ -29361,33 +30715,31 @@ var NgModuleDecoratorHandler = class {
       return { diagnostics };
     }
     let importRefs = [];
-    let rawImports = null;
-    if (ngModule.has("imports")) {
-      rawImports = ngModule.get("imports");
+    let rawImports = (_b2 = ngModule.get("imports")) != null ? _b2 : null;
+    if (this.compilationMode !== CompilationMode.LOCAL && rawImports !== null) {
       const importsMeta = this.evaluator.evaluate(rawImports, moduleResolvers);
       importRefs = this.resolveTypeList(rawImports, importsMeta, name, "imports", 0).references;
     }
     let exportRefs = [];
-    let rawExports = null;
-    if (ngModule.has("exports")) {
-      rawExports = ngModule.get("exports");
+    const rawExports = (_c2 = ngModule.get("exports")) != null ? _c2 : null;
+    if (this.compilationMode !== CompilationMode.LOCAL && rawExports !== null) {
       const exportsMeta = this.evaluator.evaluate(rawExports, moduleResolvers);
       exportRefs = this.resolveTypeList(rawExports, exportsMeta, name, "exports", 0).references;
       this.referencesRegistry.add(node, ...exportRefs);
     }
     let bootstrapRefs = [];
-    if (ngModule.has("bootstrap")) {
-      const expr = ngModule.get("bootstrap");
-      const bootstrapMeta = this.evaluator.evaluate(expr, forwardRefResolver);
-      bootstrapRefs = this.resolveTypeList(expr, bootstrapMeta, name, "bootstrap", 0).references;
+    const rawBootstrap = (_d2 = ngModule.get("bootstrap")) != null ? _d2 : null;
+    if (this.compilationMode !== CompilationMode.LOCAL && rawBootstrap !== null) {
+      const bootstrapMeta = this.evaluator.evaluate(rawBootstrap, forwardRefResolver);
+      bootstrapRefs = this.resolveTypeList(rawBootstrap, bootstrapMeta, name, "bootstrap", 0).references;
       for (const ref of bootstrapRefs) {
         const dirMeta = this.metaReader.getDirectiveMetadata(ref);
         if (dirMeta == null ? void 0 : dirMeta.isStandalone) {
-          diagnostics.push(makeStandaloneBootstrapDiagnostic(node, ref, expr));
+          diagnostics.push(makeStandaloneBootstrapDiagnostic(node, ref, rawBootstrap));
         }
       }
     }
-    const schemas = ngModule.has("schemas") ? extractSchemas(ngModule.get("schemas"), this.evaluator, "NgModule") : [];
+    const schemas = this.compilationMode !== CompilationMode.LOCAL && ngModule.has("schemas") ? extractSchemas(ngModule.get("schemas"), this.evaluator, "NgModule") : [];
     let id = null;
     if (ngModule.has("id")) {
       const idExpr = ngModule.get("id");
@@ -29416,26 +30768,42 @@ var NgModuleDecoratorHandler = class {
     const isForwardReference = (ref) => isExpressionForwardReference(ref.value, node.name, valueContext);
     const containsForwardDecls = bootstrap.some(isForwardReference) || declarations.some(isForwardReference) || imports.some(isForwardReference) || exports.some(isForwardReference);
     const type = wrapTypeReference(this.reflector, node);
-    const ngModuleMetadata = {
-      type,
-      bootstrap,
-      declarations,
-      publicDeclarationTypes: this.onlyPublishPublicTypings ? exportedDeclarations : null,
-      exports,
-      imports,
-      includeImportTypes: !this.onlyPublishPublicTypings,
-      containsForwardDecls,
-      id,
-      selectorScopeMode: R3SelectorScopeMode.SideEffect,
-      schemas: []
-    };
+    let ngModuleMetadata;
+    if (this.compilationMode === CompilationMode.LOCAL) {
+      ngModuleMetadata = {
+        kind: R3NgModuleMetadataKind.Local,
+        type,
+        bootstrapExpression: rawBootstrap ? new WrappedNodeExpr(rawBootstrap) : null,
+        declarationsExpression: rawDeclarations ? new WrappedNodeExpr(rawDeclarations) : null,
+        exportsExpression: rawExports ? new WrappedNodeExpr(rawExports) : null,
+        importsExpression: rawImports ? new WrappedNodeExpr(rawImports) : null,
+        id,
+        selectorScopeMode: R3SelectorScopeMode.SideEffect,
+        schemas: []
+      };
+    } else {
+      ngModuleMetadata = {
+        kind: R3NgModuleMetadataKind.Global,
+        type,
+        bootstrap,
+        declarations,
+        publicDeclarationTypes: this.onlyPublishPublicTypings ? exportedDeclarations : null,
+        exports,
+        imports,
+        includeImportTypes: !this.onlyPublishPublicTypings,
+        containsForwardDecls,
+        id,
+        selectorScopeMode: this.includeSelectorScope ? R3SelectorScopeMode.SideEffect : R3SelectorScopeMode.Omit,
+        schemas: []
+      };
+    }
     const rawProviders = ngModule.has("providers") ? ngModule.get("providers") : null;
     let wrappedProviders = null;
     if (rawProviders !== null && (!import_typescript48.default.isArrayLiteralExpression(rawProviders) || rawProviders.elements.length > 0)) {
       wrappedProviders = new WrappedNodeExpr(this.annotateForClosureCompiler ? wrapFunctionExpressionsInParens(rawProviders) : rawProviders);
     }
     const topLevelImports = [];
-    if (ngModule.has("imports")) {
+    if (this.compilationMode !== CompilationMode.LOCAL && ngModule.has("imports")) {
       const rawImports2 = unwrapExpression(ngModule.get("imports"));
       let topLevelExpressions = [];
       if (import_typescript48.default.isArrayLiteralExpression(rawImports2)) {
@@ -29494,7 +30862,7 @@ var NgModuleDecoratorHandler = class {
         classMetadata: this.includeClassMetadata ? extractClassMetadata(node, this.reflector, this.isCore, this.annotateForClosureCompiler) : null,
         factorySymbolName: node.name.text,
         remoteScopesMayRequireCycleProtection,
-        decorator: (_a2 = decorator == null ? void 0 : decorator.node) != null ? _a2 : null
+        decorator: (_e2 = decorator == null ? void 0 : decorator.node) != null ? _e2 : null
       }
     };
   }
@@ -29633,6 +31001,18 @@ var NgModuleDecoratorHandler = class {
     this.insertMetadataStatement(ngModuleDef.statements, metadata);
     return this.compileNgModule(factoryFn, injectorDef, ngModuleDef);
   }
+  compileLocal(node, { inj, mod, fac, classMetadata, declarations, remoteScopesMayRequireCycleProtection }) {
+    const factoryFn = compileNgFactoryDefField(fac);
+    const ngInjectorDef = compileInjector(__spreadProps(__spreadValues({}, inj), {
+      imports: []
+    }));
+    const ngModuleDef = compileNgModule(mod);
+    const statements = ngModuleDef.statements;
+    const metadata = classMetadata !== null ? compileClassMetadata(classMetadata) : null;
+    this.insertMetadataStatement(statements, metadata);
+    this.appendRemoteScopingStatements(statements, node, declarations, remoteScopesMayRequireCycleProtection);
+    return this.compileNgModule(factoryFn, ngInjectorDef, ngModuleDef);
+  }
   insertMetadataStatement(ngModuleStatements, metadata) {
     if (metadata !== null) {
       ngModuleStatements.unshift(metadata.toStmt());
@@ -29846,7 +31226,8 @@ function parseExtractedTemplate(template2, sourceStr, sourceParseRange, escapedS
     escapedString,
     enableI18nLegacyMessageIdFormat: options.enableI18nLegacyMessageIdFormat,
     i18nNormalizeLineEndingsInICUs,
-    alwaysAttemptHtmlToR3AstConversion: options.usePoisonedData
+    alwaysAttemptHtmlToR3AstConversion: options.usePoisonedData,
+    enabledBlockTypes: options.enabledBlockTypes
   });
   const { nodes: diagNodes } = parseTemplate(sourceStr, sourceMapUrl != null ? sourceMapUrl : "", {
     preserveWhitespaces: true,
@@ -30193,7 +31574,7 @@ function isLikelyModuleWithProviders(value) {
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/annotations/component/src/handler.mjs
 var EMPTY_ARRAY2 = [];
 var ComponentDecoratorHandler = class {
-  constructor(reflector, evaluator, metaRegistry, metaReader, scopeReader, dtsScopeReader, scopeRegistry, typeCheckScopeRegistry, resourceRegistry, isCore, strictCtorDeps, resourceLoader, rootDirs, defaultPreserveWhitespaces, i18nUseExternalIds, enableI18nLegacyMessageIdFormat, usePoisonedData, i18nNormalizeLineEndingsInICUs, moduleResolver, cycleAnalyzer, cycleHandlingStrategy, refEmitter, referencesRegistry, depTracker, injectableRegistry, semanticDepGraphUpdater, annotateForClosureCompiler, perf, hostDirectivesResolver, includeClassMetadata) {
+  constructor(reflector, evaluator, metaRegistry, metaReader, scopeReader, dtsScopeReader, scopeRegistry, typeCheckScopeRegistry, resourceRegistry, isCore, strictCtorDeps, resourceLoader, rootDirs, defaultPreserveWhitespaces, i18nUseExternalIds, enableI18nLegacyMessageIdFormat, usePoisonedData, i18nNormalizeLineEndingsInICUs, enabledBlockTypes, moduleResolver, cycleAnalyzer, cycleHandlingStrategy, refEmitter, referencesRegistry, depTracker, injectableRegistry, semanticDepGraphUpdater, annotateForClosureCompiler, perf, hostDirectivesResolver, includeClassMetadata, compilationMode) {
     this.reflector = reflector;
     this.evaluator = evaluator;
     this.metaRegistry = metaRegistry;
@@ -30212,6 +31593,7 @@ var ComponentDecoratorHandler = class {
     this.enableI18nLegacyMessageIdFormat = enableI18nLegacyMessageIdFormat;
     this.usePoisonedData = usePoisonedData;
     this.i18nNormalizeLineEndingsInICUs = i18nNormalizeLineEndingsInICUs;
+    this.enabledBlockTypes = enabledBlockTypes;
     this.moduleResolver = moduleResolver;
     this.cycleAnalyzer = cycleAnalyzer;
     this.cycleHandlingStrategy = cycleHandlingStrategy;
@@ -30224,6 +31606,7 @@ var ComponentDecoratorHandler = class {
     this.perf = perf;
     this.hostDirectivesResolver = hostDirectivesResolver;
     this.includeClassMetadata = includeClassMetadata;
+    this.compilationMode = compilationMode;
     this.literalCache = /* @__PURE__ */ new Map();
     this.elementSchemaRegistry = new DomElementSchemaRegistry();
     this.preanalyzeTemplateCache = /* @__PURE__ */ new Map();
@@ -30233,7 +31616,8 @@ var ComponentDecoratorHandler = class {
     this.extractTemplateOptions = {
       enableI18nLegacyMessageIdFormat: this.enableI18nLegacyMessageIdFormat,
       i18nNormalizeLineEndingsInICUs: this.i18nNormalizeLineEndingsInICUs,
-      usePoisonedData: this.usePoisonedData
+      usePoisonedData: this.usePoisonedData,
+      enabledBlockTypes: this.enabledBlockTypes
     };
   }
   detect(node, decorators) {
@@ -30293,7 +31677,7 @@ var ComponentDecoratorHandler = class {
     ]).then(() => void 0);
   }
   analyze(node, decorator) {
-    var _a2, _b2, _c2;
+    var _a2, _b2, _c2, _d2;
     this.perf.eventCount(PerfEvent.AnalyzeComponent);
     const containingFile = node.getSourceFile().fileName;
     this.literalCache.delete(decorator);
@@ -30335,15 +31719,15 @@ var ComponentDecoratorHandler = class {
       providersRequiringFactory = resolveProvidersRequiringFactory(component.get("providers"), this.reflector, this.evaluator);
     }
     let resolvedImports = null;
-    let rawImports = null;
-    if (component.has("imports") && !metadata.isStandalone) {
+    let rawImports = (_b2 = component.get("imports")) != null ? _b2 : null;
+    if (rawImports && !metadata.isStandalone) {
       if (diagnostics === void 0) {
         diagnostics = [];
       }
       diagnostics.push(makeDiagnostic(ErrorCode.COMPONENT_NOT_STANDALONE, component.get("imports"), `'imports' is only valid on a component that is standalone.`, [makeRelatedInformation(node.name, `Did you forget to add 'standalone: true' to this @Component?`)]));
       isPoisoned = true;
-    } else if (component.has("imports")) {
-      const expr = component.get("imports");
+    } else if (this.compilationMode !== CompilationMode.LOCAL && rawImports) {
+      const expr = rawImports;
       const importResolvers = combineResolvers([
         createModuleWithProvidersResolver(this.reflector, this.isCore),
         forwardRefResolver
@@ -30366,7 +31750,7 @@ var ComponentDecoratorHandler = class {
         diagnostics = [];
       }
       diagnostics.push(makeDiagnostic(ErrorCode.COMPONENT_NOT_STANDALONE, component.get("schemas"), `'schemas' is only valid on a component that is standalone.`));
-    } else if (component.has("schemas")) {
+    } else if (this.compilationMode !== CompilationMode.LOCAL && component.has("schemas")) {
       schemas = extractSchemas(component.get("schemas"), this.evaluator, "Component");
     } else if (metadata.isStandalone) {
       schemas = [];
@@ -30381,7 +31765,8 @@ var ComponentDecoratorHandler = class {
       template2 = extractTemplate(node, templateDecl, this.evaluator, this.depTracker, this.resourceLoader, {
         enableI18nLegacyMessageIdFormat: this.enableI18nLegacyMessageIdFormat,
         i18nNormalizeLineEndingsInICUs: this.i18nNormalizeLineEndingsInICUs,
-        usePoisonedData: this.usePoisonedData
+        usePoisonedData: this.usePoisonedData,
+        enabledBlockTypes: this.enabledBlockTypes
       });
     }
     const templateResource = template2.declaration.isInline ? { path: null, expression: component.get("template") } : {
@@ -30457,7 +31842,7 @@ var ComponentDecoratorHandler = class {
             ngContentSelectors: template2.ngContentSelectors
           },
           encapsulation,
-          interpolation: (_b2 = template2.interpolationConfig) != null ? _b2 : DEFAULT_INTERPOLATION_CONFIG,
+          interpolation: (_c2 = template2.interpolationConfig) != null ? _c2 : DEFAULT_INTERPOLATION_CONFIG,
           styles,
           animations,
           viewProviders: wrappedViewProviders,
@@ -30480,7 +31865,7 @@ var ComponentDecoratorHandler = class {
         rawImports,
         resolvedImports,
         schemas,
-        decorator: (_c2 = decorator == null ? void 0 : decorator.node) != null ? _c2 : null
+        decorator: (_d2 = decorator == null ? void 0 : decorator.node) != null ? _d2 : null
       },
       diagnostics
     };
@@ -30801,6 +32186,20 @@ var ComponentDecoratorHandler = class {
     const classMetadata = analysis.classMetadata !== null ? compileDeclareClassMetadata(analysis.classMetadata).toStmt() : null;
     return compileResults(fac, def, classMetadata, "\u0275cmp", inputTransformFields);
   }
+  compileLocal(node, analysis, pool) {
+    if (analysis.template.errors !== null && analysis.template.errors.length > 0) {
+      return [];
+    }
+    const meta = __spreadProps(__spreadValues({}, analysis.meta), {
+      declarationListEmitMode: 0,
+      declarations: []
+    });
+    const fac = compileNgFactoryDefField(toFactoryMetadata(meta, FactoryTarget.Component));
+    const def = compileComponentFromMetadata(meta, pool, makeBindingParser());
+    const inputTransformFields = compileInputTransformFields(analysis.inputs);
+    const classMetadata = analysis.classMetadata !== null ? compileClassMetadata(analysis.classMetadata).toStmt() : null;
+    return compileResults(fac, def, classMetadata, "\u0275cmp", inputTransformFields);
+  }
   _checkForCyclicImport(importedFile, expr, origin) {
     const imported = resolveImportedFile(this.moduleResolver, importedFile, expr, origin);
     if (imported === null) {
@@ -30910,6 +32309,9 @@ var InjectableDecoratorHandler = class {
   compilePartial(node, analysis) {
     return this.compile(compileDeclareFactory, compileDeclareInjectableFromMetadata, compileDeclareClassMetadata, node, analysis);
   }
+  compileLocal(node, analysis) {
+    return this.compile(compileNgFactoryDefField, (meta) => compileInjectable(meta, false), compileClassMetadata, node, analysis);
+  }
   compile(compileFactoryFn, compileInjectableFn, compileClassMetadataFn, node, analysis) {
     const results = [];
     if (analysis.needsFactory) {
@@ -31199,6 +32601,12 @@ var PipeDecoratorHandler = class {
     const classMetadata = analysis.classMetadata !== null ? compileDeclareClassMetadata(analysis.classMetadata).toStmt() : null;
     return compileResults(fac, def, classMetadata, "\u0275pipe", null);
   }
+  compileLocal(node, analysis) {
+    const fac = compileNgFactoryDefField(toFactoryMetadata(analysis.meta, FactoryTarget.Pipe));
+    const def = compilePipeFromMetadata(analysis.meta);
+    const classMetadata = analysis.classMetadata !== null ? compileClassMetadata(analysis.classMetadata).toStmt() : null;
+    return compileResults(fac, def, classMetadata, "\u0275pipe", null);
+  }
 };
 
 // bazel-out/k8-fastbuild/bin/packages/compiler-cli/src/ngtsc/cycles/src/analyzer.mjs
@@ -32275,16 +33683,16 @@ var TemplateVisitor = class extends RecursiveVisitor {
     this.visitAll(template2.children);
     this.visitAll(template2.references);
   }
-  visitBoundAttribute(attribute) {
-    if (attribute.valueSpan === void 0) {
+  visitBoundAttribute(attribute2) {
+    if (attribute2.valueSpan === void 0) {
       return;
     }
-    const { identifiers, errors } = ExpressionVisitor.getIdentifiers(attribute.value, attribute.valueSpan.toString(), attribute.valueSpan.start.offset, this.boundTemplate, this.targetToIdentifier.bind(this));
+    const { identifiers, errors } = ExpressionVisitor.getIdentifiers(attribute2.value, attribute2.valueSpan.toString(), attribute2.valueSpan.start.offset, this.boundTemplate, this.targetToIdentifier.bind(this));
     identifiers.forEach((id) => this.identifiers.add(id));
     this.errors.push(...errors);
   }
-  visitBoundEvent(attribute) {
-    this.visitExpression(attribute.handler);
+  visitBoundEvent(attribute2) {
+    this.visitExpression(attribute2.handler);
   }
   visitBoundText(text2) {
     this.visitExpression(text2.value);
@@ -32303,6 +33711,22 @@ var TemplateVisitor = class extends RecursiveVisitor {
     }
     this.identifiers.add(variableIdentifier);
   }
+  visitDeferredBlock(deferred) {
+    var _a2, _b2, _c2;
+    this.visitAll(deferred.children);
+    (_a2 = deferred.placeholder) == null ? void 0 : _a2.visit(this);
+    (_b2 = deferred.loading) == null ? void 0 : _b2.visit(this);
+    (_c2 = deferred.error) == null ? void 0 : _c2.visit(this);
+  }
+  visitDeferredBlockPlaceholder(block) {
+    this.visitAll(block.children);
+  }
+  visitDeferredBlockError(block) {
+    this.visitAll(block.children);
+  }
+  visitDeferredBlockLoading(block) {
+    this.visitAll(block.children);
+  }
   elementOrTemplateToIdentifier(node) {
     var _a2;
     if (this.elementAndTemplateIdentifierCache.has(node)) {
@@ -36778,9 +38202,9 @@ var TemplateTypeCheckerImpl = class {
   }
   getPotentialDomBindings(tagName) {
     const attributes = REGISTRY2.allKnownAttributesOfElement(tagName);
-    return attributes.map((attribute) => ({
-      attribute,
-      property: REGISTRY2.getMappedPropName(attribute)
+    return attributes.map((attribute2) => ({
+      attribute: attribute2,
+      property: REGISTRY2.getMappedPropName(attribute2)
     }));
   }
   getPotentialDomEvents(tagName) {
@@ -37081,13 +38505,13 @@ var TemplateVisitor2 = class extends RecursiveAstVisitor2 {
   }
   visitReference(reference2) {
   }
-  visitTextAttribute(attribute) {
+  visitTextAttribute(attribute2) {
   }
-  visitBoundAttribute(attribute) {
-    this.visitAst(attribute.value);
+  visitBoundAttribute(attribute2) {
+    this.visitAst(attribute2.value);
   }
-  visitBoundEvent(attribute) {
-    this.visitAst(attribute.handler);
+  visitBoundEvent(attribute2) {
+    this.visitAst(attribute2.handler);
   }
   visitText(text2) {
   }
@@ -37096,6 +38520,28 @@ var TemplateVisitor2 = class extends RecursiveAstVisitor2 {
   }
   visitIcu(icu) {
   }
+  visitDeferredBlock(deferred) {
+    this.visitAllNodes(deferred.children);
+    this.visitAllNodes(deferred.triggers);
+    this.visitAllNodes(deferred.prefetchTriggers);
+    deferred.placeholder && this.visit(deferred.placeholder);
+    deferred.loading && this.visit(deferred.loading);
+    deferred.error && this.visit(deferred.error);
+  }
+  visitDeferredTrigger(trigger) {
+    if (trigger instanceof BoundDeferredTrigger) {
+      this.visitAst(trigger.value);
+    }
+  }
+  visitDeferredBlockPlaceholder(block) {
+    this.visitAllNodes(block.children);
+  }
+  visitDeferredBlockError(block) {
+    this.visitAllNodes(block.children);
+  }
+  visitDeferredBlockLoading(block) {
+    this.visitAllNodes(block.children);
+  }
   getDiagnostics(template2) {
     this.diagnostics = [];
     this.visitAllNodes(template2);
@@ -37483,7 +38929,7 @@ var NgCompiler = class {
     }
   }
   constructor(adapter, options, inputProgram, programDriver, incrementalStrategy, incrementalCompilation, enableTemplateTypeChecker, usePoisonedData, livePerfRecorder) {
-    var _a2;
+    var _a2, _b2;
     this.adapter = adapter;
     this.options = options;
     this.inputProgram = inputProgram;
@@ -37497,6 +38943,7 @@ var NgCompiler = class {
     this.nonTemplateDiagnostics = null;
     this.delegatingPerfRecorder = new DelegatingPerfRecorder(this.perfRecorder);
     this.enableTemplateTypeChecker = enableTemplateTypeChecker || ((_a2 = options._enableTemplateTypeChecker) != null ? _a2 : false);
+    this.enabledBlockTypes = new Set((_b2 = options._enabledBlockTypes) != null ? _b2 : []);
     this.constructionDiagnostics.push(...this.adapter.constructionDiagnostics, ...verifyCompatibleTypeCheckOptions(this.options));
     this.currentProgram = inputProgram;
     this.closureCompilerEnabled = !!this.options.annotateForClosureCompiler;
@@ -37884,7 +39331,7 @@ var NgCompiler = class {
     return diagnostics;
   }
   makeCompilation() {
-    var _a2, _b2;
+    var _a2, _b2, _c2;
     const checker = this.inputProgram.getTypeChecker();
     const reflector = new TypeScriptReflectionHost(checker);
     let refEmitter;
@@ -37955,16 +39402,20 @@ var NgCompiler = class {
     }
     const cycleHandlingStrategy = compilationMode === CompilationMode.FULL ? 0 : 1;
     const strictCtorDeps = this.options.strictInjectionParameters || false;
-    const supportTestBed = (_a2 = this.options.supportTestBed) != null ? _a2 : true;
+    const supportJitMode = (_a2 = this.options.supportJitMode) != null ? _a2 : true;
+    const supportTestBed = (_b2 = this.options.supportTestBed) != null ? _b2 : true;
     if (supportTestBed === false && compilationMode === CompilationMode.PARTIAL) {
       throw new Error('TestBed support ("supportTestBed" option) cannot be disabled in partial compilation mode.');
     }
+    if (supportJitMode === false && compilationMode === CompilationMode.PARTIAL) {
+      throw new Error('JIT mode support ("supportJitMode" option) cannot be disabled in partial compilation mode.');
+    }
     const handlers = [
-      new ComponentDecoratorHandler(reflector, evaluator, metaRegistry, metaReader, scopeReader, depScopeReader, ngModuleScopeRegistry, typeCheckScopeRegistry, resourceRegistry, isCore, strictCtorDeps, this.resourceManager, this.adapter.rootDirs, this.options.preserveWhitespaces || false, this.options.i18nUseExternalIds !== false, this.options.enableI18nLegacyMessageIdFormat !== false, this.usePoisonedData, this.options.i18nNormalizeLineEndingsInICUs === true, this.moduleResolver, this.cycleAnalyzer, cycleHandlingStrategy, refEmitter, referencesRegistry, this.incrementalCompilation.depGraph, injectableRegistry, semanticDepGraphUpdater, this.closureCompilerEnabled, this.delegatingPerfRecorder, hostDirectivesResolver, supportTestBed),
+      new ComponentDecoratorHandler(reflector, evaluator, metaRegistry, metaReader, scopeReader, depScopeReader, ngModuleScopeRegistry, typeCheckScopeRegistry, resourceRegistry, isCore, strictCtorDeps, this.resourceManager, this.adapter.rootDirs, this.options.preserveWhitespaces || false, this.options.i18nUseExternalIds !== false, this.options.enableI18nLegacyMessageIdFormat !== false, this.usePoisonedData, this.options.i18nNormalizeLineEndingsInICUs === true, this.enabledBlockTypes, this.moduleResolver, this.cycleAnalyzer, cycleHandlingStrategy, refEmitter, referencesRegistry, this.incrementalCompilation.depGraph, injectableRegistry, semanticDepGraphUpdater, this.closureCompilerEnabled, this.delegatingPerfRecorder, hostDirectivesResolver, supportTestBed, compilationMode),
       new DirectiveDecoratorHandler(reflector, evaluator, metaRegistry, ngModuleScopeRegistry, metaReader, injectableRegistry, refEmitter, referencesRegistry, isCore, strictCtorDeps, semanticDepGraphUpdater, this.closureCompilerEnabled, this.delegatingPerfRecorder, supportTestBed),
       new PipeDecoratorHandler(reflector, evaluator, metaRegistry, ngModuleScopeRegistry, injectableRegistry, isCore, this.delegatingPerfRecorder, supportTestBed),
       new InjectableDecoratorHandler(reflector, evaluator, isCore, strictCtorDeps, injectableRegistry, this.delegatingPerfRecorder, supportTestBed),
-      new NgModuleDecoratorHandler(reflector, evaluator, metaReader, metaRegistry, ngModuleScopeRegistry, referencesRegistry, exportedProviderStatusResolver, semanticDepGraphUpdater, isCore, refEmitter, this.closureCompilerEnabled, (_b2 = this.options.onlyPublishPublicTypingsForNgModules) != null ? _b2 : false, injectableRegistry, this.delegatingPerfRecorder, supportTestBed)
+      new NgModuleDecoratorHandler(reflector, evaluator, metaReader, metaRegistry, ngModuleScopeRegistry, referencesRegistry, exportedProviderStatusResolver, semanticDepGraphUpdater, isCore, refEmitter, this.closureCompilerEnabled, (_c2 = this.options.onlyPublishPublicTypingsForNgModules) != null ? _c2 : false, injectableRegistry, this.delegatingPerfRecorder, supportTestBed, supportJitMode, compilationMode)
     ];
     const traitCompiler = new TraitCompiler(handlers, reflector, this.delegatingPerfRecorder, this.incrementalCompilation, this.options.compileNonExportedClasses !== false, compilationMode, dtsTransforms, semanticDepGraphUpdater, this.adapter);
     const notifyingDriver = new NotifyingProgramDriverWrapper(this.programDriver, (program) => {