@wavemaker/angular-codegen 11.7.0-next.42251 → 11.7.0-rc.5525

angular-codegen/dependencies/expression-parser.cjs.js

@@ -1,7 +1,7 @@
 'use strict';
 
 /**
- * @license Angular v15.2.9
+ * @license Angular v16.2.12
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -500,7 +500,7 @@ class _SerializerIgnoreIcuExpVisitor extends _SerializerVisitor {
  *          DO NOT USE IT IN A SECURITY SENSITIVE CONTEXT.
  */
 function sha1(str) {
-    textEncoder ?? (textEncoder = new TextEncoder());
+    textEncoder ??= new TextEncoder();
     const utf8 = [...textEncoder.encode(str)];
     const words32 = bytesToWords32(utf8, Endian.Big);
     const len = utf8.length * 8;
@@ -566,7 +566,7 @@ function fk(index, b, c, d) {
  * https://github.com/google/closure-compiler/blob/master/src/com/google/javascript/jscomp/GoogleJsMessageIdGenerator.java
  */
 function fingerprint(str) {
-    textEncoder ?? (textEncoder = new TextEncoder());
+    textEncoder ??= new TextEncoder();
     const utf8 = textEncoder.encode(str);
     const view = new DataView(utf8.buffer, utf8.byteOffset, utf8.byteLength);
     let hi = hash32(view, utf8.length, 0);
@@ -955,6 +955,9 @@ class ReadVarExpr extends Expression {
     visitExpression(visitor, context) {
         return visitor.visitReadVarExpr(this, context);
     }
+    clone() {
+        return new ReadVarExpr(this.name, this.type, this.sourceSpan);
+    }
     set(value) {
         return new WriteVarExpr(this.name, value, null, this.sourceSpan);
     }
@@ -973,6 +976,9 @@ class TypeofExpr extends Expression {
     isConstant() {
         return this.expr.isConstant();
     }
+    clone() {
+        return new TypeofExpr(this.expr.clone());
+    }
 }
 class WrappedNodeExpr extends Expression {
     constructor(node, type, sourceSpan) {
@@ -988,6 +994,9 @@ class WrappedNodeExpr extends Expression {
     visitExpression(visitor, context) {
         return visitor.visitWrappedNodeExpr(this, context);
     }
+    clone() {
+        return new WrappedNodeExpr(this.node, this.type, this.sourceSpan);
+    }
 }
 class WriteVarExpr extends Expression {
     constructor(name, value, type, sourceSpan) {
@@ -1004,6 +1013,9 @@ class WriteVarExpr extends Expression {
     visitExpression(visitor, context) {
         return visitor.visitWriteVarExpr(this, context);
     }
+    clone() {
+        return new WriteVarExpr(this.name, this.value.clone(), this.type, this.sourceSpan);
+    }
     toDeclStmt(type, modifiers) {
         return new DeclareVarStmt(this.name, this.value, type, modifiers, this.sourceSpan);
     }
@@ -1028,6 +1040,9 @@ class WriteKeyExpr extends Expression {
     visitExpression(visitor, context) {
         return visitor.visitWriteKeyExpr(this, context);
     }
+    clone() {
+        return new WriteKeyExpr(this.receiver.clone(), this.index.clone(), this.value.clone(), this.type, this.sourceSpan);
+    }
 }
 class WritePropExpr extends Expression {
     constructor(receiver, name, value, type, sourceSpan) {
@@ -1046,6 +1061,9 @@ class WritePropExpr extends Expression {
     visitExpression(visitor, context) {
         return visitor.visitWritePropExpr(this, context);
     }
+    clone() {
+        return new WritePropExpr(this.receiver.clone(), this.name, this.value.clone(), this.type, this.sourceSpan);
+    }
 }
 class InvokeFunctionExpr extends Expression {
     constructor(fn, args, type, sourceSpan, pure = false) {
@@ -1054,6 +1072,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;
@@ -1064,6 +1086,9 @@ class InvokeFunctionExpr extends Expression {
     visitExpression(visitor, context) {
         return visitor.visitInvokeFunctionExpr(this, context);
     }
+    clone() {
+        return new InvokeFunctionExpr(this.fn.clone(), this.args.map(arg => arg.clone()), this.type, this.sourceSpan, this.pure);
+    }
 }
 class TaggedTemplateExpr extends Expression {
     constructor(tag, template, type, sourceSpan) {
@@ -1082,6 +1107,9 @@ class TaggedTemplateExpr extends Expression {
     visitExpression(visitor, context) {
         return visitor.visitTaggedTemplateExpr(this, context);
     }
+    clone() {
+        return new TaggedTemplateExpr(this.tag.clone(), this.template.clone(), this.type, this.sourceSpan);
+    }
 }
 class InstantiateExpr extends Expression {
     constructor(classExpr, args, type, sourceSpan) {
@@ -1099,6 +1127,9 @@ class InstantiateExpr extends Expression {
     visitExpression(visitor, context) {
         return visitor.visitInstantiateExpr(this, context);
     }
+    clone() {
+        return new InstantiateExpr(this.classExpr.clone(), this.args.map(arg => arg.clone()), this.type, this.sourceSpan);
+    }
 }
 class LiteralExpr extends Expression {
     constructor(value, type, sourceSpan) {
@@ -1114,12 +1145,18 @@ class LiteralExpr extends Expression {
     visitExpression(visitor, context) {
         return visitor.visitLiteralExpr(this, context);
     }
+    clone() {
+        return new LiteralExpr(this.value, this.type, this.sourceSpan);
+    }
 }
 class TemplateLiteral {
     constructor(elements, expressions) {
         this.elements = elements;
         this.expressions = expressions;
     }
+    clone() {
+        return new TemplateLiteral(this.elements.map(el => el.clone()), this.expressions.map(expr => expr.clone()));
+    }
 }
 class TemplateLiteralElement {
     constructor(text, sourceSpan, rawText) {
@@ -1134,6 +1171,9 @@ class TemplateLiteralElement {
         this.rawText =
             rawText ?? sourceSpan?.toString() ?? escapeForTemplateLiteral(escapeSlashes(text));
     }
+    clone() {
+        return new TemplateLiteralElement(this.text, this.sourceSpan, this.rawText);
+    }
 }
 class LiteralPiece {
     constructor(text, sourceSpan) {
@@ -1178,6 +1218,9 @@ class LocalizedString extends Expression {
     visitExpression(visitor, context) {
         return visitor.visitLocalizedString(this, context);
     }
+    clone() {
+        return new LocalizedString(this.metaBlock, this.messageParts, this.placeHolderNames, this.expressions.map(expr => expr.clone()), this.sourceSpan);
+    }
     /**
      * Serialize the given `meta` and `messagePart` into "cooked" and "raw" strings that can be used
      * in a `$localize` tagged string. The format of the metadata is the same as that parsed by
@@ -1279,6 +1322,9 @@ class ExternalExpr extends Expression {
     visitExpression(visitor, context) {
         return visitor.visitExternalExpr(this, context);
     }
+    clone() {
+        return new ExternalExpr(this.value, this.type, this.typeParams, this.sourceSpan);
+    }
 }
 class ConditionalExpr extends Expression {
     constructor(condition, trueCase, falseCase = null, type, sourceSpan) {
@@ -1297,6 +1343,27 @@ class ConditionalExpr extends Expression {
     visitExpression(visitor, context) {
         return visitor.visitConditionalExpr(this, context);
     }
+    clone() {
+        return new ConditionalExpr(this.condition.clone(), this.trueCase.clone(), this.falseCase?.clone(), this.type, this.sourceSpan);
+    }
+}
+class DynamicImportExpr extends Expression {
+    constructor(url, sourceSpan) {
+        super(null, sourceSpan);
+        this.url = url;
+    }
+    isEquivalent(e) {
+        return e instanceof DynamicImportExpr && this.url === e.url;
+    }
+    isConstant() {
+        return false;
+    }
+    visitExpression(visitor, context) {
+        return visitor.visitDynamicImportExpr(this, context);
+    }
+    clone() {
+        return new DynamicImportExpr(this.url, this.sourceSpan);
+    }
 }
 class NotExpr extends Expression {
     constructor(condition, sourceSpan) {
@@ -1312,6 +1379,9 @@ class NotExpr extends Expression {
     visitExpression(visitor, context) {
         return visitor.visitNotExpr(this, context);
     }
+    clone() {
+        return new NotExpr(this.condition.clone(), this.sourceSpan);
+    }
 }
 class FnParam {
     constructor(name, type = null) {
@@ -1321,6 +1391,9 @@ class FnParam {
     isEquivalent(param) {
         return this.name === param.name;
     }
+    clone() {
+        return new FnParam(this.name, this.type);
+    }
 }
 class FunctionExpr extends Expression {
     constructor(params, statements, type, sourceSpan, name) {
@@ -1342,6 +1415,10 @@ class FunctionExpr extends Expression {
     toDeclStmt(name, modifiers) {
         return new DeclareFunctionStmt(name, this.params, this.statements, this.type, modifiers, this.sourceSpan);
     }
+    clone() {
+        // TODO: Should we deep clone statements?
+        return new FunctionExpr(this.params.map(p => p.clone()), this.statements, this.type, this.sourceSpan, this.name);
+    }
 }
 class UnaryOperatorExpr extends Expression {
     constructor(operator, expr, type, sourceSpan, parens = true) {
@@ -1360,6 +1437,9 @@ class UnaryOperatorExpr extends Expression {
     visitExpression(visitor, context) {
         return visitor.visitUnaryOperatorExpr(this, context);
     }
+    clone() {
+        return new UnaryOperatorExpr(this.operator, this.expr.clone(), this.type, this.sourceSpan, this.parens);
+    }
 }
 class BinaryOperatorExpr extends Expression {
     constructor(operator, lhs, rhs, type, sourceSpan, parens = true) {
@@ -1379,6 +1459,9 @@ class BinaryOperatorExpr extends Expression {
     visitExpression(visitor, context) {
         return visitor.visitBinaryOperatorExpr(this, context);
     }
+    clone() {
+        return new BinaryOperatorExpr(this.operator, this.lhs.clone(), this.rhs.clone(), this.type, this.sourceSpan, this.parens);
+    }
 }
 class ReadPropExpr extends Expression {
     constructor(receiver, name, type, sourceSpan) {
@@ -1386,6 +1469,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;
@@ -1399,6 +1486,9 @@ class ReadPropExpr extends Expression {
     set(value) {
         return new WritePropExpr(this.receiver, this.name, value, null, this.sourceSpan);
     }
+    clone() {
+        return new ReadPropExpr(this.receiver.clone(), this.name, this.type, this.sourceSpan);
+    }
 }
 class ReadKeyExpr extends Expression {
     constructor(receiver, index, type, sourceSpan) {
@@ -1419,6 +1509,9 @@ class ReadKeyExpr extends Expression {
     set(value) {
         return new WriteKeyExpr(this.receiver, this.index, value, null, this.sourceSpan);
     }
+    clone() {
+        return new ReadKeyExpr(this.receiver.clone(), this.index.clone(), this.type, this.sourceSpan);
+    }
 }
 class LiteralArrayExpr extends Expression {
     constructor(entries, type, sourceSpan) {
@@ -1434,6 +1527,9 @@ class LiteralArrayExpr extends Expression {
     visitExpression(visitor, context) {
         return visitor.visitLiteralArrayExpr(this, context);
     }
+    clone() {
+        return new LiteralArrayExpr(this.entries.map(e => e.clone()), this.type, this.sourceSpan);
+    }
 }
 class LiteralMapEntry {
     constructor(key, value, quoted) {
@@ -1444,6 +1540,9 @@ class LiteralMapEntry {
     isEquivalent(e) {
         return this.key === e.key && this.value.isEquivalent(e.value);
     }
+    clone() {
+        return new LiteralMapEntry(this.key, this.value.clone(), this.quoted);
+    }
 }
 class LiteralMapExpr extends Expression {
     constructor(entries, type, sourceSpan) {
@@ -1463,6 +1562,10 @@ class LiteralMapExpr extends Expression {
     visitExpression(visitor, context) {
         return visitor.visitLiteralMapExpr(this, context);
     }
+    clone() {
+        const entriesClone = this.entries.map(entry => entry.clone());
+        return new LiteralMapExpr(entriesClone, this.type, this.sourceSpan);
+    }
 }
 const NULL_EXPR = new LiteralExpr(null, null, null);
 const TYPED_NULL_EXPR = new LiteralExpr(null, INFERRED_TYPE, null);
@@ -1691,6 +1794,7 @@ class FixupExpression extends Expression {
     constructor(resolved) {
         super(resolved.type);
         this.resolved = resolved;
+        this.shared = false;
         this.original = resolved;
     }
     visitExpression(visitor, context) {
@@ -1709,6 +1813,9 @@ class FixupExpression extends Expression {
     isConstant() {
         return true;
     }
+    clone() {
+        throw new Error(`Not supported.`);
+    }
     fixup(expression) {
         this.resolved = expression;
         this.shared = true;
@@ -1725,6 +1832,7 @@ class ConstantPool {
         this.statements = [];
         this.literals = new Map();
         this.literalFactories = new Map();
+        this.sharedConstants = new Map();
         this.nextNameIndex = 0;
     }
     getConstLiteral(literal, forceShared) {
@@ -1734,7 +1842,7 @@ class ConstantPool {
             // reference to a constant.
             return literal;
         }
-        const key = this.keyOf(literal);
+        const key = GenericKeyFn.INSTANCE.keyOf(literal);
         let fixup = this.literals.get(key);
         let newValue = false;
         if (!fixup) {
@@ -1779,11 +1887,20 @@ class ConstantPool {
         }
         return fixup;
     }
+    getSharedConstant(def, expr) {
+        const key = def.keyOf(expr);
+        if (!this.sharedConstants.has(key)) {
+            const id = this.freshName();
+            this.sharedConstants.set(key, variable(id));
+            this.statements.push(def.toSharedConstantDeclaration(id, expr));
+        }
+        return this.sharedConstants.get(key);
+    }
     getLiteralFactory(literal) {
         // Create a pure function that builds an array of a mix of constant and variable expressions
         if (literal instanceof LiteralArrayExpr) {
             const argumentsForKey = literal.entries.map(e => e.isConstant() ? e : UNKNOWN_VALUE_KEY);
-            const key = this.keyOf(literalArr(argumentsForKey));
+            const key = GenericKeyFn.INSTANCE.keyOf(literalArr(argumentsForKey));
             return this._getLiteralFactory(key, literal.entries, entries => literalArr(entries));
         }
         else {
@@ -1792,7 +1909,7 @@ class ConstantPool {
                 value: e.value.isConstant() ? e.value : UNKNOWN_VALUE_KEY,
                 quoted: e.quoted
             })));
-            const key = this.keyOf(expressionForKey);
+            const key = GenericKeyFn.INSTANCE.keyOf(expressionForKey);
             return this._getLiteralFactory(key, literal.entries.map(e => e.value), entries => literalMap(entries.map((value, index) => ({
                 key: literal.entries[index].key,
                 value,
@@ -1829,65 +1946,48 @@ class ConstantPool {
     freshName() {
         return this.uniqueName(CONSTANT_PREFIX);
     }
-    keyOf(expression) {
-        return expression.visitExpression(new KeyVisitor(), KEY_CONTEXT);
-    }
 }
-/**
- * Visitor used to determine if 2 expressions are equivalent and can be shared in the
- * `ConstantPool`.
- *
- * When the id (string) generated by the visitor is equal, expressions are considered equivalent.
- */
-class KeyVisitor {
-    constructor() {
-        this.visitWrappedNodeExpr = invalid$1;
-        this.visitWriteVarExpr = invalid$1;
-        this.visitWriteKeyExpr = invalid$1;
-        this.visitWritePropExpr = invalid$1;
-        this.visitInvokeFunctionExpr = invalid$1;
-        this.visitTaggedTemplateExpr = invalid$1;
-        this.visitInstantiateExpr = invalid$1;
-        this.visitConditionalExpr = invalid$1;
-        this.visitNotExpr = invalid$1;
-        this.visitAssertNotNullExpr = invalid$1;
-        this.visitCastExpr = invalid$1;
-        this.visitFunctionExpr = invalid$1;
-        this.visitUnaryOperatorExpr = invalid$1;
-        this.visitBinaryOperatorExpr = invalid$1;
-        this.visitReadPropExpr = invalid$1;
-        this.visitReadKeyExpr = invalid$1;
-        this.visitCommaExpr = invalid$1;
-        this.visitLocalizedString = invalid$1;
-    }
-    visitLiteralExpr(ast) {
-        return `${typeof ast.value === 'string' ? '"' + ast.value + '"' : ast.value}`;
-    }
-    visitLiteralArrayExpr(ast, context) {
-        return `[${ast.entries.map(entry => entry.visitExpression(this, context)).join(',')}]`;
-    }
-    visitLiteralMapExpr(ast, context) {
-        const mapKey = (entry) => {
-            const quote = entry.quoted ? '"' : '';
-            return `${quote}${entry.key}${quote}`;
-        };
-        const mapEntry = (entry) => `${mapKey(entry)}:${entry.value.visitExpression(this, context)}`;
-        return `{${ast.entries.map(mapEntry).join(',')}`;
-    }
-    visitExternalExpr(ast) {
-        return ast.value.moduleName ? `EX:${ast.value.moduleName}:${ast.value.name}` :
-            `EX:${ast.value.runtime.name}`;
-    }
-    visitReadVarExpr(node) {
-        return `VAR:${node.name}`;
-    }
-    visitTypeofExpr(node, context) {
-        return `TYPEOF:${node.expr.visitExpression(this, context)}`;
+class GenericKeyFn {
+    static { this.INSTANCE = new GenericKeyFn(); }
+    keyOf(expr) {
+        if (expr instanceof LiteralExpr && typeof expr.value === 'string') {
+            return `"${expr.value}"`;
+        }
+        else if (expr instanceof LiteralExpr) {
+            return String(expr.value);
+        }
+        else if (expr instanceof LiteralArrayExpr) {
+            const entries = [];
+            for (const entry of expr.entries) {
+                entries.push(this.keyOf(entry));
+            }
+            return `[${entries.join(',')}]`;
+        }
+        else if (expr instanceof LiteralMapExpr) {
+            const entries = [];
+            for (const entry of expr.entries) {
+                let key = entry.key;
+                if (entry.quoted) {
+                    key = `"${key}"`;
+                }
+                entries.push(key + ':' + this.keyOf(entry.value));
+            }
+            return `{${entries.join(',')}}`;
+        }
+        else if (expr instanceof ExternalExpr) {
+            return `import("${expr.value.moduleName}", ${expr.value.name})`;
+        }
+        else if (expr instanceof ReadVarExpr) {
+            return `read(${expr.name})`;
+        }
+        else if (expr instanceof TypeofExpr) {
+            return `typeof(${this.keyOf(expr.expr)})`;
+        }
+        else {
+            throw new Error(`${this.constructor.name} does not handle expressions of type ${expr.constructor.name}`);
+        }
     }
 }
-function invalid$1(arg) {
-    throw new Error(`Invalid state: Visitor ${this.constructor.name} doesn't handle ${arg.constructor.name}`);
-}
 function isVariable(e) {
     return e instanceof ReadVarExpr;
 }
@@ -1898,209 +1998,211 @@ function isLongStringLiteral(expr) {
 
 const CORE = '@angular/core';
 class Identifiers {
+    /* Methods */
+    static { this.NEW_METHOD = 'factory'; }
+    static { this.TRANSFORM_METHOD = 'transform'; }
+    static { this.PATCH_DEPS = 'patchedDeps'; }
+    static { this.core = { name: null, moduleName: CORE }; }
+    /* Instructions */
+    static { this.namespaceHTML = { name: 'ɵɵnamespaceHTML', moduleName: CORE }; }
+    static { this.namespaceMathML = { name: 'ɵɵnamespaceMathML', moduleName: CORE }; }
+    static { this.namespaceSVG = { name: 'ɵɵnamespaceSVG', moduleName: CORE }; }
+    static { this.element = { name: 'ɵɵelement', moduleName: CORE }; }
+    static { this.elementStart = { name: 'ɵɵelementStart', moduleName: CORE }; }
+    static { this.elementEnd = { name: 'ɵɵelementEnd', moduleName: CORE }; }
+    static { this.advance = { name: 'ɵɵadvance', moduleName: CORE }; }
+    static { this.syntheticHostProperty = { name: 'ɵɵsyntheticHostProperty', moduleName: CORE }; }
+    static { this.syntheticHostListener = { name: 'ɵɵsyntheticHostListener', moduleName: CORE }; }
+    static { this.attribute = { name: 'ɵɵattribute', moduleName: CORE }; }
+    static { this.attributeInterpolate1 = { name: 'ɵɵattributeInterpolate1', moduleName: CORE }; }
+    static { this.attributeInterpolate2 = { name: 'ɵɵattributeInterpolate2', moduleName: CORE }; }
+    static { this.attributeInterpolate3 = { name: 'ɵɵattributeInterpolate3', moduleName: CORE }; }
+    static { this.attributeInterpolate4 = { name: 'ɵɵattributeInterpolate4', moduleName: CORE }; }
+    static { this.attributeInterpolate5 = { name: 'ɵɵattributeInterpolate5', moduleName: CORE }; }
+    static { this.attributeInterpolate6 = { name: 'ɵɵattributeInterpolate6', moduleName: CORE }; }
+    static { this.attributeInterpolate7 = { name: 'ɵɵattributeInterpolate7', moduleName: CORE }; }
+    static { this.attributeInterpolate8 = { name: 'ɵɵattributeInterpolate8', moduleName: CORE }; }
+    static { this.attributeInterpolateV = { name: 'ɵɵattributeInterpolateV', moduleName: CORE }; }
+    static { this.classProp = { name: 'ɵɵclassProp', moduleName: CORE }; }
+    static { this.elementContainerStart = { name: 'ɵɵelementContainerStart', moduleName: CORE }; }
+    static { this.elementContainerEnd = { name: 'ɵɵelementContainerEnd', moduleName: CORE }; }
+    static { this.elementContainer = { name: 'ɵɵelementContainer', moduleName: CORE }; }
+    static { this.styleMap = { name: 'ɵɵstyleMap', moduleName: CORE }; }
+    static { this.styleMapInterpolate1 = { name: 'ɵɵstyleMapInterpolate1', moduleName: CORE }; }
+    static { this.styleMapInterpolate2 = { name: 'ɵɵstyleMapInterpolate2', moduleName: CORE }; }
+    static { this.styleMapInterpolate3 = { name: 'ɵɵstyleMapInterpolate3', moduleName: CORE }; }
+    static { this.styleMapInterpolate4 = { name: 'ɵɵstyleMapInterpolate4', moduleName: CORE }; }
+    static { this.styleMapInterpolate5 = { name: 'ɵɵstyleMapInterpolate5', moduleName: CORE }; }
+    static { this.styleMapInterpolate6 = { name: 'ɵɵstyleMapInterpolate6', moduleName: CORE }; }
+    static { this.styleMapInterpolate7 = { name: 'ɵɵstyleMapInterpolate7', moduleName: CORE }; }
+    static { this.styleMapInterpolate8 = { name: 'ɵɵstyleMapInterpolate8', moduleName: CORE }; }
+    static { this.styleMapInterpolateV = { name: 'ɵɵstyleMapInterpolateV', moduleName: CORE }; }
+    static { this.classMap = { name: 'ɵɵclassMap', moduleName: CORE }; }
+    static { this.classMapInterpolate1 = { name: 'ɵɵclassMapInterpolate1', moduleName: CORE }; }
+    static { this.classMapInterpolate2 = { name: 'ɵɵclassMapInterpolate2', moduleName: CORE }; }
+    static { this.classMapInterpolate3 = { name: 'ɵɵclassMapInterpolate3', moduleName: CORE }; }
+    static { this.classMapInterpolate4 = { name: 'ɵɵclassMapInterpolate4', moduleName: CORE }; }
+    static { this.classMapInterpolate5 = { name: 'ɵɵclassMapInterpolate5', moduleName: CORE }; }
+    static { this.classMapInterpolate6 = { name: 'ɵɵclassMapInterpolate6', moduleName: CORE }; }
+    static { this.classMapInterpolate7 = { name: 'ɵɵclassMapInterpolate7', moduleName: CORE }; }
+    static { this.classMapInterpolate8 = { name: 'ɵɵclassMapInterpolate8', moduleName: CORE }; }
+    static { this.classMapInterpolateV = { name: 'ɵɵclassMapInterpolateV', moduleName: CORE }; }
+    static { this.styleProp = { name: 'ɵɵstyleProp', moduleName: CORE }; }
+    static { this.stylePropInterpolate1 = { name: 'ɵɵstylePropInterpolate1', moduleName: CORE }; }
+    static { this.stylePropInterpolate2 = { name: 'ɵɵstylePropInterpolate2', moduleName: CORE }; }
+    static { this.stylePropInterpolate3 = { name: 'ɵɵstylePropInterpolate3', moduleName: CORE }; }
+    static { this.stylePropInterpolate4 = { name: 'ɵɵstylePropInterpolate4', moduleName: CORE }; }
+    static { this.stylePropInterpolate5 = { name: 'ɵɵstylePropInterpolate5', moduleName: CORE }; }
+    static { this.stylePropInterpolate6 = { name: 'ɵɵstylePropInterpolate6', moduleName: CORE }; }
+    static { this.stylePropInterpolate7 = { name: 'ɵɵstylePropInterpolate7', moduleName: CORE }; }
+    static { this.stylePropInterpolate8 = { name: 'ɵɵstylePropInterpolate8', moduleName: CORE }; }
+    static { this.stylePropInterpolateV = { name: 'ɵɵstylePropInterpolateV', moduleName: CORE }; }
+    static { this.nextContext = { name: 'ɵɵnextContext', moduleName: CORE }; }
+    static { this.resetView = { name: 'ɵɵresetView', moduleName: CORE }; }
+    static { this.templateCreate = { name: 'ɵɵtemplate', moduleName: CORE }; }
+    static { this.defer = { name: 'ɵɵdefer', moduleName: CORE }; }
+    static { this.text = { name: 'ɵɵtext', moduleName: CORE }; }
+    static { this.enableBindings = { name: 'ɵɵenableBindings', moduleName: CORE }; }
+    static { this.disableBindings = { name: 'ɵɵdisableBindings', moduleName: CORE }; }
+    static { this.getCurrentView = { name: 'ɵɵgetCurrentView', moduleName: CORE }; }
+    static { this.textInterpolate = { name: 'ɵɵtextInterpolate', moduleName: CORE }; }
+    static { this.textInterpolate1 = { name: 'ɵɵtextInterpolate1', moduleName: CORE }; }
+    static { this.textInterpolate2 = { name: 'ɵɵtextInterpolate2', moduleName: CORE }; }
+    static { this.textInterpolate3 = { name: 'ɵɵtextInterpolate3', moduleName: CORE }; }
+    static { this.textInterpolate4 = { name: 'ɵɵtextInterpolate4', moduleName: CORE }; }
+    static { this.textInterpolate5 = { name: 'ɵɵtextInterpolate5', moduleName: CORE }; }
+    static { this.textInterpolate6 = { name: 'ɵɵtextInterpolate6', moduleName: CORE }; }
+    static { this.textInterpolate7 = { name: 'ɵɵtextInterpolate7', moduleName: CORE }; }
+    static { this.textInterpolate8 = { name: 'ɵɵtextInterpolate8', moduleName: CORE }; }
+    static { this.textInterpolateV = { name: 'ɵɵtextInterpolateV', moduleName: CORE }; }
+    static { this.restoreView = { name: 'ɵɵrestoreView', moduleName: CORE }; }
+    static { this.pureFunction0 = { name: 'ɵɵpureFunction0', moduleName: CORE }; }
+    static { this.pureFunction1 = { name: 'ɵɵpureFunction1', moduleName: CORE }; }
+    static { this.pureFunction2 = { name: 'ɵɵpureFunction2', moduleName: CORE }; }
+    static { this.pureFunction3 = { name: 'ɵɵpureFunction3', moduleName: CORE }; }
+    static { this.pureFunction4 = { name: 'ɵɵpureFunction4', moduleName: CORE }; }
+    static { this.pureFunction5 = { name: 'ɵɵpureFunction5', moduleName: CORE }; }
+    static { this.pureFunction6 = { name: 'ɵɵpureFunction6', moduleName: CORE }; }
+    static { this.pureFunction7 = { name: 'ɵɵpureFunction7', moduleName: CORE }; }
+    static { this.pureFunction8 = { name: 'ɵɵpureFunction8', moduleName: CORE }; }
+    static { this.pureFunctionV = { name: 'ɵɵpureFunctionV', moduleName: CORE }; }
+    static { this.pipeBind1 = { name: 'ɵɵpipeBind1', moduleName: CORE }; }
+    static { this.pipeBind2 = { name: 'ɵɵpipeBind2', moduleName: CORE }; }
+    static { this.pipeBind3 = { name: 'ɵɵpipeBind3', moduleName: CORE }; }
+    static { this.pipeBind4 = { name: 'ɵɵpipeBind4', moduleName: CORE }; }
+    static { this.pipeBindV = { name: 'ɵɵpipeBindV', moduleName: CORE }; }
+    static { this.hostProperty = { name: 'ɵɵhostProperty', moduleName: CORE }; }
+    static { this.property = { name: 'ɵɵproperty', moduleName: CORE }; }
+    static { this.propertyInterpolate = { name: 'ɵɵpropertyInterpolate', moduleName: CORE }; }
+    static { this.propertyInterpolate1 = { name: 'ɵɵpropertyInterpolate1', moduleName: CORE }; }
+    static { this.propertyInterpolate2 = { name: 'ɵɵpropertyInterpolate2', moduleName: CORE }; }
+    static { this.propertyInterpolate3 = { name: 'ɵɵpropertyInterpolate3', moduleName: CORE }; }
+    static { this.propertyInterpolate4 = { name: 'ɵɵpropertyInterpolate4', moduleName: CORE }; }
+    static { this.propertyInterpolate5 = { name: 'ɵɵpropertyInterpolate5', moduleName: CORE }; }
+    static { this.propertyInterpolate6 = { name: 'ɵɵpropertyInterpolate6', moduleName: CORE }; }
+    static { this.propertyInterpolate7 = { name: 'ɵɵpropertyInterpolate7', moduleName: CORE }; }
+    static { this.propertyInterpolate8 = { name: 'ɵɵpropertyInterpolate8', moduleName: CORE }; }
+    static { this.propertyInterpolateV = { name: 'ɵɵpropertyInterpolateV', moduleName: CORE }; }
+    static { this.i18n = { name: 'ɵɵi18n', moduleName: CORE }; }
+    static { this.i18nAttributes = { name: 'ɵɵi18nAttributes', moduleName: CORE }; }
+    static { this.i18nExp = { name: 'ɵɵi18nExp', moduleName: CORE }; }
+    static { this.i18nStart = { name: 'ɵɵi18nStart', moduleName: CORE }; }
+    static { this.i18nEnd = { name: 'ɵɵi18nEnd', moduleName: CORE }; }
+    static { this.i18nApply = { name: 'ɵɵi18nApply', moduleName: CORE }; }
+    static { this.i18nPostprocess = { name: 'ɵɵi18nPostprocess', moduleName: CORE }; }
+    static { this.pipe = { name: 'ɵɵpipe', moduleName: CORE }; }
+    static { this.projection = { name: 'ɵɵprojection', moduleName: CORE }; }
+    static { this.projectionDef = { name: 'ɵɵprojectionDef', moduleName: CORE }; }
+    static { this.reference = { name: 'ɵɵreference', moduleName: CORE }; }
+    static { this.inject = { name: 'ɵɵinject', moduleName: CORE }; }
+    static { this.injectAttribute = { name: 'ɵɵinjectAttribute', moduleName: CORE }; }
+    static { this.directiveInject = { name: 'ɵɵdirectiveInject', moduleName: CORE }; }
+    static { this.invalidFactory = { name: 'ɵɵinvalidFactory', moduleName: CORE }; }
+    static { this.invalidFactoryDep = { name: 'ɵɵinvalidFactoryDep', moduleName: CORE }; }
+    static { this.templateRefExtractor = { name: 'ɵɵtemplateRefExtractor', moduleName: CORE }; }
+    static { this.forwardRef = { name: 'forwardRef', moduleName: CORE }; }
+    static { this.resolveForwardRef = { name: 'resolveForwardRef', moduleName: CORE }; }
+    static { this.ɵɵdefineInjectable = { name: 'ɵɵdefineInjectable', moduleName: CORE }; }
+    static { this.declareInjectable = { name: 'ɵɵngDeclareInjectable', moduleName: CORE }; }
+    static { this.InjectableDeclaration = { name: 'ɵɵInjectableDeclaration', moduleName: CORE }; }
+    static { this.resolveWindow = { name: 'ɵɵresolveWindow', moduleName: CORE }; }
+    static { this.resolveDocument = { name: 'ɵɵresolveDocument', moduleName: CORE }; }
+    static { this.resolveBody = { name: 'ɵɵresolveBody', moduleName: CORE }; }
+    static { this.defineComponent = { name: 'ɵɵdefineComponent', moduleName: CORE }; }
+    static { this.declareComponent = { name: 'ɵɵngDeclareComponent', moduleName: CORE }; }
+    static { this.setComponentScope = { name: 'ɵɵsetComponentScope', moduleName: CORE }; }
+    static { this.ChangeDetectionStrategy = {
+        name: 'ChangeDetectionStrategy',
+        moduleName: CORE,
+    }; }
+    static { this.ViewEncapsulation = {
+        name: 'ViewEncapsulation',
+        moduleName: CORE,
+    }; }
+    static { this.ComponentDeclaration = {
+        name: 'ɵɵComponentDeclaration',
+        moduleName: CORE,
+    }; }
+    static { this.FactoryDeclaration = {
+        name: 'ɵɵFactoryDeclaration',
+        moduleName: CORE,
+    }; }
+    static { this.declareFactory = { name: 'ɵɵngDeclareFactory', moduleName: CORE }; }
+    static { this.FactoryTarget = { name: 'ɵɵFactoryTarget', moduleName: CORE }; }
+    static { this.defineDirective = { name: 'ɵɵdefineDirective', moduleName: CORE }; }
+    static { this.declareDirective = { name: 'ɵɵngDeclareDirective', moduleName: CORE }; }
+    static { this.DirectiveDeclaration = {
+        name: 'ɵɵDirectiveDeclaration',
+        moduleName: CORE,
+    }; }
+    static { this.InjectorDef = { name: 'ɵɵInjectorDef', moduleName: CORE }; }
+    static { this.InjectorDeclaration = { name: 'ɵɵInjectorDeclaration', moduleName: CORE }; }
+    static { this.defineInjector = { name: 'ɵɵdefineInjector', moduleName: CORE }; }
+    static { this.declareInjector = { name: 'ɵɵngDeclareInjector', moduleName: CORE }; }
+    static { this.NgModuleDeclaration = {
+        name: 'ɵɵNgModuleDeclaration',
+        moduleName: CORE,
+    }; }
+    static { this.ModuleWithProviders = {
+        name: 'ModuleWithProviders',
+        moduleName: CORE,
+    }; }
+    static { this.defineNgModule = { name: 'ɵɵdefineNgModule', moduleName: CORE }; }
+    static { this.declareNgModule = { name: 'ɵɵngDeclareNgModule', moduleName: CORE }; }
+    static { this.setNgModuleScope = { name: 'ɵɵsetNgModuleScope', moduleName: CORE }; }
+    static { this.registerNgModuleType = { name: 'ɵɵregisterNgModuleType', moduleName: CORE }; }
+    static { this.PipeDeclaration = { name: 'ɵɵPipeDeclaration', moduleName: CORE }; }
+    static { this.definePipe = { name: 'ɵɵdefinePipe', moduleName: CORE }; }
+    static { this.declarePipe = { name: 'ɵɵngDeclarePipe', moduleName: CORE }; }
+    static { this.declareClassMetadata = { name: 'ɵɵngDeclareClassMetadata', moduleName: CORE }; }
+    static { this.setClassMetadata = { name: 'ɵsetClassMetadata', moduleName: CORE }; }
+    static { this.queryRefresh = { name: 'ɵɵqueryRefresh', moduleName: CORE }; }
+    static { this.viewQuery = { name: 'ɵɵviewQuery', moduleName: CORE }; }
+    static { this.loadQuery = { name: 'ɵɵloadQuery', moduleName: CORE }; }
+    static { this.contentQuery = { name: 'ɵɵcontentQuery', moduleName: CORE }; }
+    static { this.NgOnChangesFeature = { name: 'ɵɵNgOnChangesFeature', moduleName: CORE }; }
+    static { this.InheritDefinitionFeature = { name: 'ɵɵInheritDefinitionFeature', moduleName: CORE }; }
+    static { this.CopyDefinitionFeature = { name: 'ɵɵCopyDefinitionFeature', moduleName: CORE }; }
+    static { this.StandaloneFeature = { name: 'ɵɵStandaloneFeature', moduleName: CORE }; }
+    static { this.ProvidersFeature = { name: 'ɵɵProvidersFeature', moduleName: CORE }; }
+    static { this.HostDirectivesFeature = { name: 'ɵɵHostDirectivesFeature', moduleName: CORE }; }
+    static { this.InputTransformsFeatureFeature = { name: 'ɵɵInputTransformsFeature', moduleName: CORE }; }
+    static { this.listener = { name: 'ɵɵlistener', moduleName: CORE }; }
+    static { this.getInheritedFactory = {
+        name: 'ɵɵgetInheritedFactory',
+        moduleName: CORE,
+    }; }
+    // sanitization-related functions
+    static { this.sanitizeHtml = { name: 'ɵɵsanitizeHtml', moduleName: CORE }; }
+    static { this.sanitizeStyle = { name: 'ɵɵsanitizeStyle', moduleName: CORE }; }
+    static { this.sanitizeResourceUrl = { name: 'ɵɵsanitizeResourceUrl', moduleName: CORE }; }
+    static { this.sanitizeScript = { name: 'ɵɵsanitizeScript', moduleName: CORE }; }
+    static { this.sanitizeUrl = { name: 'ɵɵsanitizeUrl', moduleName: CORE }; }
+    static { this.sanitizeUrlOrResourceUrl = { name: 'ɵɵsanitizeUrlOrResourceUrl', moduleName: CORE }; }
+    static { this.trustConstantHtml = { name: 'ɵɵtrustConstantHtml', moduleName: CORE }; }
+    static { this.trustConstantResourceUrl = { name: 'ɵɵtrustConstantResourceUrl', moduleName: CORE }; }
+    static { this.validateIframeAttribute = { name: 'ɵɵvalidateIframeAttribute', moduleName: CORE }; }
 }
-/* Methods */
-Identifiers.NEW_METHOD = 'factory';
-Identifiers.TRANSFORM_METHOD = 'transform';
-Identifiers.PATCH_DEPS = 'patchedDeps';
-Identifiers.core = { name: null, moduleName: CORE };
-/* Instructions */
-Identifiers.namespaceHTML = { name: 'ɵɵnamespaceHTML', moduleName: CORE };
-Identifiers.namespaceMathML = { name: 'ɵɵnamespaceMathML', moduleName: CORE };
-Identifiers.namespaceSVG = { name: 'ɵɵnamespaceSVG', moduleName: CORE };
-Identifiers.element = { name: 'ɵɵelement', moduleName: CORE };
-Identifiers.elementStart = { name: 'ɵɵelementStart', moduleName: CORE };
-Identifiers.elementEnd = { name: 'ɵɵelementEnd', moduleName: CORE };
-Identifiers.advance = { name: 'ɵɵadvance', moduleName: CORE };
-Identifiers.syntheticHostProperty = { name: 'ɵɵsyntheticHostProperty', moduleName: CORE };
-Identifiers.syntheticHostListener = { name: 'ɵɵsyntheticHostListener', moduleName: CORE };
-Identifiers.attribute = { name: 'ɵɵattribute', moduleName: CORE };
-Identifiers.attributeInterpolate1 = { name: 'ɵɵattributeInterpolate1', moduleName: CORE };
-Identifiers.attributeInterpolate2 = { name: 'ɵɵattributeInterpolate2', moduleName: CORE };
-Identifiers.attributeInterpolate3 = { name: 'ɵɵattributeInterpolate3', moduleName: CORE };
-Identifiers.attributeInterpolate4 = { name: 'ɵɵattributeInterpolate4', moduleName: CORE };
-Identifiers.attributeInterpolate5 = { name: 'ɵɵattributeInterpolate5', moduleName: CORE };
-Identifiers.attributeInterpolate6 = { name: 'ɵɵattributeInterpolate6', moduleName: CORE };
-Identifiers.attributeInterpolate7 = { name: 'ɵɵattributeInterpolate7', moduleName: CORE };
-Identifiers.attributeInterpolate8 = { name: 'ɵɵattributeInterpolate8', moduleName: CORE };
-Identifiers.attributeInterpolateV = { name: 'ɵɵattributeInterpolateV', moduleName: CORE };
-Identifiers.classProp = { name: 'ɵɵclassProp', moduleName: CORE };
-Identifiers.elementContainerStart = { name: 'ɵɵelementContainerStart', moduleName: CORE };
-Identifiers.elementContainerEnd = { name: 'ɵɵelementContainerEnd', moduleName: CORE };
-Identifiers.elementContainer = { name: 'ɵɵelementContainer', moduleName: CORE };
-Identifiers.styleMap = { name: 'ɵɵstyleMap', moduleName: CORE };
-Identifiers.styleMapInterpolate1 = { name: 'ɵɵstyleMapInterpolate1', moduleName: CORE };
-Identifiers.styleMapInterpolate2 = { name: 'ɵɵstyleMapInterpolate2', moduleName: CORE };
-Identifiers.styleMapInterpolate3 = { name: 'ɵɵstyleMapInterpolate3', moduleName: CORE };
-Identifiers.styleMapInterpolate4 = { name: 'ɵɵstyleMapInterpolate4', moduleName: CORE };
-Identifiers.styleMapInterpolate5 = { name: 'ɵɵstyleMapInterpolate5', moduleName: CORE };
-Identifiers.styleMapInterpolate6 = { name: 'ɵɵstyleMapInterpolate6', moduleName: CORE };
-Identifiers.styleMapInterpolate7 = { name: 'ɵɵstyleMapInterpolate7', moduleName: CORE };
-Identifiers.styleMapInterpolate8 = { name: 'ɵɵstyleMapInterpolate8', moduleName: CORE };
-Identifiers.styleMapInterpolateV = { name: 'ɵɵstyleMapInterpolateV', moduleName: CORE };
-Identifiers.classMap = { name: 'ɵɵclassMap', moduleName: CORE };
-Identifiers.classMapInterpolate1 = { name: 'ɵɵclassMapInterpolate1', moduleName: CORE };
-Identifiers.classMapInterpolate2 = { name: 'ɵɵclassMapInterpolate2', moduleName: CORE };
-Identifiers.classMapInterpolate3 = { name: 'ɵɵclassMapInterpolate3', moduleName: CORE };
-Identifiers.classMapInterpolate4 = { name: 'ɵɵclassMapInterpolate4', moduleName: CORE };
-Identifiers.classMapInterpolate5 = { name: 'ɵɵclassMapInterpolate5', moduleName: CORE };
-Identifiers.classMapInterpolate6 = { name: 'ɵɵclassMapInterpolate6', moduleName: CORE };
-Identifiers.classMapInterpolate7 = { name: 'ɵɵclassMapInterpolate7', moduleName: CORE };
-Identifiers.classMapInterpolate8 = { name: 'ɵɵclassMapInterpolate8', moduleName: CORE };
-Identifiers.classMapInterpolateV = { name: 'ɵɵclassMapInterpolateV', moduleName: CORE };
-Identifiers.styleProp = { name: 'ɵɵstyleProp', moduleName: CORE };
-Identifiers.stylePropInterpolate1 = { name: 'ɵɵstylePropInterpolate1', moduleName: CORE };
-Identifiers.stylePropInterpolate2 = { name: 'ɵɵstylePropInterpolate2', moduleName: CORE };
-Identifiers.stylePropInterpolate3 = { name: 'ɵɵstylePropInterpolate3', moduleName: CORE };
-Identifiers.stylePropInterpolate4 = { name: 'ɵɵstylePropInterpolate4', moduleName: CORE };
-Identifiers.stylePropInterpolate5 = { name: 'ɵɵstylePropInterpolate5', moduleName: CORE };
-Identifiers.stylePropInterpolate6 = { name: 'ɵɵstylePropInterpolate6', moduleName: CORE };
-Identifiers.stylePropInterpolate7 = { name: 'ɵɵstylePropInterpolate7', moduleName: CORE };
-Identifiers.stylePropInterpolate8 = { name: 'ɵɵstylePropInterpolate8', moduleName: CORE };
-Identifiers.stylePropInterpolateV = { name: 'ɵɵstylePropInterpolateV', moduleName: CORE };
-Identifiers.nextContext = { name: 'ɵɵnextContext', moduleName: CORE };
-Identifiers.resetView = { name: 'ɵɵresetView', moduleName: CORE };
-Identifiers.templateCreate = { name: 'ɵɵtemplate', moduleName: CORE };
-Identifiers.text = { name: 'ɵɵtext', moduleName: CORE };
-Identifiers.enableBindings = { name: 'ɵɵenableBindings', moduleName: CORE };
-Identifiers.disableBindings = { name: 'ɵɵdisableBindings', moduleName: CORE };
-Identifiers.getCurrentView = { name: 'ɵɵgetCurrentView', moduleName: CORE };
-Identifiers.textInterpolate = { name: 'ɵɵtextInterpolate', moduleName: CORE };
-Identifiers.textInterpolate1 = { name: 'ɵɵtextInterpolate1', moduleName: CORE };
-Identifiers.textInterpolate2 = { name: 'ɵɵtextInterpolate2', moduleName: CORE };
-Identifiers.textInterpolate3 = { name: 'ɵɵtextInterpolate3', moduleName: CORE };
-Identifiers.textInterpolate4 = { name: 'ɵɵtextInterpolate4', moduleName: CORE };
-Identifiers.textInterpolate5 = { name: 'ɵɵtextInterpolate5', moduleName: CORE };
-Identifiers.textInterpolate6 = { name: 'ɵɵtextInterpolate6', moduleName: CORE };
-Identifiers.textInterpolate7 = { name: 'ɵɵtextInterpolate7', moduleName: CORE };
-Identifiers.textInterpolate8 = { name: 'ɵɵtextInterpolate8', moduleName: CORE };
-Identifiers.textInterpolateV = { name: 'ɵɵtextInterpolateV', moduleName: CORE };
-Identifiers.restoreView = { name: 'ɵɵrestoreView', moduleName: CORE };
-Identifiers.pureFunction0 = { name: 'ɵɵpureFunction0', moduleName: CORE };
-Identifiers.pureFunction1 = { name: 'ɵɵpureFunction1', moduleName: CORE };
-Identifiers.pureFunction2 = { name: 'ɵɵpureFunction2', moduleName: CORE };
-Identifiers.pureFunction3 = { name: 'ɵɵpureFunction3', moduleName: CORE };
-Identifiers.pureFunction4 = { name: 'ɵɵpureFunction4', moduleName: CORE };
-Identifiers.pureFunction5 = { name: 'ɵɵpureFunction5', moduleName: CORE };
-Identifiers.pureFunction6 = { name: 'ɵɵpureFunction6', moduleName: CORE };
-Identifiers.pureFunction7 = { name: 'ɵɵpureFunction7', moduleName: CORE };
-Identifiers.pureFunction8 = { name: 'ɵɵpureFunction8', moduleName: CORE };
-Identifiers.pureFunctionV = { name: 'ɵɵpureFunctionV', moduleName: CORE };
-Identifiers.pipeBind1 = { name: 'ɵɵpipeBind1', moduleName: CORE };
-Identifiers.pipeBind2 = { name: 'ɵɵpipeBind2', moduleName: CORE };
-Identifiers.pipeBind3 = { name: 'ɵɵpipeBind3', moduleName: CORE };
-Identifiers.pipeBind4 = { name: 'ɵɵpipeBind4', moduleName: CORE };
-Identifiers.pipeBindV = { name: 'ɵɵpipeBindV', moduleName: CORE };
-Identifiers.hostProperty = { name: 'ɵɵhostProperty', moduleName: CORE };
-Identifiers.property = { name: 'ɵɵproperty', moduleName: CORE };
-Identifiers.propertyInterpolate = { name: 'ɵɵpropertyInterpolate', moduleName: CORE };
-Identifiers.propertyInterpolate1 = { name: 'ɵɵpropertyInterpolate1', moduleName: CORE };
-Identifiers.propertyInterpolate2 = { name: 'ɵɵpropertyInterpolate2', moduleName: CORE };
-Identifiers.propertyInterpolate3 = { name: 'ɵɵpropertyInterpolate3', moduleName: CORE };
-Identifiers.propertyInterpolate4 = { name: 'ɵɵpropertyInterpolate4', moduleName: CORE };
-Identifiers.propertyInterpolate5 = { name: 'ɵɵpropertyInterpolate5', moduleName: CORE };
-Identifiers.propertyInterpolate6 = { name: 'ɵɵpropertyInterpolate6', moduleName: CORE };
-Identifiers.propertyInterpolate7 = { name: 'ɵɵpropertyInterpolate7', moduleName: CORE };
-Identifiers.propertyInterpolate8 = { name: 'ɵɵpropertyInterpolate8', moduleName: CORE };
-Identifiers.propertyInterpolateV = { name: 'ɵɵpropertyInterpolateV', moduleName: CORE };
-Identifiers.i18n = { name: 'ɵɵi18n', moduleName: CORE };
-Identifiers.i18nAttributes = { name: 'ɵɵi18nAttributes', moduleName: CORE };
-Identifiers.i18nExp = { name: 'ɵɵi18nExp', moduleName: CORE };
-Identifiers.i18nStart = { name: 'ɵɵi18nStart', moduleName: CORE };
-Identifiers.i18nEnd = { name: 'ɵɵi18nEnd', moduleName: CORE };
-Identifiers.i18nApply = { name: 'ɵɵi18nApply', moduleName: CORE };
-Identifiers.i18nPostprocess = { name: 'ɵɵi18nPostprocess', moduleName: CORE };
-Identifiers.pipe = { name: 'ɵɵpipe', moduleName: CORE };
-Identifiers.projection = { name: 'ɵɵprojection', moduleName: CORE };
-Identifiers.projectionDef = { name: 'ɵɵprojectionDef', moduleName: CORE };
-Identifiers.reference = { name: 'ɵɵreference', moduleName: CORE };
-Identifiers.inject = { name: 'ɵɵinject', moduleName: CORE };
-Identifiers.injectAttribute = { name: 'ɵɵinjectAttribute', moduleName: CORE };
-Identifiers.directiveInject = { name: 'ɵɵdirectiveInject', moduleName: CORE };
-Identifiers.invalidFactory = { name: 'ɵɵinvalidFactory', moduleName: CORE };
-Identifiers.invalidFactoryDep = { name: 'ɵɵinvalidFactoryDep', moduleName: CORE };
-Identifiers.templateRefExtractor = { name: 'ɵɵtemplateRefExtractor', moduleName: CORE };
-Identifiers.forwardRef = { name: 'forwardRef', moduleName: CORE };
-Identifiers.resolveForwardRef = { name: 'resolveForwardRef', moduleName: CORE };
-Identifiers.ɵɵdefineInjectable = { name: 'ɵɵdefineInjectable', moduleName: CORE };
-Identifiers.declareInjectable = { name: 'ɵɵngDeclareInjectable', moduleName: CORE };
-Identifiers.InjectableDeclaration = { name: 'ɵɵInjectableDeclaration', moduleName: CORE };
-Identifiers.resolveWindow = { name: 'ɵɵresolveWindow', moduleName: CORE };
-Identifiers.resolveDocument = { name: 'ɵɵresolveDocument', moduleName: CORE };
-Identifiers.resolveBody = { name: 'ɵɵresolveBody', moduleName: CORE };
-Identifiers.defineComponent = { name: 'ɵɵdefineComponent', moduleName: CORE };
-Identifiers.declareComponent = { name: 'ɵɵngDeclareComponent', moduleName: CORE };
-Identifiers.setComponentScope = { name: 'ɵɵsetComponentScope', moduleName: CORE };
-Identifiers.ChangeDetectionStrategy = {
-    name: 'ChangeDetectionStrategy',
-    moduleName: CORE,
-};
-Identifiers.ViewEncapsulation = {
-    name: 'ViewEncapsulation',
-    moduleName: CORE,
-};
-Identifiers.ComponentDeclaration = {
-    name: 'ɵɵComponentDeclaration',
-    moduleName: CORE,
-};
-Identifiers.FactoryDeclaration = {
-    name: 'ɵɵFactoryDeclaration',
-    moduleName: CORE,
-};
-Identifiers.declareFactory = { name: 'ɵɵngDeclareFactory', moduleName: CORE };
-Identifiers.FactoryTarget = { name: 'ɵɵFactoryTarget', moduleName: CORE };
-Identifiers.defineDirective = { name: 'ɵɵdefineDirective', moduleName: CORE };
-Identifiers.declareDirective = { name: 'ɵɵngDeclareDirective', moduleName: CORE };
-Identifiers.DirectiveDeclaration = {
-    name: 'ɵɵDirectiveDeclaration',
-    moduleName: CORE,
-};
-Identifiers.InjectorDef = { name: 'ɵɵInjectorDef', moduleName: CORE };
-Identifiers.InjectorDeclaration = { name: 'ɵɵInjectorDeclaration', moduleName: CORE };
-Identifiers.defineInjector = { name: 'ɵɵdefineInjector', moduleName: CORE };
-Identifiers.declareInjector = { name: 'ɵɵngDeclareInjector', moduleName: CORE };
-Identifiers.NgModuleDeclaration = {
-    name: 'ɵɵNgModuleDeclaration',
-    moduleName: CORE,
-};
-Identifiers.ModuleWithProviders = {
-    name: 'ModuleWithProviders',
-    moduleName: CORE,
-};
-Identifiers.defineNgModule = { name: 'ɵɵdefineNgModule', moduleName: CORE };
-Identifiers.declareNgModule = { name: 'ɵɵngDeclareNgModule', moduleName: CORE };
-Identifiers.setNgModuleScope = { name: 'ɵɵsetNgModuleScope', moduleName: CORE };
-Identifiers.registerNgModuleType = { name: 'ɵɵregisterNgModuleType', moduleName: CORE };
-Identifiers.PipeDeclaration = { name: 'ɵɵPipeDeclaration', moduleName: CORE };
-Identifiers.definePipe = { name: 'ɵɵdefinePipe', moduleName: CORE };
-Identifiers.declarePipe = { name: 'ɵɵngDeclarePipe', moduleName: CORE };
-Identifiers.declareClassMetadata = { name: 'ɵɵngDeclareClassMetadata', moduleName: CORE };
-Identifiers.setClassMetadata = { name: 'ɵsetClassMetadata', moduleName: CORE };
-Identifiers.queryRefresh = { name: 'ɵɵqueryRefresh', moduleName: CORE };
-Identifiers.viewQuery = { name: 'ɵɵviewQuery', moduleName: CORE };
-Identifiers.loadQuery = { name: 'ɵɵloadQuery', moduleName: CORE };
-Identifiers.contentQuery = { name: 'ɵɵcontentQuery', moduleName: CORE };
-Identifiers.NgOnChangesFeature = { name: 'ɵɵNgOnChangesFeature', moduleName: CORE };
-Identifiers.InheritDefinitionFeature = { name: 'ɵɵInheritDefinitionFeature', moduleName: CORE };
-Identifiers.CopyDefinitionFeature = { name: 'ɵɵCopyDefinitionFeature', moduleName: CORE };
-Identifiers.StandaloneFeature = { name: 'ɵɵStandaloneFeature', moduleName: CORE };
-Identifiers.ProvidersFeature = { name: 'ɵɵProvidersFeature', moduleName: CORE };
-Identifiers.HostDirectivesFeature = { name: 'ɵɵHostDirectivesFeature', moduleName: CORE };
-Identifiers.listener = { name: 'ɵɵlistener', moduleName: CORE };
-Identifiers.getInheritedFactory = {
-    name: 'ɵɵgetInheritedFactory',
-    moduleName: CORE,
-};
-// sanitization-related functions
-Identifiers.sanitizeHtml = { name: 'ɵɵsanitizeHtml', moduleName: CORE };
-Identifiers.sanitizeStyle = { name: 'ɵɵsanitizeStyle', moduleName: CORE };
-Identifiers.sanitizeResourceUrl = { name: 'ɵɵsanitizeResourceUrl', moduleName: CORE };
-Identifiers.sanitizeScript = { name: 'ɵɵsanitizeScript', moduleName: CORE };
-Identifiers.sanitizeUrl = { name: 'ɵɵsanitizeUrl', moduleName: CORE };
-Identifiers.sanitizeUrlOrResourceUrl = { name: 'ɵɵsanitizeUrlOrResourceUrl', moduleName: CORE };
-Identifiers.trustConstantHtml = { name: 'ɵɵtrustConstantHtml', moduleName: CORE };
-Identifiers.trustConstantResourceUrl = { name: 'ɵɵtrustConstantResourceUrl', moduleName: CORE };
-Identifiers.validateIframeAttribute = { name: 'ɵɵvalidateIframeAttribute', moduleName: CORE };
 
 const DASH_CASE_REGEXP = /-+([a-z0-9])/g;
 function dashCaseToCamelCase(input) {
@@ -2186,13 +2288,7 @@ class Version {
         this.patch = splits.slice(2).join('.');
     }
 }
-// Check `global` first, because in Node tests both `global` and `window` may be defined and our
-// `_global` variable should point to the NodeJS `global` in that case. Note: Typeof/Instanceof
-// checks are considered side-effects in Terser. We explicitly mark this as side-effect free:
-// https://github.com/terser/terser/issues/250.
-const _global = ( /* @__PURE__ */(() => (typeof global !== 'undefined' && global) || (typeof window !== 'undefined' && window) ||
-    (typeof self !== 'undefined' && typeof WorkerGlobalScope !== 'undefined' &&
-        self instanceof WorkerGlobalScope && self))());
+const _global = globalThis;
 /**
  * Partitions a given array into 2 arrays, based on a boolean value returned by the condition
  * function.
@@ -2667,6 +2763,9 @@ class AbstractEmitterVisitor {
         ctx.print(ast, `)`);
         return null;
     }
+    visitDynamicImportExpr(ast, ctx) {
+        ctx.print(ast, `import(${ast.url})`);
+    }
     visitNotExpr(ast, ctx) {
         ctx.print(ast, '!');
         ast.condition.visitExpression(this, ctx);
@@ -2954,7 +3053,7 @@ function compileFactoryFunction(meta) {
     // delegated factory (which is used to create the current type) then this is only the type-to-
     // create parameter (t).
     const typeForCtor = !isDelegatedFactoryMetadata(meta) ?
-        new BinaryOperatorExpr(BinaryOperator.Or, t, meta.internalType) :
+        new BinaryOperatorExpr(BinaryOperator.Or, t, meta.type.value) :
         t;
     let ctorExpr = null;
     if (meta.deps !== null) {
@@ -3001,7 +3100,7 @@ function compileFactoryFunction(meta) {
     }
     else if (baseFactoryVar !== null) {
         // This factory uses a base factory, so call `ɵɵgetInheritedFactory()` to compute it.
-        const getInheritedFactoryCall = importExpr(Identifiers.getInheritedFactory).callFn([meta.internalType]);
+        const getInheritedFactoryCall = importExpr(Identifiers.getInheritedFactory).callFn([meta.type.value]);
         // Memoize the base factoryFn: `baseFactory || (baseFactory = ɵɵgetInheritedFactory(...))`
         const baseFactory = new BinaryOperatorExpr(BinaryOperator.Or, baseFactoryVar, baseFactoryVar.set(getInheritedFactoryCall));
         body.push(new ReturnStatement(baseFactory.callFn([typeForCtor])));
@@ -3237,6 +3336,96 @@ class Element$1 {
         return visitor.visitElement(this);
     }
 }
+class DeferredTrigger {
+    constructor(sourceSpan) {
+        this.sourceSpan = sourceSpan;
+    }
+    visit(visitor) {
+        return visitor.visitDeferredTrigger(this);
+    }
+}
+class BoundDeferredTrigger extends DeferredTrigger {
+    constructor(value, sourceSpan) {
+        super(sourceSpan);
+        this.value = value;
+    }
+}
+class IdleDeferredTrigger extends DeferredTrigger {
+}
+class ImmediateDeferredTrigger extends DeferredTrigger {
+}
+class HoverDeferredTrigger extends DeferredTrigger {
+}
+class TimerDeferredTrigger extends DeferredTrigger {
+    constructor(delay, sourceSpan) {
+        super(sourceSpan);
+        this.delay = delay;
+    }
+}
+class InteractionDeferredTrigger extends DeferredTrigger {
+    constructor(reference, sourceSpan) {
+        super(sourceSpan);
+        this.reference = reference;
+    }
+}
+class ViewportDeferredTrigger extends DeferredTrigger {
+    constructor(reference, sourceSpan) {
+        super(sourceSpan);
+        this.reference = reference;
+    }
+}
+class DeferredBlockPlaceholder {
+    constructor(children, minimumTime, sourceSpan, startSourceSpan, endSourceSpan) {
+        this.children = children;
+        this.minimumTime = minimumTime;
+        this.sourceSpan = sourceSpan;
+        this.startSourceSpan = startSourceSpan;
+        this.endSourceSpan = endSourceSpan;
+    }
+    visit(visitor) {
+        return visitor.visitDeferredBlockPlaceholder(this);
+    }
+}
+class DeferredBlockLoading {
+    constructor(children, afterTime, minimumTime, sourceSpan, startSourceSpan, endSourceSpan) {
+        this.children = children;
+        this.afterTime = afterTime;
+        this.minimumTime = minimumTime;
+        this.sourceSpan = sourceSpan;
+        this.startSourceSpan = startSourceSpan;
+        this.endSourceSpan = endSourceSpan;
+    }
+    visit(visitor) {
+        return visitor.visitDeferredBlockLoading(this);
+    }
+}
+class DeferredBlockError {
+    constructor(children, sourceSpan, startSourceSpan, endSourceSpan) {
+        this.children = children;
+        this.sourceSpan = sourceSpan;
+        this.startSourceSpan = startSourceSpan;
+        this.endSourceSpan = endSourceSpan;
+    }
+    visit(visitor) {
+        return visitor.visitDeferredBlockError(this);
+    }
+}
+class DeferredBlock {
+    constructor(children, triggers, prefetchTriggers, placeholder, loading, error, sourceSpan, startSourceSpan, endSourceSpan) {
+        this.children = children;
+        this.triggers = triggers;
+        this.prefetchTriggers = prefetchTriggers;
+        this.placeholder = placeholder;
+        this.loading = loading;
+        this.error = error;
+        this.sourceSpan = sourceSpan;
+        this.startSourceSpan = startSourceSpan;
+        this.endSourceSpan = endSourceSpan;
+    }
+    visit(visitor) {
+        return visitor.visitDeferredBlock(this);
+    }
+}
 class Template {
     constructor(
     // tagName is the name of the container element, if applicable.
@@ -3342,9 +3531,9 @@ class Message {
         this.meaning = meaning;
         this.description = description;
         this.customId = customId;
-        this.id = this.customId;
         /** The ids to use if there are no custom id and if `i18nLegacyMessageIdFormat` is not empty */
         this.legacyIds = [];
+        this.id = this.customId;
         this.messageString = serializeMessage(this.nodes);
         if (nodes.length) {
             this.sources = [{
@@ -3380,11 +3569,12 @@ class Container {
     }
 }
 class Icu {
-    constructor(expression, type, cases, sourceSpan) {
+    constructor(expression, type, cases, sourceSpan, expressionPlaceholder) {
         this.expression = expression;
         this.type = type;
         this.cases = cases;
         this.sourceSpan = sourceSpan;
+        this.expressionPlaceholder = expressionPlaceholder;
     }
     visit(visitor, context) {
         return visitor.visitIcu(this, context);
@@ -3719,37 +3909,44 @@ function asLiteral(value) {
     }
     return literal(value, INFERRED_TYPE);
 }
-function conditionallyCreateMapObjectLiteral(keys, keepDeclared) {
-    if (Object.getOwnPropertyNames(keys).length > 0) {
-        return mapToExpression(keys, keepDeclared);
+function conditionallyCreateDirectiveBindingLiteral(map, keepDeclared) {
+    const keys = Object.getOwnPropertyNames(map);
+    if (keys.length === 0) {
+        return null;
     }
-    return null;
-}
-function mapToExpression(map, keepDeclared) {
-    return literalMap(Object.getOwnPropertyNames(map).map(key => {
-        // canonical syntax: `dirProp: publicProp`
+    return literalMap(keys.map(key => {
         const value = map[key];
         let declaredName;
         let publicName;
         let minifiedName;
-        let needsDeclaredName;
-        if (Array.isArray(value)) {
-            [publicName, declaredName] = value;
+        let expressionValue;
+        if (typeof value === 'string') {
+            // canonical syntax: `dirProp: publicProp`
+            declaredName = key;
             minifiedName = key;
-            needsDeclaredName = publicName !== declaredName;
+            publicName = value;
+            expressionValue = asLiteral(publicName);
         }
         else {
-            minifiedName = declaredName = key;
-            publicName = value;
-            needsDeclaredName = false;
+            minifiedName = key;
+            declaredName = value.classPropertyName;
+            publicName = value.bindingPropertyName;
+            if (keepDeclared && (publicName !== declaredName || value.transformFunction != null)) {
+                const expressionKeys = [asLiteral(publicName), asLiteral(declaredName)];
+                if (value.transformFunction != null) {
+                    expressionKeys.push(value.transformFunction);
+                }
+                expressionValue = literalArr(expressionKeys);
+            }
+            else {
+                expressionValue = asLiteral(publicName);
+            }
         }
         return {
             key: minifiedName,
             // put quotes around keys that contain potentially unsafe characters
             quoted: UNSAFE_OBJECT_KEY_NAME_REGEXP.test(minifiedName),
-            value: (keepDeclared && needsDeclaredName) ?
-                literalArr([asLiteral(publicName), asLiteral(declaredName)]) :
-                asLiteral(publicName)
+            value: expressionValue,
         };
     }));
 }
@@ -3863,7 +4060,6 @@ function compileInjectable(meta, resolveForwardRefs) {
     const factoryMeta = {
         name: meta.name,
         type: meta.type,
-        internalType: meta.internalType,
         typeArgumentCount: meta.typeArgumentCount,
         deps: [],
         target: FactoryTarget$1.Injectable,
@@ -3875,7 +4071,7 @@ function compileInjectable(meta, resolveForwardRefs) {
         //
         // A special case exists for useClass: Type where Type is the injectable type itself and no
         // deps are specified, in which case 'useClass' is effectively ignored.
-        const useClassOnSelf = meta.useClass.expression.isEquivalent(meta.internalType);
+        const useClassOnSelf = meta.useClass.expression.isEquivalent(meta.type.value);
         let deps = undefined;
         if (meta.deps !== undefined) {
             deps = meta.deps;
@@ -3934,10 +4130,10 @@ function compileInjectable(meta, resolveForwardRefs) {
     else {
         result = {
             statements: [],
-            expression: delegateToFactory(meta.type.value, meta.internalType, resolveForwardRefs)
+            expression: delegateToFactory(meta.type.value, meta.type.value, resolveForwardRefs)
         };
     }
-    const token = meta.internalType;
+    const token = meta.type.value;
     const injectableProps = new DefinitionMap();
     injectableProps.set('token', token);
     injectableProps.set('factory', result.expression);
@@ -3956,28 +4152,28 @@ function compileInjectable(meta, resolveForwardRefs) {
 function createInjectableType(meta) {
     return new ExpressionType$1(importExpr(Identifiers.InjectableDeclaration, [typeWithParameters(meta.type.type, meta.typeArgumentCount)]));
 }
-function delegateToFactory(type, internalType, unwrapForwardRefs) {
-    if (type.node === internalType.node) {
+function delegateToFactory(type, useType, unwrapForwardRefs) {
+    if (type.node === useType.node) {
         // The types are the same, so we can simply delegate directly to the type's factory.
         // ```
         // factory: type.ɵfac
         // ```
-        return internalType.prop('ɵfac');
+        return useType.prop('ɵfac');
     }
     if (!unwrapForwardRefs) {
         // The type is not wrapped in a `forwardRef()`, so we create a simple factory function that
         // accepts a sub-type as an argument.
         // ```
-        // factory: function(t) { return internalType.ɵfac(t); }
+        // factory: function(t) { return useType.ɵfac(t); }
         // ```
-        return createFactoryFunction(internalType);
+        return createFactoryFunction(useType);
     }
-    // The internalType is actually wrapped in a `forwardRef()` so we need to resolve that before
+    // The useType is actually wrapped in a `forwardRef()` so we need to resolve that before
     // calling its factory.
     // ```
     // factory: function(t) { return core.resolveForwardRef(type).ɵfac(t); }
     // ```
-    const unwrappedType = importExpr(Identifiers.resolveForwardRef).callFn([internalType]);
+    const unwrappedType = importExpr(Identifiers.resolveForwardRef).callFn([useType]);
     return createFactoryFunction(unwrappedType);
 }
 function createFactoryFunction(type) {
@@ -4385,45 +4581,6 @@ class AbstractJsEmitterVisitor extends AbstractEmitterVisitor {
         this.visitAllObjects(param => ctx.print(null, param.name), params, ctx, ',');
     }
 }
-
-/**
- * @fileoverview
- * A module to facilitate use of a Trusted Types policy within the JIT
- * compiler. It lazily constructs the Trusted Types policy, providing helper
- * utilities for promoting strings to Trusted Types. When Trusted Types are not
- * available, strings are used as a fallback.
- * @security All use of this module is security-sensitive and should go through
- * security review.
- */
-/**
- * The Trusted Types policy, or null if Trusted Types are not
- * enabled/supported, or undefined if the policy has not been created yet.
- */
-let policy;
-/**
- * Returns the Trusted Types policy, or null if Trusted Types are not
- * enabled/supported. The first call to this function will create the policy.
- */
-function getPolicy() {
-    if (policy === undefined) {
-        policy = null;
-        if (_global.trustedTypes) {
-            try {
-                policy =
-                    _global.trustedTypes.createPolicy('angular#unsafe-jit', {
-                        createScript: (s) => s,
-                    });
-            }
-            catch {
-                // trustedTypes.createPolicy throws if called with a name that is
-                // already registered, even in report-only mode. Until the API changes,
-                // catch the error not to break the applications functionally. In such
-                // cases, the code will fall back to using strings.
-            }
-        }
-    }
-    return policy;
-}
 /**
  * Unsafely promote a string to a TrustedScript, falling back to strings when
  * Trusted Types are not available.
@@ -4432,7 +4589,7 @@ function getPolicy() {
  * interpreted and executed as a script by a browser, e.g. when calling eval.
  */
 function trustedScriptFromString(script) {
-    return getPolicy()?.createScript(script) || script;
+    return script;
 }
 /**
  * Unsafely call the Function constructor with the given string arguments.
@@ -4674,31 +4831,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 { adjacentType, internalType, bootstrap, declarations, imports, exports, schemas, containsForwardDecls, selectorScopeMode, id } = meta;
     const statements = [];
     const definitionMap = new DefinitionMap();
-    definitionMap.set('type', internalType);
-    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));
+        }
+    }
+    else {
+        if (meta.bootstrapExpression) {
+            definitionMap.set('bootstrap', meta.bootstrapExpression);
+        }
     }
-    if (selectorScopeMode === R3SelectorScopeMode.Inline) {
+    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
@@ -4709,14 +4884,14 @@ function compileNgModule(meta) {
         }
     }
     else ;
-    if (schemas !== null && schemas.length > 0) {
-        definitionMap.set('schemas', literalArr(schemas.map(ref => ref.value)));
+    if (meta.schemas !== null && meta.schemas.length > 0) {
+        definitionMap.set('schemas', literalArr(meta.schemas.map(ref => ref.value)));
     }
-    if (id !== null) {
-        definitionMap.set('id', id);
+    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([adjacentType, 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);
@@ -4749,7 +4924,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$1(meta.type.value);
+    }
+    const { type: moduleType, declarations, exports, imports, includeImportTypes, publicDeclarationTypes } = meta;
     return new ExpressionType$1(importExpr(Identifiers.NgModuleDeclaration, [
         new ExpressionType$1(moduleType.type),
         publicDeclarationTypes === null ? tupleTypeOf(declarations) :
@@ -4765,16 +4944,36 @@ function createNgModuleType({ type: moduleType, declarations, exports, imports,
  * symbols to become tree-shakeable.
  */
 function generateSetNgModuleScopeCall(meta) {
-    const { adjacentType: moduleType, declarations, imports, exports, containsForwardDecls } = meta;
     const scopeMap = new DefinitionMap();
-    if (declarations.length > 0) {
-        scopeMap.set('declarations', refsToArray(declarations, containsForwardDecls));
+    if (meta.kind === R3NgModuleMetadataKind.Global) {
+        if (meta.declarations.length > 0) {
+            scopeMap.set('declarations', refsToArray(meta.declarations, meta.containsForwardDecls));
+        }
+    }
+    else {
+        if (meta.declarationsExpression) {
+            scopeMap.set('declarations', meta.declarationsExpression);
+        }
+    }
+    if (meta.kind === R3NgModuleMetadataKind.Global) {
+        if (meta.imports.length > 0) {
+            scopeMap.set('imports', refsToArray(meta.imports, meta.containsForwardDecls));
+        }
     }
-    if (imports.length > 0) {
-        scopeMap.set('imports', refsToArray(imports, containsForwardDecls));
+    else {
+        if (meta.importsExpression) {
+            scopeMap.set('imports', meta.importsExpression);
+        }
+    }
+    if (meta.kind === R3NgModuleMetadataKind.Global) {
+        if (meta.exports.length > 0) {
+            scopeMap.set('exports', refsToArray(meta.exports, meta.containsForwardDecls));
+        }
     }
-    if (exports.length > 0) {
-        scopeMap.set('exports', refsToArray(exports, containsForwardDecls));
+    else {
+        if (meta.exportsExpression) {
+            scopeMap.set('exports', meta.exportsExpression);
+        }
     }
     if (Object.keys(scopeMap.values).length === 0) {
         return null;
@@ -4782,7 +4981,7 @@ function generateSetNgModuleScopeCall(meta) {
     // setNgModuleScope(...)
     const fnCall = new InvokeFunctionExpr(
     /* fn */ importExpr(Identifiers.setNgModuleScope), 
-    /* args */ [moduleType, scopeMap.toLiteralMap()]);
+    /* args */ [meta.type.value, scopeMap.toLiteralMap()]);
     // (ngJitMode guard) && setNgModuleScope(...)
     const guardedCall = jitOnlyGuardedExpression(fnCall);
     // function() { (ngJitMode guard) && setNgModuleScope(...); }
@@ -4870,7 +5069,7 @@ class ASTWithName extends AST {
         this.nameSpan = nameSpan;
     }
 }
-class EmptyExpr extends AST {
+class EmptyExpr$1 extends AST {
     visit(visitor, context = null) {
         // do nothing
     }
@@ -5017,7 +5216,7 @@ class LiteralMap extends AST {
         return visitor.visitLiteralMap(this, context);
     }
 }
-class Interpolation extends AST {
+class Interpolation$1 extends AST {
     constructor(span, sourceSpan, strings, expressions) {
         super(span, sourceSpan);
         this.strings = strings;
@@ -5264,7 +5463,7 @@ class AstTransformer {
         return ast;
     }
     visitInterpolation(ast, context) {
-        return new Interpolation(ast.span, ast.sourceSpan, ast.strings, this.visitAll(ast.expressions));
+        return new Interpolation$1(ast.span, ast.sourceSpan, ast.strings, this.visitAll(ast.expressions));
     }
     visitLiteralPrimitive(ast, context) {
         return new LiteralPrimitive(ast.span, ast.sourceSpan, ast.value);
@@ -5347,7 +5546,7 @@ class AstMemoryEfficientTransformer {
     visitInterpolation(ast, context) {
         const expressions = this.visitAll(ast.expressions);
         if (expressions !== ast.expressions)
-            return new Interpolation(ast.span, ast.sourceSpan, ast.strings, expressions);
+            return new Interpolation$1(ast.span, ast.sourceSpan, ast.strings, expressions);
         return ast;
     }
     visitLiteralPrimitive(ast, context) {
@@ -5560,8 +5759,8 @@ class BoundElementProperty {
 }
 
 class EventHandlerVars {
+    static { this.event = variable('$event'); }
 }
-EventHandlerVars.event = variable('$event');
 /**
  * Converts the given expression AST into an executable output AST, assuming the expression is
  * used in an action binding (e.g. an event handler).
@@ -6285,6 +6484,7 @@ class InterpolationExpression extends Expression {
         this.isConstant = unsupported;
         this.isEquivalent = unsupported;
         this.visitExpression = unsupported;
+        this.clone = unsupported;
     }
 }
 class DefaultLocalResolver {
@@ -6302,7 +6502,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;
     }
 }
@@ -6539,11 +6739,28 @@ class ShadowCss {
      * The hostSelector is the attribute added to the host itself.
      */
     shimCssText(cssText, selector, hostSelector = '') {
-        const commentsWithHash = extractCommentsWithHash(cssText);
-        cssText = stripComments(cssText);
+        // **NOTE**: Do not strip comments as this will cause component sourcemaps to break
+        // due to shift in lines.
+        // Collect comments and replace them with a placeholder, this is done to avoid complicating
+        // the rule parsing RegExp and keep it safer.
+        const comments = [];
+        cssText = cssText.replace(_commentRe, (m) => {
+            if (m.match(_commentWithHashRe)) {
+                comments.push(m);
+            }
+            else {
+                // Replace non hash comments with empty lines.
+                // This is done so that we do not leak any senstive data in comments.
+                const newLinesMatches = m.match(_newLinesRe);
+                comments.push((newLinesMatches?.join('') ?? '') + '\n');
+            }
+            return COMMENT_PLACEHOLDER;
+        });
         cssText = this._insertDirectives(cssText);
         const scopedCssText = this._scopeCssText(cssText, selector, hostSelector);
-        return [scopedCssText, ...commentsWithHash].join('\n');
+        // Add back comments at the original position.
+        let commentIdx = 0;
+        return scopedCssText.replace(_commentWithHashPlaceHolderRe, () => comments[commentIdx++]);
     }
     _insertDirectives(cssText) {
         cssText = this._insertPolyfillDirectivesInCssText(cssText);
@@ -6784,7 +7001,7 @@ class ShadowCss {
         return cssText.replace(_cssColonHostRe, (_, hostSelectors, otherSelectors) => {
             if (hostSelectors) {
                 const convertedSelectors = [];
-                const hostSelectorArray = hostSelectors.split(',').map(p => p.trim());
+                const hostSelectorArray = hostSelectors.split(',').map((p) => p.trim());
                 for (const hostSelector of hostSelectorArray) {
                     if (!hostSelector)
                         break;
@@ -6814,7 +7031,7 @@ class ShadowCss {
      * .foo<scopeName> .bar { ... }
      */
     _convertColonHostContext(cssText) {
-        return cssText.replace(_cssColonHostContextReGlobal, selectorText => {
+        return cssText.replace(_cssColonHostContextReGlobal, (selectorText) => {
             // We have captured a selector that contains a `:host-context` rule.
             // For backward compatibility `:host-context` may contain a comma separated list of selectors.
             // Each context selector group will contain a list of host-context selectors that must match
@@ -6826,10 +7043,10 @@ class ShadowCss {
             // Execute `_cssColonHostContextRe` over and over until we have extracted all the
             // `:host-context` selectors from this selector.
             let match;
-            while (match = _cssColonHostContextRe.exec(selectorText)) {
+            while ((match = _cssColonHostContextRe.exec(selectorText))) {
                 // `match` = [':host-context(<selectors>)<rest>', <selectors>, <rest>]
                 // The `<selectors>` could actually be a comma separated list: `:host-context(.one, .two)`.
-                const newContextSelectors = (match[1] ?? '').trim().split(',').map(m => m.trim()).filter(m => m !== '');
+                const newContextSelectors = (match[1] ?? '').trim().split(',').map((m) => m.trim()).filter((m) => m !== '');
                 // We must duplicate the current selector group for each of these new selectors.
                 // For example if the current groups are:
                 // ```
@@ -6852,7 +7069,7 @@ class ShadowCss {
                 repeatGroups(contextSelectorGroups, newContextSelectors.length);
                 for (let i = 0; i < newContextSelectors.length; i++) {
                     for (let j = 0; j < contextSelectorGroupsLength; j++) {
-                        contextSelectorGroups[j + (i * contextSelectorGroupsLength)].push(newContextSelectors[i]);
+                        contextSelectorGroups[j + i * contextSelectorGroupsLength].push(newContextSelectors[i]);
                     }
                 }
                 // Update the `selectorText` and see repeat to see if there are more `:host-context`s.
@@ -6862,7 +7079,7 @@ class ShadowCss {
             // selectors that `:host-context` can match. See `combineHostContextSelectors()` for more
             // info about how this is done.
             return contextSelectorGroups
-                .map(contextSelectors => combineHostContextSelectors(contextSelectors, selectorText))
+                .map((contextSelectors) => combineHostContextSelectors(contextSelectors, selectorText))
                 .join(', ');
         });
     }
@@ -6883,7 +7100,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')) {
@@ -6914,7 +7131,7 @@ class ShadowCss {
      * ```
      */
     _stripScopingSelectors(cssText) {
-        return processRules(cssText, rule => {
+        return processRules(cssText, (rule) => {
             const selector = rule.selector.replace(_shadowDeepSelectors, ' ')
                 .replace(_polyfillHostNoCombinatorRe, ' ');
             return new CssRule(selector, rule.content);
@@ -6922,7 +7139,7 @@ class ShadowCss {
     }
     _scopeSelector(selector, scopeSelector, hostSelector) {
         return selector.split(',')
-            .map(part => part.trim().split(_shadowDeepSelectors))
+            .map((part) => part.trim().split(_shadowDeepSelectors))
             .map((deepParts) => {
             const [shallowPart, ...otherParts] = deepParts;
             const applyScope = (shallowPart) => {
@@ -7105,17 +7322,14 @@ const _selectorReSuffix = '([>\\s~+[.,{:][\\s\\S]*)?$';
 const _polyfillHostRe = /-shadowcsshost/gim;
 const _colonHostRe = /:host/gim;
 const _colonHostContextRe = /:host-context/gim;
+const _newLinesRe = /\r?\n/g;
 const _commentRe = /\/\*[\s\S]*?\*\//g;
+const _commentWithHashRe = /\/\*\s*#\s*source(Mapping)?URL=/g;
+const COMMENT_PLACEHOLDER = '%COMMENT%';
+const _commentWithHashPlaceHolderRe = new RegExp(COMMENT_PLACEHOLDER, 'g');
 const _placeholderRe = /__ph-(\d+)__/g;
-function stripComments(input) {
-    return input.replace(_commentRe, '');
-}
-const _commentWithHashRe = /\/\*\s*#\s*source(Mapping)?URL=[\s\S]+?\*\//g;
-function extractCommentsWithHash(input) {
-    return input.match(_commentWithHashRe) || [];
-}
 const BLOCK_PLACEHOLDER = '%BLOCK%';
-const _ruleRe = /(\s*)([^;\{\}]+?)(\s*)((?:{%BLOCK%}?\s*;?)|(?:\s*;))/g;
+const _ruleRe = new RegExp(`(\\s*(?:${COMMENT_PLACEHOLDER}\\s*)*)([^;\\{\\}]+?)(\\s*)((?:{%BLOCK%}?\\s*;?)|(?:\\s*;))`, 'g');
 const CONTENT_PAIRS = new Map([['{', '}']]);
 const COMMA_IN_PLACEHOLDER = '%COMMA_IN_PLACEHOLDER%';
 const SEMI_IN_PLACEHOLDER = '%SEMI_IN_PLACEHOLDER%';
@@ -7324,7 +7538,6 @@ function unescapeQuotes(str, isQuoted) {
  *
  * And so on...
  *
- * @param hostMarker the string that selects the host element.
  * @param contextSelectors an array of context selectors that will be combined.
  * @param otherSelectors the rest of the selectors that are not context selectors.
  */
@@ -7378,24 +7591,754 @@ function repeatGroups(groups, multiples) {
     }
 }
 
+var TagContentType;
+(function (TagContentType) {
+    TagContentType[TagContentType["RAW_TEXT"] = 0] = "RAW_TEXT";
+    TagContentType[TagContentType["ESCAPABLE_RAW_TEXT"] = 1] = "ESCAPABLE_RAW_TEXT";
+    TagContentType[TagContentType["PARSABLE_DATA"] = 2] = "PARSABLE_DATA";
+})(TagContentType || (TagContentType = {}));
+function splitNsName(elementName) {
+    if (elementName[0] != ':') {
+        return [null, elementName];
+    }
+    const colonIndex = elementName.indexOf(':', 1);
+    if (colonIndex === -1) {
+        throw new Error(`Unsupported format "${elementName}" expecting ":namespace:name"`);
+    }
+    return [elementName.slice(1, colonIndex), elementName.slice(colonIndex + 1)];
+}
+// `<ng-container>` tags work the same regardless the namespace
+function isNgContainer(tagName) {
+    return splitNsName(tagName)[1] === 'ng-container';
+}
+// `<ng-content>` tags work the same regardless the namespace
+function isNgContent(tagName) {
+    return splitNsName(tagName)[1] === 'ng-content';
+}
+// `<ng-template>` tags work the same regardless the namespace
+function isNgTemplate(tagName) {
+    return splitNsName(tagName)[1] === 'ng-template';
+}
+function getNsPrefix(fullName) {
+    return fullName === null ? null : splitNsName(fullName)[0];
+}
+function mergeNsAndName(prefix, localName) {
+    return prefix ? `:${prefix}:${localName}` : localName;
+}
+
 /**
- * Parses string representation of a style and converts it into object literal.
- *
- * @param value string representation of style as used in the `style` attribute in HTML.
- *   Example: `color: red; height: auto`.
- * @returns An array of style property name and value pairs, e.g. `['color', 'red', 'height',
- * 'auto']`
+ * Enumeration of the types of attributes which can be applied to an element.
  */
-function parse(value) {
-    // we use a string array here instead of a string map
-    // because a string-map is not guaranteed to retain the
-    // order of the entries whereas a string array can be
-    // constructed in a [key, value, key, value] format.
-    const styles = [];
-    let i = 0;
-    let parenDepth = 0;
-    let quote = 0 /* Char.QuoteNone */;
-    let valueStart = 0;
+var BindingKind;
+(function (BindingKind) {
+    /**
+     * Static attributes.
+     */
+    BindingKind[BindingKind["Attribute"] = 0] = "Attribute";
+    /**
+     * Class bindings.
+     */
+    BindingKind[BindingKind["ClassName"] = 1] = "ClassName";
+    /**
+     * Style bindings.
+     */
+    BindingKind[BindingKind["StyleProperty"] = 2] = "StyleProperty";
+    /**
+     * Dynamic property bindings.
+     */
+    BindingKind[BindingKind["Property"] = 3] = "Property";
+    /**
+     * Property or attribute bindings on a template.
+     */
+    BindingKind[BindingKind["Template"] = 4] = "Template";
+    /**
+     * Internationalized attributes.
+     */
+    BindingKind[BindingKind["I18n"] = 5] = "I18n";
+    /**
+     * TODO: Consider how Animations are handled, and if they should be a distinct BindingKind.
+     */
+    BindingKind[BindingKind["Animation"] = 6] = "Animation";
+})(BindingKind || (BindingKind = {}));
+
+/**
+ * Distinguishes different kinds of IR operations.
+ *
+ * Includes both creation and update operations.
+ */
+var OpKind;
+(function (OpKind) {
+    /**
+     * A special operation type which is used to represent the beginning and end nodes of a linked
+     * list of operations.
+     */
+    OpKind[OpKind["ListEnd"] = 0] = "ListEnd";
+    /**
+     * An operation which wraps an output AST statement.
+     */
+    OpKind[OpKind["Statement"] = 1] = "Statement";
+    /**
+     * An operation which declares and initializes a `SemanticVariable`.
+     */
+    OpKind[OpKind["Variable"] = 2] = "Variable";
+    /**
+     * An operation to begin rendering of an element.
+     */
+    OpKind[OpKind["ElementStart"] = 3] = "ElementStart";
+    /**
+     * An operation to render an element with no children.
+     */
+    OpKind[OpKind["Element"] = 4] = "Element";
+    /**
+     * An operation which declares an embedded view.
+     */
+    OpKind[OpKind["Template"] = 5] = "Template";
+    /**
+     * An operation to end rendering of an element previously started with `ElementStart`.
+     */
+    OpKind[OpKind["ElementEnd"] = 6] = "ElementEnd";
+    /**
+     * An operation to begin an `ng-container`.
+     */
+    OpKind[OpKind["ContainerStart"] = 7] = "ContainerStart";
+    /**
+     * An operation for an `ng-container` with no children.
+     */
+    OpKind[OpKind["Container"] = 8] = "Container";
+    /**
+     * An operation to end an `ng-container`.
+     */
+    OpKind[OpKind["ContainerEnd"] = 9] = "ContainerEnd";
+    /**
+     * An operation disable binding for subsequent elements, which are descendants of a non-bindable
+     * node.
+     */
+    OpKind[OpKind["DisableBindings"] = 10] = "DisableBindings";
+    /**
+     * An operation to re-enable binding, after it was previously disabled.
+     */
+    OpKind[OpKind["EnableBindings"] = 11] = "EnableBindings";
+    /**
+     * An operation to render a text node.
+     */
+    OpKind[OpKind["Text"] = 12] = "Text";
+    /**
+     * An operation declaring an event listener for an element.
+     */
+    OpKind[OpKind["Listener"] = 13] = "Listener";
+    /**
+     * An operation to interpolate text into a text node.
+     */
+    OpKind[OpKind["InterpolateText"] = 14] = "InterpolateText";
+    /**
+     * An intermediate binding op, that has not yet been processed into an individual property,
+     * attribute, style, etc.
+     */
+    OpKind[OpKind["Binding"] = 15] = "Binding";
+    /**
+     * An operation to bind an expression to a property of an element.
+     */
+    OpKind[OpKind["Property"] = 16] = "Property";
+    /**
+     * An operation to bind an expression to a style property of an element.
+     */
+    OpKind[OpKind["StyleProp"] = 17] = "StyleProp";
+    /**
+     * An operation to bind an expression to a class property of an element.
+     */
+    OpKind[OpKind["ClassProp"] = 18] = "ClassProp";
+    /**
+     * An operation to bind an expression to the styles of an element.
+     */
+    OpKind[OpKind["StyleMap"] = 19] = "StyleMap";
+    /**
+     * An operation to bind an expression to the classes of an element.
+     */
+    OpKind[OpKind["ClassMap"] = 20] = "ClassMap";
+    /**
+     * An operation to advance the runtime's implicit slot context during the update phase of a view.
+     */
+    OpKind[OpKind["Advance"] = 21] = "Advance";
+    /**
+     * An operation to instantiate a pipe.
+     */
+    OpKind[OpKind["Pipe"] = 22] = "Pipe";
+    /**
+     * An operation to associate an attribute with an element.
+     */
+    OpKind[OpKind["Attribute"] = 23] = "Attribute";
+    /**
+     * A host binding property.
+     */
+    OpKind[OpKind["HostProperty"] = 24] = "HostProperty";
+    /**
+     * A namespace change, which causes the subsequent elements to be processed as either HTML or SVG.
+     */
+    OpKind[OpKind["Namespace"] = 25] = "Namespace";
+    // TODO: Add Host Listeners, and possibly other host ops also.
+})(OpKind || (OpKind = {}));
+/**
+ * Distinguishes different kinds of IR expressions.
+ */
+var ExpressionKind;
+(function (ExpressionKind) {
+    /**
+     * Read of a variable in a lexical scope.
+     */
+    ExpressionKind[ExpressionKind["LexicalRead"] = 0] = "LexicalRead";
+    /**
+     * A reference to the current view context.
+     */
+    ExpressionKind[ExpressionKind["Context"] = 1] = "Context";
+    /**
+     * Read of a variable declared in a `VariableOp`.
+     */
+    ExpressionKind[ExpressionKind["ReadVariable"] = 2] = "ReadVariable";
+    /**
+     * Runtime operation to navigate to the next view context in the view hierarchy.
+     */
+    ExpressionKind[ExpressionKind["NextContext"] = 3] = "NextContext";
+    /**
+     * Runtime operation to retrieve the value of a local reference.
+     */
+    ExpressionKind[ExpressionKind["Reference"] = 4] = "Reference";
+    /**
+     * Runtime operation to snapshot the current view context.
+     */
+    ExpressionKind[ExpressionKind["GetCurrentView"] = 5] = "GetCurrentView";
+    /**
+     * Runtime operation to restore a snapshotted view.
+     */
+    ExpressionKind[ExpressionKind["RestoreView"] = 6] = "RestoreView";
+    /**
+     * Runtime operation to reset the current view context after `RestoreView`.
+     */
+    ExpressionKind[ExpressionKind["ResetView"] = 7] = "ResetView";
+    /**
+     * Defines and calls a function with change-detected arguments.
+     */
+    ExpressionKind[ExpressionKind["PureFunctionExpr"] = 8] = "PureFunctionExpr";
+    /**
+     * Indicates a positional parameter to a pure function definition.
+     */
+    ExpressionKind[ExpressionKind["PureFunctionParameterExpr"] = 9] = "PureFunctionParameterExpr";
+    /**
+     * Binding to a pipe transformation.
+     */
+    ExpressionKind[ExpressionKind["PipeBinding"] = 10] = "PipeBinding";
+    /**
+     * Binding to a pipe transformation with a variable number of arguments.
+     */
+    ExpressionKind[ExpressionKind["PipeBindingVariadic"] = 11] = "PipeBindingVariadic";
+    /*
+     * A safe property read requiring expansion into a null check.
+     */
+    ExpressionKind[ExpressionKind["SafePropertyRead"] = 12] = "SafePropertyRead";
+    /**
+     * A safe keyed read requiring expansion into a null check.
+     */
+    ExpressionKind[ExpressionKind["SafeKeyedRead"] = 13] = "SafeKeyedRead";
+    /**
+     * A safe function call requiring expansion into a null check.
+     */
+    ExpressionKind[ExpressionKind["SafeInvokeFunction"] = 14] = "SafeInvokeFunction";
+    /**
+     * 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";
+    /**
+     * An expression representing a sanitizer function.
+     */
+    ExpressionKind[ExpressionKind["SanitizerExpr"] = 19] = "SanitizerExpr";
+})(ExpressionKind || (ExpressionKind = {}));
+/**
+ * Distinguishes between different kinds of `SemanticVariable`s.
+ */
+var SemanticVariableKind;
+(function (SemanticVariableKind) {
+    /**
+     * Represents the context of a particular view.
+     */
+    SemanticVariableKind[SemanticVariableKind["Context"] = 0] = "Context";
+    /**
+     * Represents an identifier declared in the lexical scope of a view.
+     */
+    SemanticVariableKind[SemanticVariableKind["Identifier"] = 1] = "Identifier";
+    /**
+     * Represents a saved state that can be used to restore a view in a listener handler function.
+     */
+    SemanticVariableKind[SemanticVariableKind["SavedView"] = 2] = "SavedView";
+})(SemanticVariableKind || (SemanticVariableKind = {}));
+/**
+ * Whether to compile in compatibilty mode. In compatibility mode, the template pipeline will
+ * attempt to match the output of `TemplateDefinitionBuilder` as exactly as possible, at the cost of
+ * producing quirky or larger code in some cases.
+ */
+var CompatibilityMode;
+(function (CompatibilityMode) {
+    CompatibilityMode[CompatibilityMode["Normal"] = 0] = "Normal";
+    CompatibilityMode[CompatibilityMode["TemplateDefinitionBuilder"] = 1] = "TemplateDefinitionBuilder";
+})(CompatibilityMode || (CompatibilityMode = {}));
+/**
+ * Represents functions used to sanitize different pieces of a template.
+ */
+var SanitizerFn;
+(function (SanitizerFn) {
+    SanitizerFn[SanitizerFn["Html"] = 0] = "Html";
+    SanitizerFn[SanitizerFn["Script"] = 1] = "Script";
+    SanitizerFn[SanitizerFn["Style"] = 2] = "Style";
+    SanitizerFn[SanitizerFn["Url"] = 3] = "Url";
+    SanitizerFn[SanitizerFn["ResourceUrl"] = 4] = "ResourceUrl";
+    SanitizerFn[SanitizerFn["IframeAttribute"] = 5] = "IframeAttribute";
+})(SanitizerFn || (SanitizerFn = {}));
+/**
+ * Marker symbol for `UsesSlotIndex` trait.
+ */
+const UsesSlotIndex = Symbol('UsesSlotIndex');
+/**
+ * Marker symbol for `ConsumesVars` trait.
+ */
+const ConsumesVarsTrait = Symbol('ConsumesVars');
+/**
+ * Marker symbol for `UsesVarOffset` trait.
+ */
+const UsesVarOffset = Symbol('UsesVarOffset');
+class Interpolation {
+    constructor(strings, expressions) {
+        this.strings = strings;
+        this.expressions = expressions;
+    }
+}
+
+var _d, _e, _f;
+/**
+ * Base type used for all logical IR expressions.
+ */
+class ExpressionBase extends Expression {
+    constructor(sourceSpan = null) {
+        super(null, sourceSpan);
+    }
+}
+class PipeBindingExpr extends ExpressionBase {
+    static { _d = UsesSlotIndex, _e = ConsumesVarsTrait, _f = UsesVarOffset; }
+    constructor(target, name, args) {
+        super();
+        this.target = target;
+        this.name = name;
+        this.args = args;
+        this.kind = ExpressionKind.PipeBinding;
+        this[_d] = true;
+        this[_e] = true;
+        this[_f] = true;
+        this.slot = null;
+        this.varOffset = null;
+    }
+    visitExpression(visitor, context) {
+        for (const arg of this.args) {
+            arg.visitExpression(visitor, context);
+        }
+    }
+    isEquivalent() {
+        return false;
+    }
+    isConstant() {
+        return false;
+    }
+    transformInternalExpressions(transform, flags) {
+        for (let idx = 0; idx < this.args.length; idx++) {
+            this.args[idx] = transformExpressionsInExpression(this.args[idx], transform, flags);
+        }
+    }
+    clone() {
+        const r = new PipeBindingExpr(this.target, this.name, this.args.map(a => a.clone()));
+        r.slot = this.slot;
+        r.varOffset = this.varOffset;
+        return r;
+    }
+}
+class SafeInvokeFunctionExpr extends ExpressionBase {
+    constructor(receiver, args) {
+        super();
+        this.receiver = receiver;
+        this.args = args;
+        this.kind = ExpressionKind.SafeInvokeFunction;
+    }
+    visitExpression(visitor, context) {
+        this.receiver.visitExpression(visitor, context);
+        for (const a of this.args) {
+            a.visitExpression(visitor, context);
+        }
+    }
+    isEquivalent() {
+        return false;
+    }
+    isConstant() {
+        return false;
+    }
+    transformInternalExpressions(transform, flags) {
+        this.receiver = transformExpressionsInExpression(this.receiver, transform, flags);
+        for (let i = 0; i < this.args.length; i++) {
+            this.args[i] = transformExpressionsInExpression(this.args[i], transform, flags);
+        }
+    }
+    clone() {
+        return new SafeInvokeFunctionExpr(this.receiver.clone(), this.args.map(a => a.clone()));
+    }
+}
+var VisitorContextFlag;
+(function (VisitorContextFlag) {
+    VisitorContextFlag[VisitorContextFlag["None"] = 0] = "None";
+    VisitorContextFlag[VisitorContextFlag["InChildOperation"] = 1] = "InChildOperation";
+})(VisitorContextFlag || (VisitorContextFlag = {}));
+/**
+ * Transform all `Expression`s in the AST of `expr` with the `transform` function.
+ *
+ * All such operations will be replaced with the result of applying `transform`, which may be an
+ * identity transformation.
+ */
+function transformExpressionsInExpression(expr, transform, flags) {
+    if (expr instanceof ExpressionBase) {
+        expr.transformInternalExpressions(transform, flags);
+    }
+    else if (expr instanceof BinaryOperatorExpr) {
+        expr.lhs = transformExpressionsInExpression(expr.lhs, transform, flags);
+        expr.rhs = transformExpressionsInExpression(expr.rhs, transform, flags);
+    }
+    else if (expr instanceof ReadPropExpr) {
+        expr.receiver = transformExpressionsInExpression(expr.receiver, transform, flags);
+    }
+    else if (expr instanceof ReadKeyExpr) {
+        expr.receiver = transformExpressionsInExpression(expr.receiver, transform, flags);
+        expr.index = transformExpressionsInExpression(expr.index, transform, flags);
+    }
+    else if (expr instanceof WritePropExpr) {
+        expr.receiver = transformExpressionsInExpression(expr.receiver, transform, flags);
+        expr.value = transformExpressionsInExpression(expr.value, transform, flags);
+    }
+    else if (expr instanceof WriteKeyExpr) {
+        expr.receiver = transformExpressionsInExpression(expr.receiver, transform, flags);
+        expr.index = transformExpressionsInExpression(expr.index, transform, flags);
+        expr.value = transformExpressionsInExpression(expr.value, transform, flags);
+    }
+    else if (expr instanceof InvokeFunctionExpr) {
+        expr.fn = transformExpressionsInExpression(expr.fn, transform, flags);
+        for (let i = 0; i < expr.args.length; i++) {
+            expr.args[i] = transformExpressionsInExpression(expr.args[i], transform, flags);
+        }
+    }
+    else if (expr instanceof LiteralArrayExpr) {
+        for (let i = 0; i < expr.entries.length; i++) {
+            expr.entries[i] = transformExpressionsInExpression(expr.entries[i], transform, flags);
+        }
+    }
+    else if (expr instanceof LiteralMapExpr) {
+        for (let i = 0; i < expr.entries.length; i++) {
+            expr.entries[i].value =
+                transformExpressionsInExpression(expr.entries[i].value, transform, flags);
+        }
+    }
+    else if (expr instanceof ConditionalExpr) {
+        expr.condition = transformExpressionsInExpression(expr.condition, transform, flags);
+        expr.trueCase = transformExpressionsInExpression(expr.trueCase, transform, flags);
+        if (expr.falseCase !== null) {
+            expr.falseCase = transformExpressionsInExpression(expr.falseCase, transform, flags);
+        }
+    }
+    else if (expr instanceof ReadVarExpr || expr instanceof ExternalExpr ||
+        expr instanceof LiteralExpr) ;
+    else {
+        throw new Error(`Unhandled expression kind: ${expr.constructor.name}`);
+    }
+    return transform(expr, flags);
+}
+
+/**
+ * A linked list of `Op` nodes of a given subtype.
+ *
+ * @param OpT specific subtype of `Op` nodes which this list contains.
+ */
+class OpList {
+    static { this.nextListId = 0; }
+    constructor() {
+        /**
+         * Debug ID of this `OpList` instance.
+         */
+        this.debugListId = OpList.nextListId++;
+        // OpList uses static head/tail nodes of a special `ListEnd` type.
+        // This avoids the need for special casing of the first and last list
+        // elements in all list operations.
+        this.head = {
+            kind: OpKind.ListEnd,
+            next: null,
+            prev: null,
+            debugListId: this.debugListId,
+        };
+        this.tail = {
+            kind: OpKind.ListEnd,
+            next: null,
+            prev: null,
+            debugListId: this.debugListId,
+        };
+        // Link `head` and `tail` together at the start (list is empty).
+        this.head.next = this.tail;
+        this.tail.prev = this.head;
+    }
+    /**
+     * Push a new operation to the tail of the list.
+     */
+    push(op) {
+        OpList.assertIsNotEnd(op);
+        OpList.assertIsUnowned(op);
+        op.debugListId = this.debugListId;
+        // The old "previous" node (which might be the head, if the list is empty).
+        const oldLast = this.tail.prev;
+        // Insert `op` following the old last node.
+        op.prev = oldLast;
+        oldLast.next = op;
+        // Connect `op` with the list tail.
+        op.next = this.tail;
+        this.tail.prev = op;
+    }
+    /**
+     * Prepend one or more nodes to the start of the list.
+     */
+    prepend(ops) {
+        if (ops.length === 0) {
+            return;
+        }
+        for (const op of ops) {
+            OpList.assertIsNotEnd(op);
+            OpList.assertIsUnowned(op);
+            op.debugListId = this.debugListId;
+        }
+        const first = this.head.next;
+        let prev = this.head;
+        for (const op of ops) {
+            prev.next = op;
+            op.prev = prev;
+            prev = op;
+        }
+        prev.next = first;
+        first.prev = prev;
+    }
+    /**
+     * `OpList` is iterable via the iteration protocol.
+     *
+     * It's safe to mutate the part of the list that has already been returned by the iterator, up to
+     * and including the last operation returned. Mutations beyond that point _may_ be safe, but may
+     * also corrupt the iteration position and should be avoided.
+     */
+    *[Symbol.iterator]() {
+        let current = this.head.next;
+        while (current !== this.tail) {
+            // Guards against corruption of the iterator state by mutations to the tail of the list during
+            // iteration.
+            OpList.assertIsOwned(current, this.debugListId);
+            const next = current.next;
+            yield current;
+            current = next;
+        }
+    }
+    *reversed() {
+        let current = this.tail.prev;
+        while (current !== this.head) {
+            OpList.assertIsOwned(current, this.debugListId);
+            const prev = current.prev;
+            yield current;
+            current = prev;
+        }
+    }
+    /**
+     * Replace `oldOp` with `newOp` in the list.
+     */
+    static replace(oldOp, newOp) {
+        OpList.assertIsNotEnd(oldOp);
+        OpList.assertIsNotEnd(newOp);
+        OpList.assertIsOwned(oldOp);
+        OpList.assertIsUnowned(newOp);
+        newOp.debugListId = oldOp.debugListId;
+        if (oldOp.prev !== null) {
+            oldOp.prev.next = newOp;
+            newOp.prev = oldOp.prev;
+        }
+        if (oldOp.next !== null) {
+            oldOp.next.prev = newOp;
+            newOp.next = oldOp.next;
+        }
+        oldOp.debugListId = null;
+        oldOp.prev = null;
+        oldOp.next = null;
+    }
+    /**
+     * Replace `oldOp` with some number of new operations in the list (which may include `oldOp`).
+     */
+    static replaceWithMany(oldOp, newOps) {
+        if (newOps.length === 0) {
+            // Replacing with an empty list -> pure removal.
+            OpList.remove(oldOp);
+            return;
+        }
+        OpList.assertIsNotEnd(oldOp);
+        OpList.assertIsOwned(oldOp);
+        const listId = oldOp.debugListId;
+        oldOp.debugListId = null;
+        for (const newOp of newOps) {
+            OpList.assertIsNotEnd(newOp);
+            // `newOp` might be `oldOp`, but at this point it's been marked as unowned.
+            OpList.assertIsUnowned(newOp);
+        }
+        // It should be safe to reuse `oldOp` in the `newOps` list - maybe you want to sandwich an
+        // operation between two new ops.
+        const { prev: oldPrev, next: oldNext } = oldOp;
+        oldOp.prev = null;
+        oldOp.next = null;
+        let prev = oldPrev;
+        for (const newOp of newOps) {
+            this.assertIsUnowned(newOp);
+            newOp.debugListId = listId;
+            prev.next = newOp;
+            newOp.prev = prev;
+            // This _should_ be the case, but set it just in case.
+            newOp.next = null;
+            prev = newOp;
+        }
+        // At the end of iteration, `prev` holds the last node in the list.
+        const first = newOps[0];
+        const last = prev;
+        // Replace `oldOp` with the chain `first` -> `last`.
+        if (oldPrev !== null) {
+            oldPrev.next = first;
+            first.prev = oldOp.prev;
+        }
+        if (oldNext !== null) {
+            oldNext.prev = last;
+            last.next = oldNext;
+        }
+    }
+    /**
+     * Remove the given node from the list which contains it.
+     */
+    static remove(op) {
+        OpList.assertIsNotEnd(op);
+        OpList.assertIsOwned(op);
+        op.prev.next = op.next;
+        op.next.prev = op.prev;
+        // Break any link between the node and this list to safeguard against its usage in future
+        // operations.
+        op.debugListId = null;
+        op.prev = null;
+        op.next = null;
+    }
+    /**
+     * Insert `op` before `target`.
+     */
+    static insertBefore(op, target) {
+        OpList.assertIsOwned(target);
+        if (target.prev === null) {
+            throw new Error(`AssertionError: illegal operation on list start`);
+        }
+        OpList.assertIsNotEnd(op);
+        OpList.assertIsUnowned(op);
+        op.debugListId = target.debugListId;
+        // Just in case.
+        op.prev = null;
+        target.prev.next = op;
+        op.prev = target.prev;
+        op.next = target;
+        target.prev = op;
+    }
+    /**
+     * Insert `op` after `target`.
+     */
+    static insertAfter(op, target) {
+        OpList.assertIsOwned(target);
+        if (target.next === null) {
+            throw new Error(`AssertionError: illegal operation on list end`);
+        }
+        OpList.assertIsNotEnd(op);
+        OpList.assertIsUnowned(op);
+        op.debugListId = target.debugListId;
+        target.next.prev = op;
+        op.next = target.next;
+        op.prev = target;
+        target.next = op;
+    }
+    /**
+     * Asserts that `op` does not currently belong to a list.
+     */
+    static assertIsUnowned(op) {
+        if (op.debugListId !== null) {
+            throw new Error(`AssertionError: illegal operation on owned node: ${OpKind[op.kind]}`);
+        }
+    }
+    /**
+     * Asserts that `op` currently belongs to a list. If `byList` is passed, `op` is asserted to
+     * specifically belong to that list.
+     */
+    static assertIsOwned(op, byList) {
+        if (op.debugListId === null) {
+            throw new Error(`AssertionError: illegal operation on unowned node: ${OpKind[op.kind]}`);
+        }
+        else if (byList !== undefined && op.debugListId !== byList) {
+            throw new Error(`AssertionError: node belongs to the wrong list (expected ${byList}, actual ${op.debugListId})`);
+        }
+    }
+    /**
+     * Asserts that `op` is not a special `ListEnd` node.
+     */
+    static assertIsNotEnd(op) {
+        if (op.kind === OpKind.ListEnd) {
+            throw new Error(`AssertionError: illegal operation on list head or tail`);
+        }
+    }
+}
+
+/**
+ * The set of OpKinds that represent the creation of an element or container
+ */
+new Set([
+    OpKind.Element, OpKind.ElementStart, OpKind.Container, OpKind.ContainerStart, OpKind.Template
+]);
+/**
+ * Whether the active namespace is HTML, MathML, or SVG mode.
+ */
+var Namespace;
+(function (Namespace) {
+    Namespace[Namespace["HTML"] = 0] = "HTML";
+    Namespace[Namespace["SVG"] = 1] = "SVG";
+    Namespace[Namespace["Math"] = 2] = "Math";
+})(Namespace || (Namespace = {}));
+
+/**
+ * Parses string representation of a style and converts it into object literal.
+ *
+ * @param value string representation of style as used in the `style` attribute in HTML.
+ *   Example: `color: red; height: auto`.
+ * @returns An array of style property name and value pairs, e.g. `['color', 'red', 'height',
+ * 'auto']`
+ */
+function parse(value) {
+    // we use a string array here instead of a string map
+    // because a string-map is not guaranteed to retain the
+    // order of the entries whereas a string array can be
+    // constructed in a [key, value, key, value] format.
+    const styles = [];
+    let i = 0;
+    let parenDepth = 0;
+    let quote = 0 /* Char.QuoteNone */;
+    let valueStart = 0;
     let propStart = 0;
     let currentProp = null;
     while (i < value.length) {
@@ -7428,7 +8371,7 @@ function parse(value) {
                 break;
             case 58 /* Char.Colon */:
                 if (!currentProp && parenDepth === 0 && quote === 0 /* Char.QuoteNone */) {
-                    currentProp = hyphenate(value.substring(propStart, i - 1).trim());
+                    currentProp = hyphenate$1(value.substring(propStart, i - 1).trim());
                     valueStart = i;
                 }
                 break;
@@ -7449,7 +8392,7 @@ function parse(value) {
     }
     return styles;
 }
-function hyphenate(value) {
+function hyphenate$1(value) {
     return value
         .replace(/[a-z][A-Z]/g, v => {
         return v.charAt(0) + '-' + v.charAt(1);
@@ -7457,6 +8400,140 @@ function hyphenate(value) {
         .toLowerCase();
 }
 
+new Map([
+    [OpKind.ElementEnd, [OpKind.ElementStart, OpKind.Element]],
+    [OpKind.ContainerEnd, [OpKind.ContainerStart, OpKind.Container]],
+]);
+// A lookup set of all the expression kinds that require a temporary variable to be generated.
+[
+    InvokeFunctionExpr, LiteralArrayExpr, LiteralMapExpr, SafeInvokeFunctionExpr,
+    PipeBindingExpr
+].map(e => e.constructor.name);
+
+new Map([
+    ['&&', BinaryOperator.And],
+    ['>', BinaryOperator.Bigger],
+    ['>=', BinaryOperator.BiggerEquals],
+    ['&', BinaryOperator.BitwiseAnd],
+    ['/', BinaryOperator.Divide],
+    ['==', BinaryOperator.Equals],
+    ['===', BinaryOperator.Identical],
+    ['<', BinaryOperator.Lower],
+    ['<=', BinaryOperator.LowerEquals],
+    ['-', BinaryOperator.Minus],
+    ['%', BinaryOperator.Modulo],
+    ['*', BinaryOperator.Multiply],
+    ['!=', BinaryOperator.NotEquals],
+    ['!==', BinaryOperator.NotIdentical],
+    ['??', BinaryOperator.NullishCoalesce],
+    ['||', BinaryOperator.Or],
+    ['+', BinaryOperator.Plus],
+]);
+new Map([['svg', Namespace.SVG], ['math', Namespace.Math]]);
+
+function kindTest(kind) {
+    return (op) => op.kind === kind;
+}
+/**
+ * Defines the groups based on `OpKind` that ops will be divided into. Ops will be collected into
+ * groups, then optionally transformed, before recombining the groups in the order defined here.
+ */
+[
+    { test: kindTest(OpKind.StyleMap), transform: keepLast },
+    { test: kindTest(OpKind.ClassMap), transform: keepLast },
+    { test: kindTest(OpKind.StyleProp) },
+    { test: kindTest(OpKind.ClassProp) },
+    {
+        test: (op) => (op.kind === OpKind.Property || op.kind === OpKind.HostProperty) &&
+            op.expression instanceof Interpolation
+    },
+    {
+        test: (op) => (op.kind === OpKind.Property || op.kind === OpKind.HostProperty) &&
+            !(op.expression instanceof Interpolation)
+    },
+    { test: kindTest(OpKind.Attribute) },
+];
+/**
+ * The set of all op kinds we handle in the reordering phase.
+ */
+new Set([
+    OpKind.StyleMap,
+    OpKind.ClassMap,
+    OpKind.StyleProp,
+    OpKind.ClassProp,
+    OpKind.Property,
+    OpKind.HostProperty,
+    OpKind.Attribute,
+]);
+/**
+ * Keeps only the last op in a list of ops.
+ */
+function keepLast(ops) {
+    return ops.slice(ops.length - 1);
+}
+
+/**
+ * Map of sanitizers to their identifier.
+ */
+new Map([
+    [SanitizerFn.Html, Identifiers.sanitizeHtml],
+    [SanitizerFn.IframeAttribute, Identifiers.validateIframeAttribute],
+    [SanitizerFn.ResourceUrl, Identifiers.sanitizeResourceUrl],
+    [SanitizerFn.Script, Identifiers.sanitizeScript],
+    [SanitizerFn.Style, Identifiers.sanitizeStyle], [SanitizerFn.Url, Identifiers.sanitizeUrl]
+]);
+
+/**
+ * Mapping of security contexts to sanitizer function for that context.
+ */
+new Map([
+    [SecurityContext.HTML, SanitizerFn.Html], [SecurityContext.SCRIPT, SanitizerFn.Script],
+    [SecurityContext.STYLE, SanitizerFn.Style], [SecurityContext.URL, SanitizerFn.Url],
+    [SecurityContext.RESOURCE_URL, SanitizerFn.ResourceUrl]
+]);
+/**
+ * A [fence](https://en.wikipedia.org/wiki/Memory_barrier) flag for an expression which indicates
+ * how that expression can be optimized in relation to other expressions or instructions.
+ *
+ * `Fence`s are a bitfield, so multiple flags may be set on a single expression.
+ */
+var Fence;
+(function (Fence) {
+    /**
+     * Empty flag (no fence exists).
+     */
+    Fence[Fence["None"] = 0] = "None";
+    /**
+     * A context read fence, meaning that the expression in question reads from the "current view"
+     * context of the runtime.
+     */
+    Fence[Fence["ViewContextRead"] = 1] = "ViewContextRead";
+    /**
+     * A context write fence, meaning that the expression in question writes to the "current view"
+     * context of the runtime.
+     *
+     * Note that all `ContextWrite` fences are implicitly `ContextRead` fences as operations which
+     * change the view context do so based on the current one.
+     */
+    Fence[Fence["ViewContextWrite"] = 3] = "ViewContextWrite";
+    /**
+     * Indicates that a call is required for its side-effects, even if nothing reads its result.
+     *
+     * This is also true of `ViewContextWrite` operations **if** they are followed by a
+     * `ViewContextRead`.
+     */
+    Fence[Fence["SideEffectful"] = 4] = "SideEffectful";
+})(Fence || (Fence = {}));
+
+CompatibilityMode.TemplateDefinitionBuilder;
+new Map([
+    [0 /* e.BindingType.Property */, BindingKind.Property],
+    [1 /* e.BindingType.Attribute */, BindingKind.Attribute],
+    [2 /* e.BindingType.Class */, BindingKind.ClassName],
+    [3 /* e.BindingType.Style */, BindingKind.StyleProperty],
+    [4 /* e.BindingType.Animation */, BindingKind.Animation],
+]);
+
 const IMPORTANT_FLAG = '!important';
 /**
  * Minimum amount of binding slots required in the runtime for style/class bindings.
@@ -7626,7 +8703,7 @@ class StylingBuilder {
         // CSS custom properties are case-sensitive so we shouldn't normalize them.
         // See: https://www.w3.org/TR/css-variables-1/#defining-variables
         if (!isCssCustomProperty(name)) {
-            name = hyphenate(name);
+            name = hyphenate$1(name);
         }
         const { property, hasOverrideFlag, suffix: bindingSuffix } = parseProperty(name);
         suffix = typeof suffix === 'string' && suffix.length !== 0 ? suffix : bindingSuffix;
@@ -7756,7 +8833,7 @@ class StylingBuilder {
         // pipes can be picked up in time before the template is built
         const mapValue = stylingInput.value.visit(valueConverter);
         let reference;
-        if (mapValue instanceof Interpolation) {
+        if (mapValue instanceof Interpolation$1) {
             totalBindingSlotsRequired += mapValue.expressions.length;
             reference = isClassBased ? getClassMapInterpolationExpression(mapValue) :
                 getStyleMapInterpolationExpression(mapValue);
@@ -7791,7 +8868,7 @@ class StylingBuilder {
             //      We need to store the intermediate value so that we don't allocate
             //      the strings on each CD.
             let totalBindingSlotsRequired = MIN_STYLING_BINDING_SLOTS_REQUIRED;
-            if (value instanceof Interpolation) {
+            if (value instanceof Interpolation$1) {
                 totalBindingSlotsRequired += value.expressions.length;
                 if (getInterpolationExpressionFn) {
                     referenceForCall = getInterpolationExpressionFn(value);
@@ -7983,7 +9060,7 @@ function isEmptyExpression(ast) {
     if (ast instanceof ASTWithSource) {
         ast = ast.ast;
     }
-    return ast instanceof EmptyExpr;
+    return ast instanceof EmptyExpr$1;
 }
 
 var TokenType;
@@ -8419,6 +9496,7 @@ class Parser$1 {
         ast.visit(checker);
         return checker.errors;
     }
+    // Host bindings parsed here
     parseSimpleBinding(input, location, absoluteOffset, interpolationConfig = DEFAULT_INTERPOLATION_CONFIG) {
         const ast = this._parseBindingAst(input, location, absoluteOffset, interpolationConfig);
         const errors = this.checkSimpleExpression(ast);
@@ -8501,7 +9579,7 @@ class Parser$1 {
     }
     createInterpolationAst(strings, expressions, input, location, absoluteOffset) {
         const span = new ParseSpan(0, input.length);
-        const interpolation = new Interpolation(span, span.toAbsolute(absoluteOffset), strings, expressions);
+        const interpolation = new Interpolation$1(span, span.toAbsolute(absoluteOffset), strings, expressions);
         return new ASTWithSource(interpolation, input, location, absoluteOffset, this.errors);
     }
     /**
@@ -8872,7 +9950,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];
@@ -8933,7 +10011,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();
@@ -9158,15 +10236,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) {
@@ -9227,7 +10305,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);
@@ -9237,7 +10315,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);
@@ -9367,7 +10445,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--;
@@ -9385,7 +10463,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));
         });
     }
     /**
@@ -9680,6 +10758,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 ?
@@ -9694,41 +10805,6 @@ function visitAll(visitor, nodes, context = null) {
     return result;
 }
 
-var TagContentType;
-(function (TagContentType) {
-    TagContentType[TagContentType["RAW_TEXT"] = 0] = "RAW_TEXT";
-    TagContentType[TagContentType["ESCAPABLE_RAW_TEXT"] = 1] = "ESCAPABLE_RAW_TEXT";
-    TagContentType[TagContentType["PARSABLE_DATA"] = 2] = "PARSABLE_DATA";
-})(TagContentType || (TagContentType = {}));
-function splitNsName(elementName) {
-    if (elementName[0] != ':') {
-        return [null, elementName];
-    }
-    const colonIndex = elementName.indexOf(':', 1);
-    if (colonIndex === -1) {
-        throw new Error(`Unsupported format "${elementName}" expecting ":namespace:name"`);
-    }
-    return [elementName.slice(1, colonIndex), elementName.slice(colonIndex + 1)];
-}
-// `<ng-container>` tags work the same regardless the namespace
-function isNgContainer(tagName) {
-    return splitNsName(tagName)[1] === 'ng-container';
-}
-// `<ng-content>` tags work the same regardless the namespace
-function isNgContent(tagName) {
-    return splitNsName(tagName)[1] === 'ng-content';
-}
-// `<ng-template>` tags work the same regardless the namespace
-function isNgTemplate(tagName) {
-    return splitNsName(tagName)[1] === 'ng-template';
-}
-function getNsPrefix(fullName) {
-    return fullName === null ? null : splitNsName(fullName)[0];
-}
-function mergeNsAndName(prefix, localName) {
-    return prefix ? `:${prefix}:${localName}` : localName;
-}
-
 class ElementSchemaRegistry {
 }
 
@@ -12400,8 +13476,9 @@ const NAMED_ENTITIES = {
     'zwj': '\u200D',
     'zwnj': '\u200C'
 };
-// The &ngsp; pseudo-entity is denoting a space. see:
-// https://github.com/dart-lang/angular/blob/0bb611387d29d65b5af7f9d2515ab571fd3fbee4/_tests/test/compiler/preserve_whitespace_test.dart
+// The &ngsp; pseudo-entity is denoting a space.
+// 0xE500 is a PUA (Private Use Areas) unicode character
+// This is inspired by the Angular Dart implementation.
 const NGSP_UNICODE = '\uE500';
 NAMED_ENTITIES['ngsp'] = NGSP_UNICODE;
 
@@ -12468,8 +13545,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();
         }
@@ -12510,18 +13587,96 @@ 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.
                     this._consumeWithInterpolation(5 /* TokenType.TEXT */, 8 /* TokenType.INTERPOLATION */, () => this._isTextEnd(), () => this._isTagStart());
                 }
             }
-            catch (e) {
-                this.handleError(e);
-            }
+            catch (e) {
+                this.handleError(e);
+            }
+        }
+        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;
+            let openBraces = 0;
+            // 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() !== $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;
+                }
+                else if (char === $LBRACE && inQuote === null) {
+                    openBraces++;
+                }
+                else if (char === $RBRACE && inQuote === null) {
+                    if (openBraces === 0) {
+                        break;
+                    }
+                    else if (openBraces > 0) {
+                        openBraces--;
+                    }
+                }
+                this._cursor.advance();
+            }
+            this._endToken([this._cursor.getChars(start)]);
+            // Skip to the next parameter.
+            this._attemptCharCodeUntilFn(isBlockParameterChar);
         }
-        this._beginToken(24 /* TokenType.EOF */);
-        this._endToken([]);
     }
     /**
      * @returns whether an ICU token has been created
@@ -13044,7 +14199,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) {
@@ -13077,6 +14232,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);
@@ -13132,6 +14304,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;
@@ -13419,7 +14597,7 @@ class _TreeBuilder {
         this.tokens = tokens;
         this.getTagDefinition = getTagDefinition;
         this._index = -1;
-        this._elementStack = [];
+        this._containerStack = [];
         this.rootNodes = [];
         this.errors = [];
         this._advance();
@@ -13449,6 +14627,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();
@@ -13476,9 +14666,12 @@ class _TreeBuilder {
     }
     _consumeComment(token) {
         const text = this._advanceIf(7 /* TokenType.RAW_TEXT */);
-        this._advanceIf(11 /* TokenType.COMMENT_END */);
+        const endToken = this._advanceIf(11 /* TokenType.COMMENT_END */);
         const value = text != null ? text.parts[0].trim() : null;
-        this._addToParent(new Comment(value, token.sourceSpan));
+        const sourceSpan = endToken == null ?
+            token.sourceSpan :
+            new ParseSourceSpan(token.sourceSpan.start, endToken.sourceSpan.end, token.sourceSpan.fullStart);
+        this._addToParent(new Comment(value, sourceSpan));
     }
     _consumeExpansion(token) {
         const switchValue = this._advance();
@@ -13565,7 +14758,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);
@@ -13596,9 +14794,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) {
@@ -13607,7 +14805,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...
@@ -13628,33 +14826,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));
         }
@@ -13665,20 +14864,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.
@@ -13737,16 +14939,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) {
@@ -13804,10 +15082,9 @@ function hasPreserveWhitespacesAttr(attrs) {
     return attrs.some((attr) => attr.name === PRESERVE_WS_ATTR_NAME);
 }
 /**
- * Angular Dart introduced &ngsp; as a placeholder for non-removable space, see:
- * https://github.com/dart-lang/angular/blob/0bb611387d29d65b5af7f9d2515ab571fd3fbee4/_tests/test/compiler/preserve_whitespace_test.dart#L25-L32
- * In Angular Dart &ngsp; is converted to the 0xE500 PUA (Private Use Areas) unicode character
- * and later on replaced by a space. We are re-implementing the same idea here.
+ * &ngsp; is a placeholder for non-removable space
+ * &ngsp; is converted to the 0xE500 PUA (Private Use Areas) unicode character
+ * and later on replaced by a space.
  */
 function replaceNgsp(value) {
     // lexer is replacing the &ngsp; pseudo-entity with NGSP_UNICODE
@@ -13861,6 +15138,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 };
@@ -14118,7 +15404,7 @@ class BindingParser {
             this._parseAnimation(name, expression, sourceSpan, absoluteOffset, keySpan, valueSpan, targetMatchableAttrs, targetProps);
         }
         else {
-            this._parsePropertyAst(name, this._parseBinding(expression, isHost, valueSpan || sourceSpan, absoluteOffset), sourceSpan, keySpan, valueSpan, targetMatchableAttrs, targetProps);
+            this._parsePropertyAst(name, this.parseBinding(expression, isHost, valueSpan || sourceSpan, absoluteOffset), sourceSpan, keySpan, valueSpan, targetMatchableAttrs, targetProps);
         }
     }
     parsePropertyInterpolation(name, value, sourceSpan, valueSpan, targetMatchableAttrs, targetProps, keySpan, interpolatedTokens) {
@@ -14140,11 +15426,11 @@ class BindingParser {
         // This will occur when a @trigger is not paired with an expression.
         // For animations it is valid to not have an expression since */void
         // states will be applied by angular when the element is attached/detached
-        const ast = this._parseBinding(expression || 'undefined', false, valueSpan || sourceSpan, absoluteOffset);
+        const ast = this.parseBinding(expression || 'undefined', false, valueSpan || sourceSpan, absoluteOffset);
         targetMatchableAttrs.push([name, ast.source]);
         targetProps.push(new ParsedProperty(name, ast, ParsedPropertyType.ANIMATION, sourceSpan, keySpan, valueSpan));
     }
-    _parseBinding(value, isHostBinding, sourceSpan, absoluteOffset) {
+    parseBinding(value, isHostBinding, sourceSpan, absoluteOffset) {
         const sourceInfo = (sourceSpan && sourceSpan.start || '(unknown)').toString();
         try {
             const ast = isHostBinding ?
@@ -14263,7 +15549,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);
             }
@@ -14409,6 +15695,415 @@ function normalizeNgContentSelect(selectAttr) {
     return selectAttr;
 }
 
+/** Pattern for a timing value in a trigger. */
+const TIME_PATTERN = /^\d+(ms|s)?$/;
+/** Pattern for a separator between keywords in a trigger expression. */
+const SEPARATOR_PATTERN = /^\s$/;
+/** Pairs of characters that form syntax that is comma-delimited. */
+const COMMA_DELIMITED_SYNTAX = new Map([
+    [$LBRACE, $RBRACE],
+    [$LBRACKET, $RBRACKET],
+    [$LPAREN, $RPAREN], // Function calls
+]);
+/** Possible types of `on` triggers. */
+var OnTriggerType;
+(function (OnTriggerType) {
+    OnTriggerType["IDLE"] = "idle";
+    OnTriggerType["TIMER"] = "timer";
+    OnTriggerType["INTERACTION"] = "interaction";
+    OnTriggerType["IMMEDIATE"] = "immediate";
+    OnTriggerType["HOVER"] = "hover";
+    OnTriggerType["VIEWPORT"] = "viewport";
+})(OnTriggerType || (OnTriggerType = {}));
+/** Parses a `when` deferred trigger. */
+function parseWhenTrigger({ expression, sourceSpan }, bindingParser, errors) {
+    const whenIndex = expression.indexOf('when');
+    // This is here just to be safe, we shouldn't enter this function
+    // in the first place if a block doesn't have the "when" keyword.
+    if (whenIndex === -1) {
+        errors.push(new ParseError(sourceSpan, `Could not find "when" keyword in expression`));
+        return null;
+    }
+    const start = getTriggerParametersStart(expression, whenIndex + 1);
+    const parsed = bindingParser.parseBinding(expression.slice(start), false, sourceSpan, sourceSpan.start.offset + start);
+    return new BoundDeferredTrigger(parsed, sourceSpan);
+}
+/** Parses an `on` trigger */
+function parseOnTrigger({ expression, sourceSpan }, errors) {
+    const onIndex = expression.indexOf('on');
+    // This is here just to be safe, we shouldn't enter this function
+    // in the first place if a block doesn't have the "on" keyword.
+    if (onIndex === -1) {
+        errors.push(new ParseError(sourceSpan, `Could not find "on" keyword in expression`));
+        return [];
+    }
+    const start = getTriggerParametersStart(expression, onIndex + 1);
+    return new OnTriggerParser(expression, start, sourceSpan, errors).parse();
+}
+class OnTriggerParser {
+    constructor(expression, start, span, errors) {
+        this.expression = expression;
+        this.start = start;
+        this.span = span;
+        this.errors = errors;
+        this.index = 0;
+        this.triggers = [];
+        this.tokens = new Lexer().tokenize(expression.slice(start));
+    }
+    parse() {
+        while (this.tokens.length > 0 && this.index < this.tokens.length) {
+            const token = this.token();
+            if (!token.isIdentifier()) {
+                this.unexpectedToken(token);
+                break;
+            }
+            // An identifier immediately followed by a comma or the end of
+            // the expression cannot have parameters so we can exit early.
+            if (this.isFollowedByOrLast($COMMA)) {
+                this.consumeTrigger(token, []);
+                this.advance();
+            }
+            else if (this.isFollowedByOrLast($LPAREN)) {
+                this.advance(); // Advance to the opening paren.
+                const prevErrors = this.errors.length;
+                const parameters = this.consumeParameters();
+                if (this.errors.length !== prevErrors) {
+                    break;
+                }
+                this.consumeTrigger(token, parameters);
+                this.advance(); // Advance past the closing paren.
+            }
+            else if (this.index < this.tokens.length - 1) {
+                this.unexpectedToken(this.tokens[this.index + 1]);
+            }
+            this.advance();
+        }
+        return this.triggers;
+    }
+    advance() {
+        this.index++;
+    }
+    isFollowedByOrLast(char) {
+        if (this.index === this.tokens.length - 1) {
+            return true;
+        }
+        return this.tokens[this.index + 1].isCharacter(char);
+    }
+    token() {
+        return this.tokens[Math.min(this.index, this.tokens.length - 1)];
+    }
+    consumeTrigger(identifier, parameters) {
+        const startSpan = this.span.start.moveBy(this.start + identifier.index - this.tokens[0].index);
+        const endSpan = startSpan.moveBy(this.token().end - identifier.index);
+        const sourceSpan = new ParseSourceSpan(startSpan, endSpan);
+        try {
+            switch (identifier.toString()) {
+                case OnTriggerType.IDLE:
+                    this.triggers.push(createIdleTrigger(parameters, sourceSpan));
+                    break;
+                case OnTriggerType.TIMER:
+                    this.triggers.push(createTimerTrigger(parameters, sourceSpan));
+                    break;
+                case OnTriggerType.INTERACTION:
+                    this.triggers.push(createInteractionTrigger(parameters, sourceSpan));
+                    break;
+                case OnTriggerType.IMMEDIATE:
+                    this.triggers.push(createImmediateTrigger(parameters, sourceSpan));
+                    break;
+                case OnTriggerType.HOVER:
+                    this.triggers.push(createHoverTrigger(parameters, sourceSpan));
+                    break;
+                case OnTriggerType.VIEWPORT:
+                    this.triggers.push(createViewportTrigger(parameters, sourceSpan));
+                    break;
+                default:
+                    throw new Error(`Unrecognized trigger type "${identifier}"`);
+            }
+        }
+        catch (e) {
+            this.error(identifier, e.message);
+        }
+    }
+    consumeParameters() {
+        const parameters = [];
+        if (!this.token().isCharacter($LPAREN)) {
+            this.unexpectedToken(this.token());
+            return parameters;
+        }
+        this.advance();
+        const commaDelimStack = [];
+        let current = '';
+        while (this.index < this.tokens.length) {
+            const token = this.token();
+            // Stop parsing if we've hit the end character and we're outside of a comma-delimited syntax.
+            // Note that we don't need to account for strings here since the lexer already parsed them
+            // into string tokens.
+            if (token.isCharacter($RPAREN) && commaDelimStack.length === 0) {
+                if (current.length) {
+                    parameters.push(current);
+                }
+                break;
+            }
+            // In the `on` microsyntax "top-level" commas (e.g. ones outside of an parameters) separate
+            // the different triggers (e.g. `on idle,timer(500)`). This is problematic, because the
+            // function-like syntax also implies that multiple parameters can be passed into the
+            // individual trigger (e.g. `on foo(a, b)`). To avoid tripping up the parser with commas that
+            // are part of other sorts of syntax (object literals, arrays), we treat anything inside
+            // a comma-delimited syntax block as plain text.
+            if (token.type === TokenType.Character && COMMA_DELIMITED_SYNTAX.has(token.numValue)) {
+                commaDelimStack.push(COMMA_DELIMITED_SYNTAX.get(token.numValue));
+            }
+            if (commaDelimStack.length > 0 &&
+                token.isCharacter(commaDelimStack[commaDelimStack.length - 1])) {
+                commaDelimStack.pop();
+            }
+            // If we hit a comma outside of a comma-delimited syntax, it means
+            // that we're at the top level and we're starting a new parameter.
+            if (commaDelimStack.length === 0 && token.isCharacter($COMMA) && current.length > 0) {
+                parameters.push(current);
+                current = '';
+                this.advance();
+                continue;
+            }
+            // Otherwise treat the token as a plain text character in the current parameter.
+            current += this.tokenText();
+            this.advance();
+        }
+        if (!this.token().isCharacter($RPAREN) || commaDelimStack.length > 0) {
+            this.error(this.token(), 'Unexpected end of expression');
+        }
+        if (this.index < this.tokens.length - 1 &&
+            !this.tokens[this.index + 1].isCharacter($COMMA)) {
+            this.unexpectedToken(this.tokens[this.index + 1]);
+        }
+        return parameters;
+    }
+    tokenText() {
+        // Tokens have a toString already which we could use, but for string tokens it omits the quotes.
+        // Eventually we could expose this information on the token directly.
+        return this.expression.slice(this.start + this.token().index, this.start + this.token().end);
+    }
+    error(token, message) {
+        const newStart = this.span.start.moveBy(this.start + token.index);
+        const newEnd = newStart.moveBy(token.end - token.index);
+        this.errors.push(new ParseError(new ParseSourceSpan(newStart, newEnd), message));
+    }
+    unexpectedToken(token) {
+        this.error(token, `Unexpected token "${token}"`);
+    }
+}
+function createIdleTrigger(parameters, sourceSpan) {
+    if (parameters.length > 0) {
+        throw new Error(`"${OnTriggerType.IDLE}" trigger cannot have parameters`);
+    }
+    return new IdleDeferredTrigger(sourceSpan);
+}
+function createTimerTrigger(parameters, sourceSpan) {
+    if (parameters.length !== 1) {
+        throw new Error(`"${OnTriggerType.TIMER}" trigger must have exactly one parameter`);
+    }
+    const delay = parseDeferredTime(parameters[0]);
+    if (delay === null) {
+        throw new Error(`Could not parse time value of trigger "${OnTriggerType.TIMER}"`);
+    }
+    return new TimerDeferredTrigger(delay, sourceSpan);
+}
+function createInteractionTrigger(parameters, sourceSpan) {
+    if (parameters.length > 1) {
+        throw new Error(`"${OnTriggerType.INTERACTION}" trigger can only have zero or one parameters`);
+    }
+    return new InteractionDeferredTrigger(parameters[0] ?? null, sourceSpan);
+}
+function createImmediateTrigger(parameters, sourceSpan) {
+    if (parameters.length > 0) {
+        throw new Error(`"${OnTriggerType.IMMEDIATE}" trigger cannot have parameters`);
+    }
+    return new ImmediateDeferredTrigger(sourceSpan);
+}
+function createHoverTrigger(parameters, sourceSpan) {
+    if (parameters.length > 0) {
+        throw new Error(`"${OnTriggerType.HOVER}" trigger cannot have parameters`);
+    }
+    return new HoverDeferredTrigger(sourceSpan);
+}
+function createViewportTrigger(parameters, sourceSpan) {
+    // TODO: the RFC has some more potential parameters for `viewport`.
+    if (parameters.length > 1) {
+        throw new Error(`"${OnTriggerType.VIEWPORT}" trigger can only have zero or one parameters`);
+    }
+    return new ViewportDeferredTrigger(parameters[0] ?? null, sourceSpan);
+}
+/** Gets the index within an expression at which the trigger parameters start. */
+function getTriggerParametersStart(value, startPosition = 0) {
+    let hasFoundSeparator = false;
+    for (let i = startPosition; i < value.length; i++) {
+        if (SEPARATOR_PATTERN.test(value[i])) {
+            hasFoundSeparator = true;
+        }
+        else if (hasFoundSeparator) {
+            return i;
+        }
+    }
+    return -1;
+}
+/**
+ * Parses a time expression from a deferred trigger to
+ * milliseconds. Returns null if it cannot be parsed.
+ */
+function parseDeferredTime(value) {
+    const match = value.match(TIME_PATTERN);
+    if (!match) {
+        return null;
+    }
+    const [time, units] = match;
+    return parseInt(time) * (units === 's' ? 1000 : 1);
+}
+
+/** Pattern to identify a `prefetch when` trigger. */
+const PREFETCH_WHEN_PATTERN = /^prefetch\s+when\s/;
+/** Pattern to identify a `prefetch on` trigger. */
+const PREFETCH_ON_PATTERN = /^prefetch\s+on\s/;
+/** Pattern to identify a `minimum` parameter in a block. */
+const MINIMUM_PARAMETER_PATTERN = /^minimum\s/;
+/** Pattern to identify a `after` parameter in a block. */
+const AFTER_PARAMETER_PATTERN = /^after\s/;
+/** Pattern to identify a `when` parameter in a block. */
+const WHEN_PARAMETER_PATTERN = /^when\s/;
+/** Pattern to identify a `on` parameter in a block. */
+const ON_PARAMETER_PATTERN = /^on\s/;
+/** Possible types of secondary deferred blocks. */
+var SecondaryDeferredBlockType;
+(function (SecondaryDeferredBlockType) {
+    SecondaryDeferredBlockType["PLACEHOLDER"] = "placeholder";
+    SecondaryDeferredBlockType["LOADING"] = "loading";
+    SecondaryDeferredBlockType["ERROR"] = "error";
+})(SecondaryDeferredBlockType || (SecondaryDeferredBlockType = {}));
+/** Creates a deferred block from an HTML AST node. */
+function createDeferredBlock(ast, visitor, bindingParser) {
+    const errors = [];
+    const [primaryBlock, ...secondaryBlocks] = ast.blocks;
+    const { triggers, prefetchTriggers } = parsePrimaryTriggers(primaryBlock.parameters, bindingParser, errors);
+    const { placeholder, loading, error } = parseSecondaryBlocks(secondaryBlocks, errors, visitor);
+    return {
+        node: new DeferredBlock(visitAll(visitor, primaryBlock.children), triggers, prefetchTriggers, placeholder, loading, error, ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan),
+        errors,
+    };
+}
+function parseSecondaryBlocks(blocks, errors, visitor) {
+    let placeholder = null;
+    let loading = null;
+    let error = null;
+    for (const block of blocks) {
+        try {
+            switch (block.name) {
+                case SecondaryDeferredBlockType.PLACEHOLDER:
+                    if (placeholder !== null) {
+                        errors.push(new ParseError(block.startSourceSpan, `"defer" block can only have one "${SecondaryDeferredBlockType.PLACEHOLDER}" block`));
+                    }
+                    else {
+                        placeholder = parsePlaceholderBlock(block, visitor);
+                    }
+                    break;
+                case SecondaryDeferredBlockType.LOADING:
+                    if (loading !== null) {
+                        errors.push(new ParseError(block.startSourceSpan, `"defer" block can only have one "${SecondaryDeferredBlockType.LOADING}" block`));
+                    }
+                    else {
+                        loading = parseLoadingBlock(block, visitor);
+                    }
+                    break;
+                case SecondaryDeferredBlockType.ERROR:
+                    if (error !== null) {
+                        errors.push(new ParseError(block.startSourceSpan, `"defer" block can only have one "${SecondaryDeferredBlockType.ERROR}" block`));
+                    }
+                    else {
+                        error = parseErrorBlock(block, visitor);
+                    }
+                    break;
+                default:
+                    errors.push(new ParseError(block.startSourceSpan, `Unrecognized block "${block.name}"`));
+                    break;
+            }
+        }
+        catch (e) {
+            errors.push(new ParseError(block.startSourceSpan, e.message));
+        }
+    }
+    return { placeholder, loading, error };
+}
+function parsePlaceholderBlock(ast, visitor) {
+    let minimumTime = null;
+    for (const param of ast.parameters) {
+        if (MINIMUM_PARAMETER_PATTERN.test(param.expression)) {
+            const parsedTime = parseDeferredTime(param.expression.slice(getTriggerParametersStart(param.expression)));
+            if (parsedTime === null) {
+                throw new Error(`Could not parse time value of parameter "minimum"`);
+            }
+            minimumTime = parsedTime;
+        }
+        else {
+            throw new Error(`Unrecognized parameter in "${SecondaryDeferredBlockType.PLACEHOLDER}" block: "${param.expression}"`);
+        }
+    }
+    return new DeferredBlockPlaceholder(visitAll(visitor, ast.children), minimumTime, ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan);
+}
+function parseLoadingBlock(ast, visitor) {
+    let afterTime = null;
+    let minimumTime = null;
+    for (const param of ast.parameters) {
+        if (AFTER_PARAMETER_PATTERN.test(param.expression)) {
+            const parsedTime = parseDeferredTime(param.expression.slice(getTriggerParametersStart(param.expression)));
+            if (parsedTime === null) {
+                throw new Error(`Could not parse time value of parameter "after"`);
+            }
+            afterTime = parsedTime;
+        }
+        else if (MINIMUM_PARAMETER_PATTERN.test(param.expression)) {
+            const parsedTime = parseDeferredTime(param.expression.slice(getTriggerParametersStart(param.expression)));
+            if (parsedTime === null) {
+                throw new Error(`Could not parse time value of parameter "minimum"`);
+            }
+            minimumTime = parsedTime;
+        }
+        else {
+            throw new Error(`Unrecognized parameter in "${SecondaryDeferredBlockType.LOADING}" block: "${param.expression}"`);
+        }
+    }
+    return new DeferredBlockLoading(visitAll(visitor, ast.children), afterTime, minimumTime, ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan);
+}
+function parseErrorBlock(ast, visitor) {
+    if (ast.parameters.length > 0) {
+        throw new Error(`"${SecondaryDeferredBlockType.ERROR}" block cannot have parameters`);
+    }
+    return new DeferredBlockError(visitAll(visitor, ast.children), ast.sourceSpan, ast.startSourceSpan, ast.endSourceSpan);
+}
+function parsePrimaryTriggers(params, bindingParser, errors) {
+    const triggers = [];
+    const prefetchTriggers = [];
+    for (const param of params) {
+        // The lexer ignores the leading spaces so we can assume
+        // that the expression starts with a keyword.
+        if (WHEN_PARAMETER_PATTERN.test(param.expression)) {
+            const result = parseWhenTrigger(param, bindingParser, errors);
+            result !== null && triggers.push(result);
+        }
+        else if (ON_PARAMETER_PATTERN.test(param.expression)) {
+            triggers.push(...parseOnTrigger(param, errors));
+        }
+        else if (PREFETCH_WHEN_PATTERN.test(param.expression)) {
+            const result = parseWhenTrigger(param, bindingParser, errors);
+            result !== null && prefetchTriggers.push(result);
+        }
+        else if (PREFETCH_ON_PATTERN.test(param.expression)) {
+            prefetchTriggers.push(...parseOnTrigger(param, errors));
+        }
+        else {
+            errors.push(new ParseError(param.sourceSpan, 'Unrecognized trigger'));
+        }
+    }
+    return { triggers, prefetchTriggers };
+}
+
 const BIND_NAME_REGEXP = /^(?:(bind-)|(let-)|(ref-|#)|(on-)|(bindon-)|(@))(.*)$/;
 // Group 1 = "bind-"
 const KW_BIND_IDX = 1;
@@ -14532,7 +16227,16 @@ class HtmlAstToIvyAst {
                 attributes.push(this.visitAttribute(attribute));
             }
         }
-        const children = visitAll(preparsedElement.nonBindable ? NON_BINDABLE_VISITOR : this, element.children);
+        let children;
+        if (preparsedElement.nonBindable) {
+            // The `NonBindableVisitor` may need to return an array of nodes for block groups so we need
+            // to flatten the array here. Avoid doing this for the `HtmlAstToIvyAst` since `flat` creates
+            // a new array.
+            children = visitAll(NON_BINDABLE_VISITOR, element.children).flat(Infinity);
+        }
+        else {
+            children = visitAll(this, element.children);
+        }
         let parsedElement;
         if (preparsedElement.type === PreparsedElementType.NG_CONTENT) {
             // `<ng-content>`
@@ -14630,6 +16334,23 @@ class HtmlAstToIvyAst {
         }
         return null;
     }
+    visitBlockGroup(group, context) {
+        const primaryBlock = group.blocks[0];
+        // The HTML parser ensures that we don't hit this case, but we have an assertion just in case.
+        if (!primaryBlock) {
+            this.reportError('Block group must have at least one block.', group.sourceSpan);
+            return null;
+        }
+        if (primaryBlock.name === 'defer' && this.options.enabledBlockTypes.has(primaryBlock.name)) {
+            const { node, errors } = createDeferredBlock(group, this, this.bindingParser);
+            this.errors.push(...errors);
+            return node;
+        }
+        this.reportError(`Unrecognized block "${primaryBlock.name}".`, primaryBlock.sourceSpan);
+        return null;
+    }
+    visitBlock(block, context) { }
+    visitBlockParameter(parameter, context) { }
     // convert view engine `ParsedProperty` to a format suitable for IVY
     extractAttributes(elementName, properties, i18nPropsMeta) {
         const bound = [];
@@ -14807,6 +16528,25 @@ class NonBindableVisitor {
     visitExpansionCase(expansionCase) {
         return null;
     }
+    visitBlockGroup(group, context) {
+        const nodes = visitAll(this, group.blocks);
+        // We only need to do the end tag since the start will be added as a part of the primary block.
+        if (group.endSourceSpan !== null) {
+            nodes.push(new Text$3(group.endSourceSpan.toString(), group.endSourceSpan));
+        }
+        return nodes;
+    }
+    visitBlock(block, context) {
+        return [
+            // In an ngNonBindable context we treat the opening/closing tags of block as plain text.
+            // This is the as if the `tokenizeBlocks` option was disabled.
+            new Text$3(block.startSourceSpan.toString(), block.startSourceSpan),
+            ...visitAll(this, block.children)
+        ];
+    }
+    visitBlockParameter(parameter, context) {
+        return null;
+    }
 }
 const NON_BINDABLE_VISITOR = new NonBindableVisitor();
 function normalizeAttributeName(attrName) {
@@ -15254,6 +16994,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.
      *
@@ -15397,12 +17148,11 @@ class I18nMetaVisitor {
         // whether visited nodes contain i18n information
         this.hasI18nMeta = false;
         this._errors = [];
-        // i18n message generation factory
-        this._createI18nMessage = createI18nMessageFactory(this.interpolationConfig);
     }
     _generateI18nMessage(nodes, meta = '', visitNodeFn) {
         const { meaning, description, customId } = this._parseMetadata(meta);
-        const message = this._createI18nMessage(nodes, meaning, description, customId, visitNodeFn);
+        const createI18nMessage = createI18nMessageFactory(this.interpolationConfig);
+        const message = createI18nMessage(nodes, meaning, description, customId, visitNodeFn);
         this._setMessageId(message, meta);
         this._setLegacyIds(message, meta);
         return message;
@@ -15501,6 +17251,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`.
@@ -15882,7 +17643,7 @@ function createComponentDefConsts() {
     };
 }
 class TemplateDefinitionBuilder {
-    constructor(constantPool, parentBindingScope, level = 0, contextName, i18nContext, templateIndex, templateName, _namespace, relativeContextFilePath, i18nUseExternalIds, _constants = createComponentDefConsts()) {
+    constructor(constantPool, parentBindingScope, level = 0, contextName, i18nContext, templateIndex, templateName, _namespace, relativeContextFilePath, i18nUseExternalIds, deferBlocks, _constants = createComponentDefConsts()) {
         this.constantPool = constantPool;
         this.level = level;
         this.contextName = contextName;
@@ -15891,6 +17652,7 @@ class TemplateDefinitionBuilder {
         this.templateName = templateName;
         this._namespace = _namespace;
         this.i18nUseExternalIds = i18nUseExternalIds;
+        this.deferBlocks = deferBlocks;
         this._constants = _constants;
         this._dataIndex = 0;
         this._bindingContext = 0;
@@ -16093,7 +17855,7 @@ class TemplateDefinitionBuilder {
             else {
                 const value = prop.value.visit(this._valueConverter);
                 this.allocateBindingSlots(value);
-                if (value instanceof Interpolation) {
+                if (value instanceof Interpolation$1) {
                     const { strings, expressions } = value;
                     const { id, bindings } = this.i18n;
                     const label = assembleI18nBoundString(strings, bindings.size, id);
@@ -16213,7 +17975,7 @@ class TemplateDefinitionBuilder {
             const message = attr.i18n;
             const converted = attr.value.visit(this._valueConverter);
             this.allocateBindingSlots(converted);
-            if (converted instanceof Interpolation) {
+            if (converted instanceof Interpolation$1) {
                 const placeholders = assembleBoundTextPlaceholders(message);
                 const params = placeholdersToParams(placeholders);
                 i18nAttrArgs.push(literal(attr.name), this.i18nTranslate(message, params));
@@ -16433,7 +18195,7 @@ class TemplateDefinitionBuilder {
                     }
                     this.allocateBindingSlots(value);
                     if (inputType === 0 /* BindingType.Property */) {
-                        if (value instanceof Interpolation) {
+                        if (value instanceof Interpolation$1) {
                             // prop="{{value}}" and friends
                             this.interpolatedUpdateInstruction(getPropertyInterpolationExpression(value), elementIndex, attrName, input, value, params);
                         }
@@ -16447,12 +18209,12 @@ class TemplateDefinitionBuilder {
                         }
                     }
                     else if (inputType === 1 /* BindingType.Attribute */) {
-                        if (value instanceof Interpolation && getInterpolationArgsLength(value) > 1) {
+                        if (value instanceof Interpolation$1 && getInterpolationArgsLength(value) > 1) {
                             // attr.name="text{{value}}" and friends
                             this.interpolatedUpdateInstruction(getAttributeInterpolationExpression(value), elementIndex, attrName, input, value, params);
                         }
                         else {
-                            const boundValue = value instanceof Interpolation ? value.expressions[0] : value;
+                            const boundValue = value instanceof Interpolation$1 ? value.expressions[0] : value;
                             // [attr.name]="value" or attr.name="{{value}}"
                             // Collect the attribute bindings so that they can be chained at the end.
                             attributeBindings.push({
@@ -16522,7 +18284,7 @@ class TemplateDefinitionBuilder {
             parameters.push(importExpr(Identifiers.templateRefExtractor));
         }
         // Create the template function
-        const templateVisitor = new TemplateDefinitionBuilder(this.constantPool, this._bindingScope, this.level + 1, contextName, this.i18n, templateIndex, templateName, this._namespace, this.fileBasedI18nSuffix, this.i18nUseExternalIds, this._constants);
+        const templateVisitor = new TemplateDefinitionBuilder(this.constantPool, this._bindingScope, this.level + 1, contextName, this.i18n, templateIndex, templateName, this._namespace, this.fileBasedI18nSuffix, this.i18nUseExternalIds, this.deferBlocks, this._constants);
         // Nested templates must not be visited until after their parent templates have completed
         // processing, so they are queued here until after the initial pass. Otherwise, we wouldn't
         // be able to support bindings in nested templates to local refs that occur after the
@@ -16565,7 +18327,7 @@ class TemplateDefinitionBuilder {
         if (this.i18n) {
             const value = text.value.visit(this._valueConverter);
             this.allocateBindingSlots(value);
-            if (value instanceof Interpolation) {
+            if (value instanceof Interpolation$1) {
                 this.i18n.appendBoundText(text.i18n);
                 this.i18nAppendBindings(value.expressions);
             }
@@ -16575,7 +18337,7 @@ class TemplateDefinitionBuilder {
         this.creationInstruction(text.sourceSpan, Identifiers.text, [literal(nodeIndex)]);
         const value = text.value.visit(this._valueConverter);
         this.allocateBindingSlots(value);
-        if (value instanceof Interpolation) {
+        if (value instanceof Interpolation$1) {
             this.updateInstructionWithAdvance(nodeIndex, text.sourceSpan, getTextInterpolationExpression(value), () => this.getUpdateInstructionArguments(value));
         }
         else {
@@ -16632,6 +18394,47 @@ class TemplateDefinitionBuilder {
         }
         return null;
     }
+    visitDeferredBlock(deferred) {
+        const templateIndex = this.allocateDataSlot();
+        const deferredDeps = this.deferBlocks.get(deferred);
+        const contextName = `${this.contextName}_Defer_${templateIndex}`;
+        const depsFnName = `${contextName}_DepsFn`;
+        const parameters = [
+            literal(templateIndex),
+            deferredDeps ? variable(depsFnName) : TYPED_NULL_EXPR,
+        ];
+        if (deferredDeps) {
+            // This defer block has deps for which we need to generate dynamic imports.
+            const dependencyExp = [];
+            for (const deferredDep of deferredDeps) {
+                if (deferredDep.isDeferrable) {
+                    // Callback function, e.g. `function(m) { return m.MyCmp; }`.
+                    const innerFn = fn([new FnParam('m', DYNAMIC_TYPE)], [new ReturnStatement(variable('m').prop(deferredDep.symbolName))]);
+                    const fileName = deferredDep.importPath;
+                    // Dynamic import, e.g. `import('./a').then(...)`.
+                    const importExpr = (new DynamicImportExpr(fileName)).prop('then').callFn([innerFn]);
+                    dependencyExp.push(importExpr);
+                }
+                else {
+                    // Non-deferrable symbol, just use a reference to the type.
+                    dependencyExp.push(deferredDep.type);
+                }
+            }
+            const depsFnBody = [];
+            depsFnBody.push(new ReturnStatement(literalArr(dependencyExp)));
+            const depsFnExpr = fn([] /* args */, depsFnBody, INFERRED_TYPE, null, depsFnName);
+            this.constantPool.statements.push(depsFnExpr.toDeclStmt(depsFnName));
+        }
+        // e.g. `defer(1, MyComp_Defer_1_DepsFn, ...)`
+        this.creationInstruction(deferred.sourceSpan, Identifiers.defer, () => {
+            return trimTrailingNulls(parameters);
+        });
+    }
+    // TODO: implement nested deferred block instructions.
+    visitDeferredTrigger(trigger) { }
+    visitDeferredBlockPlaceholder(block) { }
+    visitDeferredBlockError(block) { }
+    visitDeferredBlockLoading(block) { }
     allocateDataSlot() {
         return this._dataIndex++;
     }
@@ -16663,7 +18466,7 @@ class TemplateDefinitionBuilder {
                 continue;
             }
             this.allocateBindingSlots(value);
-            if (value instanceof Interpolation) {
+            if (value instanceof Interpolation$1) {
                 // Params typically contain attribute namespace and value sanitizer, which is applicable
                 // for regular HTML elements, but not applicable for <ng-template> (since props act as
                 // inputs to directives), so keep params array empty.
@@ -16695,7 +18498,7 @@ class TemplateDefinitionBuilder {
         if (instruction) {
             for (const call of instruction.calls) {
                 allocateBindingSlots += call.allocateBindingSlots;
-                this.updateInstructionWithAdvance(elementIndex, call.sourceSpan, instruction.reference, () => call.params(value => (call.supportsInterpolation && value instanceof Interpolation) ?
+                this.updateInstructionWithAdvance(elementIndex, call.sourceSpan, instruction.reference, () => call.params(value => (call.supportsInterpolation && value instanceof Interpolation$1) ?
                     this.getUpdateInstructionArguments(value) :
                     this.convertPropertyBinding(value)));
             }
@@ -16728,7 +18531,7 @@ class TemplateDefinitionBuilder {
         return originalSlots;
     }
     allocateBindingSlots(value) {
-        this._bindingSlots += value instanceof Interpolation ? value.expressions.length : 1;
+        this._bindingSlots += value instanceof Interpolation$1 ? value.expressions.length : 1;
     }
     /**
      * Gets an expression that refers to the implicit receiver. The implicit
@@ -17350,7 +19153,12 @@ function parseTemplate(template, templateUrl, options = {}) {
     const { interpolationConfig, preserveWhitespaces, enableI18nLegacyMessageIdFormat } = options;
     const bindingParser = makeBindingParser(interpolationConfig);
     const htmlParser = new HtmlParser();
-    const parseResult = htmlParser.parse(template, templateUrl, { leadingTriviaChars: LEADING_TRIVIA_CHARS, ...options, tokenizeExpansionForms: true });
+    const parseResult = htmlParser.parse(template, templateUrl, {
+        leadingTriviaChars: LEADING_TRIVIA_CHARS,
+        ...options,
+        tokenizeExpansionForms: true,
+        tokenizeBlocks: options.enabledBlockTypes != null && options.enabledBlockTypes.size > 0,
+    });
     if (!options.alwaysAttemptHtmlToR3AstConversion && parseResult.errors &&
         parseResult.errors.length > 0) {
         const parsedTemplate = {
@@ -17401,7 +19209,10 @@ function parseTemplate(template, templateUrl, options = {}) {
             rootNodes = visitAll(new I18nMetaVisitor(interpolationConfig, /* keepI18nAttrs */ false), rootNodes);
         }
     }
-    const { nodes, errors, styleUrls, styles, ngContentSelectors, commentNodes } = htmlAstToRender3Ast(rootNodes, bindingParser, { collectCommentNodes: !!options.collectCommentNodes });
+    const { nodes, errors, styleUrls, styles, ngContentSelectors, commentNodes } = htmlAstToRender3Ast(rootNodes, bindingParser, {
+        collectCommentNodes: !!options.collectCommentNodes,
+        enabledBlockTypes: options.enabledBlockTypes || new Set(),
+    });
     errors.push(...parseResult.errors, ...i18nMetaResult.errors);
     const parsedTemplate = {
         interpolationConfig,
@@ -17548,7 +19359,7 @@ function baseDirectiveFields(meta, constantPool, bindingParser) {
     const definitionMap = new DefinitionMap();
     const selectors = parseSelectorToR3Selector(meta.selector);
     // e.g. `type: MyDirective`
-    definitionMap.set('type', meta.internalType);
+    definitionMap.set('type', meta.type.value);
     // e.g. `selectors: [['', 'someDir', '']]`
     if (selectors.length > 0) {
         definitionMap.set('selectors', asLiteral(selectors));
@@ -17563,15 +19374,18 @@ function baseDirectiveFields(meta, constantPool, bindingParser) {
     // e.g. `hostBindings: (rf, ctx) => { ... }
     definitionMap.set('hostBindings', createHostBindingsFunction(meta.host, meta.typeSourceSpan, bindingParser, constantPool, meta.selector || '', meta.name, definitionMap));
     // e.g 'inputs: {a: 'a'}`
-    definitionMap.set('inputs', conditionallyCreateMapObjectLiteral(meta.inputs, true));
+    definitionMap.set('inputs', conditionallyCreateDirectiveBindingLiteral(meta.inputs, true));
     // e.g 'outputs: {a: 'a'}`
-    definitionMap.set('outputs', conditionallyCreateMapObjectLiteral(meta.outputs));
+    definitionMap.set('outputs', conditionallyCreateDirectiveBindingLiteral(meta.outputs));
     if (meta.exportAs !== null) {
         definitionMap.set('exportAs', literalArr(meta.exportAs.map(e => literal(e))));
     }
     if (meta.isStandalone) {
         definitionMap.set('standalone', literal(true));
     }
+    if (meta.isSignal) {
+        definitionMap.set('signals', literal(true));
+    }
     return definitionMap;
 }
 /**
@@ -17582,6 +19396,7 @@ function addFeatures(definitionMap, meta) {
     const features = [];
     const providers = meta.providers;
     const viewProviders = meta.viewProviders;
+    const inputKeys = Object.keys(meta.inputs);
     if (providers || viewProviders) {
         const args = [providers || new LiteralArrayExpr([])];
         if (viewProviders) {
@@ -17589,6 +19404,12 @@ function addFeatures(definitionMap, meta) {
         }
         features.push(importExpr(Identifiers.ProvidersFeature).callFn(args));
     }
+    for (const key of inputKeys) {
+        if (meta.inputs[key].transformFunction !== null) {
+            features.push(importExpr(Identifiers.InputTransformsFeatureFeature));
+            break;
+        }
+    }
     if (meta.usesInheritance) {
         features.push(importExpr(Identifiers.InheritDefinitionFeature));
     }
@@ -17640,34 +19461,43 @@ function compileComponentFromMetadata(meta, constantPool, bindingParser) {
     const templateTypeName = meta.name;
     const templateName = templateTypeName ? `${templateTypeName}_Template` : null;
     const changeDetection = meta.changeDetection;
-    const template = meta.template;
-    const templateBuilder = new TemplateDefinitionBuilder(constantPool, BindingScope.createRootScope(), 0, templateTypeName, null, null, templateName, Identifiers.namespaceHTML, meta.relativeContextFilePath, meta.i18nUseExternalIds);
-    const templateFunctionExpression = templateBuilder.buildTemplateFunction(template.nodes, []);
-    // We need to provide this so that dynamically generated components know what
-    // projected content blocks to pass through to the component when it is instantiated.
-    const ngContentSelectors = templateBuilder.getNgContentSelectors();
-    if (ngContentSelectors) {
-        definitionMap.set('ngContentSelectors', ngContentSelectors);
-    }
-    // e.g. `decls: 2`
-    definitionMap.set('decls', literal(templateBuilder.getConstCount()));
-    // e.g. `vars: 2`
-    definitionMap.set('vars', literal(templateBuilder.getVarCount()));
-    // Generate `consts` section of ComponentDef:
-    // - either as an array:
-    //   `consts: [['one', 'two'], ['three', 'four']]`
-    // - or as a factory function in case additional statements are present (to support i18n):
-    //   `consts: function() { var i18n_0; if (ngI18nClosureMode) {...} else {...} return [i18n_0]; }`
-    const { constExpressions, prepareStatements } = templateBuilder.getConsts();
-    if (constExpressions.length > 0) {
-        let constsExpr = literalArr(constExpressions);
-        // Prepare statements are present - turn `consts` into a function.
-        if (prepareStatements.length > 0) {
-            constsExpr = fn([], [...prepareStatements, new ReturnStatement(constsExpr)]);
-        }
-        definitionMap.set('consts', constsExpr);
-    }
-    definitionMap.set('template', templateFunctionExpression);
+    // Template compilation is currently conditional as we're in the process of rewriting it.
+    {
+        // This is the main path currently used in compilation, which compiles the template with the
+        // legacy `TemplateDefinitionBuilder`.
+        const template = meta.template;
+        const templateBuilder = new TemplateDefinitionBuilder(constantPool, BindingScope.createRootScope(), 0, templateTypeName, null, null, templateName, Identifiers.namespaceHTML, meta.relativeContextFilePath, meta.i18nUseExternalIds, meta.deferBlocks);
+        const templateFunctionExpression = templateBuilder.buildTemplateFunction(template.nodes, []);
+        // We need to provide this so that dynamically generated components know what
+        // projected content blocks to pass through to the component when it is
+        //     instantiated.
+        const ngContentSelectors = templateBuilder.getNgContentSelectors();
+        if (ngContentSelectors) {
+            definitionMap.set('ngContentSelectors', ngContentSelectors);
+        }
+        // e.g. `decls: 2`
+        // definitionMap.set('decls', o.literal(tpl.root.decls!));
+        definitionMap.set('decls', literal(templateBuilder.getConstCount()));
+        // e.g. `vars: 2`
+        // definitionMap.set('vars', o.literal(tpl.root.vars!));
+        definitionMap.set('vars', literal(templateBuilder.getVarCount()));
+        // Generate `consts` section of ComponentDef:
+        // - either as an array:
+        //   `consts: [['one', 'two'], ['three', 'four']]`
+        // - or as a factory function in case additional statements are present (to support i18n):
+        //   `consts: function() { var i18n_0; if (ngI18nClosureMode) {...} else {...} return [i18n_0];
+        //   }`
+        const { constExpressions, prepareStatements } = templateBuilder.getConsts();
+        if (constExpressions.length > 0) {
+            let constsExpr = literalArr(constExpressions);
+            // Prepare statements are present - turn `consts` into a function.
+            if (prepareStatements.length > 0) {
+                constsExpr = fn([], [...prepareStatements, new ReturnStatement(constsExpr)]);
+            }
+            definitionMap.set('consts', constsExpr);
+        }
+        definitionMap.set('template', templateFunctionExpression);
+    }
     if (meta.declarations.length > 0) {
         definitionMap.set('dependencies', compileDeclarationList(literalArr(meta.declarations.map(decl => decl.type)), meta.declarationListEmitMode));
     }
@@ -17718,6 +19548,12 @@ function createComponentType(meta) {
     typeParams.push(stringArrayAsType(meta.template.ngContentSelectors));
     typeParams.push(expressionType(literal(meta.isStandalone)));
     typeParams.push(createHostDirectivesType(meta));
+    // TODO(signals): Always include this metadata starting with v17. Right
+    // now Angular v16.0.x does not support this field and library distributions
+    // would then be incompatible with v16.0.x framework users.
+    if (meta.isSignal) {
+        typeParams.push(expressionType(literal(meta.isSignal)));
+    }
     return expressionType(importExpr(Identifiers.ComponentDeclaration, typeParams));
 }
 /**
@@ -17816,11 +19652,24 @@ function createBaseDirectiveTypeParams(meta) {
         typeWithParameters(meta.type.type, meta.typeArgumentCount),
         selectorForType !== null ? stringAsType(selectorForType) : NONE_TYPE,
         meta.exportAs !== null ? stringArrayAsType(meta.exportAs) : NONE_TYPE,
-        expressionType(stringMapAsLiteralExpression(meta.inputs)),
+        expressionType(getInputsTypeExpression(meta)),
         expressionType(stringMapAsLiteralExpression(meta.outputs)),
         stringArrayAsType(meta.queries.map(q => q.propertyName)),
     ];
 }
+function getInputsTypeExpression(meta) {
+    return literalMap(Object.keys(meta.inputs).map(key => {
+        const value = meta.inputs[key];
+        return {
+            key,
+            value: literalMap([
+                { key: 'alias', value: literal(value.bindingPropertyName), quoted: true },
+                { key: 'required', value: literal(value.required), quoted: true }
+            ]),
+            quoted: true
+        };
+    }));
+}
 /**
  * Creates the type specification from the directive meta. This type is inserted into .d.ts files
  * to be consumed by upstream compilations.
@@ -17832,6 +19681,12 @@ function createDirectiveType(meta) {
     typeParams.push(NONE_TYPE);
     typeParams.push(expressionType(literal(meta.isStandalone)));
     typeParams.push(createHostDirectivesType(meta));
+    // TODO(signals): Always include this metadata starting with v17. Right
+    // now Angular v16.0.x does not support this field and library distributions
+    // would then be incompatible with v16.0.x framework users.
+    if (meta.isSignal) {
+        typeParams.push(expressionType(literal(meta.isSignal)));
+    }
     return expressionType(importExpr(Identifiers.DirectiveDeclaration, typeParams));
 }
 // Define and update any view queries
@@ -17860,6 +19715,9 @@ function createViewQueriesFunction(viewQueries, constantPool, name) {
 }
 // Return a host binding function or null if one is not necessary.
 function createHostBindingsFunction(hostBindingsMetadata, typeSourceSpan, bindingParser, constantPool, selector, name, definitionMap) {
+    const bindings = bindingParser.createBoundHostProperties(hostBindingsMetadata.properties, typeSourceSpan);
+    // Calculate host event bindings
+    const eventBindings = bindingParser.createDirectiveHostEventAsts(hostBindingsMetadata.listeners, typeSourceSpan);
     const bindingContext = variable(CONTEXT_NAME);
     const styleBuilder = new StylingBuilder(bindingContext);
     const { styleAttr, classAttr } = hostBindingsMetadata.specialAttributes;
@@ -17873,13 +19731,10 @@ function createHostBindingsFunction(hostBindingsMetadata, typeSourceSpan, bindin
     const updateInstructions = [];
     const updateVariables = [];
     const hostBindingSourceSpan = typeSourceSpan;
-    // Calculate host event bindings
-    const eventBindings = bindingParser.createDirectiveHostEventAsts(hostBindingsMetadata.listeners, hostBindingSourceSpan);
     if (eventBindings && eventBindings.length) {
         createInstructions.push(...createHostListeners(eventBindings, name));
     }
     // Calculate the host property bindings
-    const bindings = bindingParser.createBoundHostProperties(hostBindingsMetadata.properties, hostBindingSourceSpan);
     const allOtherBindings = [];
     // We need to calculate the total amount of binding slots required by
     // all the instructions together before any value conversions happen.
@@ -18222,6 +20077,7 @@ function createHostDirectivesMappingArray(mapping) {
 class ResourceLoader {
 }
 
+let enabledBlockTypes;
 class CompilerFacadeImpl {
     constructor(jitEvaluator = new JitEvaluator()) {
         this.jitEvaluator = jitEvaluator;
@@ -18233,7 +20089,6 @@ class CompilerFacadeImpl {
         const metadata = {
             name: facade.name,
             type: wrapReference(facade.type),
-            internalType: new WrappedNodeExpr(facade.type),
             typeArgumentCount: 0,
             deps: null,
             pipeName: facade.pipeName,
@@ -18252,7 +20107,6 @@ class CompilerFacadeImpl {
         const { expression, statements } = compileInjectable({
             name: facade.name,
             type: wrapReference(facade.type),
-            internalType: new WrappedNodeExpr(facade.type),
             typeArgumentCount: facade.typeArgumentCount,
             providedIn: computeProvidedIn(facade.providedIn),
             useClass: convertToProviderExpression(facade, 'useClass'),
@@ -18268,7 +20122,6 @@ class CompilerFacadeImpl {
         const { expression, statements } = compileInjectable({
             name: facade.type.name,
             type: wrapReference(facade.type),
-            internalType: new WrappedNodeExpr(facade.type),
             typeArgumentCount: 0,
             providedIn: computeProvidedIn(facade.providedIn),
             useClass: convertToProviderExpression(facade, 'useClass'),
@@ -18284,7 +20137,6 @@ class CompilerFacadeImpl {
         const meta = {
             name: facade.name,
             type: wrapReference(facade.type),
-            internalType: new WrappedNodeExpr(facade.type),
             providers: facade.providers && facade.providers.length > 0 ?
                 new WrappedNodeExpr(facade.providers) :
                 null,
@@ -18300,9 +20152,8 @@ class CompilerFacadeImpl {
     }
     compileNgModule(angularCoreEnv, sourceMapUrl, facade) {
         const meta = {
+            kind: R3NgModuleMetadataKind.Global,
             type: wrapReference(facade.type),
-            internalType: new WrappedNodeExpr(facade.type),
-            adjacentType: new WrappedNodeExpr(facade.type),
             bootstrap: facade.bootstrap.map(wrapReference),
             declarations: facade.declarations.map(wrapReference),
             publicDeclarationTypes: null,
@@ -18347,6 +20198,10 @@ class CompilerFacadeImpl {
             template,
             declarations: facade.declarations.map(convertDeclarationFacadeToMetadata),
             declarationListEmitMode: 0 /* DeclarationListEmitMode.Direct */,
+            // TODO: leaving empty in JIT mode for now,
+            // to be implemented as one of the next steps.
+            deferBlocks: new Map(),
+            deferrableDeclToImportDecl: new Map(),
             styles: [...facade.styles, ...template.styles],
             encapsulation: facade.encapsulation,
             interpolation,
@@ -18375,7 +20230,6 @@ class CompilerFacadeImpl {
         const factoryRes = compileFactoryFunction({
             name: meta.name,
             type: wrapReference(meta.type),
-            internalType: new WrappedNodeExpr(meta.type),
             typeArgumentCount: meta.typeArgumentCount,
             deps: convertR3DependencyMetadataArray(meta.deps),
             target: meta.target,
@@ -18386,7 +20240,6 @@ class CompilerFacadeImpl {
         const factoryRes = compileFactoryFunction({
             name: meta.type.name,
             type: wrapReference(meta.type),
-            internalType: new WrappedNodeExpr(meta.type),
             typeArgumentCount: 0,
             deps: Array.isArray(meta.deps) ? meta.deps.map(convertR3DeclareDependencyMetadata) :
                 meta.deps,
@@ -18446,8 +20299,8 @@ function convertQueryPredicate(predicate) {
         createMayBeForwardRefExpression(new WrappedNodeExpr(predicate), 1 /* ForwardRefHandling.Wrapped */);
 }
 function convertDirectiveFacadeToMetadata(facade) {
-    const inputsFromMetadata = parseInputOutputs(facade.inputs || []);
-    const outputsFromMetadata = parseInputOutputs(facade.outputs || []);
+    const inputsFromMetadata = parseInputsArray(facade.inputs || []);
+    const outputsFromMetadata = parseMappingStringArray(facade.outputs || []);
     const propMetadata = facade.propMetadata;
     const inputsFromType = {};
     const outputsFromType = {};
@@ -18455,11 +20308,15 @@ function convertDirectiveFacadeToMetadata(facade) {
         if (propMetadata.hasOwnProperty(field)) {
             propMetadata[field].forEach(ann => {
                 if (isInput(ann)) {
-                    inputsFromType[field] =
-                        ann.bindingPropertyName ? [ann.bindingPropertyName, field] : field;
+                    inputsFromType[field] = {
+                        bindingPropertyName: ann.alias || field,
+                        classPropertyName: field,
+                        required: ann.required || false,
+                        transformFunction: ann.transform != null ? new WrappedNodeExpr(ann.transform) : null,
+                    };
                 }
                 else if (isOutput(ann)) {
-                    outputsFromType[field] = ann.bindingPropertyName || field;
+                    outputsFromType[field] = ann.alias || field;
                 }
             });
         }
@@ -18469,7 +20326,6 @@ function convertDirectiveFacadeToMetadata(facade) {
         typeArgumentCount: 0,
         typeSourceSpan: facade.typeSourceSpan,
         type: wrapReference(facade.type),
-        internalType: new WrappedNodeExpr(facade.type),
         deps: null,
         host: extractHostBindings(facade.propMetadata, facade.typeSourceSpan, facade.host),
         inputs: { ...inputsFromMetadata, ...inputsFromType },
@@ -18486,9 +20342,8 @@ function convertDeclareDirectiveFacadeToMetadata(declaration, typeSourceSpan) {
         name: declaration.type.name,
         type: wrapReference(declaration.type),
         typeSourceSpan,
-        internalType: new WrappedNodeExpr(declaration.type),
         selector: declaration.selector ?? null,
-        inputs: declaration.inputs ?? {},
+        inputs: declaration.inputs ? inputsMappingToInputMetadata(declaration.inputs) : {},
         outputs: declaration.outputs ?? {},
         host: convertHostDeclarationToMetadata(declaration.host),
         queries: (declaration.queries ?? []).map(convertQueryDeclarationToMetadata),
@@ -18502,6 +20357,7 @@ function convertDeclareDirectiveFacadeToMetadata(declaration, typeSourceSpan) {
         typeArgumentCount: 0,
         fullInheritance: false,
         isStandalone: declaration.isStandalone ?? false,
+        isSignal: declaration.isSignal ?? false,
         hostDirectives: convertHostDirectivesToMetadata(declaration),
     };
 }
@@ -18529,8 +20385,8 @@ function convertHostDirectivesToMetadata(metadata) {
                 {
                     directive: wrapReference(hostDirective.directive),
                     isForwardReference: false,
-                    inputs: hostDirective.inputs ? parseInputOutputs(hostDirective.inputs) : null,
-                    outputs: hostDirective.outputs ? parseInputOutputs(hostDirective.outputs) : null,
+                    inputs: hostDirective.inputs ? parseMappingStringArray(hostDirective.inputs) : null,
+                    outputs: hostDirective.outputs ? parseMappingStringArray(hostDirective.outputs) : null,
                 };
         });
     }
@@ -18576,6 +20432,10 @@ function convertDeclareComponentFacadeToMetadata(decl, typeSourceSpan, sourceMap
         viewProviders: decl.viewProviders !== undefined ? new WrappedNodeExpr(decl.viewProviders) :
             null,
         animations: decl.animations !== undefined ? new WrappedNodeExpr(decl.animations) : null,
+        // TODO: leaving empty in JIT mode for now,
+        // to be implemented as one of the next steps.
+        deferBlocks: new Map(),
+        deferrableDeclToImportDecl: new Map(),
         changeDetection: decl.changeDetection ?? ChangeDetectionStrategy.Default,
         encapsulation: decl.encapsulation ?? ViewEncapsulation.Emulated,
         interpolation,
@@ -18623,7 +20483,7 @@ function convertPipeDeclarationToMetadata(pipe) {
 function parseJitTemplate(template, typeName, sourceMapUrl, preserveWhitespaces, interpolation) {
     const interpolationConfig = interpolation ? InterpolationConfig.fromArray(interpolation) : DEFAULT_INTERPOLATION_CONFIG;
     // Parse the template and check for errors.
-    const parsed = parseTemplate(template, sourceMapUrl, { preserveWhitespaces, interpolationConfig });
+    const parsed = parseTemplate(template, sourceMapUrl, { preserveWhitespaces, interpolationConfig, enabledBlockTypes });
     if (parsed.errors !== null) {
         const errors = parsed.errors.map(err => err.toString()).join(', ');
         throw new Error(`Errors during JIT compilation of template for ${typeName}: ${errors}`);
@@ -18722,18 +20582,67 @@ function isInput(value) {
 function isOutput(value) {
     return value.ngMetadataName === 'Output';
 }
-function parseInputOutputs(values) {
+function inputsMappingToInputMetadata(inputs) {
+    return Object.keys(inputs).reduce((result, key) => {
+        const value = inputs[key];
+        if (typeof value === 'string') {
+            result[key] = {
+                bindingPropertyName: value,
+                classPropertyName: value,
+                transformFunction: null,
+                required: false,
+            };
+        }
+        else {
+            result[key] = {
+                bindingPropertyName: value[0],
+                classPropertyName: value[1],
+                transformFunction: value[2] ? new WrappedNodeExpr(value[2]) : null,
+                required: false,
+            };
+        }
+        return result;
+    }, {});
+}
+function parseInputsArray(values) {
+    return values.reduce((results, value) => {
+        if (typeof value === 'string') {
+            const [bindingPropertyName, classPropertyName] = parseMappingString(value);
+            results[classPropertyName] = {
+                bindingPropertyName,
+                classPropertyName,
+                required: false,
+                transformFunction: null,
+            };
+        }
+        else {
+            results[value.name] = {
+                bindingPropertyName: value.alias || value.name,
+                classPropertyName: value.name,
+                required: value.required || false,
+                transformFunction: value.transform != null ? new WrappedNodeExpr(value.transform) : null,
+            };
+        }
+        return results;
+    }, {});
+}
+function parseMappingStringArray(values) {
     return values.reduce((results, value) => {
-        const [field, property] = value.split(':', 2).map(str => str.trim());
-        results[field] = property || field;
+        const [alias, fieldName] = parseMappingString(value);
+        results[fieldName] = alias;
         return results;
     }, {});
 }
+function parseMappingString(value) {
+    // Either the value is 'field' or 'field: property'. In the first case, `property` will
+    // be undefined, in which case the field name should also be used as the property name.
+    const [fieldName, bindingPropertyName] = value.split(':', 2).map(str => str.trim());
+    return [bindingPropertyName ?? fieldName, fieldName];
+}
 function convertDeclarePipeFacadeToMetadata(declaration) {
     return {
         name: declaration.type.name,
         type: wrapReference(declaration.type),
-        internalType: new WrappedNodeExpr(declaration.type),
         typeArgumentCount: 0,
         pipeName: declaration.name,
         deps: null,
@@ -18745,7 +20654,6 @@ function convertDeclareInjectorFacadeToMetadata(declaration) {
     return {
         name: declaration.type.name,
         type: wrapReference(declaration.type),
-        internalType: new WrappedNodeExpr(declaration.type),
         providers: declaration.providers !== undefined && declaration.providers.length > 0 ?
             new WrappedNodeExpr(declaration.providers) :
             null,
@@ -18764,7 +20672,7 @@ function publishFacade(global) {
  * @description
  * Entry point for all public APIs of the compiler package.
  */
-new Version('15.2.9');
+new Version('16.2.12');
 var _VisitorMode;
 (function (_VisitorMode) {
     _VisitorMode[_VisitorMode["Extract"] = 0] = "Extract";
@@ -18994,6 +20902,14 @@ class ASTCompiler {
         }
         return this.handleBinaryDefault();
     }
+    processUnary() {
+        const ast = this.cAst;
+        const stmts = this.cStmts;
+        const e = this.build(ast.expr, stmts);
+        const v = this.createVar();
+        stmts.push(`${v}=${ast.operator}${e}`);
+        return v;
+    }
     processConditional() {
         const ast = this.cAst;
         const stmts = this.cStmts;
@@ -19085,6 +21001,9 @@ class ASTCompiler {
         else if (ast instanceof PrefixNot) {
             return this.processPrefixNot();
         }
+        else if (ast instanceof Unary) {
+            return this.processUnary();
+        }
         else if (ast instanceof Binary) {
             return this.processBinary();
         }