@angular/compiler 16.2.0-next.0 → 16.2.0-next.2

package/fesm2022/compiler.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v16.2.0-next.0
+ * @license Angular v16.2.0-next.2
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -1339,6 +1339,10 @@ class InvokeFunctionExpr extends Expression {
         this.args = args;
         this.pure = pure;
     }
+    // An alias for fn, which allows other logic to handle calls and property reads together.
+    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;
@@ -1721,6 +1725,10 @@ class ReadPropExpr extends Expression {
         this.receiver = receiver;
         this.name = name;
     }
+    // An alias for name, which allows other logic to handle property reads and keyed reads together.
+    get index() {
+        return this.name;
+    }
     isEquivalent(e) {
         return e instanceof ReadPropExpr && this.receiver.isEquivalent(e.receiver) &&
             this.name === e.name;
@@ -5717,31 +5725,49 @@ var R3SelectorScopeMode;
      */
     R3SelectorScopeMode[R3SelectorScopeMode["Omit"] = 2] = "Omit";
 })(R3SelectorScopeMode || (R3SelectorScopeMode = {}));
+/**
+ * The type of the NgModule meta data.
+ * - Global: Used for full and partial compilation modes which mainly includes R3References.
+ * - Local: Used for the local compilation mode which mainly includes the raw expressions as appears
+ * in the NgModule decorator.
+ */
+var R3NgModuleMetadataKind;
+(function (R3NgModuleMetadataKind) {
+    R3NgModuleMetadataKind[R3NgModuleMetadataKind["Global"] = 0] = "Global";
+    R3NgModuleMetadataKind[R3NgModuleMetadataKind["Local"] = 1] = "Local";
+})(R3NgModuleMetadataKind || (R3NgModuleMetadataKind = {}));
 /**
  * Construct an `R3NgModuleDef` for the given `R3NgModuleMetadata`.
  */
 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);
+    // Assign bootstrap definition
+    if (meta.kind === R3NgModuleMetadataKind.Global) {
+        if (meta.bootstrap.length > 0) {
+            definitionMap.set('bootstrap', refsToArray(meta.bootstrap, meta.containsForwardDecls));
+        }
     }
-    if (selectorScopeMode === R3SelectorScopeMode.Inline) {
+    else {
+        if (meta.bootstrapExpression) {
+            definitionMap.set('bootstrap', meta.bootstrapExpression);
+        }
+    }
+    if (meta.selectorScopeMode === R3SelectorScopeMode.Inline) {
         // If requested to emit scope information inline, pass the `declarations`, `imports` and
         // `exports` to the `ɵɵdefineNgModule()` call directly.
-        if (declarations.length > 0) {
-            definitionMap.set('declarations', refsToArray(declarations, containsForwardDecls));
+        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) {
         // In this mode, scope information is not passed into `ɵɵdefineNgModule` as it
         // would prevent tree-shaking of the declarations, imports and exports references. Instead, it's
         // patched onto the NgModule definition with a `ɵɵsetNgModuleScope` call that's guarded by the
@@ -5754,14 +5780,14 @@ function compileNgModule(meta) {
     else {
         // Selector scope emit was not requested, so skip it.
     }
-    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);
+    if (meta.id !== null) {
+        definitionMap.set('id', meta.id);
         // Generate a side-effectful call to register this NgModule by its id, as per the semantics of
         // NgModule ids.
-        statements.push(importExpr(Identifiers.registerNgModuleType).callFn([moduleType.value, id]).toStmt());
+        statements.push(importExpr(Identifiers.registerNgModuleType).callFn([meta.type.value, meta.id]).toStmt());
     }
     const expression = importExpr(Identifiers.defineNgModule).callFn([definitionMap.toLiteralMap()], undefined, true);
     const type = createNgModuleType(meta);
@@ -5794,7 +5820,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) :
@@ -5810,16 +5840,36 @@ function createNgModuleType({ type: moduleType, declarations, exports, imports,
  * symbols to become tree-shakeable.
  */
 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));
+        }
     }
-    if (imports.length > 0) {
-        scopeMap.set('imports', refsToArray(imports, containsForwardDecls));
+    else {
+        if (meta.declarationsExpression) {
+            scopeMap.set('declarations', meta.declarationsExpression);
+        }
+    }
+    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;
@@ -5827,7 +5877,7 @@ function generateSetNgModuleScopeCall(meta) {
     // setNgModuleScope(...)
     const fnCall = new InvokeFunctionExpr(
     /* fn */ importExpr(Identifiers.setNgModuleScope), 
-    /* args */ [moduleType.value, scopeMap.toLiteralMap()]);
+    /* args */ [meta.type.value, scopeMap.toLiteralMap()]);
     // (ngJitMode guard) && setNgModuleScope(...)
     const guardedCall = jitOnlyGuardedExpression(fnCall);
     // function() { (ngJitMode guard) && setNgModuleScope(...); }
@@ -5915,7 +5965,7 @@ class ASTWithName extends AST {
         this.nameSpan = nameSpan;
     }
 }
-class EmptyExpr extends AST {
+class EmptyExpr$1 extends AST {
     visit(visitor, context = null) {
         // do nothing
     }
@@ -7348,7 +7398,7 @@ class DefaultLocalResolver {
 }
 class BuiltinFunctionCall extends Call {
     constructor(span, sourceSpan, args, converter) {
-        super(span, sourceSpan, new EmptyExpr(span, sourceSpan), args, null);
+        super(span, sourceSpan, new EmptyExpr$1(span, sourceSpan), args, null);
         this.converter = converter;
     }
 }
@@ -7946,7 +7996,7 @@ class ShadowCss {
             }
             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('@container') || rule.selector.startsWith('@scope')) {
                 content = this._scopeSelectors(rule.content, scopeSelector, hostSelector);
             }
             else if (rule.selector.startsWith('@font-face') || rule.selector.startsWith('@page')) {
@@ -8631,22 +8681,42 @@ var OpKind;
      * An operation to bind an expression to a property of an element.
      */
     OpKind[OpKind["Property"] = 13] = "Property";
+    /**
+     * An operation to bind an expression to a style property of an element.
+     */
+    OpKind[OpKind["StyleProp"] = 14] = "StyleProp";
+    /**
+     * An operation to bind an expression to the styles of an element.
+     */
+    OpKind[OpKind["StyleMap"] = 15] = "StyleMap";
     /**
      * An operation to interpolate text into a property binding.
      */
-    OpKind[OpKind["InterpolateProperty"] = 14] = "InterpolateProperty";
+    OpKind[OpKind["InterpolateProperty"] = 16] = "InterpolateProperty";
+    /**
+     * An operation to interpolate text into a style property binding.
+     */
+    OpKind[OpKind["InterpolateStyleProp"] = 17] = "InterpolateStyleProp";
+    /**
+     * An operation to interpolate text into a style mapping.
+     */
+    OpKind[OpKind["InterpolateStyleMap"] = 18] = "InterpolateStyleMap";
     /**
      * An operation to advance the runtime's implicit slot context during the update phase of a view.
      */
-    OpKind[OpKind["Advance"] = 15] = "Advance";
+    OpKind[OpKind["Advance"] = 19] = "Advance";
     /**
      * An operation to instantiate a pipe.
      */
-    OpKind[OpKind["Pipe"] = 16] = "Pipe";
+    OpKind[OpKind["Pipe"] = 20] = "Pipe";
     /**
      * An operation to associate an attribute with an element.
      */
-    OpKind[OpKind["Attribute"] = 17] = "Attribute";
+    OpKind[OpKind["Attribute"] = 21] = "Attribute";
+    /**
+     * An operation to interpolate text into an attribute binding.
+     */
+    OpKind[OpKind["InterpolateAttribute"] = 22] = "InterpolateAttribute";
 })(OpKind || (OpKind = {}));
 /**
  * Distinguishes different kinds of IR expressions.
@@ -8717,6 +8787,18 @@ var ExpressionKind;
      * An intermediate expression that will be expanded from a safe read into an explicit ternary.
      */
     ExpressionKind[ExpressionKind["SafeTernaryExpr"] = 15] = "SafeTernaryExpr";
