@wavemaker/angular-codegen 11.6.0-next.140456 → 11.6.0-next.141106

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

@@ -1,7 +1,7 @@
 'use strict';
 
 /**
- * @license Angular v16.2.12
+ * @license Angular v15.2.9
  * (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 ??= new TextEncoder();
+    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 ??= new TextEncoder();
+    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,9 +955,6 @@ 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);
     }
@@ -976,9 +973,6 @@ class TypeofExpr extends Expression {
     isConstant() {
         return this.expr.isConstant();
     }
-    clone() {
-        return new TypeofExpr(this.expr.clone());
-    }
 }
 class WrappedNodeExpr extends Expression {
     constructor(node, type, sourceSpan) {
@@ -994,9 +988,6 @@ 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) {
@@ -1013,9 +1004,6 @@ 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);
     }
@@ -1040,9 +1028,6 @@ 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) {
@@ -1061,9 +1046,6 @@ 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) {
@@ -1072,10 +1054,6 @@ 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;
@@ -1086,9 +1064,6 @@ 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) {
@@ -1107,9 +1082,6 @@ 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) {
@@ -1127,9 +1099,6 @@ 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) {
@@ -1145,18 +1114,12 @@ 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) {
@@ -1171,9 +1134,6 @@ 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) {
@@ -1218,9 +1178,6 @@ 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
@@ -1322,9 +1279,6 @@ 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) {
@@ -1343,27 +1297,6 @@ 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) {
@@ -1379,9 +1312,6 @@ 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) {
@@ -1391,9 +1321,6 @@ 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) {
@@ -1415,10 +1342,6 @@ 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) {
@@ -1437,9 +1360,6 @@ 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) {
@@ -1459,9 +1379,6 @@ 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) {
@@ -1469,10 +1386,6 @@ 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;
@@ -1486,9 +1399,6 @@ 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) {
@@ -1509,9 +1419,6 @@ 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) {
@@ -1527,9 +1434,6 @@ 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) {
@@ -1540,9 +1444,6 @@ 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) {
@@ -1562,10 +1463,6 @@ 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);
@@ -1794,7 +1691,6 @@ class FixupExpression extends Expression {
     constructor(resolved) {
         super(resolved.type);
         this.resolved = resolved;
-        this.shared = false;
         this.original = resolved;
     }
     visitExpression(visitor, context) {
@@ -1813,9 +1709,6 @@ class FixupExpression extends Expression {
     isConstant() {
         return true;
     }
-    clone() {
-        throw new Error(`Not supported.`);
-    }
     fixup(expression) {
         this.resolved = expression;
         this.shared = true;
@@ -1832,7 +1725,6 @@ class ConstantPool {
         this.statements = [];
         this.literals = new Map();
         this.literalFactories = new Map();
-        this.sharedConstants = new Map();
         this.nextNameIndex = 0;
     }
     getConstLiteral(literal, forceShared) {
@@ -1842,7 +1734,7 @@ class ConstantPool {
             // reference to a constant.
             return literal;
         }
-        const key = GenericKeyFn.INSTANCE.keyOf(literal);
+        const key = this.keyOf(literal);
         let fixup = this.literals.get(key);
         let newValue = false;
         if (!fixup) {
@@ -1887,20 +1779,11 @@ 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 = GenericKeyFn.INSTANCE.keyOf(literalArr(argumentsForKey));
+            const key = this.keyOf(literalArr(argumentsForKey));
             return this._getLiteralFactory(key, literal.entries, entries => literalArr(entries));
         }
         else {
@@ -1909,7 +1792,7 @@ class ConstantPool {
                 value: e.value.isConstant() ? e.value : UNKNOWN_VALUE_KEY,
                 quoted: e.quoted
             })));
-            const key = GenericKeyFn.INSTANCE.keyOf(expressionForKey);
+            const key = this.keyOf(expressionForKey);
             return this._getLiteralFactory(key, literal.entries.map(e => e.value), entries => literalMap(entries.map((value, index) => ({
                 key: literal.entries[index].key,
                 value,
@@ -1946,47 +1829,64 @@ class ConstantPool {
     freshName() {
         return this.uniqueName(CONSTANT_PREFIX);
     }
+    keyOf(expression) {
+        return expression.visitExpression(new KeyVisitor(), KEY_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}`);
-        }
+/**
+ * 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)}`;
+    }
+}
+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;
@@ -1998,211 +1898,209 @@ 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) {
@@ -2288,7 +2186,13 @@ class Version {
         this.patch = splits.slice(2).join('.');
     }
 }
-const _global = globalThis;
+// 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))());
 /**
  * Partitions a given array into 2 arrays, based on a boolean value returned by the condition
  * function.
@@ -2763,9 +2667,6 @@ 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);
@@ -3053,7 +2954,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.type.value) :
+        new BinaryOperatorExpr(BinaryOperator.Or, t, meta.internalType) :
         t;
     let ctorExpr = null;
     if (meta.deps !== null) {
@@ -3100,7 +3001,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.type.value]);
+        const getInheritedFactoryCall = importExpr(Identifiers.getInheritedFactory).callFn([meta.internalType]);
         // Memoize the base factoryFn: `baseFactory || (baseFactory = ɵɵgetInheritedFactory(...))`
         const baseFactory = new BinaryOperatorExpr(BinaryOperator.Or, baseFactoryVar, baseFactoryVar.set(getInheritedFactoryCall));
         body.push(new ReturnStatement(baseFactory.callFn([typeForCtor])));
@@ -3336,96 +3237,6 @@ 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.
@@ -3531,9 +3342,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 = [{
@@ -3569,12 +3380,11 @@ class Container {
     }
 }
 class Icu {
-    constructor(expression, type, cases, sourceSpan, expressionPlaceholder) {
+    constructor(expression, type, cases, sourceSpan) {
         this.expression = expression;
         this.type = type;
         this.cases = cases;
         this.sourceSpan = sourceSpan;
-        this.expressionPlaceholder = expressionPlaceholder;
     }
     visit(visitor, context) {
         return visitor.visitIcu(this, context);
@@ -3909,44 +3719,37 @@ function asLiteral(value) {
     }
     return literal(value, INFERRED_TYPE);
 }
-function conditionallyCreateDirectiveBindingLiteral(map, keepDeclared) {
-    const keys = Object.getOwnPropertyNames(map);
-    if (keys.length === 0) {
-        return null;
+function conditionallyCreateMapObjectLiteral(keys, keepDeclared) {
+    if (Object.getOwnPropertyNames(keys).length > 0) {
+        return mapToExpression(keys, keepDeclared);
     }
-    return literalMap(keys.map(key => {
+    return null;
+}
+function mapToExpression(map, keepDeclared) {
+    return literalMap(Object.getOwnPropertyNames(map).map(key => {
+        // canonical syntax: `dirProp: publicProp`
         const value = map[key];
         let declaredName;
         let publicName;
         let minifiedName;
-        let expressionValue;
-        if (typeof value === 'string') {
-            // canonical syntax: `dirProp: publicProp`
-            declaredName = key;
+        let needsDeclaredName;
+        if (Array.isArray(value)) {
+            [publicName, declaredName] = value;
             minifiedName = key;
-            publicName = value;
-            expressionValue = asLiteral(publicName);
+            needsDeclaredName = publicName !== declaredName;
         }
         else {
-            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);
-            }
+            minifiedName = declaredName = key;
+            publicName = value;
+            needsDeclaredName = false;
         }
         return {
             key: minifiedName,
             // put quotes around keys that contain potentially unsafe characters
             quoted: UNSAFE_OBJECT_KEY_NAME_REGEXP.test(minifiedName),
-            value: expressionValue,
+            value: (keepDeclared && needsDeclaredName) ?
+                literalArr([asLiteral(publicName), asLiteral(declaredName)]) :
+                asLiteral(publicName)
         };
     }));
 }
@@ -4060,6 +3863,7 @@ function compileInjectable(meta, resolveForwardRefs) {
     const factoryMeta = {
         name: meta.name,
         type: meta.type,
+        internalType: meta.internalType,
         typeArgumentCount: meta.typeArgumentCount,
         deps: [],
         target: FactoryTarget$1.Injectable,
@@ -4071,7 +3875,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.type.value);
+        const useClassOnSelf = meta.useClass.expression.isEquivalent(meta.internalType);
         let deps = undefined;
         if (meta.deps !== undefined) {
             deps = meta.deps;
@@ -4130,10 +3934,10 @@ function compileInjectable(meta, resolveForwardRefs) {
     else {
         result = {
             statements: [],
-            expression: delegateToFactory(meta.type.value, meta.type.value, resolveForwardRefs)
+            expression: delegateToFactory(meta.type.value, meta.internalType, resolveForwardRefs)
         };
     }
-    const token = meta.type.value;
+    const token = meta.internalType;
     const injectableProps = new DefinitionMap();
     injectableProps.set('token', token);
     injectableProps.set('factory', result.expression);
@@ -4152,28 +3956,28 @@ function compileInjectable(meta, resolveForwardRefs) {
 function createInjectableType(meta) {
     return new ExpressionType$1(importExpr(Identifiers.InjectableDeclaration, [typeWithParameters(meta.type.type, meta.typeArgumentCount)]));
 }
-function delegateToFactory(type, useType, unwrapForwardRefs) {
-    if (type.node === useType.node) {
+function delegateToFactory(type, internalType, unwrapForwardRefs) {
+    if (type.node === internalType.node) {
         // The types are the same, so we can simply delegate directly to the type's factory.
         // ```
         // factory: type.ɵfac
         // ```
-        return useType.prop('ɵfac');
+        return internalType.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 useType.ɵfac(t); }
+        // factory: function(t) { return internalType.ɵfac(t); }
         // ```
-        return createFactoryFunction(useType);
+        return createFactoryFunction(internalType);
     }
-    // The useType is actually wrapped in a `forwardRef()` so we need to resolve that before
+    // The internalType 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([useType]);
+    const unwrappedType = importExpr(Identifiers.resolveForwardRef).callFn([internalType]);
     return createFactoryFunction(unwrappedType);
 }
 function createFactoryFunction(type) {
@@ -4581,6 +4385,45 @@ 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.
@@ -4589,7 +4432,7 @@ class AbstractJsEmitterVisitor extends AbstractEmitterVisitor {
  * interpreted and executed as a script by a browser, e.g. when calling eval.
  */
 function trustedScriptFromString(script) {
-    return script;
+    return getPolicy()?.createScript(script) || script;
 }
 /**
  * Unsafely call the Function constructor with the given string arguments.
@@ -4831,49 +4674,31 @@ 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', 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);
-        }
+    definitionMap.set('type', internalType);
+    if (bootstrap.length > 0) {
+        definitionMap.set('bootstrap', refsToArray(bootstrap, containsForwardDecls));
     }
-    if (meta.selectorScopeMode === R3SelectorScopeMode.Inline) {
+    if (selectorScopeMode === R3SelectorScopeMode.Inline) {
         // If requested to emit scope information inline, pass the `declarations`, `imports` and
         // `exports` to the `ɵɵdefineNgModule()` call directly.
-        if (meta.declarations.length > 0) {
-            definitionMap.set('declarations', refsToArray(meta.declarations, meta.containsForwardDecls));
+        if (declarations.length > 0) {
+            definitionMap.set('declarations', refsToArray(declarations, containsForwardDecls));
         }
-        if (meta.imports.length > 0) {
-            definitionMap.set('imports', refsToArray(meta.imports, meta.containsForwardDecls));
+        if (imports.length > 0) {
+            definitionMap.set('imports', refsToArray(imports, containsForwardDecls));
         }
-        if (meta.exports.length > 0) {
-            definitionMap.set('exports', refsToArray(meta.exports, meta.containsForwardDecls));
+        if (exports.length > 0) {
+            definitionMap.set('exports', refsToArray(exports, containsForwardDecls));
         }
     }
-    else if (meta.selectorScopeMode === R3SelectorScopeMode.SideEffect) {
+    else if (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
@@ -4884,14 +4709,14 @@ function compileNgModule(meta) {
         }
     }
     else ;
-    if (meta.schemas !== null && meta.schemas.length > 0) {
-        definitionMap.set('schemas', literalArr(meta.schemas.map(ref => ref.value)));
+    if (schemas !== null && schemas.length > 0) {
+        definitionMap.set('schemas', literalArr(schemas.map(ref => ref.value)));
     }
-    if (meta.id !== null) {
-        definitionMap.set('id', meta.id);
+    if (id !== null) {
+        definitionMap.set('id', 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([meta.type.value, meta.id]).toStmt());
+        statements.push(importExpr(Identifiers.registerNgModuleType).callFn([adjacentType, id]).toStmt());
     }
     const expression = importExpr(Identifiers.defineNgModule).callFn([definitionMap.toLiteralMap()], undefined, true);
     const type = createNgModuleType(meta);
@@ -4924,11 +4749,7 @@ function compileNgModuleDeclarationExpression(meta) {
     }
     return importExpr(Identifiers.defineNgModule).callFn([definitionMap.toLiteralMap()]);
 }
-function createNgModuleType(meta) {
-    if (meta.kind === R3NgModuleMetadataKind.Local) {
-        return new ExpressionType$1(meta.type.value);
-    }
-    const { type: moduleType, declarations, exports, imports, includeImportTypes, publicDeclarationTypes } = meta;
+function createNgModuleType({ type: moduleType, declarations, exports, imports, includeImportTypes, publicDeclarationTypes }) {
     return new ExpressionType$1(importExpr(Identifiers.NgModuleDeclaration, [
         new ExpressionType$1(moduleType.type),
         publicDeclarationTypes === null ? tupleTypeOf(declarations) :
@@ -4944,36 +4765,16 @@ function createNgModuleType(meta) {
  * symbols to become tree-shakeable.
  */
 function generateSetNgModuleScopeCall(meta) {
+    const { adjacentType: moduleType, declarations, imports, exports, containsForwardDecls } = meta;
     const scopeMap = new DefinitionMap();
-    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 (declarations.length > 0) {
+        scopeMap.set('declarations', refsToArray(declarations, 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 (imports.length > 0) {
+        scopeMap.set('imports', refsToArray(imports, containsForwardDecls));
     }
-    else {
-        if (meta.exportsExpression) {
-            scopeMap.set('exports', meta.exportsExpression);
-        }
+    if (exports.length > 0) {
+        scopeMap.set('exports', refsToArray(exports, containsForwardDecls));
     }
     if (Object.keys(scopeMap.values).length === 0) {
         return null;
@@ -4981,7 +4782,7 @@ function generateSetNgModuleScopeCall(meta) {
     // setNgModuleScope(...)
     const fnCall = new InvokeFunctionExpr(
     /* fn */ importExpr(Identifiers.setNgModuleScope), 
-    /* args */ [meta.type.value, scopeMap.toLiteralMap()]);
+    /* args */ [moduleType, scopeMap.toLiteralMap()]);
     // (ngJitMode guard) && setNgModuleScope(...)
     const guardedCall = jitOnlyGuardedExpression(fnCall);
     // function() { (ngJitMode guard) && setNgModuleScope(...); }
@@ -5069,7 +4870,7 @@ class ASTWithName extends AST {
         this.nameSpan = nameSpan;
     }
 }
-class EmptyExpr$1 extends AST {
+class EmptyExpr extends AST {
     visit(visitor, context = null) {
         // do nothing
     }
@@ -5216,7 +5017,7 @@ class LiteralMap extends AST {
         return visitor.visitLiteralMap(this, context);
     }
 }
-class Interpolation$1 extends AST {
+class Interpolation extends AST {
     constructor(span, sourceSpan, strings, expressions) {
         super(span, sourceSpan);
         this.strings = strings;
@@ -5463,7 +5264,7 @@ class AstTransformer {
         return ast;
     }
     visitInterpolation(ast, context) {
-        return new Interpolation$1(ast.span, ast.sourceSpan, ast.strings, this.visitAll(ast.expressions));
+        return new Interpolation(ast.span, ast.sourceSpan, ast.strings, this.visitAll(ast.expressions));
     }
     visitLiteralPrimitive(ast, context) {
         return new LiteralPrimitive(ast.span, ast.sourceSpan, ast.value);
@@ -5546,7 +5347,7 @@ class AstMemoryEfficientTransformer {
     visitInterpolation(ast, context) {
         const expressions = this.visitAll(ast.expressions);
         if (expressions !== ast.expressions)
-            return new Interpolation$1(ast.span, ast.sourceSpan, ast.strings, expressions);
+            return new Interpolation(ast.span, ast.sourceSpan, ast.strings, expressions);
         return ast;
     }
     visitLiteralPrimitive(ast, context) {
@@ -5759,8 +5560,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).
@@ -6484,7 +6285,6 @@ class InterpolationExpression extends Expression {
         this.isConstant = unsupported;
         this.isEquivalent = unsupported;
         this.visitExpression = unsupported;
-        this.clone = unsupported;
     }
 }
 class DefaultLocalResolver {
@@ -6502,7 +6302,7 @@ class DefaultLocalResolver {
 }
 class BuiltinFunctionCall extends Call {
     constructor(span, sourceSpan, args, converter) {
-        super(span, sourceSpan, new EmptyExpr$1(span, sourceSpan), args, null);
+        super(span, sourceSpan, new EmptyExpr(span, sourceSpan), args, null);
         this.converter = converter;
     }
 }
@@ -6739,28 +6539,11 @@ class ShadowCss {
      * The hostSelector is the attribute added to the host itself.
      */
     shimCssText(cssText, selector, hostSelector = '') {
-        // **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;
-        });
+        const commentsWithHash = extractCommentsWithHash(cssText);
+        cssText = stripComments(cssText);
         cssText = this._insertDirectives(cssText);
         const scopedCssText = this._scopeCssText(cssText, selector, hostSelector);
-        // Add back comments at the original position.
-        let commentIdx = 0;
-        return scopedCssText.replace(_commentWithHashPlaceHolderRe, () => comments[commentIdx++]);
+        return [scopedCssText, ...commentsWithHash].join('\n');
     }
     _insertDirectives(cssText) {
         cssText = this._insertPolyfillDirectivesInCssText(cssText);
@@ -7001,7 +6784,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;
@@ -7031,7 +6814,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
@@ -7043,10 +6826,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:
                 // ```
@@ -7069,7 +6852,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.
@@ -7079,7 +6862,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(', ');
         });
     }
@@ -7100,7 +6883,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('@scope')) {
+                rule.selector.startsWith('@container')) {
                 content = this._scopeSelectors(rule.content, scopeSelector, hostSelector);
             }
             else if (rule.selector.startsWith('@font-face') || rule.selector.startsWith('@page')) {
@@ -7131,7 +6914,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);
@@ -7139,7 +6922,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) => {
@@ -7322,14 +7105,17 @@ 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 = new RegExp(`(\\s*(?:${COMMENT_PLACEHOLDER}\\s*)*)([^;\\{\\}]+?)(\\s*)((?:{%BLOCK%}?\\s*;?)|(?:\\s*;))`, 'g');
+const _ruleRe = /(\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%';
@@ -7538,6 +7324,7 @@ 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.
  */
@@ -7591,743 +7378,13 @@ 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;
-}
-
 /**
- * Enumeration of the types of attributes which can be applied to an element.
- */
-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']`
+ * 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
@@ -8371,7 +7428,7 @@ function parse(value) {
                 break;
             case 58 /* Char.Colon */:
                 if (!currentProp && parenDepth === 0 && quote === 0 /* Char.QuoteNone */) {
-                    currentProp = hyphenate$1(value.substring(propStart, i - 1).trim());
+                    currentProp = hyphenate(value.substring(propStart, i - 1).trim());
                     valueStart = i;
                 }
                 break;
@@ -8392,7 +7449,7 @@ function parse(value) {
     }
     return styles;
 }
-function hyphenate$1(value) {
+function hyphenate(value) {
     return value
         .replace(/[a-z][A-Z]/g, v => {
         return v.charAt(0) + '-' + v.charAt(1);
@@ -8400,140 +7457,6 @@ function hyphenate$1(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.
@@ -8703,7 +7626,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$1(name);
+            name = hyphenate(name);
         }
         const { property, hasOverrideFlag, suffix: bindingSuffix } = parseProperty(name);
         suffix = typeof suffix === 'string' && suffix.length !== 0 ? suffix : bindingSuffix;
@@ -8833,7 +7756,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$1) {
+        if (mapValue instanceof Interpolation) {
             totalBindingSlotsRequired += mapValue.expressions.length;
             reference = isClassBased ? getClassMapInterpolationExpression(mapValue) :
                 getStyleMapInterpolationExpression(mapValue);
@@ -8868,7 +7791,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$1) {
+            if (value instanceof Interpolation) {
                 totalBindingSlotsRequired += value.expressions.length;
                 if (getInterpolationExpressionFn) {
                     referenceForCall = getInterpolationExpressionFn(value);
@@ -9060,7 +7983,7 @@ function isEmptyExpression(ast) {
     if (ast instanceof ASTWithSource) {
         ast = ast.ast;
     }
-    return ast instanceof EmptyExpr$1;
+    return ast instanceof EmptyExpr;
 }
 
 var TokenType;
@@ -9496,7 +8419,6 @@ 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);
@@ -9579,7 +8501,7 @@ class Parser$1 {
     }
     createInterpolationAst(strings, expressions, input, location, absoluteOffset) {
         const span = new ParseSpan(0, input.length);
-        const interpolation = new Interpolation$1(span, span.toAbsolute(absoluteOffset), strings, expressions);
+        const interpolation = new Interpolation(span, span.toAbsolute(absoluteOffset), strings, expressions);
         return new ASTWithSource(interpolation, input, location, absoluteOffset, this.errors);
     }
     /**
@@ -9950,7 +8872,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$1(this.span(artificialStart, artificialEnd), this.sourceSpan(artificialStart, artificialEnd));
+            return new EmptyExpr(this.span(artificialStart, artificialEnd), this.sourceSpan(artificialStart, artificialEnd));
         }
         if (exprs.length == 1)
             return exprs[0];
@@ -10011,7 +8933,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$1(this.span(start), this.sourceSpan(start));
+                no = new EmptyExpr(this.span(start), this.sourceSpan(start));
             }
             else {
                 no = this.parsePipe();
@@ -10236,15 +9158,15 @@ class _ParseAST {
         }
         else if (this.next.isPrivateIdentifier()) {
             this._reportErrorForPrivateIdentifier(this.next, null);
-            return new EmptyExpr$1(this.span(start), this.sourceSpan(start));
+            return new EmptyExpr(this.span(start), this.sourceSpan(start));
         }
         else if (this.index >= this.tokens.length) {
             this.error(`Unexpected end of expression: ${this.input}`);
-            return new EmptyExpr$1(this.span(start), this.sourceSpan(start));
+            return new EmptyExpr(this.span(start), this.sourceSpan(start));
         }
         else {
             this.error(`Unexpected token ${this.next}`);
-            return new EmptyExpr$1(this.span(start), this.sourceSpan(start));
+            return new EmptyExpr(this.span(start), this.sourceSpan(start));
         }
     }
     parseExpressionList(terminator) {
@@ -10305,7 +9227,7 @@ class _ParseAST {
         if (isSafe) {
             if (this.consumeOptionalAssignment()) {
                 this.error('The \'?.\' operator cannot be used in the assignment');
-                receiver = new EmptyExpr$1(this.span(start), this.sourceSpan(start));
+                receiver = new EmptyExpr(this.span(start), this.sourceSpan(start));
             }
             else {
                 receiver = new SafePropertyRead(this.span(start), this.sourceSpan(start), nameSpan, readReceiver, id);
@@ -10315,7 +9237,7 @@ class _ParseAST {
             if (this.consumeOptionalAssignment()) {
                 if (!(this.parseFlags & 1 /* ParseFlags.Action */)) {
                     this.error('Bindings cannot contain assignments');
-                    return new EmptyExpr$1(this.span(start), this.sourceSpan(start));
+                    return new EmptyExpr(this.span(start), this.sourceSpan(start));
                 }
                 const value = this.parseConditional();
                 receiver = new PropertyWrite(this.span(start), this.sourceSpan(start), nameSpan, readReceiver, id, value);
@@ -10445,7 +9367,7 @@ class _ParseAST {
         return this.withContext(ParseContextFlags.Writable, () => {
             this.rbracketsExpected++;
             const key = this.parsePipe();
-            if (key instanceof EmptyExpr$1) {
+            if (key instanceof EmptyExpr) {
                 this.error(`Key access cannot be empty`);
             }
             this.rbracketsExpected--;
@@ -10463,7 +9385,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$1(this.span(start), this.sourceSpan(start));
+            return new EmptyExpr(this.span(start), this.sourceSpan(start));
         });
     }
     /**
@@ -10758,39 +9680,6 @@ 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 ?
@@ -10805,6 +9694,41 @@ 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 {
 }
 
@@ -13476,9 +12400,8 @@ const NAMED_ENTITIES = {
     'zwj': '\u200D',
     'zwnj': '\u200C'
 };
-// 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.
+// The &ngsp; pseudo-entity is denoting a space. see:
+// https://github.com/dart-lang/angular/blob/0bb611387d29d65b5af7f9d2515ab571fd3fbee4/_tests/test/compiler/preserve_whitespace_test.dart
 const NGSP_UNICODE = '\uE500';
 NAMED_ENTITIES['ngsp'] = NGSP_UNICODE;
 
@@ -13545,8 +12468,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();
         }
@@ -13581,102 +12504,24 @@ class _Tokenizer {
                         }
                     }
                     else if (this._attemptCharCode($SLASH)) {
-                        this._consumeTagClose(start);
-                    }
-                    else {
-                        this._consumeTagOpen(start);
-                    }
-                }
-                else if (this._tokenizeBlocks && this._attemptStr('{#')) {
-                    this._consumeBlockGroupOpen(start);
-                }
-                else if (this._tokenizeBlocks && this._attemptStr('{/')) {
-                    this._consumeBlockGroupClose(start);
-                }
-                else if (this._tokenizeBlocks && this._attemptStr('{:')) {
-                    this._consumeBlock(start);
-                }
-                else if (!(this._tokenizeIcu && this._tokenizeExpansionForm())) {
-                    // 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);
-            }
-        }
-        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;
+                        this._consumeTagClose(start);
                     }
-                    else if (openBraces > 0) {
-                        openBraces--;
+                    else {
+                        this._consumeTagOpen(start);
                     }
                 }
-                this._cursor.advance();
+                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);
             }
-            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
@@ -14199,7 +13044,7 @@ class _Tokenizer {
         return this._processCarriageReturns(end.getChars(start));
     }
     _isTextEnd() {
-        if (this._isTagStart() || this._isBlockStart() || this._cursor.peek() === $EOF) {
+        if (this._isTagStart() || this._cursor.peek() === $EOF) {
             return true;
         }
         if (this._tokenizeIcu && !this._inInterpolation) {
@@ -14232,23 +13077,6 @@ 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);
@@ -14304,12 +13132,6 @@ 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;
@@ -14597,7 +13419,7 @@ class _TreeBuilder {
         this.tokens = tokens;
         this.getTagDefinition = getTagDefinition;
         this._index = -1;
-        this._containerStack = [];
+        this._elementStack = [];
         this.rootNodes = [];
         this.errors = [];
         this._advance();
@@ -14627,18 +13449,6 @@ 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();
@@ -14666,12 +13476,9 @@ class _TreeBuilder {
     }
     _consumeComment(token) {
         const text = this._advanceIf(7 /* TokenType.RAW_TEXT */);
-        const endToken = this._advanceIf(11 /* TokenType.COMMENT_END */);
+        this._advanceIf(11 /* TokenType.COMMENT_END */);
         const value = text != null ? text.parts[0].trim() : null;
-        const sourceSpan = endToken == null ?
-            token.sourceSpan :
-            new ParseSourceSpan(token.sourceSpan.start, endToken.sourceSpan.end, token.sourceSpan.fullStart);
-        this._addToParent(new Comment(value, sourceSpan));
+        this._addToParent(new Comment(value, token.sourceSpan));
     }
     _consumeExpansion(token) {
         const switchValue = this._advance();
@@ -14758,12 +13565,7 @@ class _TreeBuilder {
         const startSpan = token.sourceSpan;
         let text = token.parts[0];
         if (text.length > 0 && text[0] === '\n') {
-            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;
-            }
+            const parent = this._getParentElement();
             if (parent != null && parent.children.length === 0 &&
                 this.getTagDefinition(parent.name).ignoreFirstLf) {
                 text = text.substring(1);
@@ -14794,9 +13596,9 @@ class _TreeBuilder {
         }
     }
     _closeVoidElement() {
-        const el = this._getContainer();
-        if (el instanceof Element && this.getTagDefinition(el.name).isVoid) {
-            this._containerStack.pop();
+        const el = this._getParentElement();
+        if (el && this.getTagDefinition(el.name).isVoid) {
+            this._elementStack.pop();
         }
     }
     _consumeStartTag(startTagToken) {
@@ -14805,7 +13607,7 @@ class _TreeBuilder {
         while (this._peek.type === 14 /* TokenType.ATTR_NAME */) {
             attrs.push(this._consumeAttr(this._advance()));
         }
-        const fullName = this._getElementFullName(prefix, name, this._getClosestParentElement());
+        const fullName = this._getElementFullName(prefix, name, this._getParentElement());
         let selfClosing = false;
         // Note: There could have been a tokenizer error
         // so that we don't get a token for the end tag...
@@ -14826,34 +13628,33 @@ 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);
-        const parentEl = this._getContainer();
-        this._pushContainer(el, parentEl instanceof Element &&
-            this.getTagDefinition(parentEl.name).isClosedByChild(el.name));
+        this._pushElement(el);
         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._popContainer(fullName, Element, span);
+            this._popElement(fullName, 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._popContainer(fullName, Element, null);
+            this._popElement(fullName, null);
             this.errors.push(TreeError.create(fullName, span, `Opening tag "${fullName}" not terminated.`));
         }
     }
-    _pushContainer(node, isClosedByChild) {
-        if (isClosedByChild) {
-            this._containerStack.pop();
+    _pushElement(el) {
+        const parentEl = this._getParentElement();
+        if (parentEl && this.getTagDefinition(parentEl.name).isClosedByChild(el.name)) {
+            this._elementStack.pop();
         }
-        this._addToParent(node);
-        this._containerStack.push(node);
+        this._addToParent(el);
+        this._elementStack.push(el);
     }
     _consumeEndTag(endTagToken) {
-        const fullName = this._getElementFullName(endTagToken.parts[0], endTagToken.parts[1], this._getClosestParentElement());
+        const fullName = this._getElementFullName(endTagToken.parts[0], endTagToken.parts[1], this._getParentElement());
         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._popContainer(fullName, Element, endTagToken.sourceSpan)) {
+        else if (!this._popElement(fullName, 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));
         }
@@ -14864,23 +13665,20 @@ class _TreeBuilder {
      * not have a closing tag (for example, this happens when an incomplete
      * opening tag is recovered).
      */
-    _popContainer(fullName, expectedType, endSourceSpan) {
+    _popElement(fullName, endSourceSpan) {
         let unexpectedCloseTagDetected = false;
-        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) {
+        for (let stackIndex = this._elementStack.length - 1; stackIndex >= 0; stackIndex--) {
+            const el = this._elementStack[stackIndex];
+            if (el.name === fullName) {
                 // 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).
-                node.endSourceSpan = endSourceSpan;
-                node.sourceSpan.end = endSourceSpan !== null ? endSourceSpan.end : node.sourceSpan.end;
-                this._containerStack.splice(stackIndex, this._containerStack.length - stackIndex);
+                el.endSourceSpan = endSourceSpan;
+                el.sourceSpan.end = endSourceSpan !== null ? endSourceSpan.end : el.sourceSpan.end;
+                this._elementStack.splice(stackIndex, this._elementStack.length - stackIndex);
                 return !unexpectedCloseTagDetected;
             }
-            // 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) {
+            if (!this.getTagDefinition(el.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.
@@ -14939,92 +13737,16 @@ 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);
     }
-    _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;
+    _getParentElement() {
+        return this._elementStack.length > 0 ? this._elementStack[this._elementStack.length - 1] : null;
     }
     _addToParent(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.'));
+        const parent = this._getParentElement();
+        if (parent != null) {
+            parent.children.push(node);
         }
         else {
-            parent.children.push(node);
+            this.rootNodes.push(node);
         }
     }
     _getElementFullName(prefix, localName, parentElement) {
@@ -15082,9 +13804,10 @@ function hasPreserveWhitespacesAttr(attrs) {
     return attrs.some((attr) => attr.name === PRESERVE_WS_ATTR_NAME);
 }
 /**
- * &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.
+ * 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.
  */
 function replaceNgsp(value) {
     // lexer is replacing the &ngsp; pseudo-entity with NGSP_UNICODE
@@ -15138,15 +13861,6 @@ 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 };
@@ -15404,7 +14118,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) {
@@ -15426,11 +14140,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 ?
@@ -15549,7 +14263,7 @@ class BindingParser {
             if (ast) {
                 this._reportExpressionParserErrors(ast.errors, sourceSpan);
             }
-            if (!ast || ast.ast instanceof EmptyExpr$1) {
+            if (!ast || ast.ast instanceof EmptyExpr) {
                 this._reportError(`Empty expressions are not allowed`, sourceSpan);
                 return this._exprParser.wrapLiteralPrimitive('ERROR', sourceInfo, absoluteOffset);
             }
@@ -15695,415 +14409,6 @@ 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;
@@ -16227,16 +14532,7 @@ class HtmlAstToIvyAst {
                 attributes.push(this.visitAttribute(attribute));
             }
         }
-        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);
-        }
+        const children = visitAll(preparsedElement.nonBindable ? NON_BINDABLE_VISITOR : this, element.children);
         let parsedElement;
         if (preparsedElement.type === PreparsedElementType.NG_CONTENT) {
             // `<ng-content>`
@@ -16334,23 +14630,6 @@ 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 = [];
@@ -16528,25 +14807,6 @@ 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) {
@@ -16994,17 +15254,6 @@ 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.
      *
@@ -17148,11 +15397,12 @@ 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 createI18nMessage = createI18nMessageFactory(this.interpolationConfig);
-        const message = createI18nMessage(nodes, meaning, description, customId, visitNodeFn);
+        const message = this._createI18nMessage(nodes, meaning, description, customId, visitNodeFn);
         this._setMessageId(message, meta);
         this._setLegacyIds(message, meta);
         return message;
@@ -17251,17 +15501,6 @@ 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`.
@@ -17643,7 +15882,7 @@ function createComponentDefConsts() {
     };
 }
 class TemplateDefinitionBuilder {
-    constructor(constantPool, parentBindingScope, level = 0, contextName, i18nContext, templateIndex, templateName, _namespace, relativeContextFilePath, i18nUseExternalIds, deferBlocks, _constants = createComponentDefConsts()) {
+    constructor(constantPool, parentBindingScope, level = 0, contextName, i18nContext, templateIndex, templateName, _namespace, relativeContextFilePath, i18nUseExternalIds, _constants = createComponentDefConsts()) {
         this.constantPool = constantPool;
         this.level = level;
         this.contextName = contextName;
@@ -17652,7 +15891,6 @@ class TemplateDefinitionBuilder {
         this.templateName = templateName;
         this._namespace = _namespace;
         this.i18nUseExternalIds = i18nUseExternalIds;
-        this.deferBlocks = deferBlocks;
         this._constants = _constants;
         this._dataIndex = 0;
         this._bindingContext = 0;
@@ -17855,7 +16093,7 @@ class TemplateDefinitionBuilder {
             else {
                 const value = prop.value.visit(this._valueConverter);
                 this.allocateBindingSlots(value);
-                if (value instanceof Interpolation$1) {
+                if (value instanceof Interpolation) {
                     const { strings, expressions } = value;
                     const { id, bindings } = this.i18n;
                     const label = assembleI18nBoundString(strings, bindings.size, id);
@@ -17975,7 +16213,7 @@ class TemplateDefinitionBuilder {
             const message = attr.i18n;
             const converted = attr.value.visit(this._valueConverter);
             this.allocateBindingSlots(converted);
-            if (converted instanceof Interpolation$1) {
+            if (converted instanceof Interpolation) {
                 const placeholders = assembleBoundTextPlaceholders(message);
                 const params = placeholdersToParams(placeholders);
                 i18nAttrArgs.push(literal(attr.name), this.i18nTranslate(message, params));
@@ -18195,7 +16433,7 @@ class TemplateDefinitionBuilder {
                     }
                     this.allocateBindingSlots(value);
                     if (inputType === 0 /* BindingType.Property */) {
-                        if (value instanceof Interpolation$1) {
+                        if (value instanceof Interpolation) {
                             // prop="{{value}}" and friends
                             this.interpolatedUpdateInstruction(getPropertyInterpolationExpression(value), elementIndex, attrName, input, value, params);
                         }
@@ -18209,12 +16447,12 @@ class TemplateDefinitionBuilder {
                         }
                     }
                     else if (inputType === 1 /* BindingType.Attribute */) {
-                        if (value instanceof Interpolation$1 && getInterpolationArgsLength(value) > 1) {
+                        if (value instanceof Interpolation && getInterpolationArgsLength(value) > 1) {
                             // attr.name="text{{value}}" and friends
                             this.interpolatedUpdateInstruction(getAttributeInterpolationExpression(value), elementIndex, attrName, input, value, params);
                         }
                         else {
-                            const boundValue = value instanceof Interpolation$1 ? value.expressions[0] : value;
+                            const boundValue = value instanceof Interpolation ? 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({
@@ -18284,7 +16522,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.deferBlocks, 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._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
@@ -18327,7 +16565,7 @@ class TemplateDefinitionBuilder {
         if (this.i18n) {
             const value = text.value.visit(this._valueConverter);
             this.allocateBindingSlots(value);
-            if (value instanceof Interpolation$1) {
+            if (value instanceof Interpolation) {
                 this.i18n.appendBoundText(text.i18n);
                 this.i18nAppendBindings(value.expressions);
             }
@@ -18337,7 +16575,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$1) {
+        if (value instanceof Interpolation) {
             this.updateInstructionWithAdvance(nodeIndex, text.sourceSpan, getTextInterpolationExpression(value), () => this.getUpdateInstructionArguments(value));
         }
         else {
@@ -18394,47 +16632,6 @@ 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++;
     }
@@ -18466,7 +16663,7 @@ class TemplateDefinitionBuilder {
                 continue;
             }
             this.allocateBindingSlots(value);
-            if (value instanceof Interpolation$1) {
+            if (value instanceof Interpolation) {
                 // 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.
@@ -18498,7 +16695,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$1) ?
+                this.updateInstructionWithAdvance(elementIndex, call.sourceSpan, instruction.reference, () => call.params(value => (call.supportsInterpolation && value instanceof Interpolation) ?
                     this.getUpdateInstructionArguments(value) :
                     this.convertPropertyBinding(value)));
             }
@@ -18531,7 +16728,7 @@ class TemplateDefinitionBuilder {
         return originalSlots;
     }
     allocateBindingSlots(value) {
-        this._bindingSlots += value instanceof Interpolation$1 ? value.expressions.length : 1;
+        this._bindingSlots += value instanceof Interpolation ? value.expressions.length : 1;
     }
     /**
      * Gets an expression that refers to the implicit receiver. The implicit
@@ -19153,12 +17350,7 @@ 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,
-        tokenizeBlocks: options.enabledBlockTypes != null && options.enabledBlockTypes.size > 0,
-    });
+    const parseResult = htmlParser.parse(template, templateUrl, { leadingTriviaChars: LEADING_TRIVIA_CHARS, ...options, tokenizeExpansionForms: true });
     if (!options.alwaysAttemptHtmlToR3AstConversion && parseResult.errors &&
         parseResult.errors.length > 0) {
         const parsedTemplate = {
@@ -19209,10 +17401,7 @@ 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,
-        enabledBlockTypes: options.enabledBlockTypes || new Set(),
-    });
+    const { nodes, errors, styleUrls, styles, ngContentSelectors, commentNodes } = htmlAstToRender3Ast(rootNodes, bindingParser, { collectCommentNodes: !!options.collectCommentNodes });
     errors.push(...parseResult.errors, ...i18nMetaResult.errors);
     const parsedTemplate = {
         interpolationConfig,
@@ -19359,7 +17548,7 @@ function baseDirectiveFields(meta, constantPool, bindingParser) {
     const definitionMap = new DefinitionMap();
     const selectors = parseSelectorToR3Selector(meta.selector);
     // e.g. `type: MyDirective`
-    definitionMap.set('type', meta.type.value);
+    definitionMap.set('type', meta.internalType);
     // e.g. `selectors: [['', 'someDir', '']]`
     if (selectors.length > 0) {
         definitionMap.set('selectors', asLiteral(selectors));
@@ -19374,18 +17563,15 @@ 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', conditionallyCreateDirectiveBindingLiteral(meta.inputs, true));
+    definitionMap.set('inputs', conditionallyCreateMapObjectLiteral(meta.inputs, true));
     // e.g 'outputs: {a: 'a'}`
-    definitionMap.set('outputs', conditionallyCreateDirectiveBindingLiteral(meta.outputs));
+    definitionMap.set('outputs', conditionallyCreateMapObjectLiteral(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;
 }
 /**
@@ -19396,7 +17582,6 @@ 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) {
@@ -19404,12 +17589,6 @@ 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));
     }
@@ -19461,43 +17640,34 @@ function compileComponentFromMetadata(meta, constantPool, bindingParser) {
     const templateTypeName = meta.name;
     const templateName = templateTypeName ? `${templateTypeName}_Template` : null;
     const changeDetection = meta.changeDetection;
-    // 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);
-    }
+    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);
     if (meta.declarations.length > 0) {
         definitionMap.set('dependencies', compileDeclarationList(literalArr(meta.declarations.map(decl => decl.type)), meta.declarationListEmitMode));
     }
@@ -19548,12 +17718,6 @@ 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));
 }
 /**
@@ -19652,24 +17816,11 @@ function createBaseDirectiveTypeParams(meta) {
         typeWithParameters(meta.type.type, meta.typeArgumentCount),
         selectorForType !== null ? stringAsType(selectorForType) : NONE_TYPE,
         meta.exportAs !== null ? stringArrayAsType(meta.exportAs) : NONE_TYPE,
-        expressionType(getInputsTypeExpression(meta)),
+        expressionType(stringMapAsLiteralExpression(meta.inputs)),
         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.
@@ -19681,12 +17832,6 @@ 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
@@ -19715,9 +17860,6 @@ 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;
@@ -19731,10 +17873,13 @@ 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.
@@ -20077,7 +18222,6 @@ function createHostDirectivesMappingArray(mapping) {
 class ResourceLoader {
 }
 
-let enabledBlockTypes;
 class CompilerFacadeImpl {
     constructor(jitEvaluator = new JitEvaluator()) {
         this.jitEvaluator = jitEvaluator;
@@ -20089,6 +18233,7 @@ class CompilerFacadeImpl {
         const metadata = {
             name: facade.name,
             type: wrapReference(facade.type),
+            internalType: new WrappedNodeExpr(facade.type),
             typeArgumentCount: 0,
             deps: null,
             pipeName: facade.pipeName,
@@ -20107,6 +18252,7 @@ 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'),
@@ -20122,6 +18268,7 @@ 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'),
@@ -20137,6 +18284,7 @@ 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,
@@ -20152,8 +18300,9 @@ 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,
@@ -20198,10 +18347,6 @@ 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,
@@ -20230,6 +18375,7 @@ 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,
@@ -20240,6 +18386,7 @@ 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,
@@ -20299,8 +18446,8 @@ function convertQueryPredicate(predicate) {
         createMayBeForwardRefExpression(new WrappedNodeExpr(predicate), 1 /* ForwardRefHandling.Wrapped */);
 }
 function convertDirectiveFacadeToMetadata(facade) {
-    const inputsFromMetadata = parseInputsArray(facade.inputs || []);
-    const outputsFromMetadata = parseMappingStringArray(facade.outputs || []);
+    const inputsFromMetadata = parseInputOutputs(facade.inputs || []);
+    const outputsFromMetadata = parseInputOutputs(facade.outputs || []);
     const propMetadata = facade.propMetadata;
     const inputsFromType = {};
     const outputsFromType = {};
@@ -20308,15 +18455,11 @@ function convertDirectiveFacadeToMetadata(facade) {
         if (propMetadata.hasOwnProperty(field)) {
             propMetadata[field].forEach(ann => {
                 if (isInput(ann)) {
-                    inputsFromType[field] = {
-                        bindingPropertyName: ann.alias || field,
-                        classPropertyName: field,
-                        required: ann.required || false,
-                        transformFunction: ann.transform != null ? new WrappedNodeExpr(ann.transform) : null,
-                    };
+                    inputsFromType[field] =
+                        ann.bindingPropertyName ? [ann.bindingPropertyName, field] : field;
                 }
                 else if (isOutput(ann)) {
-                    outputsFromType[field] = ann.alias || field;
+                    outputsFromType[field] = ann.bindingPropertyName || field;
                 }
             });
         }
@@ -20326,6 +18469,7 @@ 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 },
@@ -20342,8 +18486,9 @@ 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 ? inputsMappingToInputMetadata(declaration.inputs) : {},
+        inputs: declaration.inputs ?? {},
         outputs: declaration.outputs ?? {},
         host: convertHostDeclarationToMetadata(declaration.host),
         queries: (declaration.queries ?? []).map(convertQueryDeclarationToMetadata),
@@ -20357,7 +18502,6 @@ function convertDeclareDirectiveFacadeToMetadata(declaration, typeSourceSpan) {
         typeArgumentCount: 0,
         fullInheritance: false,
         isStandalone: declaration.isStandalone ?? false,
-        isSignal: declaration.isSignal ?? false,
         hostDirectives: convertHostDirectivesToMetadata(declaration),
     };
 }
@@ -20385,8 +18529,8 @@ function convertHostDirectivesToMetadata(metadata) {
                 {
                     directive: wrapReference(hostDirective.directive),
                     isForwardReference: false,
-                    inputs: hostDirective.inputs ? parseMappingStringArray(hostDirective.inputs) : null,
-                    outputs: hostDirective.outputs ? parseMappingStringArray(hostDirective.outputs) : null,
+                    inputs: hostDirective.inputs ? parseInputOutputs(hostDirective.inputs) : null,
+                    outputs: hostDirective.outputs ? parseInputOutputs(hostDirective.outputs) : null,
                 };
         });
     }
@@ -20432,10 +18576,6 @@ 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,
@@ -20483,7 +18623,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, enabledBlockTypes });
+    const parsed = parseTemplate(template, sourceMapUrl, { preserveWhitespaces, interpolationConfig });
     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}`);
@@ -20582,67 +18722,18 @@ function isInput(value) {
 function isOutput(value) {
     return value.ngMetadataName === 'Output';
 }
-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) {
+function parseInputOutputs(values) {
     return values.reduce((results, value) => {
-        const [alias, fieldName] = parseMappingString(value);
-        results[fieldName] = alias;
+        const [field, property] = value.split(':', 2).map(str => str.trim());
+        results[field] = property || field;
         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,
@@ -20654,6 +18745,7 @@ 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,
@@ -20672,7 +18764,7 @@ function publishFacade(global) {
  * @description
  * Entry point for all public APIs of the compiler package.
  */
-new Version('16.2.12');
+new Version('15.2.9');
 var _VisitorMode;
 (function (_VisitorMode) {
     _VisitorMode[_VisitorMode["Extract"] = 0] = "Extract";