+    /**
+     * An empty expression that will be stipped before generating the final output.
+     */
+    ExpressionKind[ExpressionKind["EmptyExpr"] = 16] = "EmptyExpr";
+    /*
+     * An assignment to a temporary variable.
+     */
+    ExpressionKind[ExpressionKind["AssignTemporaryExpr"] = 17] = "AssignTemporaryExpr";
+    /**
+     * A reference to a temporary variable.
+     */
+    ExpressionKind[ExpressionKind["ReadTemporaryExpr"] = 18] = "ReadTemporaryExpr";
 })(ExpressionKind || (ExpressionKind = {}));
 /**
  * Distinguishes between different kinds of `SemanticVariable`s.
@@ -9184,7 +9266,13 @@ class SafePropertyReadExpr extends ExpressionBase {
         this.name = name;
         this.kind = ExpressionKind.SafePropertyRead;
     }
-    visitExpression(visitor, context) { }
+    // An alias for name, which allows other logic to handle property reads and keyed reads together.
+    get index() {
+        return this.name;
+    }
+    visitExpression(visitor, context) {
+        this.receiver.visitExpression(visitor, context);
+    }
     isEquivalent() {
         return false;
     }
@@ -9205,7 +9293,10 @@ class SafeKeyedReadExpr extends ExpressionBase {
         this.index = index;
         this.kind = ExpressionKind.SafeKeyedRead;
     }
-    visitExpression(visitor, context) { }
+    visitExpression(visitor, context) {
+        this.receiver.visitExpression(visitor, context);
+        this.index.visitExpression(visitor, context);
+    }
     isEquivalent() {
         return false;
     }
@@ -9227,7 +9318,12 @@ class SafeInvokeFunctionExpr extends ExpressionBase {
         this.args = args;
         this.kind = ExpressionKind.SafeInvokeFunction;
     }
-    visitExpression(visitor, context) { }
+    visitExpression(visitor, context) {
+        this.receiver.visitExpression(visitor, context);
+        for (const a of this.args) {
+            a.visitExpression(visitor, context);
+        }
+    }
     isEquivalent() {
         return false;
     }
@@ -9251,7 +9347,10 @@ class SafeTernaryExpr extends ExpressionBase {
         this.expr = expr;
         this.kind = ExpressionKind.SafeTernaryExpr;
     }
-    visitExpression(visitor, context) { }
+    visitExpression(visitor, context) {
+        this.guard.visitExpression(visitor, context);
+        this.expr.visitExpression(visitor, context);
+    }
     isEquivalent() {
         return false;
     }
@@ -9266,6 +9365,70 @@ class SafeTernaryExpr extends ExpressionBase {
         return new SafeTernaryExpr(this.guard.clone(), this.expr.clone());
     }
 }
+class EmptyExpr extends ExpressionBase {
+    constructor() {
+        super(...arguments);
+        this.kind = ExpressionKind.EmptyExpr;
+    }
+    visitExpression(visitor, context) { }
+    isEquivalent(e) {
+        return e instanceof EmptyExpr;
+    }
+    isConstant() {
+        return true;
+    }
+    clone() {
+        return new EmptyExpr();
+    }
+    transformInternalExpressions() { }
+}
+class AssignTemporaryExpr 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;
+    }
+}
+class ReadTemporaryExpr 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;
+    }
+}
 /**
  * Visits all `Expression`s in the AST of `op` with the `visitor` function.
  */
@@ -9289,9 +9452,14 @@ var VisitorContextFlag;
 function transformExpressionsInOp(op, transform, flags) {
     switch (op.kind) {
         case OpKind.Property:
+        case OpKind.StyleProp:
+        case OpKind.StyleMap:
             op.expression = transformExpressionsInExpression(op.expression, transform, flags);
             break;
         case OpKind.InterpolateProperty:
+        case OpKind.InterpolateStyleProp:
+        case OpKind.InterpolateStyleMap:
+        case OpKind.InterpolateText:
             for (let i = 0; i < op.expressions.length; i++) {
                 op.expressions[i] = transformExpressionsInExpression(op.expressions[i], transform, flags);
             }
@@ -9301,17 +9469,17 @@ 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.Variable:
-            op.initializer = transformExpressionsInExpression(op.initializer, transform, flags);
-            break;
-        case OpKind.InterpolateText:
+        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:
+            op.initializer = transformExpressionsInExpression(op.initializer, transform, flags);
+            break;
         case OpKind.Listener:
             for (const innerOp of op.handlerOps) {
                 transformExpressionsInOp(innerOp, transform, flags | VisitorContextFlag.InChildOperation);
@@ -9409,6 +9577,11 @@ function transformExpressionsInStatement(stmt, transform, flags) {
     else if (stmt instanceof ReturnStatement) {
         stmt.value = transformExpressionsInExpression(stmt.value, transform, flags);
     }
+    else if (stmt instanceof DeclareVarStmt) {
+        if (stmt.value !== undefined) {
+            stmt.value = transformExpressionsInExpression(stmt.value, transform, flags);
+        }
+    }
     else {
         throw new Error(`Unhandled statement kind: ${stmt.constructor.name}`);
     }
@@ -9791,6 +9964,30 @@ function createPropertyOp(xref, bindingKind, name, expression) {
         ...NEW_OP,
     };
 }
+/** Create a `StylePropOp`. */
+function createStylePropOp(xref, name, expression, unit) {
+    return {
+        kind: OpKind.StyleProp,
+        target: xref,
+        name,
+        expression,
+        unit,
+        ...TRAIT_DEPENDS_ON_SLOT_CONTEXT,
+        ...TRAIT_CONSUMES_VARS,
+        ...NEW_OP,
+    };
+}
+/** Create a `StyleMapOp`. */
+function createStyleMapOp(xref, expression) {
+    return {
+        kind: OpKind.StyleMap,
+        target: xref,
+        expression,
+        ...TRAIT_DEPENDS_ON_SLOT_CONTEXT,
+        ...TRAIT_CONSUMES_VARS,
+        ...NEW_OP,
+    };
+}
 /**
  * Create an `AttributeOp`.
  */
@@ -9801,6 +9998,8 @@ function createAttributeOp(target, attributeKind, name, value) {
         attributeKind,
         name,
         value,
+        ...TRAIT_DEPENDS_ON_SLOT_CONTEXT,
+        ...TRAIT_CONSUMES_VARS,
         ...NEW_OP,
     };
 }
@@ -9820,6 +10019,49 @@ function createInterpolatePropertyOp(xref, bindingKind, name, strings, expressio
         ...NEW_OP,
     };
 }
+function createInterpolateAttributeOp(target, attributeKind, name, strings, expressions) {
+    return {
+        kind: OpKind.InterpolateAttribute,
+        target: target,
+        attributeKind,
+        name,
+        strings,
+        expressions,
+        ...TRAIT_DEPENDS_ON_SLOT_CONTEXT,
+        ...TRAIT_CONSUMES_VARS,
+        ...NEW_OP,
+    };
+}
+/**
+ * Create a `InterpolateStyleProp`.
+ */
+function createInterpolateStylePropOp(xref, name, strings, expressions, unit) {
+    return {
+        kind: OpKind.InterpolateStyleProp,
+        target: xref,
+        name,
+        strings,
+        expressions,
+        unit,
+        ...TRAIT_DEPENDS_ON_SLOT_CONTEXT,
+        ...TRAIT_CONSUMES_VARS,
+        ...NEW_OP,
+    };
+}
+/**
+ * Create a `InterpolateStyleMap`.
+ */
+function createInterpolateStyleMapOp(xref, strings, expressions) {
+    return {
+        kind: OpKind.InterpolateStyleMap,
+        target: xref,
+        strings,
+        expressions,
+        ...TRAIT_DEPENDS_ON_SLOT_CONTEXT,
+        ...TRAIT_CONSUMES_VARS,
+        ...NEW_OP,
+    };
+}
 /**
  * Create an `AdvanceOp`.
  */
@@ -9877,15 +10119,25 @@ function phaseVarCounting(cpl) {
 function varsUsedByOp(op) {
     switch (op.kind) {
         case OpKind.Property:
+        case OpKind.StyleProp:
+        case OpKind.StyleMap:
             // Property bindings use 1 variable slot.
             return 1;
+        case OpKind.Attribute:
+            // Attribute bindings use 1 variable slot.
+            return 1;
         case OpKind.InterpolateText:
             // `ir.InterpolateTextOp`s use a variable slot for each dynamic expression.
             return op.expressions.length;
         case OpKind.InterpolateProperty:
+        case OpKind.InterpolateStyleProp:
+        case OpKind.InterpolateStyleMap:
             // `ir.InterpolatePropertyOp`s use a variable slot for each dynamic expression, plus one for
             // the result.
             return 1 + op.expressions.length;
+        case OpKind.InterpolateAttribute:
+            // One variable slot for each dynamic expression, plus one for the result.
+            return 1 + op.expressions.length;
         default:
             throw new Error(`Unhandled op: ${OpKind[op.kind]}`);
     }
@@ -9935,6 +10187,15 @@ function phaseAlignPipeVariadicVarOffset(cpl) {
     }
 }
 
+/**
+ * Find all attribute and binding ops, and collect them into the ElementAttribute structures.
+ * In cases where no instruction needs to be generated for the attribute or binding, it is removed.
+ */
+function phaseAttributeExtraction(cpl, compatibility) {
+    for (const [_, view] of cpl.views) {
+        populateElementAttributes(view, compatibility);
+    }
+}
 /**
  * Looks up an element in the given map by xref ID.
  */
@@ -9946,13 +10207,14 @@ function lookupElement(elements, xref) {
     return el;
 }
 /**
- * Find all attribute and binding ops, and collect them into the ElementAttribute structures.
- * In cases where no instruction needs to be generated for the attribute or binding, it is removed.
+ * Removes the op if its expression is empty.
  */
-function phaseAttributeExtraction(cpl, compatibility) {
-    for (const [_, view] of cpl.views) {
-        populateElementAttributes(view, compatibility);
+function removeIfExpressionIsEmpty(op, expression) {
+    if (expression instanceof EmptyExpr) {
+        OpList.remove(op);
+        return true;
     }
+    return false;
 }
 /**
  * Populates the ElementAttributes map for the given view, and removes ops for any bindings that do
@@ -9972,6 +10234,8 @@ function populateElementAttributes(view, compatibility) {
             case OpKind.Attribute:
                 ownerOp = lookupElement(elements, op.target);
                 assertIsElementAttributes(ownerOp.attributes);
+                // The old compiler only extracted string constants, so we emulate that behavior in
+                // compaitiblity mode, otherwise we optimize more aggressively.
                 let extractable = compatibility ?
                     (op.value instanceof LiteralExpr && typeof op.value.value === 'string') :
                     (op.value.isConstant());
@@ -9982,11 +10246,25 @@ function populateElementAttributes(view, compatibility) {
                 }
                 break;
             case OpKind.Property:
+                ownerOp = lookupElement(elements, op.target);
+                assertIsElementAttributes(ownerOp.attributes);
+                removeIfExpressionIsEmpty(op, op.expression);
+                ownerOp.attributes.add(op.bindingKind, op.name, null);
+                break;
             case OpKind.InterpolateProperty:
                 ownerOp = lookupElement(elements, op.target);
                 assertIsElementAttributes(ownerOp.attributes);
                 ownerOp.attributes.add(op.bindingKind, op.name, null);
                 break;
+            case OpKind.StyleProp:
+                ownerOp = lookupElement(elements, op.target);
+                assertIsElementAttributes(ownerOp.attributes);
+                // The old compiler treated empty style bindings as regular bindings for the purpose of
+                // directive matching. That behavior is incorrect, but we emulate it in compatibility mode.
+                if (removeIfExpressionIsEmpty(op, op.expression) && compatibility) {
+                    ownerOp.attributes.add(ElementAttributeKind.Binding, op.name, null);
+                }
+                break;
             case OpKind.Listener:
                 ownerOp = lookupElement(elements, op.target);
                 assertIsElementAttributes(ownerOp.attributes);
@@ -10004,6 +10282,8 @@ const CHAINABLE = new Set([
     Identifiers.elementStart,
     Identifiers.elementEnd,
     Identifiers.property,
+    Identifiers.styleProp,
+    Identifiers.attribute,
     Identifiers.elementContainerStart,
     Identifiers.elementContainerEnd,
     Identifiers.elementContainer,
@@ -10201,10 +10481,11 @@ function phaseNullishCoalescing(cpl) {
                     expr.operator !== BinaryOperator.NullishCoalesce) {
                     return expr;
                 }
-                // TODO: We need to unconditionally emit a temporary variable to match
-                // TemplateDefinitionBuilder. (We could also emit one conditionally when not in
-                // compatibility mode.)
-                return new ConditionalExpr(new BinaryOperatorExpr(BinaryOperator.And, new BinaryOperatorExpr(BinaryOperator.NotIdentical, expr.lhs, NULL_EXPR), new BinaryOperatorExpr(BinaryOperator.NotIdentical, expr.lhs, new LiteralExpr(undefined))), expr.lhs, expr.rhs);
+                const assignment = new AssignTemporaryExpr(expr.lhs.clone(), cpl.allocateXrefId());
+                const read = new ReadTemporaryExpr(assignment.xref);
+                // TODO: When not in compatibility mode for TemplateDefinitionBuilder, we can just emit
+                // `t != null` instead of including an undefined check as well.
+                return new ConditionalExpr(new BinaryOperatorExpr(BinaryOperator.And, new BinaryOperatorExpr(BinaryOperator.NotIdentical, assignment, NULL_EXPR), new BinaryOperatorExpr(BinaryOperator.NotIdentical, read, new LiteralExpr(undefined))), read.clone(), expr.rhs);
             }, VisitorContextFlag.None);
         }
     }
@@ -10237,11 +10518,6 @@ function phaseGenerateVariables(cpl) {
 function recursivelyProcessView(view, parentScope) {
     // Extract a `Scope` from this view.
     const scope = getScopeForView(view, parentScope);
-    // Embedded views require an operation to save/restore the view context.
-    if (view.parent !== null) {
-        // Start the view creation block with an operation to save the current view context. This may be
-        // used to restore the view context in any listeners that may be present.
-    }
     for (const op of view.create) {
         switch (op.kind) {
             case OpKind.Template:
@@ -10780,6 +11056,19 @@ 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) {
+        args.push(literal(unit));
+    }
+    return call(Identifiers.styleProp, args);
+}
+function styleMap(expression) {
+    return call(Identifiers.styleMap, [expression]);
+}
 const PIPE_BINDINGS = [
     Identifiers.pipeBind1,
     Identifiers.pipeBind2,
@@ -10823,6 +11112,35 @@ function textInterpolate(strings, expressions) {
     return callVariadicInstruction(TEXT_INTERPOLATE_CONFIG, [], interpolationArgs);
 }
 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 = [];
+    if (unit !== null) {
+        extraArgs.push(literal(unit));
+    }
+    return callVariadicInstruction(STYLE_PROP_INTERPOLATE_CONFIG, [literal(name)], interpolationArgs, extraArgs);
+}
+function styleMapInterpolate(strings, expressions) {
+    const interpolationArgs = collateInterpolationArgs(strings, expressions);
+    return callVariadicInstruction(STYLE_MAP_INTERPOLATE_CONFIG, [], interpolationArgs);
+}
+function pureFunction(varOffset, fn, args) {
+    return callVariadicInstructionExpr(PURE_FUNCTION_CONFIG, [
+        literal(varOffset),
+        fn,
+    ], args);
+}
+/**
+ * Collates the string an expression arguments for an interpolation instruction.
+ */
+function collateInterpolationArgs(strings, expressions) {
     if (strings.length < 1 || expressions.length !== strings.length - 1) {
         throw new Error(`AssertionError: expected specific shape of args for strings/expressions in interpolation`);
     }
@@ -10838,13 +11156,7 @@ function propertyInterpolate(name, strings, expressions) {
         // idx points at the last string.
         interpolationArgs.push(literal(strings[idx]));
     }
-    return callVariadicInstruction(PROPERTY_INTERPOLATE_CONFIG, [literal(name)], interpolationArgs);
-}
-function pureFunction(varOffset, fn, args) {
-    return callVariadicInstructionExpr(PURE_FUNCTION_CONFIG, [
-        literal(varOffset),
-        fn,
-    ], args);
+    return interpolationArgs;
 }
 function call(instruction, args) {
     return createStatementOp(importExpr(instruction).callFn(args).toStmt());
@@ -10895,6 +11207,81 @@ const PROPERTY_INTERPOLATE_CONFIG = {
         return (n - 1) / 2;
     },
 };
+/**
+ * `InterpolationConfig` for the `stylePropInterpolate` instruction.
+ */
+const STYLE_PROP_INTERPOLATE_CONFIG = {
+    constant: [
+        null,
+        Identifiers.stylePropInterpolate1,
+        Identifiers.stylePropInterpolate2,
+        Identifiers.stylePropInterpolate3,
+        Identifiers.stylePropInterpolate4,
+        Identifiers.stylePropInterpolate5,
+        Identifiers.stylePropInterpolate6,
+        Identifiers.stylePropInterpolate7,
+        Identifiers.stylePropInterpolate8,
+    ],
+    variable: Identifiers.stylePropInterpolateV,
+    mapping: n => {
+        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;
+    },
+};
+/**
+ * `InterpolationConfig` for the `attributeInterpolate` instruction.
+ */
+const 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;
+    },
+};
+/**
+ * `InterpolationConfig` for the `styleMapInterpolate` instruction.
+ */
+const STYLE_MAP_INTERPOLATE_CONFIG = {
+    constant: [
+        null,
+        Identifiers.styleMapInterpolate1,
+        Identifiers.styleMapInterpolate2,
+        Identifiers.styleMapInterpolate3,
+        Identifiers.styleMapInterpolate4,
+        Identifiers.styleMapInterpolate5,
+        Identifiers.styleMapInterpolate6,
+        Identifiers.styleMapInterpolate7,
+        Identifiers.styleMapInterpolate8,
+    ],
+    variable: Identifiers.styleMapInterpolateV,
+    mapping: n => {
+        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;
+    },
+};
 const PURE_FUNCTION_CONFIG = {
     constant: [
         Identifiers.pureFunction0,
@@ -10910,22 +11297,26 @@ const PURE_FUNCTION_CONFIG = {
     variable: Identifiers.pureFunctionV,
     mapping: n => n,
 };
-function callVariadicInstructionExpr(config, baseArgs, interpolationArgs) {
+function callVariadicInstructionExpr(config, baseArgs, interpolationArgs, extraArgs = []) {
     const n = config.mapping(interpolationArgs.length);
     if (n < config.constant.length) {
         // Constant calling pattern.
-        return importExpr(config.constant[n]).callFn([...baseArgs, ...interpolationArgs]);
+        return importExpr(config.constant[n]).callFn([
+            ...baseArgs, ...interpolationArgs, ...extraArgs
+        ]);
     }
     else if (config.variable !== null) {
         // Variable calling pattern.
-        return importExpr(config.variable).callFn([...baseArgs, literalArr(interpolationArgs)]);
+        return importExpr(config.variable).callFn([
+            ...baseArgs, literalArr(interpolationArgs), ...extraArgs
+        ]);
     }
     else {
         throw new Error(`AssertionError: unable to call variadic function`);
     }
 }
-function callVariadicInstruction(config, baseArgs, interpolationArgs) {
-    return createStatementOp(callVariadicInstructionExpr(config, baseArgs, interpolationArgs).toStmt());
+function callVariadicInstruction(config, baseArgs, interpolationArgs, extraArgs = []) {
+    return createStatementOp(callVariadicInstructionExpr(config, baseArgs, interpolationArgs, extraArgs).toStmt());
 }
 
 /**
@@ -11002,12 +11393,30 @@ function reifyUpdateOperations(_view, ops) {
             case OpKind.Property:
                 OpList.replace(op, property(op.name, op.expression));
                 break;
+            case OpKind.StyleProp:
+                OpList.replace(op, styleProp(op.name, op.expression, op.unit));
+                break;
+            case OpKind.StyleMap:
+                OpList.replace(op, styleMap(op.expression));
+                break;
             case OpKind.InterpolateProperty:
                 OpList.replace(op, propertyInterpolate(op.name, op.strings, op.expressions));
                 break;
+            case OpKind.InterpolateStyleProp:
+                OpList.replace(op, stylePropInterpolate(op.name, op.strings, op.expressions, op.unit));
+                break;
+            case OpKind.InterpolateStyleMap:
+                OpList.replace(op, styleMapInterpolate(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}`);
@@ -11047,6 +11456,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`);
@@ -11234,14 +11653,17 @@ function processLexicalScope(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}`);
+            }
+        });
+    }
 }
 
 function phaseSaveRestoreView(cpl) {
     for (const view of cpl.views.values()) {
-        if (view === cpl.root) {
-            // Save/restore operations are not necessary for the root view.
-            continue;
-        }
         view.create.prepend([
             createVariableOp(view.tpl.allocateXrefId(), {
                 kind: SemanticVariableKind.SavedView,
@@ -11253,22 +11675,39 @@ 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)),
-            ]);
-            // The "restore view" operation in listeners requires a call to `resetView` to reset the
-            // context prior to returning from the listener operation. Find any `return` statements in
-            // the listener body and wrap them in a call to reset the view.
-            for (const handlerOp of op.handlerOps) {
-                if (handlerOp.kind === OpKind.Statement &&
-                    handlerOp.statement instanceof ReturnStatement) {
-                    handlerOp.statement.value = new ResetViewExpr(handlerOp.statement.value);
+            // Embedded views always need the save/restore view operation.
+            let needsRestoreView = view !== cpl.root;
+            if (!needsRestoreView) {
+                for (const handlerOp of op.handlerOps) {
+                    visitExpressionsInOp(handlerOp, expr => {
+                        if (expr instanceof ReferenceExpr) {
+                            // Listeners that reference() a local ref need the save/restore view operation.
+                            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)),
+    ]);
+    // The "restore view" operation in listeners requires a call to `resetView` to reset the
+    // context prior to returning from the listener operation. Find any `return` statements in
+    // the listener body and wrap them in a call to reset the view.
+    for (const handlerOp of op.handlerOps) {
+        if (handlerOp.kind === OpKind.Statement &&
+            handlerOp.statement instanceof ReturnStatement) {
+            handlerOp.statement.value = new ResetViewExpr(handlerOp.statement.value);
         }
     }
 }
@@ -11717,19 +12156,107 @@ function allowConservativeInlining(decl, target) {
  * Finds all unresolved safe read expressions, and converts them into the appropriate output AST
  * reads, guarded by null checks.
  */
-function phaseExpandSafeReads(cpl) {
+function phaseExpandSafeReads(cpl, compatibility) {
     for (const [_, view] of cpl.views) {
         for (const op of view.ops()) {
-            transformExpressionsInOp(op, safeTransform, VisitorContextFlag.None);
+            transformExpressionsInOp(op, e => safeTransform(e, { cpl, compatibility }), VisitorContextFlag.None);
             transformExpressionsInOp(op, ternaryTransform, VisitorContextFlag.None);
         }
     }
 }
+// A lookup set of all the expression kinds that require a temporary variable to be generated.
+const requiresTemporary = [
+    InvokeFunctionExpr, LiteralArrayExpr, LiteralMapExpr, SafeInvokeFunctionExpr,
+    PipeBindingExpr
+].map(e => e.constructor.name);
+function needsTemporaryInSafeAccess(e) {
+    // TODO: We probably want to use an expression visitor to recursively visit all descendents.
+    // However, that would potentially do a lot of extra work (because it cannot short circuit), so we
+    // implement the logic ourselves for now.
+    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);
+    }
+    // TODO: Switch to a method which is exhaustive of newly added expression subtypes.
+    return e instanceof InvokeFunctionExpr || e instanceof LiteralArrayExpr ||
+        e instanceof LiteralMapExpr || e instanceof SafeInvokeFunctionExpr ||
+        e instanceof PipeBindingExpr;
+}
+function temporariesIn(e) {
+    const temporaries = new Set();
+    // TODO: Although it's not currently supported by the transform helper, we should be able to
+    // short-circuit exploring the tree to do less work. In particular, we don't have to penetrate
+    // into the subexpressions of temporary assignments.
+    transformExpressionsInExpression(e, e => {
+        if (e instanceof AssignTemporaryExpr) {
+            temporaries.add(e.xref);
+        }
+        return e;
+    }, VisitorContextFlag.None);
+    return temporaries;
+}
+function eliminateTemporaryAssignments(e, tmps, ctx) {
+    // TODO: We can be more efficient than the transform helper here. We don't need to visit any
+    // descendents of temporary assignments.
+    transformExpressionsInExpression(e, e => {
+        if (e instanceof AssignTemporaryExpr && tmps.has(e.xref)) {
+            const read = new ReadTemporaryExpr(e.xref);
+            // `TemplateDefinitionBuilder` has the (accidental?) behavior of generating assignments of
+            // temporary variables to themselves. This happens because some subexpression that the
+            // temporary refers to, possibly through nested temporaries, has a function call. We copy that
+            // behavior here.
+            return ctx.compatibility ? new AssignTemporaryExpr(read, read.xref) : read;
+        }
+        return e;
+    }, VisitorContextFlag.None);
+    return e;
+}
+/**
+ * Creates a safe ternary guarded by the input expression, and with a body generated by the provided
+ * callback on the input expression. Generates a temporary variable assignment if needed, and
+ * deduplicates nested temporary assignments if needed.
+ */
+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()];
+        // Consider an expression like `a?.[b?.c()]?.d`. The `b?.c()` will be transformed first,
+        // introducing a temporary assignment into the key. Then, as part of expanding the `?.d`. That
+        // assignment will be duplicated into both the guard and expression sides. We de-duplicate it,
+        // by transforming it from an assignment into a read on the expression side.
+        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;
+    return e instanceof ReadPropExpr || e instanceof ReadKeyExpr ||
+        e instanceof InvokeFunctionExpr;
 }
 function isAccessExpression(e) {
     return isSafeAccessExpression(e) || isUnsafeAccessExpression(e);
@@ -11745,8 +12272,8 @@ function deepestSafeTernary(e) {
     return null;
 }
 // TODO: When strict compatibility with TemplateDefinitionBuilder is not required, we can use `&&`
-// instead.
-function safeTransform(e) {
+// instead to save some code size.
+function safeTransform(e, ctx) {
     if (e instanceof SafeInvokeFunctionExpr) {
         // TODO: Implement safe function calls in a subsequent commit.
         return new InvokeFunctionExpr(e.receiver, e.args);
@@ -11756,6 +12283,10 @@ function safeTransform(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;
@@ -11765,20 +12296,20 @@ function safeTransform(e) {
             return e.receiver;
         }
         if (e instanceof SafePropertyReadExpr) {
-            dst.expr = new SafeTernaryExpr(dst.expr.clone(), dst.expr.prop(e.name));
+            dst.expr = safeTernaryWithTemporary(dst.expr, (r) => r.prop(e.name), ctx);
             return e.receiver;
         }
         if (e instanceof SafeKeyedReadExpr) {
-            dst.expr = new SafeTernaryExpr(dst.expr.clone(), dst.expr.key(e.index));
+            dst.expr = safeTernaryWithTemporary(dst.expr, (r) => r.key(e.index), ctx);
             return e.receiver;
         }
     }
     else {
         if (e instanceof SafePropertyReadExpr) {
-            return new SafeTernaryExpr(e.receiver.clone(), e.receiver.prop(e.name));
+            return safeTernaryWithTemporary(e.receiver, (r) => r.prop(e.name), ctx);
         }
         if (e instanceof SafeKeyedReadExpr) {
-            return new SafeTernaryExpr(e.receiver.clone(), e.receiver.key(e.index));
+            return safeTernaryWithTemporary(e.receiver, (r) => r.key(e.index), ctx);
         }
     }
     return e;
@@ -11790,6 +12321,50 @@ function ternaryTransform(e) {
     return new ConditionalExpr(new BinaryOperatorExpr(BinaryOperator.Equals, e.guard, NULL_EXPR), NULL_EXPR, e.expr);
 }
 
+/**
+ * Find all assignments and usages of temporary variables, which are linked to each other with cross
+ * references. Generate names for each cross-reference, and add a `DeclareVarStmt` to initialize
+ * them at the beginning of the update block.
+ *
+ * TODO: Sometimes, it will be possible to reuse names across different subexpressions. For example,
+ * in the double keyed read `a?.[f()]?.[f()]`, the two function calls have non-overlapping scopes.
+ * Implement an algorithm for reuse.
+ */
+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 = new Set();
+            let defs = new Map();
+            visitExpressionsInOp(op, expr => {
+                if (expr instanceof ReadTemporaryExpr || expr instanceof AssignTemporaryExpr) {
+                    xrefs.add(expr.xref);
+                }
+            });
+            for (const xref of xrefs) {
+                // TODO: Exactly replicate the naming scheme used by `TemplateDefinitionBuilder`. It seems
+                // to rely on an expression index instead of an op index.
+                defs.set(xref, `tmp_${opCount}_${count++}`);
+            }
+            visitExpressionsInOp(op, expr => {
+                if (expr instanceof ReadTemporaryExpr || expr instanceof AssignTemporaryExpr) {
+                    const name = defs.get(expr.xref);
+                    if (name === undefined) {
+                        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);
+    }
+}
+
 /**
  * Run all transformation phases in the correct order against a `ComponentCompilation`. After this
  * processing, the compilation should be in a state where it can be emitted via `emitTemplateFn`.s
@@ -11806,7 +12381,8 @@ function transformTemplate(cpl) {
     phaseLocalRefs(cpl);
     phaseConstCollection(cpl);
     phaseNullishCoalescing(cpl);
-    phaseExpandSafeReads(cpl);
+    phaseExpandSafeReads(cpl, true);
+    phaseTemporaryVariables(cpl);
     phaseSlotAllocation(cpl);
     phaseVarCounting(cpl);
     phaseGenerateAdvance(cpl);
@@ -12180,6 +12756,9 @@ function convertAst(ast, cpl) {
     else if (ast instanceof SafeCall) {
         return new SafeInvokeFunctionExpr(convertAst(ast.receiver, cpl), ast.args.map(a => convertAst(a, cpl)));
     }
+    else if (ast instanceof EmptyExpr$1) {
+        return new EmptyExpr();
+    }
     else {
         throw new Error(`Unhandled expression type: ${ast.constructor.name}`);
     }
@@ -12200,6 +12779,9 @@ function ingestBindings(view, op, element) {
         }
     }
     for (const attr of element.attributes) {
+        // This is only attribute TextLiteral bindings, such as `attr.foo="bar'`. This can never be
+        // `[attr.foo]="bar"` or `attr.foo="{{bar}}"`, both of which will be handled as inputs with
+        // `BindingType.Attribute`.
         view.update.push(createAttributeOp(op.xref, ElementAttributeKind.Attribute, attr.name, literal(attr.value)));
     }
     for (const input of element.inputs) {
@@ -12233,14 +12815,35 @@ function ingestBindings(view, op, element) {
         view.create.push(listenerOp);
     }
 }
-function ingestPropertyBinding(view, xref, bindingKind, { name, value, type }) {
+function ingestPropertyBinding(view, xref, bindingKind, { name, value, type, unit }) {
     if (value instanceof ASTWithSource) {
         value = value.ast;
     }
     if (value instanceof Interpolation) {
         switch (type) {
             case 0 /* e.BindingType.Property */:
-                view.update.push(createInterpolatePropertyOp(xref, bindingKind, name, value.strings, value.expressions.map(expr => convertAst(expr, view.tpl))));
+                if (name === 'style') {
+                    if (bindingKind !== ElementAttributeKind.Binding) {
+                        throw Error('Unexpected style binding on ng-template');
+                    }
+                    view.update.push(createInterpolateStyleMapOp(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))));
+                }
+                break;
+            case 3 /* e.BindingType.Style */:
+                if (bindingKind !== ElementAttributeKind.Binding) {
+                    throw Error('Unexpected style binding on ng-template');
+                }
+                view.update.push(createInterpolateStylePropOp(xref, name, value.strings, value.expressions.map(expr => convertAst(expr, view.tpl)), unit));
+                break;
+            case 1 /* e.BindingType.Attribute */:
+                if (bindingKind !== ElementAttributeKind.Binding) {
+                    throw new Error('Attribute bindings on templates are not expected to be valid');
+                }
+                const attributeInterpolate = createInterpolateAttributeOp(xref, bindingKind, name, value.strings, value.expressions.map(expr => convertAst(expr, view.tpl)));
+                view.update.push(attributeInterpolate);
                 break;
             default:
                 // TODO: implement remaining binding types.
@@ -12250,7 +12853,29 @@ function ingestPropertyBinding(view, xref, bindingKind, { name, value, type }) {
     else {
         switch (type) {
             case 0 /* e.BindingType.Property */:
-                view.update.push(createPropertyOp(xref, bindingKind, name, convertAst(value, view.tpl)));
+                // Bindings to [style] are mapped to their own special instruction.
+                if (name === 'style') {
+                    if (bindingKind !== ElementAttributeKind.Binding) {
+                        throw Error('Unexpected style binding on ng-template');
+                    }
+                    view.update.push(createStyleMapOp(xref, convertAst(value, view.tpl)));
+                }
+                else {
+                    view.update.push(createPropertyOp(xref, bindingKind, name, convertAst(value, view.tpl)));
+                }
+                break;
+            case 3 /* e.BindingType.Style */:
+                if (bindingKind !== ElementAttributeKind.Binding) {
+                    throw Error('Unexpected style binding on ng-template');
+                }
+                view.update.push(createStylePropOp(xref, name, convertAst(value, view.tpl), unit));
+                break;
+            case 1 /* e.BindingType.Attribute */:
+                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;
             default:
                 // TODO: implement remaining binding types.
@@ -12887,7 +13512,7 @@ function isEmptyExpression(ast) {
     if (ast instanceof ASTWithSource) {
         ast = ast.ast;
     }
-    return ast instanceof EmptyExpr;
+    return ast instanceof EmptyExpr$1;
 }
 
 var TokenType;
@@ -13792,7 +14417,7 @@ class _ParseAST {
             // We have no expressions so create an empty expression that spans the entire input length
             const artificialStart = this.offset;
             const artificialEnd = this.offset + this.input.length;
-            return new EmptyExpr(this.span(artificialStart, artificialEnd), this.sourceSpan(artificialStart, artificialEnd));
+            return new EmptyExpr$1(this.span(artificialStart, artificialEnd), this.sourceSpan(artificialStart, artificialEnd));
         }
         if (exprs.length == 1)
             return exprs[0];
@@ -13853,7 +14478,7 @@ class _ParseAST {
                 const end = this.inputIndex;
                 const expression = this.input.substring(start, end);
                 this.error(`Conditional expression ${expression} requires all 3 expressions`);
-                no = new EmptyExpr(this.span(start), this.sourceSpan(start));
+                no = new EmptyExpr$1(this.span(start), this.sourceSpan(start));
             }
             else {
                 no = this.parsePipe();
@@ -14078,15 +14703,15 @@ class _ParseAST {
         }
         else if (this.next.isPrivateIdentifier()) {
             this._reportErrorForPrivateIdentifier(this.next, null);
-            return new EmptyExpr(this.span(start), this.sourceSpan(start));
+            return new EmptyExpr$1(this.span(start), this.sourceSpan(start));
         }
         else if (this.index >= this.tokens.length) {
             this.error(`Unexpected end of expression: ${this.input}`);
-            return new EmptyExpr(this.span(start), this.sourceSpan(start));
+            return new EmptyExpr$1(this.span(start), this.sourceSpan(start));
         }
         else {
             this.error(`Unexpected token ${this.next}`);
-            return new EmptyExpr(this.span(start), this.sourceSpan(start));
+            return new EmptyExpr$1(this.span(start), this.sourceSpan(start));
         }
     }
     parseExpressionList(terminator) {
@@ -14147,7 +14772,7 @@ class _ParseAST {
         if (isSafe) {
             if (this.consumeOptionalAssignment()) {
                 this.error('The \'?.\' operator cannot be used in the assignment');
-                receiver = new EmptyExpr(this.span(start), this.sourceSpan(start));
+                receiver = new EmptyExpr$1(this.span(start), this.sourceSpan(start));
             }
             else {
                 receiver = new SafePropertyRead(this.span(start), this.sourceSpan(start), nameSpan, readReceiver, id);
@@ -14157,7 +14782,7 @@ class _ParseAST {
             if (this.consumeOptionalAssignment()) {
                 if (!(this.parseFlags & 1 /* ParseFlags.Action */)) {
                     this.error('Bindings cannot contain assignments');
-                    return new EmptyExpr(this.span(start), this.sourceSpan(start));
+                    return new EmptyExpr$1(this.span(start), this.sourceSpan(start));
                 }
                 const value = this.parseConditional();
                 receiver = new PropertyWrite(this.span(start), this.sourceSpan(start), nameSpan, readReceiver, id, value);
@@ -14287,7 +14912,7 @@ class _ParseAST {
         return this.withContext(ParseContextFlags.Writable, () => {
             this.rbracketsExpected++;
             const key = this.parsePipe();
-            if (key instanceof EmptyExpr) {
+            if (key instanceof EmptyExpr$1) {
                 this.error(`Key access cannot be empty`);
             }
             this.rbracketsExpected--;
@@ -14305,7 +14930,7 @@ class _ParseAST {
                 return isSafe ? new SafeKeyedRead(this.span(start), this.sourceSpan(start), receiver, key) :
                     new KeyedRead(this.span(start), this.sourceSpan(start), receiver, key);
             }
-            return new EmptyExpr(this.span(start), this.sourceSpan(start));
+            return new EmptyExpr$1(this.span(start), this.sourceSpan(start));
         });
     }
     /**
@@ -14600,6 +15225,39 @@ class Comment {
         return visitor.visitComment(this, context);
     }
 }
+class BlockGroup {
+    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);
+    }
+}
+class Block {
+    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);
+    }
+}
+class BlockParameter {
+    constructor(expression, sourceSpan) {
+        this.expression = expression;
+        this.sourceSpan = sourceSpan;
+    }
+    visit(visitor, context) {
+        return visitor.visitBlockParameter(this, context);
+    }
+}
 function visitAll(visitor, nodes, context = null) {
     const result = [];
     const visit = visitor.visit ?
@@ -14630,6 +15288,18 @@ class RecursiveVisitor {
         });
     }
     visitExpansionCase(ast, context) { }
+    visitBlockGroup(ast, context) {
+        this.visitChildren(context, visit => {
+            visit(ast.blocks);
+        });
+    }
+    visitBlock(block, context) {
+        this.visitChildren(context, visit => {
+            visit(block.parameters);
+            visit(block.children);
+        });
+    }
+    visitBlockParameter(ast, context) { }
     visitChildren(context, cb) {
         let results = [];
         let t = this;
@@ -17382,8 +18052,8 @@ class _Tokenizer {
         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();
         }
@@ -17424,6 +18094,15 @@ class _Tokenizer {
                         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())) {
                     // In (possibly interpolated) text the end of the text is given by `isTextEnd()`, while
                     // the premature end of an interpolation is given by the start of a new HTML element.
@@ -17437,6 +18116,64 @@ class _Tokenizer {
         this._beginToken(24 /* TokenType.EOF */);
         this._endToken([]);
     }
+    _consumeBlockGroupOpen(start) {
+        this._beginToken(25 /* TokenType.BLOCK_GROUP_OPEN_START */, start);
+        const nameCursor = this._cursor.clone();
+        this._attemptCharCodeUntilFn(code => !isBlockNameChar(code));
+        this._endToken([this._cursor.getChars(nameCursor)]);
+        this._consumeBlockParameters();
+        this._beginToken(26 /* TokenType.BLOCK_GROUP_OPEN_END */);
+        this._requireCharCode($RBRACE);
+        this._endToken([]);
+    }
+    _consumeBlockGroupClose(start) {
+        this._beginToken(27 /* TokenType.BLOCK_GROUP_CLOSE */, 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 /* TokenType.BLOCK_OPEN_START */, start);
+        const nameCursor = this._cursor.clone();
+        this._attemptCharCodeUntilFn(code => !isBlockNameChar(code));
+        this._endToken([this._cursor.getChars(nameCursor)]);
+        this._consumeBlockParameters();
+        this._beginToken(30 /* TokenType.BLOCK_OPEN_END */);
+        this._requireCharCode($RBRACE);
+        this._endToken([]);
+    }
+    _consumeBlockParameters() {
+        // Trim the whitespace until the first parameter.
+        this._attemptCharCodeUntilFn(isBlockParameterChar);
+        while (this._cursor.peek() !== $RBRACE && this._cursor.peek() !== $EOF) {
+            this._beginToken(28 /* TokenType.BLOCK_PARAMETER */);
+            const start = this._cursor.clone();
+            let inQuote = null;
+            // Consume the parameter until the next semicolon or brace.
+            // Note that we skip over semicolons/braces inside of strings.
+            while ((this._cursor.peek() !== $SEMICOLON && this._cursor.peek() !== $RBRACE &&
+                this._cursor.peek() !== $EOF) ||
+                inQuote !== null) {
+                const char = this._cursor.peek();
+                // Skip to the next character if it was escaped.
+                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)]);
+            // Skip to the next parameter.
+            this._attemptCharCodeUntilFn(isBlockParameterChar);
+        }
+    }
     /**
      * @returns whether an ICU token has been created
      * @internal
@@ -17770,7 +18507,6 @@ class _Tokenizer {
         this._endToken(prefixAndName);
     }
     _consumeAttributeValue() {
-        let value;
         if (this._cursor.peek() === $SQ || this._cursor.peek() === $DQ) {
             const quoteChar = this._cursor.peek();
             this._consumeQuote(quoteChar);
@@ -17959,7 +18695,7 @@ class _Tokenizer {
         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) {
@@ -17992,6 +18728,23 @@ class _Tokenizer {
         }
         return false;
     }
+    _isBlockStart() {
+        if (this._tokenizeBlocks && this._cursor.peek() === $LBRACE) {
+            const tmp = this._cursor.clone();
+            // Check that the cursor is on a `{#`, `{/` or `{:`.
+            tmp.advance();
+            const next = tmp.peek();
+            if (next !== $BANG && next !== $SLASH && next !== $COLON) {
+                return false;
+            }
+            // If it is, also verify that the next character is a valid block identifier.
+            tmp.advance();
+            if (isBlockNameChar(tmp.peek())) {
+                return true;
+            }
+        }
+        return false;
+    }
     _readUntil(char) {
         const start = this._cursor.clone();
         this._attemptUntilChar(char);
@@ -18047,6 +18800,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 = undefined;
@@ -18334,7 +19093,7 @@ class _TreeBuilder {
         this.tokens = tokens;
         this.getTagDefinition = getTagDefinition;
         this._index = -1;
-        this._elementStack = [];
+        this._containerStack = [];
         this.rootNodes = [];
         this.errors = [];
         this._advance();
@@ -18364,6 +19123,18 @@ class _TreeBuilder {
             else if (this._peek.type === 19 /* TokenType.EXPANSION_FORM_START */) {
                 this._consumeExpansion(this._advance());
             }
+            else if (this._peek.type === 25 /* TokenType.BLOCK_GROUP_OPEN_START */) {
+                this._closeVoidElement();
+                this._consumeBlockGroupOpen(this._advance());
+            }
+            else if (this._peek.type === 29 /* TokenType.BLOCK_OPEN_START */) {
+                this._closeVoidElement();
+                this._consumeBlock(this._advance(), 30 /* TokenType.BLOCK_OPEN_END */);
+            }
+            else if (this._peek.type === 27 /* TokenType.BLOCK_GROUP_CLOSE */) {
+                this._closeVoidElement();
+                this._consumeBlockGroupClose(this._advance());
+            }
             else {
                 // Skip all other tokens...
                 this._advance();
@@ -18480,7 +19251,12 @@ class _TreeBuilder {
         const startSpan = token.sourceSpan;
         let text = token.parts[0];
         if (text.length > 0 && text[0] === '\n') {
-            const parent = this._getParentElement();
+            const parent = this._getContainer();
+            // This is unlikely to happen, but we have an assertion just in case.
+            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) {
                 text = text.substring(1);
@@ -18511,9 +19287,9 @@ class _TreeBuilder {
         }
     }
     _closeVoidElement() {
-        const el = this._getParentElement();
-        if (el && this.getTagDefinition(el.name).isVoid) {
-            this._elementStack.pop();
+        const el = this._getContainer();
+        if (el instanceof Element && this.getTagDefinition(el.name).isVoid) {
+            this._containerStack.pop();
         }
     }
     _consumeStartTag(startTagToken) {
@@ -18522,7 +19298,7 @@ class _TreeBuilder {
         while (this._peek.type === 14 /* TokenType.ATTR_NAME */) {
             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;
         // Note: There could have been a tokenizer error
         // so that we don't get a token for the end tag...
@@ -18543,33 +19319,34 @@ class _TreeBuilder {
         // Create a separate `startSpan` because `span` will be modified when there is an `end` span.
         const startSpan = new ParseSourceSpan(startTagToken.sourceSpan.start, end, startTagToken.sourceSpan.fullStart);
         const el = new Element(fullName, attrs, [], span, startSpan, undefined);
-        this._pushElement(el);
+        const parentEl = this._getContainer();
+        this._pushContainer(el, parentEl instanceof Element &&
+            this.getTagDefinition(parentEl.name).isClosedByChild(el.name));
         if (selfClosing) {
             // Elements that are self-closed have their `endSourceSpan` set to the full span, as the
             // element start tag also represents the end tag.
-            this._popElement(fullName, span);
+            this._popContainer(fullName, Element, span);
         }
         else if (startTagToken.type === 4 /* TokenType.INCOMPLETE_TAG_OPEN */) {
             // We already know the opening tag is not complete, so it is unlikely it has a corresponding
             // close tag. Let's optimistically parse it as a full element and emit an error.
-            this._popElement(fullName, null);
+            this._popContainer(fullName, Element, 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, Element, 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));
         }
@@ -18580,20 +19357,23 @@ class _TreeBuilder {
      * not have a closing tag (for example, this happens when an incomplete
      * opening tag is recovered).
      */
-    _popElement(fullName, endSourceSpan) {
+    _popContainer(fullName, expectedType, endSourceSpan) {
         let unexpectedCloseTagDetected = false;
-        for (let stackIndex = this._elementStack.length - 1; stackIndex >= 0; stackIndex--) {
-            const el = this._elementStack[stackIndex];
-            if (el.name === fullName) {
+        for (let stackIndex = this._containerStack.length - 1; stackIndex >= 0; stackIndex--) {
+            const node = this._containerStack[stackIndex];
+            const name = node instanceof BlockGroup ? node.blocks[0]?.name : node.name;
+            if (name === fullName && node instanceof expectedType) {
                 // Record the parse span with the element that is being closed. Any elements that are
                 // removed from the element stack at this point are closed implicitly, so they won't get
                 // an end source span (as there is no explicit closing element).
-                el.endSourceSpan = endSourceSpan;
-                el.sourceSpan.end = endSourceSpan !== null ? endSourceSpan.end : el.sourceSpan.end;
-                this._elementStack.splice(stackIndex, this._elementStack.length - stackIndex);
+                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) {
+            // Blocks are self-closing while block groups and (most times) elements are not.
+            if (node instanceof BlockGroup ||
+                node instanceof Element && !this.getTagDefinition(node.name).closedByParent) {
                 // Note that we encountered an unexpected close tag but continue processing the element
                 // stack so we can assign an `endSourceSpan` if there is a corresponding start tag for this
                 // end tag in the stack.
@@ -18652,16 +19432,92 @@ class _TreeBuilder {
             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 : undefined, undefined);
     }
-    _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);
+        // Create a separate `startSpan` because `span` will be modified when there is an `end` span.
+        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 /* TokenType.BLOCK_GROUP_OPEN_END */);
+        // Block parameters are consumed as a part of the implicit block so we need to expand the
+        // start source span once the block is parsed to include the full opening tag.
+        startSpan.end = implicitBlock.startSourceSpan.end;
+    }
+    _consumeBlock(token, closeToken) {
+        // The start of a block implicitly closes the previous block.
+        this._conditionallyClosePreviousBlock();
+        const parameters = [];
+        while (this._peek.type === 28 /* TokenType.BLOCK_PARAMETER */) {
+            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);
+        // Create a separate `startSpan` because `span` will be modified when there is an `end` span.
+        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();
+        // Blocks are implcitly closed by the block group.
+        this._conditionallyClosePreviousBlock();
+        if (!this._popContainer(name, BlockGroup, token.sourceSpan)) {
+            const context = previousContainer instanceof Element ?
+                `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) {
+            // Blocks don't have an explicit closing tag, they're closed either by the next block or
+            // the end of the block group. Infer the end span from the last child node.
+            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 Element) {
+                return this._containerStack[i];
+            }
+        }
+        return null;
     }
     _addToParent(node) {
-        const parent = this._getParentElement();
-        if (parent != null) {
-            parent.children.push(node);
+        const parent = this._getContainer();
+        if (parent === null) {
+            this.rootNodes.push(node);
+        }
+        else if (parent instanceof BlockGroup) {
+            // Due to how parsing is set up, we're unlikely to hit this code path, but we
+            // have the assertion here just in case and to satisfy the type checker.
+            this.errors.push(TreeError.create(null, node.sourceSpan, 'Block groups can only contain blocks.'));
         }
         else {
-            this.rootNodes.push(node);
+            parent.children.push(node);
         }
     }
     _getElementFullName(prefix, localName, parentElement) {
@@ -18775,6 +19631,15 @@ class WhitespaceVisitor {
     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 };
@@ -19184,7 +20049,7 @@ class BindingParser {
             if (ast) {
                 this._reportExpressionParserErrors(ast.errors, sourceSpan);
             }
-            if (!ast || ast.ast instanceof EmptyExpr) {
+            if (!ast || ast.ast instanceof EmptyExpr$1) {
                 this._reportError(`Empty expressions are not allowed`, sourceSpan);
                 return this._exprParser.wrapLiteralPrimitive('ERROR', sourceInfo, absoluteOffset);
             }
@@ -19563,6 +20428,15 @@ class HtmlAstToIvyAst {
         }
         return null;
     }
+    visitBlockGroup(group, context) {
+        throw new Error('TODO');
+    }
+    visitBlock(block, context) {
+        throw new Error('TODO');
+    }
+    visitBlockParameter(parameter, context) {
+        throw new Error('TODO');
+    }
     // convert view engine `ParsedProperty` to a format suitable for IVY
     extractAttributes(elementName, properties, i18nPropsMeta) {
         const bound = [];
@@ -19740,6 +20614,15 @@ class NonBindableVisitor {
     visitExpansionCase(expansionCase) {
         return null;
     }
+    visitBlockGroup(group, context) {
+        throw new Error('TODO');
+    }
+    visitBlock(block, context) {
+        throw new Error('TODO');
+    }
+    visitBlockParameter(parameter, context) {
+        throw new Error('TODO');
+    }
 }
 const NON_BINDABLE_VISITOR = new NonBindableVisitor();
 function normalizeAttributeName(attrName) {
@@ -20187,6 +21070,17 @@ class _I18nVisitor {
     visitExpansionCase(_icuCase, _context) {
         throw new Error('Unreachable code');
     }
+    visitBlockGroup(group, context) {
+        const children = visitAll(this, group.blocks, context);
+        const node = new Container(children, group.sourceSpan);
+        return context.visitNodeFn(group, node);
+    }
+    visitBlock(block, context) {
+        const children = visitAll(this, block.children, context);
+        const node = new Container(children, block.sourceSpan);
+        return context.visitNodeFn(block, node);
+    }
+    visitBlockParameter(_parameter, _context) { }
     /**
      * Convert, text and interpolated tokens up into text and placeholder pieces.
      *
@@ -20433,6 +21327,17 @@ class I18nMetaVisitor {
     visitExpansionCase(expansionCase) {
         return expansionCase;
     }
+    visitBlockGroup(group, context) {
+        visitAll(this, group.blocks, context);
+        return group;
+    }
+    visitBlock(block, context) {
+        visitAll(this, block.children, context);
+        return block;
+    }
+    visitBlockParameter(parameter, context) {
+        return parameter;
+    }
     /**
      * Parse the general form `meta` passed into extract the explicit metadata needed to create a
      * `Message`.
@@ -23305,6 +24210,7 @@ class CompilerFacadeImpl {
     }
     compileNgModule(angularCoreEnv, sourceMapUrl, facade) {
         const meta = {
+            kind: R3NgModuleMetadataKind.Global,
             type: wrapReference(facade.type),
             bootstrap: facade.bootstrap.map(wrapReference),
             declarations: facade.declarations.map(wrapReference),
@@ -23816,7 +24722,7 @@ function publishFacade(global) {
  * @description
  * Entry point for all public APIs of the compiler package.
  */
-const VERSION = new Version('16.2.0-next.0');
+const VERSION = new Version('16.2.0-next.2');
 
 class CompilerConfig {
     constructor({ defaultEncapsulation = ViewEncapsulation.Emulated, useJit = true, missingTranslation = null, preserveWhitespaces, strictInjectionParameters } = {}) {
@@ -24037,6 +24943,13 @@ class _Visitor {
     visitAttribute(attribute, context) {
         throw new Error('unreachable code');
     }
+    visitBlockGroup(group, context) {
+        visitAll(this, group.blocks, context);
+    }
+    visitBlock(block, context) {
+        visitAll(this, block.children, context);
+    }
+    visitBlockParameter(parameter, context) { }
     _init(mode, interpolationConfig) {
         this._mode = mode;
         this._inI18nBlock = false;
@@ -24249,8 +25162,9 @@ class XmlParser extends Parser {
     constructor() {
         super(getXmlTagDefinition);
     }
-    parse(source, url, options) {
-        return super.parse(source, url, options);
+    parse(source, url, options = {}) {
+        // Blocks aren't supported in an XML context.
+        return super.parse(source, url, { ...options, tokenizeBlocks: false });
     }
 }
 
@@ -24434,6 +25348,9 @@ class XliffParser {
     visitComment(comment, context) { }
     visitExpansion(expansion, context) { }
     visitExpansionCase(expansionCase, context) { }
+    visitBlockGroup(group, context) { }
+    visitBlock(block, context) { }
+    visitBlockParameter(parameter, context) { }
     _addError(node, message) {
         this._errors.push(new I18nError(node.sourceSpan, message));
     }
@@ -24484,6 +25401,9 @@ class XmlToI18n$2 {
     }
     visitComment(comment, context) { }
     visitAttribute(attribute, context) { }
+    visitBlockGroup(group, context) { }
+    visitBlock(block, context) { }
+    visitBlockParameter(parameter, context) { }
     _addError(node, message) {
         this._errors.push(new I18nError(node.sourceSpan, message));
     }
@@ -24707,6 +25627,9 @@ class Xliff2Parser {
     visitComment(comment, context) { }
     visitExpansion(expansion, context) { }
     visitExpansionCase(expansionCase, context) { }
+    visitBlockGroup(group, context) { }
+    visitBlock(block, context) { }
+    visitBlockParameter(parameter, context) { }
     _addError(node, message) {
         this._errors.push(new I18nError(node.sourceSpan, message));
     }
@@ -24774,6 +25697,9 @@ class XmlToI18n$1 {
     }
     visitComment(comment, context) { }
     visitAttribute(attribute, context) { }
+    visitBlockGroup(group, context) { }
+    visitBlock(block, context) { }
+    visitBlockParameter(parameter, context) { }
     _addError(node, message) {
         this._errors.push(new I18nError(node.sourceSpan, message));
     }
@@ -24908,6 +25834,9 @@ class XtbParser {
     visitComment(comment, context) { }
     visitExpansion(expansion, context) { }
     visitExpansionCase(expansionCase, context) { }
+    visitBlockGroup(group, context) { }
+    visitBlock(block, context) { }
+    visitBlockParameter(block, context) { }
     _addError(node, message) {
         this._errors.push(new I18nError(node.sourceSpan, message));
     }
@@ -24956,6 +25885,9 @@ class XmlToI18n {
     }
     visitComment(comment, context) { }
     visitAttribute(attribute, context) { }
+    visitBlockGroup(group, context) { }
+    visitBlock(block, context) { }
+    visitBlockParameter(block, context) { }
     _addError(node, message) {
         this._errors.push(new I18nError(node.sourceSpan, message));
     }
@@ -25744,7 +26676,7 @@ const MINIMUM_PARTIAL_LINKER_VERSION$6 = '12.0.0';
 function compileDeclareClassMetadata(metadata) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$6));
-    definitionMap.set('version', literal('16.2.0-next.0'));
+    definitionMap.set('version', literal('16.2.0-next.2'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('decorators', metadata.decorators);
@@ -25847,7 +26779,7 @@ function compileDeclareDirectiveFromMetadata(meta) {
 function createDirectiveDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$5));
-    definitionMap.set('version', literal('16.2.0-next.0'));
+    definitionMap.set('version', literal('16.2.0-next.2'));
     // e.g. `type: MyDirective`
     definitionMap.set('type', meta.type.value);
     if (meta.isStandalone) {
@@ -26075,7 +27007,7 @@ const MINIMUM_PARTIAL_LINKER_VERSION$4 = '12.0.0';
 function compileDeclareFactoryFunction(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$4));
-    definitionMap.set('version', literal('16.2.0-next.0'));
+    definitionMap.set('version', literal('16.2.0-next.2'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('deps', compileDependencies(meta.deps));
@@ -26110,7 +27042,7 @@ function compileDeclareInjectableFromMetadata(meta) {
 function createInjectableDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$3));
-    definitionMap.set('version', literal('16.2.0-next.0'));
+    definitionMap.set('version', literal('16.2.0-next.2'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     // Only generate providedIn property if it has a non-null value
@@ -26161,7 +27093,7 @@ function compileDeclareInjectorFromMetadata(meta) {
 function createInjectorDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$2));
-    definitionMap.set('version', literal('16.2.0-next.0'));
+    definitionMap.set('version', literal('16.2.0-next.2'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('providers', meta.providers);
@@ -26190,8 +27122,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_VERSION$1));
-    definitionMap.set('version', literal('16.2.0-next.0'));
+    definitionMap.set('version', literal('16.2.0-next.2'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     // We only generate the keys in the metadata if the arrays contain values.
@@ -26242,7 +27177,7 @@ function compileDeclarePipeFromMetadata(meta) {
 function createPipeDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION));
-    definitionMap.set('version', literal('16.2.0-next.0'));
+    definitionMap.set('version', literal('16.2.0-next.2'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     // e.g. `type: MyPipe`
     definitionMap.set('type', meta.type.value);
@@ -26275,5 +27210,5 @@ publishFacade(_global);
 
 // This file is not used to build this module. It is only used during editing
 
-export { AST, ASTWithName, ASTWithSource, AbsoluteSourceSpan, ArrayType, AstMemoryEfficientTransformer, AstTransformer, Attribute, Binary, BinaryOperator, BinaryOperatorExpr, BindingPipe, BoundElementProperty, BuiltinType, BuiltinTypeName, CUSTOM_ELEMENTS_SCHEMA, Call, Chain, ChangeDetectionStrategy, CommaExpr, Comment, CompilerConfig, Conditional, ConditionalExpr, ConstantPool, CssSelector, DEFAULT_INTERPOLATION_CONFIG, DYNAMIC_TYPE, DeclareFunctionStmt, DeclareVarStmt, DomElementSchemaRegistry, EOF, Element, ElementSchemaRegistry, EmitterVisitorContext, EmptyExpr, Expansion, ExpansionCase, Expression, ExpressionBinding, ExpressionStatement, ExpressionType, ExternalExpr, ExternalReference, FactoryTarget$1 as FactoryTarget, FunctionExpr, HtmlParser, HtmlTagDefinition, I18NHtmlParser, IfStmt, ImplicitReceiver, InstantiateExpr, Interpolation, InterpolationConfig, InvokeFunctionExpr, JSDocComment, JitEvaluator, KeyedRead, KeyedWrite, LeadingComment, Lexer, LiteralArray, LiteralArrayExpr, LiteralExpr, LiteralMap, LiteralMapExpr, LiteralPrimitive, LocalizedString, MapType, MessageBundle, NONE_TYPE, NO_ERRORS_SCHEMA, NodeWithI18n, NonNullAssert, NotExpr, ParseError, ParseErrorLevel, ParseLocation, ParseSourceFile, ParseSourceSpan, ParseSpan, ParseTreeResult, ParsedEvent, ParsedProperty, ParsedPropertyType, ParsedVariable, Parser$1 as Parser, ParserError, PrefixNot, PropertyRead, PropertyWrite, R3BoundTarget, Identifiers as R3Identifiers, R3SelectorScopeMode, R3TargetBinder, R3TemplateDependencyKind, ReadKeyExpr, ReadPropExpr, ReadVarExpr, RecursiveAstVisitor, RecursiveVisitor, ResourceLoader, ReturnStatement, STRING_TYPE, SafeCall, SafeKeyedRead, SafePropertyRead, SelectorContext, SelectorListContext, SelectorMatcher, Serializer, SplitInterpolation, Statement, StmtModifier, TagContentType, TaggedTemplateExpr, TemplateBindingParseResult, TemplateLiteral, TemplateLiteralElement, Text, ThisReceiver, BoundAttribute as TmplAstBoundAttribute, BoundEvent as TmplAstBoundEvent, BoundText as TmplAstBoundText, Content as TmplAstContent, Element$1 as TmplAstElement, Icu$1 as TmplAstIcu, RecursiveVisitor$1 as TmplAstRecursiveVisitor, Reference as TmplAstReference, Template as TmplAstTemplate, Text$3 as TmplAstText, TextAttribute as TmplAstTextAttribute, Variable as TmplAstVariable, Token, TokenType, TransplantedType, TreeError, Type, TypeModifier, TypeofExpr, Unary, UnaryOperator, UnaryOperatorExpr, VERSION, VariableBinding, Version, ViewEncapsulation, WrappedNodeExpr, WriteKeyExpr, WritePropExpr, WriteVarExpr, Xliff, Xliff2, Xmb, XmlParser, Xtb, _ParseAST, compileClassMetadata, compileComponentFromMetadata, compileDeclareClassMetadata, compileDeclareComponentFromMetadata, compileDeclareDirectiveFromMetadata, compileDeclareFactoryFunction, compileDeclareInjectableFromMetadata, compileDeclareInjectorFromMetadata, compileDeclareNgModuleFromMetadata, compileDeclarePipeFromMetadata, compileDirectiveFromMetadata, compileFactoryFunction, compileInjectable, compileInjector, compileNgModule, compilePipeFromMetadata, computeMsgId, core, createInjectableType, createMayBeForwardRefExpression, devOnlyGuardedExpression, emitDistinctChangesOnlyDefaultValue, getHtmlTagDefinition, getNsPrefix, getSafePropertyAccessString, identifierName, isIdentifier, isNgContainer, isNgContent, isNgTemplate, jsDocComment, leadingComment, literalMap, makeBindingParser, mergeNsAndName, output_ast as outputAst, parseHostBindings, parseTemplate, preserveWhitespacesDefault, publishFacade, r3JitTypeSourceSpan, sanitizeIdentifier, splitNsName, verifyHostBindings, visitAll };
+export { AST, ASTWithName, ASTWithSource, AbsoluteSourceSpan, ArrayType, AstMemoryEfficientTransformer, AstTransformer, Attribute, Binary, BinaryOperator, BinaryOperatorExpr, BindingPipe, Block, BlockGroup, BlockParameter, BoundElementProperty, BuiltinType, BuiltinTypeName, CUSTOM_ELEMENTS_SCHEMA, Call, Chain, ChangeDetectionStrategy, CommaExpr, Comment, CompilerConfig, Conditional, ConditionalExpr, ConstantPool, CssSelector, DEFAULT_INTERPOLATION_CONFIG, DYNAMIC_TYPE, DeclareFunctionStmt, DeclareVarStmt, DomElementSchemaRegistry, EOF, Element, ElementSchemaRegistry, EmitterVisitorContext, EmptyExpr$1 as EmptyExpr, Expansion, ExpansionCase, Expression, ExpressionBinding, ExpressionStatement, ExpressionType, ExternalExpr, ExternalReference, FactoryTarget$1 as FactoryTarget, FunctionExpr, HtmlParser, HtmlTagDefinition, I18NHtmlParser, IfStmt, ImplicitReceiver, InstantiateExpr, Interpolation, InterpolationConfig, InvokeFunctionExpr, JSDocComment, JitEvaluator, KeyedRead, KeyedWrite, LeadingComment, Lexer, LiteralArray, LiteralArrayExpr, LiteralExpr, LiteralMap, LiteralMapExpr, LiteralPrimitive, LocalizedString, MapType, MessageBundle, NONE_TYPE, NO_ERRORS_SCHEMA, NodeWithI18n, NonNullAssert, NotExpr, ParseError, ParseErrorLevel, ParseLocation, ParseSourceFile, ParseSourceSpan, ParseSpan, ParseTreeResult, ParsedEvent, ParsedProperty, ParsedPropertyType, ParsedVariable, Parser$1 as Parser, ParserError, PrefixNot, PropertyRead, PropertyWrite, R3BoundTarget, Identifiers as R3Identifiers, R3NgModuleMetadataKind, R3SelectorScopeMode, R3TargetBinder, R3TemplateDependencyKind, ReadKeyExpr, ReadPropExpr, ReadVarExpr, RecursiveAstVisitor, RecursiveVisitor, ResourceLoader, ReturnStatement, STRING_TYPE, SafeCall, SafeKeyedRead, SafePropertyRead, SelectorContext, SelectorListContext, SelectorMatcher, Serializer, SplitInterpolation, Statement, StmtModifier, TagContentType, TaggedTemplateExpr, TemplateBindingParseResult, TemplateLiteral, TemplateLiteralElement, Text, ThisReceiver, BoundAttribute as TmplAstBoundAttribute, BoundEvent as TmplAstBoundEvent, BoundText as TmplAstBoundText, Content as TmplAstContent, Element$1 as TmplAstElement, Icu$1 as TmplAstIcu, RecursiveVisitor$1 as TmplAstRecursiveVisitor, Reference as TmplAstReference, Template as TmplAstTemplate, Text$3 as TmplAstText, TextAttribute as TmplAstTextAttribute, Variable as TmplAstVariable, Token, TokenType, TransplantedType, TreeError, Type, TypeModifier, TypeofExpr, Unary, UnaryOperator, UnaryOperatorExpr, VERSION, VariableBinding, Version, ViewEncapsulation, WrappedNodeExpr, WriteKeyExpr, WritePropExpr, WriteVarExpr, Xliff, Xliff2, Xmb, XmlParser, Xtb, _ParseAST, compileClassMetadata, compileComponentFromMetadata, compileDeclareClassMetadata, compileDeclareComponentFromMetadata, compileDeclareDirectiveFromMetadata, compileDeclareFactoryFunction, compileDeclareInjectableFromMetadata, compileDeclareInjectorFromMetadata, compileDeclareNgModuleFromMetadata, compileDeclarePipeFromMetadata, compileDirectiveFromMetadata, compileFactoryFunction, compileInjectable, compileInjector, compileNgModule, compilePipeFromMetadata, computeMsgId, core, createInjectableType, createMayBeForwardRefExpression, devOnlyGuardedExpression, emitDistinctChangesOnlyDefaultValue, getHtmlTagDefinition, getNsPrefix, getSafePropertyAccessString, identifierName, isIdentifier, isNgContainer, isNgContent, isNgTemplate, jsDocComment, leadingComment, literalMap, makeBindingParser, mergeNsAndName, output_ast as outputAst, parseHostBindings, parseTemplate, preserveWhitespacesDefault, publishFacade, r3JitTypeSourceSpan, sanitizeIdentifier, splitNsName, verifyHostBindings, visitAll };
 //# sourceMappingURL=compiler.mjs.map