@wavemaker-ai/angular-codegen 1.0.0-rc.330 → 1.0.0-rc.334

package/dependencies/transpilation-web.cjs.js

@@ -1,7 +1,7 @@
 'use strict';
 
 /**
- * @license Angular v20.3.19
+ * @license Angular v20.3.28
  * (c) 2010-2025 Google LLC. https://angular.dev/
  * License: MIT
  */
@@ -408,6 +408,151 @@ class SelectorlessMatcher {
         return this.registry.has(name) ? this.registry.get(name) : [];
     }
 }
+
+/**
+ * A SecurityContext marks a location that has dangerous security implications, e.g. a DOM property
+ * like `innerHTML` that could cause Cross Site Scripting (XSS) security bugs when improperly
+ * handled.
+ *
+ * See DomSanitizer for more details on security in Angular applications.
+ *
+ * @publicApi
+ */
+var SecurityContext$1;
+(function (SecurityContext) {
+    SecurityContext[SecurityContext["NONE"] = 0] = "NONE";
+    SecurityContext[SecurityContext["HTML"] = 1] = "HTML";
+    SecurityContext[SecurityContext["STYLE"] = 2] = "STYLE";
+    SecurityContext[SecurityContext["SCRIPT"] = 3] = "SCRIPT";
+    SecurityContext[SecurityContext["URL"] = 4] = "URL";
+    SecurityContext[SecurityContext["RESOURCE_URL"] = 5] = "RESOURCE_URL";
+    SecurityContext[SecurityContext["ATTRIBUTE_NO_BINDING"] = 6] = "ATTRIBUTE_NO_BINDING";
+})(SecurityContext$1 || (SecurityContext$1 = {}));
+// =================================================================================================
+// =================================================================================================
+// =========== S T O P   -  S T O P   -  S T O P   -  S T O P   -  S T O P   -  S T O P  ===========
+// =================================================================================================
+// =================================================================================================
+//
+//        DO NOT EDIT THIS LIST OF SECURITY SENSITIVE PROPERTIES WITHOUT A SECURITY REVIEW!
+//
+// =================================================================================================
+/**
+ *  Map from tagName|propertyName to SecurityContext. Properties applying to all tags use '*'.
+ */
+let _SECURITY_SCHEMA$1;
+const SVG_NAMESPACE$1$1 = 'svg';
+const MATH_ML_NAMESPACE$1$1 = 'math';
+/**
+ * @remarks Keep is a copy of DOM Security Schema.
+ * @see [SECURITY_SCHEMA](../../../compiler/src/schema/dom_security_schema.ts)
+ */
+function SECURITY_SCHEMA$1() {
+    if (!_SECURITY_SCHEMA$1) {
+        _SECURITY_SCHEMA$1 = {};
+        // Case is insignificant below, all element and attribute names are lower-cased for lookup.
+        registerContext$1(SecurityContext$1.HTML, /** Namespace */ undefined, [
+            ['iframe', ['srcdoc']],
+            ['*', ['innerHTML', 'outerHTML']],
+        ]);
+        registerContext$1(SecurityContext$1.STYLE, /** Namespace */ undefined, [['*', ['style']]]);
+        // NB: no SCRIPT contexts here, they are never allowed due to the parser stripping them.
+        registerContext$1(SecurityContext$1.URL, /** Namespace */ undefined, [
+            ['*', ['formAction']],
+            ['area', ['href']],
+            ['a', ['href', 'xlink:href']],
+            ['form', ['action']],
+            // The below two items are safe and should be removed but they require a G3 clean-up as a small number of tests fail.
+            ['img', ['src']],
+            ['video', ['src']],
+        ]);
+        registerContext$1(SecurityContext$1.URL, MATH_ML_NAMESPACE$1$1, [
+            // MathML namespace
+            // https://crsrc.org/c/third_party/blink/renderer/core/sanitizer/sanitizer.cc;l=753-768;drc=b3eb16372dcd3317d65e9e0265015e322494edcd;bpv=1;bpt=1
+            ['*', ['href', 'xlink:href']],
+            ['annotation', ['href', 'xlink:href']],
+            ['annotation-xml', ['href', 'xlink:href']],
+            ['maction', ['href', 'xlink:href']],
+            ['malignmark', ['href', 'xlink:href']],
+            ['math', ['href', 'xlink:href']],
+            ['mroot', ['href', 'xlink:href']],
+            ['msqrt', ['href', 'xlink:href']],
+            ['merror', ['href', 'xlink:href']],
+            ['mfrac', ['href', 'xlink:href']],
+            ['mglyph', ['href', 'xlink:href']],
+            ['msub', ['href', 'xlink:href']],
+            ['msup', ['href', 'xlink:href']],
+            ['msubsup', ['href', 'xlink:href']],
+            ['mmultiscripts', ['href', 'xlink:href']],
+            ['mprescripts', ['href', 'xlink:href']],
+            ['mi', ['href', 'xlink:href']],
+            ['mn', ['href', 'xlink:href']],
+            ['mo', ['href', 'xlink:href']],
+            ['mpadded', ['href', 'xlink:href']],
+            ['mphantom', ['href', 'xlink:href']],
+            ['mrow', ['href', 'xlink:href']],
+            ['ms', ['href', 'xlink:href']],
+            ['mspace', ['href', 'xlink:href']],
+            ['mstyle', ['href', 'xlink:href']],
+            ['mtable', ['href', 'xlink:href']],
+            ['mtd', ['href', 'xlink:href']],
+            ['mtr', ['href', 'xlink:href']],
+            ['mtext', ['href', 'xlink:href']],
+            ['mover', ['href', 'xlink:href']],
+            ['munder', ['href', 'xlink:href']],
+            ['munderover', ['href', 'xlink:href']],
+            ['semantics', ['href', 'xlink:href']],
+            ['none', ['href', 'xlink:href']],
+        ]);
+        registerContext$1(SecurityContext$1.RESOURCE_URL, /** Namespace */ undefined, [
+            ['base', ['href']],
+            ['embed', ['src']],
+            ['frame', ['src']],
+            ['iframe', ['src']],
+            ['link', ['href']],
+            ['object', ['codebase', 'data']],
+        ]);
+        registerContext$1(SecurityContext$1.URL, SVG_NAMESPACE$1$1, [['a', ['href', 'xlink:href']]]);
+        // Keep this in sync with SECURITY_SENSITIVE_ELEMENTS in packages/core/src/sanitization/sanitization.ts
+        // Unknown is the internal tag name for unknown elements example used for host-bindings.
+        // These are unsafe as `attributeName` can be `href` or `xlink:href`
+        // See: http://b/463880509#comment7
+        registerContext$1(SecurityContext$1.ATTRIBUTE_NO_BINDING, SVG_NAMESPACE$1$1, [
+            ['animate', ['attributeName', 'values', 'to', 'from']],
+            ['set', ['to', 'attributeName']],
+            ['animateMotion', ['attributeName']],
+            ['animateTransform', ['attributeName']],
+        ]);
+        registerContext$1(SecurityContext$1.ATTRIBUTE_NO_BINDING, /** Namespace */ undefined, [
+            [
+                'unknown',
+                [
+                    'attributeName',
+                    'values',
+                    'to',
+                    'from',
+                    'sandbox',
+                    'allow',
+                    'allowFullscreen',
+                    'referrerPolicy',
+                    'csp',
+                    'fetchPriority',
+                ],
+            ],
+            ['iframe', ['sandbox', 'allow', 'allowFullscreen', 'referrerPolicy', 'csp', 'fetchPriority']],
+        ]);
+    }
+    return _SECURITY_SCHEMA$1;
+}
+function registerContext$1(ctx, namespace, specs) {
+    for (const [element, attributeNames] of specs) {
+        let tagName = namespace && element !== 'unknown' ? `:${namespace}:${element}` : element;
+        tagName = tagName.toLowerCase();
+        for (const attr of attributeNames) {
+            _SECURITY_SCHEMA$1[`${tagName}|${attr.toLowerCase()}`] = ctx;
+        }
+    }
+}
 var ViewEncapsulation$1$1;
 (function (ViewEncapsulation) {
     ViewEncapsulation[ViewEncapsulation["Emulated"] = 0] = "Emulated";
@@ -433,16 +578,6 @@ const CUSTOM_ELEMENTS_SCHEMA$1 = {
 const NO_ERRORS_SCHEMA$1 = {
     name: 'no-errors-schema',
 };
-var SecurityContext$1;
-(function (SecurityContext) {
-    SecurityContext[SecurityContext["NONE"] = 0] = "NONE";
-    SecurityContext[SecurityContext["HTML"] = 1] = "HTML";
-    SecurityContext[SecurityContext["STYLE"] = 2] = "STYLE";
-    SecurityContext[SecurityContext["SCRIPT"] = 3] = "SCRIPT";
-    SecurityContext[SecurityContext["URL"] = 4] = "URL";
-    SecurityContext[SecurityContext["RESOURCE_URL"] = 5] = "RESOURCE_URL";
-    SecurityContext[SecurityContext["ATTRIBUTE_NO_BINDING"] = 6] = "ATTRIBUTE_NO_BINDING";
-})(SecurityContext$1 || (SecurityContext$1 = {}));
 var MissingTranslationStrategy$1;
 (function (MissingTranslationStrategy) {
     MissingTranslationStrategy[MissingTranslationStrategy["Error"] = 0] = "Error";
@@ -4277,7 +4412,7 @@ var TagContentType;
     TagContentType[TagContentType["ESCAPABLE_RAW_TEXT"] = 1] = "ESCAPABLE_RAW_TEXT";
     TagContentType[TagContentType["PARSABLE_DATA"] = 2] = "PARSABLE_DATA";
 })(TagContentType || (TagContentType = {}));
-function splitNsName(elementName, fatal = true) {
+function splitNsName$1(elementName, fatal = true) {
     if (elementName[0] != ':') {
         return [null, elementName];
     }
@@ -4294,18 +4429,18 @@ function splitNsName(elementName, fatal = true) {
 }
 // `<ng-container>` tags work the same regardless the namespace
 function isNgContainer(tagName) {
-    return splitNsName(tagName)[1] === 'ng-container';
+    return splitNsName$1(tagName)[1] === 'ng-container';
 }
 // `<ng-content>` tags work the same regardless the namespace
 function isNgContent(tagName) {
-    return splitNsName(tagName)[1] === 'ng-content';
+    return splitNsName$1(tagName)[1] === 'ng-content';
 }
 // `<ng-template>` tags work the same regardless the namespace
 function isNgTemplate(tagName) {
-    return splitNsName(tagName)[1] === 'ng-template';
+    return splitNsName$1(tagName)[1] === 'ng-template';
 }
 function getNsPrefix(fullName) {
-    return fullName === null ? null : splitNsName(fullName)[0];
+    return fullName === null ? null : splitNsName$1(fullName)[0];
 }
 function mergeNsAndName(prefix, localName) {
     return prefix ? `:${prefix}:${localName}` : localName;
@@ -5363,10 +5498,10 @@ function createCssSelectorFromNode(node) {
     const elementName = node instanceof Element$1 ? node.name : 'ng-template';
     const attributes = getAttrsForDirectiveMatching(node);
     const cssSelector = new CssSelector();
-    const elementNameNoNs = splitNsName(elementName)[1];
+    const elementNameNoNs = splitNsName$1(elementName)[1];
     cssSelector.setElement(elementNameNoNs);
     Object.getOwnPropertyNames(attributes).forEach((name) => {
-        const nameNoNs = splitNsName(name)[1];
+        const nameNoNs = splitNsName$1(name)[1];
         const value = attributes[name];
         cssSelector.addAttribute(nameNoNs, value);
         if (name.toLowerCase() === 'class') {
@@ -11013,7 +11148,7 @@ function specializeBindings(job) {
                         OpList.replace(op, createAnimationBindingOp(op.name, op.target, op.name === 'animate.enter' ? "enter" /* ir.AnimationKind.ENTER */ : "leave" /* ir.AnimationKind.LEAVE */, op.expression, op.securityContext, op.sourceSpan, 0 /* ir.AnimationBindingKind.STRING */));
                     }
                     else {
-                        const [namespace, name] = splitNsName(op.name);
+                        const [namespace, name] = splitNsName$1(op.name);
                         OpList.replace(op, createAttributeOp(op.target, namespace, name, op.expression, op.securityContext, op.isTextAttribute, op.isStructuralTemplateAttribute, op.templateKind, op.i18nMessage, op.sourceSpan));
                     }
                     break;
@@ -11451,10 +11586,7 @@ class ElementAttributes {
             if (value === null) {
                 throw Error('Attribute, i18n attribute, & style element attributes must have a value');
             }
-            if (trustedValueFn !== null) {
-                if (!isStringLiteral(value)) {
-                    throw Error('AssertionError: extracted attribute value should be string literal');
-                }
+            if (trustedValueFn !== null && isStringLiteral(value)) {
                 array.push(taggedTemplate(trustedValueFn, new TemplateLiteralExpr([new TemplateLiteralElementExpr(value.value)], []), undefined, value.sourceSpan));
             }
             else {
@@ -17116,7 +17248,7 @@ class _TreeBuilder {
         if (!prefix && parent) {
             const parentName = parent instanceof Element$2 ? parent.name : parent.tagName;
             if (parentName !== null) {
-                const parentTagName = splitNsName(parentName)[1];
+                const parentTagName = splitNsName$1(parentName)[1];
                 const parentTagDefinition = this._getTagDefinition(parentTagName);
                 if (parentTagDefinition !== null && !parentTagDefinition.preventNamespaceInheritance) {
                     prefix = getNsPrefix(parentName);
@@ -19409,162 +19541,8 @@ function interleave(left, right) {
     return result;
 }
 
-// =================================================================================================
-// =================================================================================================
-// =========== S T O P   -  S T O P   -  S T O P   -  S T O P   -  S T O P   -  S T O P  ===========
-// =================================================================================================
-// =================================================================================================
-//
-//        DO NOT EDIT THIS LIST OF SECURITY SENSITIVE PROPERTIES WITHOUT A SECURITY REVIEW!
-//
-// =================================================================================================
-/** Map from tagName|propertyName to SecurityContext. Properties applying to all tags use '*'. */
-let _SECURITY_SCHEMA;
-function SECURITY_SCHEMA() {
-    if (!_SECURITY_SCHEMA) {
-        _SECURITY_SCHEMA = {};
-        // Case is insignificant below, all element and attribute names are lower-cased for lookup.
-        registerContext(SecurityContext$1.HTML, ['iframe|srcdoc', '*|innerHTML', '*|outerHTML']);
-        registerContext(SecurityContext$1.STYLE, ['*|style']);
-        // NB: no SCRIPT contexts here, they are never allowed due to the parser stripping them.
-        registerContext(SecurityContext$1.URL, [
-            '*|formAction',
-            'area|href',
-            'area|ping',
-            'audio|src',
-            'a|href',
-            'a|xlink:href',
-            'a|ping',
-            'blockquote|cite',
-            'body|background',
-            'del|cite',
-            'form|action',
-            'img|src',
-            'input|src',
-            'ins|cite',
-            'q|cite',
-            'source|src',
-            'track|src',
-            'video|poster',
-            'video|src',
-            // MathML namespace
-            // https://crsrc.org/c/third_party/blink/renderer/core/sanitizer/sanitizer.cc;l=753-768;drc=b3eb16372dcd3317d65e9e0265015e322494edcd;bpv=1;bpt=1
-            'annotation|href',
-            'annotation|xlink:href',
-            'annotation-xml|href',
-            'annotation-xml|xlink:href',
-            'maction|href',
-            'maction|xlink:href',
-            'malignmark|href',
-            'malignmark|xlink:href',
-            'math|href',
-            'math|xlink:href',
-            'mroot|href',
-            'mroot|xlink:href',
-            'msqrt|href',
-            'msqrt|xlink:href',
-            'merror|href',
-            'merror|xlink:href',
-            'mfrac|href',
-            'mfrac|xlink:href',
-            'mglyph|href',
-            'mglyph|xlink:href',
-            'msub|href',
-            'msub|xlink:href',
-            'msup|href',
-            'msup|xlink:href',
-            'msubsup|href',
-            'msubsup|xlink:href',
-            'mmultiscripts|href',
-            'mmultiscripts|xlink:href',
-            'mprescripts|href',
-            'mprescripts|xlink:href',
-            'mi|href',
-            'mi|xlink:href',
-            'mn|href',
-            'mn|xlink:href',
-            'mo|href',
-            'mo|xlink:href',
-            'mpadded|href',
-            'mpadded|xlink:href',
-            'mphantom|href',
-            'mphantom|xlink:href',
-            'mrow|href',
-            'mrow|xlink:href',
-            'ms|href',
-            'ms|xlink:href',
-            'mspace|href',
-            'mspace|xlink:href',
-            'mstyle|href',
-            'mstyle|xlink:href',
-            'mtable|href',
-            'mtable|xlink:href',
-            'mtd|href',
-            'mtd|xlink:href',
-            'mtr|href',
-            'mtr|xlink:href',
-            'mtext|href',
-            'mtext|xlink:href',
-            'mover|href',
-            'mover|xlink:href',
-            'munder|href',
-            'munder|xlink:href',
-            'munderover|href',
-            'munderover|xlink:href',
-            'semantics|href',
-            'semantics|xlink:href',
-            'none|href',
-            'none|xlink:href',
-        ]);
-        registerContext(SecurityContext$1.RESOURCE_URL, [
-            'applet|code',
-            'applet|codebase',
-            'base|href',
-            'embed|src',
-            'frame|src',
-            'head|profile',
-            'html|manifest',
-            'iframe|src',
-            'link|href',
-            'media|src',
-            'object|codebase',
-            'object|data',
-            'script|src',
-            // The below two are for Script SVG
-            // See: https://developer.mozilla.org/en-US/docs/Web/API/SVGScriptElement/href
-            'script|href',
-            'script|xlink:href',
-        ]);
-        // Keep this in sync with SECURITY_SENSITIVE_ELEMENTS in packages/core/src/sanitization/sanitization.ts
-        // Unknown is the internal tag name for unknown elements example used for host-bindings.
-        // These are unsafe as `attributeName` can be `href` or `xlink:href`
-        // See: http://b/463880509#comment7
-        registerContext(SecurityContext$1.ATTRIBUTE_NO_BINDING, [
-            'animate|attributeName',
-            'set|attributeName',
-            'animateMotion|attributeName',
-            'animateTransform|attributeName',
-            'unknown|attributeName',
-            'iframe|sandbox',
-            'iframe|allow',
-            'iframe|allowFullscreen',
-            'iframe|referrerPolicy',
-            'iframe|csp',
-            'iframe|fetchPriority',
-            'unknown|sandbox',
-            'unknown|allow',
-            'unknown|allowFullscreen',
-            'unknown|referrerPolicy',
-            'unknown|csp',
-            'unknown|fetchPriority',
-        ]);
-    }
-    return _SECURITY_SCHEMA;
-}
-function registerContext(ctx, specs) {
-    for (const spec of specs)
-        _SECURITY_SCHEMA[spec.toLowerCase()] = ctx;
-}
+const SVG_NAMESPACE$2 = 'svg';
+const MATH_ML_NAMESPACE$2 = 'math';
 
 class ElementSchemaRegistry {
 }
@@ -19573,6 +19551,11 @@ const BOOLEAN = 'boolean';
 const NUMBER = 'number';
 const STRING = 'string';
 const OBJECT = 'object';
+function normalizeTagName$1(tagName) {
+    const tagNameLower = tagName.toLowerCase();
+    const [ns, name] = splitNsName$1(tagNameLower, false);
+    return ns === SVG_NAMESPACE$2 || ns === MATH_ML_NAMESPACE$2 ? `:${ns}:${name}` : name;
+}
 /**
  * This array represents the DOM schema. It encodes inheritance, properties, and events.
  *
@@ -19918,8 +19901,9 @@ class DomElementSchemaRegistry extends ElementSchemaRegistry {
         if (schemaMetas.some((schema) => schema.name === NO_ERRORS_SCHEMA$1.name)) {
             return true;
         }
-        if (tagName.indexOf('-') > -1) {
-            if (isNgContainer(tagName) || isNgContent(tagName)) {
+        const normalizedTag = normalizeTagName$1(tagName);
+        if (normalizedTag.includes('-')) {
+            if (isNgContainer(normalizedTag) || isNgContent(normalizedTag)) {
                 return false;
             }
             if (schemaMetas.some((schema) => schema.name === CUSTOM_ELEMENTS_SCHEMA$1.name)) {
@@ -19928,15 +19912,16 @@ class DomElementSchemaRegistry extends ElementSchemaRegistry {
                 return true;
             }
         }
-        const elementProperties = this._schema.get(tagName.toLowerCase()) || this._schema.get('unknown');
+        const elementProperties = this._schema.get(normalizedTag) || this._schema.get('unknown');
         return elementProperties.has(propName);
     }
     hasElement(tagName, schemaMetas) {
         if (schemaMetas.some((schema) => schema.name === NO_ERRORS_SCHEMA$1.name)) {
             return true;
         }
-        if (tagName.indexOf('-') > -1) {
-            if (isNgContainer(tagName) || isNgContent(tagName)) {
+        const normalizedTag = normalizeTagName$1(tagName);
+        if (normalizedTag.includes('-')) {
+            if (isNgContainer(normalizedTag) || isNgContent(normalizedTag)) {
                 return true;
             }
             if (schemaMetas.some((schema) => schema.name === CUSTOM_ELEMENTS_SCHEMA$1.name)) {
@@ -19944,7 +19929,7 @@ class DomElementSchemaRegistry extends ElementSchemaRegistry {
                 return true;
             }
         }
-        return this._schema.has(tagName.toLowerCase());
+        return this._schema.has(normalizedTag);
     }
     /**
      * securityContext returns the security context for the given property on the given DOM tag.
@@ -19961,16 +19946,15 @@ class DomElementSchemaRegistry extends ElementSchemaRegistry {
             // NB: For security purposes, use the mapped property name, not the attribute name.
             propName = this.getMappedPropName(propName);
         }
-        // Make sure comparisons are case insensitive, so that case differences between attribute and
-        // property names do not have a security impact.
-        tagName = tagName.toLowerCase();
+        const normalizedTag = normalizeTagName$1(tagName);
         propName = propName.toLowerCase();
-        let ctx = SECURITY_SCHEMA()[tagName + '|' + propName];
-        if (ctx) {
-            return ctx;
-        }
-        ctx = SECURITY_SCHEMA()['*|' + propName];
-        return ctx ? ctx : SecurityContext$1.NONE;
+        const [namespace] = splitNsName$1(normalizedTag, false);
+        const securitySchema = SECURITY_SCHEMA$1();
+        const ctx = securitySchema[normalizedTag + '|' + propName] ??
+            (namespace ? securitySchema[`:${namespace}:*|${propName}`] : undefined) ??
+            securitySchema['*|' + propName] ??
+            SecurityContext$1.NONE;
+        return ctx;
     }
     getMappedPropName(propName) {
         return _ATTR_TO_PROP.get(propName) ?? propName;
@@ -20004,12 +19988,14 @@ class DomElementSchemaRegistry extends ElementSchemaRegistry {
         return Array.from(this._schema.keys());
     }
     allKnownAttributesOfElement(tagName) {
-        const elementProperties = this._schema.get(tagName.toLowerCase()) || this._schema.get('unknown');
+        const normalizedTag = normalizeTagName$1(tagName);
+        const elementProperties = this._schema.get(normalizedTag) || this._schema.get('unknown');
         // Convert properties to attributes.
         return Array.from(elementProperties.keys()).map((prop) => _PROP_TO_ATTR.get(prop) ?? prop);
     }
     allKnownEventsOfElement(tagName) {
-        return Array.from(this._eventSchema.get(tagName.toLowerCase()) ?? []);
+        const normalizedTag = normalizeTagName$1(tagName);
+        return Array.from(this._eventSchema.get(normalizedTag) ?? []);
     }
     normalizeAnimationStyleProperty(propName) {
         return dashCaseToCamelCase(propName);
@@ -20858,7 +20844,7 @@ class I18nMetaVisitor {
                     else {
                         isTrustedType = isTrustedTypesSink(node.name, name);
                     }
-                    if (isTrustedType) {
+                    if (isTrustedType || isPossibleEventHandler(name)) {
                         this._reportError(attr, `Translating attribute '${name}' is disallowed for security reasons.`);
                     }
                     else {
@@ -20989,6 +20975,16 @@ function i18nMetaToJSDoc(meta) {
     }
     return jsDocComment(tags);
 }
+/**
+ * Check if the propertyName is a potential event handler.
+ * We consider a property to be a potential event handler if its name is longer than 2 characters and starts with 'on' (e.g. 'onclick', 'onload', etc.).
+ * @param propertyName The name of the property to check.
+ * @returns True if the property is a potential event handler, false otherwise.
+ */
+function isPossibleEventHandler(propertyName) {
+    const name = propertyName.toLowerCase();
+    return name.length > 2 && name !== 'only' && name.startsWith('on');
+}
 
 /** Closure uses `goog.getMsg(message)` to lookup translations */
 const GOOG_GET_MSG = 'goog.getMsg';
@@ -24214,6 +24210,61 @@ function updatePlaceholder(op, value, i18nContexts, icuPlaceholders) {
     }
 }
 
+/**
+ * Wraps static i18n extracted attributes in their corresponding sanitizers/validators.
+ */
+function resolveI18nAttrSanitizers(job) {
+    const tagNamesByElement = new Map();
+    for (const unit of job.units) {
+        for (const op of unit.ops()) {
+            if (op.kind === OpKind.ElementStart || op.kind === OpKind.Template) {
+                let tag = op.tag ?? '';
+                switch (op.namespace) {
+                    case Namespace.SVG:
+                        tag = `:${SVG_NAMESPACE$2}:${tag}`;
+                        break;
+                    case Namespace.Math:
+                        tag = `:${MATH_ML_NAMESPACE$2}:${tag}`;
+                        break;
+                }
+                tagNamesByElement.set(op.xref, tag);
+            }
+        }
+    }
+    for (const unit of job.units) {
+        for (const op of unit.create) {
+            if (op.kind === OpKind.ExtractedAttribute &&
+                op.i18nContext !== null &&
+                op.expression !== null) {
+                const tagName = tagNamesByElement.get(op.target) ?? '';
+                let expr = op.expression;
+                switch (op.securityContext) {
+                    case SecurityContext$1.HTML:
+                        expr = importExpr(Identifiers.sanitizeHtml).callFn([expr]);
+                        break;
+                    case SecurityContext$1.STYLE:
+                        expr = importExpr(Identifiers.sanitizeStyle).callFn([expr]);
+                        break;
+                    case SecurityContext$1.SCRIPT:
+                        expr = importExpr(Identifiers.sanitizeScript).callFn([expr]);
+                        break;
+                    case SecurityContext$1.URL:
+                        expr = importExpr(Identifiers.sanitizeUrl).callFn([expr]);
+                        break;
+                    case SecurityContext$1.RESOURCE_URL:
+                        expr = importExpr(Identifiers.sanitizeResourceUrl).callFn([expr]);
+                        break;
+                    case SecurityContext$1.ATTRIBUTE_NO_BINDING:
+                        expr = importExpr(Identifiers.validateAttribute)
+                            .callFn([expr, literal(tagName), literal(op.name)]);
+                        break;
+                }
+                op.expression = expr;
+            }
+        }
+    }
+}
+
 /**
  * Resolves lexical references in views (`ir.LexicalReadExpr`) to either a target variable or to
  * property reads on the top-level component context.
@@ -24379,15 +24430,14 @@ function resolveSanitizers(job) {
                 case OpKind.Property:
                 case OpKind.Attribute:
                 case OpKind.DomProperty:
+                case OpKind.TwoWayProperty:
                     let sanitizerFn = null;
                     if (Array.isArray(op.securityContext) &&
-                        op.securityContext.length === 2 &&
-                        op.securityContext.includes(SecurityContext$1.URL) &&
-                        op.securityContext.includes(SecurityContext$1.RESOURCE_URL)) {
-                        // When the host element isn't known, some URL attributes (such as "src" and "href") may
-                        // be part of multiple different security contexts. In this case we use special
-                        // sanitization function and select the actual sanitizer at runtime based on a tag name
-                        // that is provided while invoking sanitization function.
+                        hasCompositeUrlSecurityContext(op.securityContext)) {
+                        // When the host element isn't known, attributes such as `href`, `src`, `data`,
+                        // `action`, and `codebase` may be part of multiple security contexts. In this case we
+                        // use a special sanitization function and select the actual behavior at runtime based
+                        // on the concrete host element.
                         sanitizerFn = Identifiers.sanitizeUrlOrResourceUrl;
                     }
                     else {
@@ -24399,21 +24449,47 @@ function resolveSanitizers(job) {
         }
     }
 }
+function hasCompositeUrlSecurityContext(securityContext) {
+    let hasUrlContext = false;
+    let hasResourceUrlContext = false;
+    let hasNoneContext = false;
+    for (const context of securityContext) {
+        switch (context) {
+            case SecurityContext$1.URL:
+                hasUrlContext = true;
+                break;
+            case SecurityContext$1.RESOURCE_URL:
+                hasResourceUrlContext = true;
+                break;
+            case SecurityContext$1.NONE:
+                hasNoneContext = true;
+                break;
+            default:
+                return false;
+        }
+    }
+    return (((hasUrlContext || hasResourceUrlContext) && hasNoneContext) ||
+        (hasUrlContext && hasResourceUrlContext));
+}
 /**
- * Asserts that there is only a single security context and returns it.
+ * Asserts that there is only a single non-NONE security context and returns it.
  */
 function getOnlySecurityContext(securityContext) {
-    if (Array.isArray(securityContext)) {
-        if (securityContext.length > 1) {
-            // TODO: What should we do here? TDB just took the first one, but this feels like something we
-            // would want to know about and create a special case for like we did for Url/ResourceUrl. My
-            // guess is that, outside of the Url/ResourceUrl case, this never actually happens. If there
-            // do turn out to be other cases, throwing an error until we can address it feels safer.
-            throw Error(`AssertionError: Ambiguous security context`);
-        }
-        return securityContext[0] || SecurityContext$1.NONE;
+    if (!Array.isArray(securityContext)) {
+        return securityContext;
+    }
+    if (securityContext.length < 2) {
+        return securityContext[0] ?? SecurityContext$1.NONE;
     }
-    return securityContext;
+    const nonNoneSecurityContexts = securityContext.filter((context) => context !== SecurityContext$1.NONE);
+    if (nonNoneSecurityContexts.length > 1) {
+        // TODO: What should we do here? TDB just took the first one, but this feels like something we
+        // would want to know about and create a special case for like we did for Url/ResourceUrl. My
+        // guess is that, outside of the Url/ResourceUrl case, this never actually happens. If there
+        // do turn out to be other cases, throwing an error until we can address it feels safer.
+        throw Error(`AssertionError: Ambiguous security context`);
+    }
+    return nonNoneSecurityContexts[0] ?? SecurityContext$1.NONE;
 }
 
 /**
@@ -25613,6 +25689,7 @@ const phases = [
     { kind: CompilationJobKind.Tmpl, fn: resolveI18nExpressionPlaceholders },
     { kind: CompilationJobKind.Tmpl, fn: extractI18nMessages },
     { kind: CompilationJobKind.Tmpl, fn: collectI18nConsts },
+    { kind: CompilationJobKind.Tmpl, fn: resolveI18nAttrSanitizers },
     { kind: CompilationJobKind.Tmpl, fn: collectConstExpressions },
     { kind: CompilationJobKind.Both, fn: collectElementConsts },
     { kind: CompilationJobKind.Tmpl, fn: removeI18nContexts },
@@ -25726,200 +25803,714 @@ function emitHostBindingFunction(job) {
     /* sourceSpan */ undefined, job.root.fnName);
 }
 
-const compatibilityMode = CompatibilityMode.TemplateDefinitionBuilder;
-// Schema containing DOM elements and their properties.
-const domSchema = new DomElementSchemaRegistry();
-// Tag name of the `ng-template` element.
-const NG_TEMPLATE_TAG_NAME = 'ng-template';
-// prefix for any animation binding
-const ANIMATE_PREFIX$1 = 'animate.';
-function isI18nRootNode(meta) {
-    return meta instanceof Message;
-}
-function isSingleI18nIcu(meta) {
-    return isI18nRootNode(meta) && meta.nodes.length === 1 && meta.nodes[0] instanceof Icu;
-}
-/**
- * Process a template AST and convert it into a `ComponentCompilation` in the intermediate
- * representation.
- * TODO: Refactor more of the ingestion code into phases.
- */
-function ingestComponent(componentName, template, constantPool, compilationMode, relativeContextFilePath, i18nUseExternalIds, deferMeta, allDeferrableDepsFn, relativeTemplatePath, enableDebugLocations) {
-    const job = new ComponentCompilationJob(componentName, constantPool, compatibilityMode, compilationMode, relativeContextFilePath, i18nUseExternalIds, deferMeta, allDeferrableDepsFn, relativeTemplatePath, enableDebugLocations);
-    ingestNodes(job.root, template);
-    return job;
-}
+const PROPERTY_PARTS_SEPARATOR = '.';
+const ATTRIBUTE_PREFIX = 'attr';
+const ANIMATE_PREFIX$1 = 'animate';
+const CLASS_PREFIX = 'class';
+const STYLE_PREFIX = 'style';
+const TEMPLATE_ATTR_PREFIX$1 = '*';
+const LEGACY_ANIMATE_PROP_PREFIX = 'animate-';
 /**
- * Process a host binding AST and convert it into a `HostBindingCompilationJob` in the intermediate
- * representation.
+ * Parses bindings in templates and in the directive host area.
  */
-function ingestHostBinding(input, bindingParser, constantPool) {
-    const job = new HostBindingCompilationJob(input.componentName, constantPool, compatibilityMode, TemplateCompilationMode.DomOnly);
-    for (const property of input.properties ?? []) {
-        let bindingKind = BindingKind.Property;
-        // TODO: this should really be handled in the parser.
-        if (property.name.startsWith('attr.')) {
-            property.name = property.name.substring('attr.'.length);
-            bindingKind = BindingKind.Attribute;
-        }
-        if (property.isLegacyAnimation) {
-            bindingKind = BindingKind.LegacyAnimation;
-        }
-        if (property.isAnimation) {
-            bindingKind = BindingKind.Animation;
-        }
-        const securityContexts = bindingParser
-            .calcPossibleSecurityContexts(input.componentSelector, property.name, bindingKind === BindingKind.Attribute)
-            .filter((context) => context !== SecurityContext$1.NONE);
-        ingestDomProperty(job, property, bindingKind, securityContexts);
-    }
-    for (const [name, expr] of Object.entries(input.attributes) ?? []) {
-        const securityContexts = bindingParser
-            .calcPossibleSecurityContexts(input.componentSelector, name, true)
-            .filter((context) => context !== SecurityContext$1.NONE);
-        ingestHostAttribute(job, name, expr, securityContexts);
-    }
-    for (const event of input.events ?? []) {
-        ingestHostEvent(job, event);
+class BindingParser {
+    _exprParser;
+    _interpolationConfig;
+    _schemaRegistry;
+    errors;
+    constructor(_exprParser, _interpolationConfig, _schemaRegistry, errors) {
+        this._exprParser = _exprParser;
+        this._interpolationConfig = _interpolationConfig;
+        this._schemaRegistry = _schemaRegistry;
+        this.errors = errors;
     }
-    return job;
-}
-// TODO: We should refactor the parser to use the same types and structures for host bindings as
-// with ordinary components. This would allow us to share a lot more ingestion code.
-function ingestDomProperty(job, property, bindingKind, securityContexts) {
-    let expression;
-    const ast = property.expression.ast;
-    if (ast instanceof Interpolation$1) {
-        expression = new Interpolation(ast.strings, ast.expressions.map((expr) => convertAst(expr, job, property.sourceSpan)), []);
+    get interpolationConfig() {
+        return this._interpolationConfig;
     }
-    else {
-        expression = convertAst(ast, job, property.sourceSpan);
+    createBoundHostProperties(properties, sourceSpan) {
+        const boundProps = [];
+        for (const propName of Object.keys(properties)) {
+            const expression = properties[propName];
+            if (typeof expression === 'string') {
+                this.parsePropertyBinding(propName, expression, true, false, sourceSpan, sourceSpan.start.offset, undefined, [], 
+                // Use the `sourceSpan` for  `keySpan`. This isn't really accurate, but neither is the
+                // sourceSpan, as it represents the sourceSpan of the host itself rather than the
+                // source of the host binding (which doesn't exist in the template). Regardless,
+                // neither of these values are used in Ivy but are only here to satisfy the function
+                // signature. This should likely be refactored in the future so that `sourceSpan`
+                // isn't being used inaccurately.
+                boundProps, sourceSpan);
+            }
+            else {
+                this._reportError(`Value of the host property binding "${propName}" needs to be a string representing an expression but got "${expression}" (${typeof expression})`, sourceSpan);
+            }
+        }
+        return boundProps;
     }
-    job.root.update.push(createBindingOp(job.root.xref, bindingKind, property.name, expression, null, securityContexts, false, false, null, 
-    /* TODO: How do Host bindings handle i18n attrs? */ null, property.sourceSpan));
-}
-function ingestHostAttribute(job, name, value, securityContexts) {
-    const attrBinding = createBindingOp(job.root.xref, BindingKind.Attribute, name, value, null, securityContexts, 
-    /* Host attributes should always be extracted to const hostAttrs, even if they are not
-     *strictly* text literals */
-    true, false, null, 
-    /* TODO */ null, 
-    /** TODO: May be null? */ value.sourceSpan);
-    job.root.update.push(attrBinding);
-}
-function ingestHostEvent(job, event) {
-    let eventBinding;
-    if (event.type === ParsedEventType.Animation) {
-        eventBinding = createAnimationListenerOp(job.root.xref, new SlotHandle(), event.name, null, makeListenerHandlerOps(job.root, event.handler, event.handlerSpan), event.name.endsWith('enter') ? "enter" /* ir.AnimationKind.ENTER */ : "leave" /* ir.AnimationKind.LEAVE */, event.targetOrPhase, true, event.sourceSpan);
+    createDirectiveHostEventAsts(hostListeners, sourceSpan) {
+        const targetEvents = [];
+        for (const propName of Object.keys(hostListeners)) {
+            const expression = hostListeners[propName];
+            if (typeof expression === 'string') {
+                // Use the `sourceSpan` for  `keySpan` and `handlerSpan`. This isn't really accurate, but
+                // neither is the `sourceSpan`, as it represents the `sourceSpan` of the host itself
+                // rather than the source of the host binding (which doesn't exist in the template).
+                // Regardless, neither of these values are used in Ivy but are only here to satisfy the
+                // function signature. This should likely be refactored in the future so that `sourceSpan`
+                // isn't being used inaccurately.
+                this.parseEvent(propName, expression, 
+                /* isAssignmentEvent */ false, sourceSpan, sourceSpan, [], targetEvents, sourceSpan);
+            }
+            else {
+                this._reportError(`Value of the host listener "${propName}" needs to be a string representing an expression but got "${expression}" (${typeof expression})`, sourceSpan);
+            }
+        }
+        return targetEvents;
     }
-    else {
-        const [phase, target] = event.type !== ParsedEventType.LegacyAnimation
-            ? [null, event.targetOrPhase]
-            : [event.targetOrPhase, null];
-        eventBinding = createListenerOp(job.root.xref, new SlotHandle(), event.name, null, makeListenerHandlerOps(job.root, event.handler, event.handlerSpan), phase, target, true, event.sourceSpan);
+    parseInterpolation(value, sourceSpan, interpolatedTokens) {
+        const absoluteOffset = sourceSpan.fullStart.offset;
+        try {
+            const ast = this._exprParser.parseInterpolation(value, sourceSpan, absoluteOffset, interpolatedTokens, this._interpolationConfig);
+            if (ast) {
+                this.errors.push(...ast.errors);
+            }
+            return ast;
+        }
+        catch (e) {
+            this._reportError(`${e}`, sourceSpan);
+            return this._exprParser.wrapLiteralPrimitive('ERROR', sourceSpan, absoluteOffset);
+        }
     }
-    job.root.create.push(eventBinding);
-}
-/**
- * Ingest the nodes of a template AST into the given `ViewCompilation`.
- */
-function ingestNodes(unit, template) {
-    for (const node of template) {
-        if (node instanceof Element$1) {
-            ingestElement(unit, node);
+    /**
+     * Similar to `parseInterpolation`, but treats the provided string as a single expression
+     * element that would normally appear within the interpolation prefix and suffix (`{{` and `}}`).
+     * This is used for parsing the switch expression in ICUs.
+     */
+    parseInterpolationExpression(expression, sourceSpan) {
+        const absoluteOffset = sourceSpan.start.offset;
+        try {
+            const ast = this._exprParser.parseInterpolationExpression(expression, sourceSpan, absoluteOffset);
+            if (ast) {
+                this.errors.push(...ast.errors);
+            }
+            return ast;
         }
-        else if (node instanceof Template) {
-            ingestTemplate(unit, node);
+        catch (e) {
+            this._reportError(`${e}`, sourceSpan);
+            return this._exprParser.wrapLiteralPrimitive('ERROR', sourceSpan, absoluteOffset);
         }
-        else if (node instanceof Content) {
-            ingestContent(unit, node);
+    }
+    /**
+     * Parses the bindings in a microsyntax expression, and converts them to
+     * `ParsedProperty` or `ParsedVariable`.
+     *
+     * @param tplKey template binding name
+     * @param tplValue template binding value
+     * @param sourceSpan span of template binding relative to entire the template
+     * @param absoluteValueOffset start of the tplValue relative to the entire template
+     * @param targetMatchableAttrs potential attributes to match in the template
+     * @param targetProps target property bindings in the template
+     * @param targetVars target variables in the template
+     */
+    parseInlineTemplateBinding(tplKey, tplValue, sourceSpan, absoluteValueOffset, targetMatchableAttrs, targetProps, targetVars, isIvyAst) {
+        const absoluteKeyOffset = sourceSpan.start.offset + TEMPLATE_ATTR_PREFIX$1.length;
+        const bindings = this._parseTemplateBindings(tplKey, tplValue, sourceSpan, absoluteKeyOffset, absoluteValueOffset);
+        for (const binding of bindings) {
+            // sourceSpan is for the entire HTML attribute. bindingSpan is for a particular
+            // binding within the microsyntax expression so it's more narrow than sourceSpan.
+            const bindingSpan = moveParseSourceSpan(sourceSpan, binding.sourceSpan);
+            const key = binding.key.source;
+            const keySpan = moveParseSourceSpan(sourceSpan, binding.key.span);
+            if (binding instanceof VariableBinding) {
+                const value = binding.value ? binding.value.source : '$implicit';
+                const valueSpan = binding.value
+                    ? moveParseSourceSpan(sourceSpan, binding.value.span)
+                    : undefined;
+                targetVars.push(new ParsedVariable(key, value, bindingSpan, keySpan, valueSpan));
+            }
+            else if (binding.value) {
+                const srcSpan = isIvyAst ? bindingSpan : sourceSpan;
+                const valueSpan = moveParseSourceSpan(sourceSpan, binding.value.ast.sourceSpan);
+                this._parsePropertyAst(key, binding.value, false, srcSpan, keySpan, valueSpan, targetMatchableAttrs, targetProps);
+            }
+            else {
+                targetMatchableAttrs.push([key, '' /* value */]);
+                // Since this is a literal attribute with no RHS, source span should be
+                // just the key span.
+                this.parseLiteralAttr(key, null /* value */, keySpan, absoluteValueOffset, undefined /* valueSpan */, targetMatchableAttrs, targetProps, keySpan);
+            }
         }
-        else if (node instanceof Text$3) {
-            ingestText(unit, node, null);
+    }
+    /**
+     * Parses the bindings in a microsyntax expression, e.g.
+     * ```html
+     *    <tag *tplKey="let value1 = prop; let value2 = localVar">
+     * ```
+     *
+     * @param tplKey template binding name
+     * @param tplValue template binding value
+     * @param sourceSpan span of template binding relative to entire the template
+     * @param absoluteKeyOffset start of the `tplKey`
+     * @param absoluteValueOffset start of the `tplValue`
+     */
+    _parseTemplateBindings(tplKey, tplValue, sourceSpan, absoluteKeyOffset, absoluteValueOffset) {
+        try {
+            const bindingsResult = this._exprParser.parseTemplateBindings(tplKey, tplValue, sourceSpan, absoluteKeyOffset, absoluteValueOffset);
+            bindingsResult.errors.forEach((e) => this.errors.push(e));
+            bindingsResult.warnings.forEach((warning) => {
+                this._reportError(warning, sourceSpan, ParseErrorLevel.WARNING);
+            });
+            return bindingsResult.templateBindings;
         }
-        else if (node instanceof BoundText) {
-            ingestBoundText(unit, node, null);
+        catch (e) {
+            this._reportError(`${e}`, sourceSpan);
+            return [];
         }
-        else if (node instanceof IfBlock) {
-            ingestIfBlock(unit, node);
+    }
+    parseLiteralAttr(name, value, sourceSpan, absoluteOffset, valueSpan, targetMatchableAttrs, targetProps, keySpan) {
+        if (isLegacyAnimationLabel(name)) {
+            name = name.substring(1);
+            if (keySpan !== undefined) {
+                keySpan = moveParseSourceSpan(keySpan, new AbsoluteSourceSpan(keySpan.start.offset + 1, keySpan.end.offset));
+            }
+            if (value) {
+                this._reportError(`Assigning animation triggers via @prop="exp" attributes with an expression is invalid.` +
+                    ` Use property bindings (e.g. [@prop]="exp") or use an attribute without a value (e.g. @prop) instead.`, sourceSpan, ParseErrorLevel.ERROR);
+            }
+            this._parseLegacyAnimation(name, value, sourceSpan, absoluteOffset, keySpan, valueSpan, targetMatchableAttrs, targetProps);
         }
-        else if (node instanceof SwitchBlock) {
-            ingestSwitchBlock(unit, node);
+        else {
+            targetProps.push(new ParsedProperty(name, this._exprParser.wrapLiteralPrimitive(value, '', absoluteOffset), ParsedPropertyType.LITERAL_ATTR, sourceSpan, keySpan, valueSpan));
         }
-        else if (node instanceof DeferredBlock) {
-            ingestDeferBlock(unit, node);
+    }
+    parsePropertyBinding(name, expression, isHost, isPartOfAssignmentBinding, sourceSpan, absoluteOffset, valueSpan, targetMatchableAttrs, targetProps, keySpan) {
+        if (name.length === 0) {
+            this._reportError(`Property name is missing in binding`, sourceSpan);
         }
-        else if (node instanceof Icu$1) {
-            ingestIcu(unit, node);
+        let isLegacyAnimationProp = false;
+        if (name.startsWith(LEGACY_ANIMATE_PROP_PREFIX)) {
+            isLegacyAnimationProp = true;
+            name = name.substring(LEGACY_ANIMATE_PROP_PREFIX.length);
+            if (keySpan !== undefined) {
+                keySpan = moveParseSourceSpan(keySpan, new AbsoluteSourceSpan(keySpan.start.offset + LEGACY_ANIMATE_PROP_PREFIX.length, keySpan.end.offset));
+            }
         }
-        else if (node instanceof ForLoopBlock) {
-            ingestForBlock(unit, node);
+        else if (isLegacyAnimationLabel(name)) {
+            isLegacyAnimationProp = true;
+            name = name.substring(1);
+            if (keySpan !== undefined) {
+                keySpan = moveParseSourceSpan(keySpan, new AbsoluteSourceSpan(keySpan.start.offset + 1, keySpan.end.offset));
+            }
         }
-        else if (node instanceof LetDeclaration$1) {
-            ingestLetDeclaration(unit, node);
+        if (isLegacyAnimationProp) {
+            this._parseLegacyAnimation(name, expression, sourceSpan, absoluteOffset, keySpan, valueSpan, targetMatchableAttrs, targetProps);
+        }
+        else if (name.startsWith(`${ANIMATE_PREFIX$1}${PROPERTY_PARTS_SEPARATOR}`)) {
+            this._parseAnimation(name, this.parseBinding(expression, isHost, valueSpan || sourceSpan, absoluteOffset), sourceSpan, keySpan, valueSpan, targetMatchableAttrs, targetProps);
         }
-        else if (node instanceof Component$1) ;
         else {
-            throw new Error(`Unsupported template node: ${node.constructor.name}`);
+            this._parsePropertyAst(name, this.parseBinding(expression, isHost, valueSpan || sourceSpan, absoluteOffset), isPartOfAssignmentBinding, sourceSpan, keySpan, valueSpan, targetMatchableAttrs, targetProps);
         }
     }
-}
-/**
- * Ingest an element AST from the template into the given `ViewCompilation`.
- */
-function ingestElement(unit, element) {
-    if (element.i18n !== undefined &&
-        !(element.i18n instanceof Message || element.i18n instanceof TagPlaceholder)) {
-        throw Error(`Unhandled i18n metadata type for element: ${element.i18n.constructor.name}`);
-    }
-    const id = unit.job.allocateXrefId();
-    const [namespaceKey, elementName] = splitNsName(element.name);
-    const startOp = createElementStartOp(elementName, id, namespaceForKey(namespaceKey), element.i18n instanceof TagPlaceholder ? element.i18n : undefined, element.startSourceSpan, element.sourceSpan);
-    unit.create.push(startOp);
-    ingestElementBindings(unit, startOp, element);
-    ingestReferences(startOp, element);
-    // Start i18n, if needed, goes after the element create and bindings, but before the nodes
-    let i18nBlockId = null;
-    if (element.i18n instanceof Message) {
-        i18nBlockId = unit.job.allocateXrefId();
-        unit.create.push(createI18nStartOp(i18nBlockId, element.i18n, undefined, element.startSourceSpan));
+    parsePropertyInterpolation(name, value, sourceSpan, valueSpan, targetMatchableAttrs, targetProps, keySpan, interpolatedTokens) {
+        const expr = this.parseInterpolation(value, valueSpan || sourceSpan, interpolatedTokens);
+        if (expr) {
+            this._parsePropertyAst(name, expr, false, sourceSpan, keySpan, valueSpan, targetMatchableAttrs, targetProps);
+            return true;
+        }
+        return false;
     }
-    ingestNodes(unit, element.children);
-    // The source span for the end op is typically the element closing tag. However, if no closing tag
-    // exists, such as in `<input>`, we use the start source span instead. Usually the start and end
-    // instructions will be collapsed into one `element` instruction, negating the purpose of this
-    // fallback, but in cases when it is not collapsed (such as an input with a binding), we still
-    // want to map the end instruction to the main element.
-    const endOp = createElementEndOp(id, element.endSourceSpan ?? element.startSourceSpan);
-    unit.create.push(endOp);
-    // If there is an i18n message associated with this element, insert i18n start and end ops.
-    if (i18nBlockId !== null) {
-        OpList.insertBefore(createI18nEndOp(i18nBlockId, element.endSourceSpan ?? element.startSourceSpan), endOp);
+    _parsePropertyAst(name, ast, isPartOfAssignmentBinding, sourceSpan, keySpan, valueSpan, targetMatchableAttrs, targetProps) {
+        targetMatchableAttrs.push([name, ast.source]);
+        targetProps.push(new ParsedProperty(name, ast, isPartOfAssignmentBinding ? ParsedPropertyType.TWO_WAY : ParsedPropertyType.DEFAULT, sourceSpan, keySpan, valueSpan));
     }
-}
-/**
- * Ingest an `ng-template` node from the AST into the given `ViewCompilation`.
- */
-function ingestTemplate(unit, tmpl) {
-    if (tmpl.i18n !== undefined &&
-        !(tmpl.i18n instanceof Message || tmpl.i18n instanceof TagPlaceholder)) {
-        throw Error(`Unhandled i18n metadata type for template: ${tmpl.i18n.constructor.name}`);
+    _parseAnimation(name, ast, sourceSpan, keySpan, valueSpan, targetMatchableAttrs, targetProps) {
+        targetMatchableAttrs.push([name, ast.source]);
+        targetProps.push(new ParsedProperty(name, ast, ParsedPropertyType.ANIMATION, sourceSpan, keySpan, valueSpan));
     }
-    const childView = unit.job.allocateView(unit.xref);
-    let tagNameWithoutNamespace = tmpl.tagName;
-    let namespacePrefix = '';
-    if (tmpl.tagName) {
-        [namespacePrefix, tagNameWithoutNamespace] = splitNsName(tmpl.tagName);
+    _parseLegacyAnimation(name, expression, sourceSpan, absoluteOffset, keySpan, valueSpan, targetMatchableAttrs, targetProps) {
+        if (name.length === 0) {
+            this._reportError('Animation trigger is missing', sourceSpan);
+        }
+        // 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);
+        targetMatchableAttrs.push([name, ast.source]);
+        targetProps.push(new ParsedProperty(name, ast, ParsedPropertyType.LEGACY_ANIMATION, sourceSpan, keySpan, valueSpan));
     }
-    const i18nPlaceholder = tmpl.i18n instanceof TagPlaceholder ? tmpl.i18n : undefined;
-    const namespace = namespaceForKey(namespacePrefix);
-    const functionNameSuffix = tagNameWithoutNamespace === null ? '' : prefixWithNamespace(tagNameWithoutNamespace, namespace);
-    const templateKind = isPlainTemplate(tmpl)
-        ? TemplateKind.NgTemplate
-        : TemplateKind.Structural;
-    const templateOp = createTemplateOp(childView.xref, templateKind, tagNameWithoutNamespace, functionNameSuffix, namespace, i18nPlaceholder, tmpl.startSourceSpan, tmpl.sourceSpan);
-    unit.create.push(templateOp);
-    ingestTemplateBindings(unit, templateOp, tmpl, templateKind);
+    parseBinding(value, isHostBinding, sourceSpan, absoluteOffset) {
+        try {
+            const ast = isHostBinding
+                ? this._exprParser.parseSimpleBinding(value, sourceSpan, absoluteOffset, this._interpolationConfig)
+                : this._exprParser.parseBinding(value, sourceSpan, absoluteOffset, this._interpolationConfig);
+            if (ast) {
+                this.errors.push(...ast.errors);
+            }
+            return ast;
+        }
+        catch (e) {
+            this._reportError(`${e}`, sourceSpan);
+            return this._exprParser.wrapLiteralPrimitive('ERROR', sourceSpan, absoluteOffset);
+        }
+    }
+    createBoundElementProperty(elementSelector, boundProp, skipValidation = false, mapPropertyName = true) {
+        if (boundProp.isLegacyAnimation) {
+            return new BoundElementProperty(boundProp.name, BindingType.LegacyAnimation, SecurityContext$1.NONE, boundProp.expression, null, boundProp.sourceSpan, boundProp.keySpan, boundProp.valueSpan);
+        }
+        let unit = null;
+        let bindingType = undefined;
+        let boundPropertyName = null;
+        const parts = boundProp.name.split(PROPERTY_PARTS_SEPARATOR);
+        let securityContexts = undefined;
+        // Check for special cases (prefix style, attr, class)
+        if (parts.length > 1) {
+            if (parts[0] == ATTRIBUTE_PREFIX) {
+                boundPropertyName = parts.slice(1).join(PROPERTY_PARTS_SEPARATOR);
+                if (!skipValidation) {
+                    this._validatePropertyOrAttributeName(boundPropertyName, boundProp.sourceSpan, true);
+                }
+                securityContexts = calcPossibleSecurityContexts(this._schemaRegistry, elementSelector, boundPropertyName, true);
+                const nsSeparatorIdx = boundPropertyName.indexOf(':');
+                if (nsSeparatorIdx > -1) {
+                    const ns = boundPropertyName.substring(0, nsSeparatorIdx);
+                    const name = boundPropertyName.substring(nsSeparatorIdx + 1);
+                    boundPropertyName = mergeNsAndName(ns, name);
+                }
+                bindingType = BindingType.Attribute;
+            }
+            else if (parts[0] == CLASS_PREFIX) {
+                boundPropertyName = parts[1];
+                bindingType = BindingType.Class;
+                securityContexts = [SecurityContext$1.NONE];
+            }
+            else if (parts[0] == STYLE_PREFIX) {
+                unit = parts.length > 2 ? parts[2] : null;
+                boundPropertyName = parts[1];
+                bindingType = BindingType.Style;
+                securityContexts = [SecurityContext$1.STYLE];
+            }
+            else if (parts[0] == ANIMATE_PREFIX$1) {
+                boundPropertyName = boundProp.name;
+                bindingType = BindingType.Animation;
+                securityContexts = [SecurityContext$1.NONE];
+            }
+        }
+        // If not a special case, use the full property name
+        if (boundPropertyName === null) {
+            const mappedPropName = this._schemaRegistry.getMappedPropName(boundProp.name);
+            boundPropertyName = mapPropertyName ? mappedPropName : boundProp.name;
+            securityContexts = calcPossibleSecurityContexts(this._schemaRegistry, elementSelector, mappedPropName, false);
+            bindingType =
+                boundProp.type === ParsedPropertyType.TWO_WAY ? BindingType.TwoWay : BindingType.Property;
+            if (!skipValidation) {
+                this._validatePropertyOrAttributeName(mappedPropName, boundProp.sourceSpan, false);
+            }
+        }
+        return new BoundElementProperty(boundPropertyName, bindingType, securityContexts[0], boundProp.expression, unit, boundProp.sourceSpan, boundProp.keySpan, boundProp.valueSpan);
+    }
+    parseEvent(name, expression, isAssignmentEvent, sourceSpan, handlerSpan, targetMatchableAttrs, targetEvents, keySpan) {
+        if (name.length === 0) {
+            this._reportError(`Event name is missing in binding`, sourceSpan);
+        }
+        if (isLegacyAnimationLabel(name)) {
+            name = name.slice(1);
+            if (keySpan !== undefined) {
+                keySpan = moveParseSourceSpan(keySpan, new AbsoluteSourceSpan(keySpan.start.offset + 1, keySpan.end.offset));
+            }
+            this._parseLegacyAnimationEvent(name, expression, sourceSpan, handlerSpan, targetEvents, keySpan);
+        }
+        else {
+            this._parseRegularEvent(name, expression, isAssignmentEvent, sourceSpan, handlerSpan, targetMatchableAttrs, targetEvents, keySpan);
+        }
+    }
+    calcPossibleSecurityContexts(selector, propName, isAttribute) {
+        const prop = this._schemaRegistry.getMappedPropName(propName);
+        return calcPossibleSecurityContexts(this._schemaRegistry, selector, prop, isAttribute);
+    }
+    parseEventListenerName(rawName) {
+        const [target, eventName] = splitAtColon(rawName, [null, rawName]);
+        return { eventName: eventName, target };
+    }
+    parseLegacyAnimationEventName(rawName) {
+        const matches = splitAtPeriod(rawName, [rawName, null]);
+        return { eventName: matches[0], phase: matches[1] === null ? null : matches[1].toLowerCase() };
+    }
+    _parseLegacyAnimationEvent(name, expression, sourceSpan, handlerSpan, targetEvents, keySpan) {
+        const { eventName, phase } = this.parseLegacyAnimationEventName(name);
+        const ast = this._parseAction(expression, handlerSpan);
+        targetEvents.push(new ParsedEvent(eventName, phase, ParsedEventType.LegacyAnimation, ast, sourceSpan, handlerSpan, keySpan));
+        if (eventName.length === 0) {
+            this._reportError(`Animation event name is missing in binding`, sourceSpan);
+        }
+        if (phase) {
+            if (phase !== 'start' && phase !== 'done') {
+                this._reportError(`The provided animation output phase value "${phase}" for "@${eventName}" is not supported (use start or done)`, sourceSpan);
+            }
+        }
+        else {
+            this._reportError(`The animation trigger output event (@${eventName}) is missing its phase value name (start or done are currently supported)`, sourceSpan);
+        }
+    }
+    _parseRegularEvent(name, expression, isAssignmentEvent, sourceSpan, handlerSpan, targetMatchableAttrs, targetEvents, keySpan) {
+        // long format: 'target: eventName'
+        const { eventName, target } = this.parseEventListenerName(name);
+        const prevErrorCount = this.errors.length;
+        const ast = this._parseAction(expression, handlerSpan);
+        const isValid = this.errors.length === prevErrorCount;
+        targetMatchableAttrs.push([name, ast.source]);
+        // Don't try to validate assignment events if there were other
+        // parsing errors to avoid adding more noise to the error logs.
+        if (isAssignmentEvent && isValid && !this._isAllowedAssignmentEvent(ast)) {
+            this._reportError('Unsupported expression in a two-way binding', sourceSpan);
+        }
+        let eventType = ParsedEventType.Regular;
+        if (isAssignmentEvent) {
+            eventType = ParsedEventType.TwoWay;
+        }
+        if (name.startsWith(`${ANIMATE_PREFIX$1}${PROPERTY_PARTS_SEPARATOR}`)) {
+            eventType = ParsedEventType.Animation;
+        }
+        targetEvents.push(new ParsedEvent(eventName, target, eventType, ast, sourceSpan, handlerSpan, keySpan));
+        // Don't detect directives for event names for now,
+        // so don't add the event name to the matchableAttrs
+    }
+    _parseAction(value, sourceSpan) {
+        const absoluteOffset = sourceSpan && sourceSpan.start ? sourceSpan.start.offset : 0;
+        try {
+            const ast = this._exprParser.parseAction(value, sourceSpan, absoluteOffset, this._interpolationConfig);
+            if (ast) {
+                this.errors.push(...ast.errors);
+            }
+            if (!ast || ast.ast instanceof EmptyExpr$1) {
+                this._reportError(`Empty expressions are not allowed`, sourceSpan);
+                return this._exprParser.wrapLiteralPrimitive('ERROR', sourceSpan, absoluteOffset);
+            }
+            return ast;
+        }
+        catch (e) {
+            this._reportError(`${e}`, sourceSpan);
+            return this._exprParser.wrapLiteralPrimitive('ERROR', sourceSpan, absoluteOffset);
+        }
+    }
+    _reportError(message, sourceSpan, level = ParseErrorLevel.ERROR) {
+        this.errors.push(new ParseError(sourceSpan, message, level));
+    }
+    /**
+     * @param propName the name of the property / attribute
+     * @param sourceSpan
+     * @param isAttr true when binding to an attribute
+     */
+    _validatePropertyOrAttributeName(propName, sourceSpan, isAttr) {
+        const report = isAttr
+            ? this._schemaRegistry.validateAttribute(propName)
+            : this._schemaRegistry.validateProperty(propName);
+        if (report.error) {
+            this._reportError(report.msg, sourceSpan, ParseErrorLevel.ERROR);
+        }
+    }
+    /**
+     * Returns whether a parsed AST is allowed to be used within the event side of a two-way binding.
+     * @param ast Parsed AST to be checked.
+     */
+    _isAllowedAssignmentEvent(ast) {
+        if (ast instanceof ASTWithSource) {
+            return this._isAllowedAssignmentEvent(ast.ast);
+        }
+        if (ast instanceof NonNullAssert) {
+            return this._isAllowedAssignmentEvent(ast.expression);
+        }
+        if (ast instanceof Call &&
+            ast.args.length === 1 &&
+            ast.receiver instanceof PropertyRead &&
+            ast.receiver.name === '$any' &&
+            ast.receiver.receiver instanceof ImplicitReceiver &&
+            !(ast.receiver.receiver instanceof ThisReceiver)) {
+            return this._isAllowedAssignmentEvent(ast.args[0]);
+        }
+        if (ast instanceof PropertyRead || ast instanceof KeyedRead) {
+            if (!hasRecursiveSafeReceiver(ast)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+function hasRecursiveSafeReceiver(ast) {
+    if (ast instanceof SafePropertyRead || ast instanceof SafeKeyedRead) {
+        return true;
+    }
+    if (ast instanceof ParenthesizedExpression) {
+        return hasRecursiveSafeReceiver(ast.expression);
+    }
+    if (ast instanceof PropertyRead || ast instanceof KeyedRead || ast instanceof Call) {
+        return hasRecursiveSafeReceiver(ast.receiver);
+    }
+    return false;
+}
+function isLegacyAnimationLabel(name) {
+    return name[0] == '@';
+}
+function calcPossibleSecurityContexts(registry, selector, propName, isAttribute) {
+    let ctxs;
+    const [namespaceKey, baseSelector] = selector ? splitNsName$1(selector, false) : [null, selector];
+    const nameToContext = (elName) => {
+        const [nsStr, name] = splitNsName$1(elName, false);
+        const ns = nsStr ?? namespaceKey;
+        const fullName = ns ? `:${ns}:${name}` : name;
+        return registry.securityContext(fullName, propName, isAttribute);
+    };
+    const allKnownElements = registry.allKnownElementNames();
+    if (baseSelector === null) {
+        ctxs = allKnownElements.map(nameToContext);
+    }
+    else {
+        ctxs = [];
+        CssSelector.parse(baseSelector).forEach((selector) => {
+            let elementNames = selector.element ? [selector.element] : allKnownElements;
+            if (selector.element && !registry.hasElement(selector.element, [])) {
+                const svgElement = `:${SVG_NAMESPACE$2}:${selector.element}`;
+                const mathElement = `:${MATH_ML_NAMESPACE$2}:${selector.element}`;
+                if (registry.hasElement(svgElement, [])) {
+                    elementNames = [svgElement];
+                }
+                else if (registry.hasElement(mathElement, [])) {
+                    elementNames = [mathElement];
+                }
+            }
+            const notElementNames = new Set(selector.notSelectors
+                .filter((selector) => selector.isElementSelector())
+                .map((selector) => selector.element?.toLowerCase()));
+            const possibleElementNames = elementNames.filter((elName) => {
+                const elNameLowerCase = elName.toLowerCase();
+                return (!notElementNames.has(elNameLowerCase) &&
+                    !notElementNames.has(splitNsName$1(elNameLowerCase)[1]));
+            });
+            ctxs.push(...possibleElementNames.map(nameToContext));
+        });
+    }
+    return ctxs.length === 0 ? [SecurityContext$1.NONE] : Array.from(new Set(ctxs)).sort();
+}
+/**
+ * Compute a new ParseSourceSpan based off an original `sourceSpan` by using
+ * absolute offsets from the specified `absoluteSpan`.
+ *
+ * @param sourceSpan original source span
+ * @param absoluteSpan absolute source span to move to
+ */
+function moveParseSourceSpan(sourceSpan, absoluteSpan) {
+    // The difference of two absolute offsets provide the relative offset
+    const startDiff = absoluteSpan.start - sourceSpan.start.offset;
+    const endDiff = absoluteSpan.end - sourceSpan.end.offset;
+    return new ParseSourceSpan(sourceSpan.start.moveBy(startDiff), sourceSpan.end.moveBy(endDiff), sourceSpan.fullStart.moveBy(startDiff), sourceSpan.details);
+}
+
+const compatibilityMode = CompatibilityMode.TemplateDefinitionBuilder;
+// Schema containing DOM elements and their properties.
+const domSchema = new DomElementSchemaRegistry();
+// Tag name of the `ng-template` element.
+const NG_TEMPLATE_TAG_NAME = 'ng-template';
+// prefix for any animation binding
+const ANIMATE_PREFIX = 'animate.';
+function isI18nRootNode(meta) {
+    return meta instanceof Message;
+}
+function isSingleI18nIcu(meta) {
+    return isI18nRootNode(meta) && meta.nodes.length === 1 && meta.nodes[0] instanceof Icu;
+}
+/**
+ * Process a template AST and convert it into a `ComponentCompilation` in the intermediate
+ * representation.
+ * TODO: Refactor more of the ingestion code into phases.
+ */
+function ingestComponent(componentName, template, constantPool, compilationMode, relativeContextFilePath, i18nUseExternalIds, deferMeta, allDeferrableDepsFn, relativeTemplatePath, enableDebugLocations) {
+    const job = new ComponentCompilationJob(componentName, constantPool, compatibilityMode, compilationMode, relativeContextFilePath, i18nUseExternalIds, deferMeta, allDeferrableDepsFn, relativeTemplatePath, enableDebugLocations);
+    ingestNodes(job.root, template);
+    return job;
+}
+/**
+ * Process a host binding AST and convert it into a `HostBindingCompilationJob` in the intermediate
+ * representation.
+ */
+function ingestHostBinding(input, bindingParser, constantPool) {
+    const job = new HostBindingCompilationJob(input.componentName, constantPool, compatibilityMode, TemplateCompilationMode.DomOnly);
+    for (const property of input.properties ?? []) {
+        let bindingKind = BindingKind.Property;
+        // TODO: this should really be handled in the parser.
+        if (property.name.startsWith('attr.')) {
+            property.name = property.name.substring('attr.'.length);
+            bindingKind = BindingKind.Attribute;
+        }
+        if (property.isLegacyAnimation) {
+            bindingKind = BindingKind.LegacyAnimation;
+        }
+        if (property.isAnimation) {
+            bindingKind = BindingKind.Animation;
+        }
+        const securityContexts = calcHostBindingSecurityContexts(bindingParser, input.componentSelector, property.name, bindingKind === BindingKind.Attribute);
+        ingestDomProperty(job, property, bindingKind, securityContexts);
+    }
+    for (const [name, expr] of Object.entries(input.attributes) ?? []) {
+        const securityContexts = calcHostBindingSecurityContexts(bindingParser, input.componentSelector, name, true);
+        ingestHostAttribute(job, name, expr, securityContexts);
+    }
+    for (const event of input.events ?? []) {
+        ingestHostEvent(job, event);
+    }
+    return job;
+}
+function calcHostBindingSecurityContexts(bindingParser, selector, name, isAttribute) {
+    const declaringSelectorContexts = bindingParser.calcPossibleSecurityContexts(selector, name, isAttribute);
+    const concreteHostContexts = calcPossibleSecurityContexts(domSchema, null, domSchema.getMappedPropName(name), isAttribute);
+    const concreteHostNonNoneContexts = concreteHostContexts.filter((context) => context !== SecurityContext$1.NONE);
+    const concreteHostNonNoneCount = concreteHostNonNoneContexts.length;
+    const hasConcreteHostNoneContext = concreteHostNonNoneCount !== concreteHostContexts.length;
+    // Host bindings can run against a concrete host whose element name differs from the declaring
+    // selector, including dynamic root components whose TNode name is `#host`.
+    if (hasConcreteHostNoneContext && concreteHostNonNoneCount > 0) {
+        return concreteHostContexts;
+    }
+    if (concreteHostNonNoneContexts.some((context) => !declaringSelectorContexts.includes(context))) {
+        return concreteHostContexts;
+    }
+    return declaringSelectorContexts.filter((context) => context !== SecurityContext$1.NONE);
+}
+// TODO: We should refactor the parser to use the same types and structures for host bindings as
+// with ordinary components. This would allow us to share a lot more ingestion code.
+function ingestDomProperty(job, property, bindingKind, securityContexts) {
+    let expression;
+    const ast = property.expression.ast;
+    if (ast instanceof Interpolation$1) {
+        expression = new Interpolation(ast.strings, ast.expressions.map((expr) => convertAst(expr, job, property.sourceSpan)), []);
+    }
+    else {
+        expression = convertAst(ast, job, property.sourceSpan);
+    }
+    job.root.update.push(createBindingOp(job.root.xref, bindingKind, property.name, expression, null, securityContexts, false, false, null, 
+    /* TODO: How do Host bindings handle i18n attrs? */ null, property.sourceSpan));
+}
+function ingestHostAttribute(job, name, value, securityContexts) {
+    const attrBinding = createBindingOp(job.root.xref, BindingKind.Attribute, name, value, null, securityContexts, 
+    /* Host attributes should always be extracted to const hostAttrs, even if they are not
+     *strictly* text literals */
+    true, false, null, 
+    /* TODO */ null, 
+    /** TODO: May be null? */ value.sourceSpan);
+    job.root.update.push(attrBinding);
+}
+function ingestHostEvent(job, event) {
+    let eventBinding;
+    if (event.type === ParsedEventType.Animation) {
+        eventBinding = createAnimationListenerOp(job.root.xref, new SlotHandle(), event.name, null, makeListenerHandlerOps(job.root, event.handler, event.handlerSpan), event.name.endsWith('enter') ? "enter" /* ir.AnimationKind.ENTER */ : "leave" /* ir.AnimationKind.LEAVE */, event.targetOrPhase, true, event.sourceSpan);
+    }
+    else {
+        const [phase, target] = event.type !== ParsedEventType.LegacyAnimation
+            ? [null, event.targetOrPhase]
+            : [event.targetOrPhase, null];
+        eventBinding = createListenerOp(job.root.xref, new SlotHandle(), event.name, null, makeListenerHandlerOps(job.root, event.handler, event.handlerSpan), phase, target, true, event.sourceSpan);
+    }
+    job.root.create.push(eventBinding);
+}
+/**
+ * Ingest the nodes of a template AST into the given `ViewCompilation`.
+ */
+function ingestNodes(unit, template) {
+    for (const node of template) {
+        if (node instanceof Element$1) {
+            ingestElement(unit, node);
+        }
+        else if (node instanceof Template) {
+            ingestTemplate(unit, node);
+        }
+        else if (node instanceof Content) {
+            ingestContent(unit, node);
+        }
+        else if (node instanceof Text$3) {
+            ingestText(unit, node, null);
+        }
+        else if (node instanceof BoundText) {
+            ingestBoundText(unit, node, null);
+        }
+        else if (node instanceof IfBlock) {
+            ingestIfBlock(unit, node);
+        }
+        else if (node instanceof SwitchBlock) {
+            ingestSwitchBlock(unit, node);
+        }
+        else if (node instanceof DeferredBlock) {
+            ingestDeferBlock(unit, node);
+        }
+        else if (node instanceof Icu$1) {
+            ingestIcu(unit, node);
+        }
+        else if (node instanceof ForLoopBlock) {
+            ingestForBlock(unit, node);
+        }
+        else if (node instanceof LetDeclaration$1) {
+            ingestLetDeclaration(unit, node);
+        }
+        else if (node instanceof Component$1) ;
+        else {
+            throw new Error(`Unsupported template node: ${node.constructor.name}`);
+        }
+    }
+}
+/**
+ * Ingest an element AST from the template into the given `ViewCompilation`.
+ */
+function ingestElement(unit, element) {
+    if (element.i18n !== undefined &&
+        !(element.i18n instanceof Message || element.i18n instanceof TagPlaceholder)) {
+        throw Error(`Unhandled i18n metadata type for element: ${element.i18n.constructor.name}`);
+    }
+    const id = unit.job.allocateXrefId();
+    const [namespaceKey, elementName] = splitNsName$1(element.name);
+    const startOp = createElementStartOp(elementName, id, namespaceForKey(namespaceKey), element.i18n instanceof TagPlaceholder ? element.i18n : undefined, element.startSourceSpan, element.sourceSpan);
+    unit.create.push(startOp);
+    ingestElementBindings(unit, startOp, element);
+    ingestReferences(startOp, element);
+    // Start i18n, if needed, goes after the element create and bindings, but before the nodes
+    let i18nBlockId = null;
+    if (element.i18n instanceof Message) {
+        i18nBlockId = unit.job.allocateXrefId();
+        unit.create.push(createI18nStartOp(i18nBlockId, element.i18n, undefined, element.startSourceSpan));
+    }
+    ingestNodes(unit, element.children);
+    // The source span for the end op is typically the element closing tag. However, if no closing tag
+    // exists, such as in `<input>`, we use the start source span instead. Usually the start and end
+    // instructions will be collapsed into one `element` instruction, negating the purpose of this
+    // fallback, but in cases when it is not collapsed (such as an input with a binding), we still
+    // want to map the end instruction to the main element.
+    const endOp = createElementEndOp(id, element.endSourceSpan ?? element.startSourceSpan);
+    unit.create.push(endOp);
+    // If there is an i18n message associated with this element, insert i18n start and end ops.
+    if (i18nBlockId !== null) {
+        OpList.insertBefore(createI18nEndOp(i18nBlockId, element.endSourceSpan ?? element.startSourceSpan), endOp);
+    }
+}
+/**
+ * Ingest an `ng-template` node from the AST into the given `ViewCompilation`.
+ */
+function ingestTemplate(unit, tmpl) {
+    if (tmpl.i18n !== undefined &&
+        !(tmpl.i18n instanceof Message || tmpl.i18n instanceof TagPlaceholder)) {
+        throw Error(`Unhandled i18n metadata type for template: ${tmpl.i18n.constructor.name}`);
+    }
+    const childView = unit.job.allocateView(unit.xref);
+    let tagNameWithoutNamespace = tmpl.tagName;
+    let namespacePrefix = '';
+    if (tmpl.tagName) {
+        [namespacePrefix, tagNameWithoutNamespace] = splitNsName$1(tmpl.tagName);
+    }
+    const i18nPlaceholder = tmpl.i18n instanceof TagPlaceholder ? tmpl.i18n : undefined;
+    const namespace = namespaceForKey(namespacePrefix);
+    const functionNameSuffix = tagNameWithoutNamespace === null ? '' : prefixWithNamespace(tagNameWithoutNamespace, namespace);
+    const templateKind = isPlainTemplate(tmpl)
+        ? TemplateKind.NgTemplate
+        : TemplateKind.Structural;
+    const templateOp = createTemplateOp(childView.xref, templateKind, tagNameWithoutNamespace, functionNameSuffix, namespace, i18nPlaceholder, tmpl.startSourceSpan, tmpl.sourceSpan);
+    unit.create.push(templateOp);
+    ingestTemplateBindings(unit, templateOp, tmpl, templateKind);
     ingestReferences(templateOp, tmpl);
     ingestNodes(childView, tmpl.children);
     for (const { name, value } of tmpl.variables) {
@@ -26460,7 +27051,7 @@ const BINDING_KINDS = new Map([
  * | `<ng-template *ngIf>` (structural) | null               |
  */
 function isPlainTemplate(tmpl) {
-    return splitNsName(tmpl.tagName ?? '')[1] === NG_TEMPLATE_TAG_NAME;
+    return splitNsName$1(tmpl.tagName ?? '')[1] === NG_TEMPLATE_TAG_NAME;
 }
 /**
  * Ensures that the i18nMeta, if provided, is an i18n.Message.
@@ -26483,7 +27074,19 @@ function ingestElementBindings(unit, op, element) {
     let i18nAttributeBindingNames = new Set();
     for (const attr of element.attributes) {
         // Attribute literal bindings, such as `attr.foo="bar"`.
-        const securityContext = domSchema.securityContext(element.name, attr.name, true);
+        const [ns, elementName] = splitNsName$1(element.name);
+        let namespace = ns;
+        if (!ns) {
+            switch (op.namespace) {
+                case Namespace.SVG:
+                    namespace = SVG_NAMESPACE$2;
+                    break;
+                case Namespace.Math:
+                    namespace = MATH_ML_NAMESPACE$2;
+                    break;
+            }
+        }
+        const securityContext = domSchema.securityContext(namespace ? `:${namespace}:${elementName}` : elementName, attr.name, true);
         bindings.push(createBindingOp(op.xref, BindingKind.Attribute, attr.name, convertAstWithInterpolation(unit.job, attr.value, attr.i18n), null, securityContext, true, false, null, asMessage(attr.i18n), attr.sourceSpan));
         if (attr.i18n) {
             i18nAttributeBindingNames.add(attr.name);
@@ -26767,715 +27370,234 @@ function ingestControlFlowInsertionPoint(unit, xref, node) {
         if (child instanceof Element$1 || (child instanceof Template && child.tagName !== null)) {
             root = child;
         }
-        else {
-            return null;
-        }
-    }
-    // If we've found a single root node, its tag name and attributes can be
-    // copied to the surrounding template to be used for content projection.
-    if (root !== null) {
-        // Collect the static attributes for content projection purposes.
-        for (const attr of root.attributes) {
-            if (!attr.name.startsWith(ANIMATE_PREFIX$1)) {
-                const securityContext = domSchema.securityContext(NG_TEMPLATE_TAG_NAME, attr.name, true);
-                unit.update.push(createBindingOp(xref, BindingKind.Attribute, attr.name, literal(attr.value), null, securityContext, true, false, null, asMessage(attr.i18n), attr.sourceSpan));
-            }
-        }
-        // Also collect the inputs since they participate in content projection as well.
-        // Note that TDB used to collect the outputs as well, but it wasn't passing them into
-        // the template instruction. Here we just don't collect them.
-        for (const attr of root.inputs) {
-            if (attr.type !== BindingType.LegacyAnimation &&
-                attr.type !== BindingType.Animation &&
-                attr.type !== BindingType.Attribute) {
-                const securityContext = domSchema.securityContext(NG_TEMPLATE_TAG_NAME, attr.name, true);
-                unit.create.push(createExtractedAttributeOp(xref, BindingKind.Property, null, attr.name, null, null, null, securityContext));
-            }
-        }
-        const tagName = root instanceof Element$1 ? root.name : root.tagName;
-        // Don't pass along `ng-template` tag name since it enables directive matching.
-        return tagName === NG_TEMPLATE_TAG_NAME ? null : tagName;
-    }
-    return null;
-}
-
-/*!
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.dev/license
- */
-/**
- * Whether to produce instructions that will attach the source location to each DOM node.
- *
- * !!!Important!!! at the time of writing this flag isn't exposed externally, but internal debug
- * tools enable it via a local change. Any modifications to this flag need to update the
- * internal tooling as well.
- */
-let ENABLE_TEMPLATE_SOURCE_LOCATIONS = false;
-/** Gets whether template source locations are enabled. */
-function getTemplateSourceLocationsEnabled() {
-    return ENABLE_TEMPLATE_SOURCE_LOCATIONS;
-}
-
-//  if (rf & flags) { .. }
-function renderFlagCheckIfStmt(flags, statements) {
-    return ifStmt(variable(RENDER_FLAGS).bitwiseAnd(literal(flags), null), statements);
-}
-/**
- * Translates query flags into `TQueryFlags` type in
- * packages/core/src/render3/interfaces/query.ts
- * @param query
- */
-function toQueryFlags(query) {
-    return ((query.descendants ? 1 /* QueryFlags.descendants */ : 0 /* QueryFlags.none */) |
-        (query.static ? 2 /* QueryFlags.isStatic */ : 0 /* QueryFlags.none */) |
-        (query.emitDistinctChangesOnly ? 4 /* QueryFlags.emitDistinctChangesOnly */ : 0 /* QueryFlags.none */));
-}
-function getQueryPredicate(query, constantPool) {
-    if (Array.isArray(query.predicate)) {
-        let predicate = [];
-        query.predicate.forEach((selector) => {
-            // Each item in predicates array may contain strings with comma-separated refs
-            // (for ex. 'ref, ref1, ..., refN'), thus we extract individual refs and store them
-            // as separate array entities
-            const selectors = selector.split(',').map((token) => literal(token.trim()));
-            predicate.push(...selectors);
-        });
-        return constantPool.getConstLiteral(literalArr(predicate), true);
-    }
-    else {
-        // The original predicate may have been wrapped in a `forwardRef()` call.
-        switch (query.predicate.forwardRef) {
-            case 0 /* ForwardRefHandling.None */:
-            case 2 /* ForwardRefHandling.Unwrapped */:
-                return query.predicate.expression;
-            case 1 /* ForwardRefHandling.Wrapped */:
-                return importExpr(Identifiers.resolveForwardRef).callFn([query.predicate.expression]);
-        }
-    }
-}
-function createQueryCreateCall(query, constantPool, queryTypeFns, prependParams) {
-    const parameters = [];
-    if (prependParams !== undefined) {
-        parameters.push(...prependParams);
-    }
-    if (query.isSignal) {
-        parameters.push(new ReadPropExpr(variable(CONTEXT_NAME), query.propertyName));
-    }
-    parameters.push(getQueryPredicate(query, constantPool), literal(toQueryFlags(query)));
-    if (query.read) {
-        parameters.push(query.read);
-    }
-    const queryCreateFn = query.isSignal ? queryTypeFns.signalBased : queryTypeFns.nonSignal;
-    return importExpr(queryCreateFn).callFn(parameters);
-}
-const queryAdvancePlaceholder = Symbol('queryAdvancePlaceholder');
-/**
- * Collapses query advance placeholders in a list of statements.
- *
- * This allows for less generated code because multiple sibling query advance
- * statements can be collapsed into a single call with the count as argument.
- *
- * e.g.
- *
- * ```ts
- *   bla();
- *   queryAdvance();
- *   queryAdvance();
- *   bla();
- * ```
- *
- *   --> will turn into
- *
- * ```ts
- *   bla();
- *   queryAdvance(2);
- *   bla();
- * ```
- */
-function collapseAdvanceStatements(statements) {
-    const result = [];
-    let advanceCollapseCount = 0;
-    const flushAdvanceCount = () => {
-        if (advanceCollapseCount > 0) {
-            result.unshift(importExpr(Identifiers.queryAdvance)
-                .callFn(advanceCollapseCount === 1 ? [] : [literal(advanceCollapseCount)])
-                .toStmt());
-            advanceCollapseCount = 0;
-        }
-    };
-    // Iterate through statements in reverse and collapse advance placeholders.
-    for (let i = statements.length - 1; i >= 0; i--) {
-        const st = statements[i];
-        if (st === queryAdvancePlaceholder) {
-            advanceCollapseCount++;
-        }
-        else {
-            flushAdvanceCount();
-            result.unshift(st);
-        }
-    }
-    flushAdvanceCount();
-    return result;
-}
-// Define and update any view queries
-function createViewQueriesFunction(viewQueries, constantPool, name) {
-    const createStatements = [];
-    const updateStatements = [];
-    const tempAllocator = temporaryAllocator((st) => updateStatements.push(st), TEMPORARY_NAME);
-    viewQueries.forEach((query) => {
-        // creation call, e.g. r3.viewQuery(somePredicate, true) or
-        //                r3.viewQuerySignal(ctx.prop, somePredicate, true);
-        const queryDefinitionCall = createQueryCreateCall(query, constantPool, {
-            signalBased: Identifiers.viewQuerySignal,
-            nonSignal: Identifiers.viewQuery,
-        });
-        createStatements.push(queryDefinitionCall.toStmt());
-        // Signal queries update lazily and we just advance the index.
-        if (query.isSignal) {
-            updateStatements.push(queryAdvancePlaceholder);
-            return;
-        }
-        // update, e.g. (r3.queryRefresh(tmp = r3.loadQuery()) && (ctx.someDir = tmp));
-        const temporary = tempAllocator();
-        const getQueryList = importExpr(Identifiers.loadQuery).callFn([]);
-        const refresh = importExpr(Identifiers.queryRefresh).callFn([temporary.set(getQueryList)]);
-        const updateDirective = variable(CONTEXT_NAME)
-            .prop(query.propertyName)
-            .set(query.first ? temporary.prop('first') : temporary);
-        updateStatements.push(refresh.and(updateDirective).toStmt());
-    });
-    const viewQueryFnName = name ? `${name}_Query` : null;
-    return fn([new FnParam(RENDER_FLAGS, NUMBER_TYPE), new FnParam(CONTEXT_NAME, null)], [
-        renderFlagCheckIfStmt(1 /* core.RenderFlags.Create */, createStatements),
-        renderFlagCheckIfStmt(2 /* core.RenderFlags.Update */, collapseAdvanceStatements(updateStatements)),
-    ], INFERRED_TYPE, null, viewQueryFnName);
-}
-// Define and update any content queries
-function createContentQueriesFunction(queries, constantPool, name) {
-    const createStatements = [];
-    const updateStatements = [];
-    const tempAllocator = temporaryAllocator((st) => updateStatements.push(st), TEMPORARY_NAME);
-    for (const query of queries) {
-        // creation, e.g. r3.contentQuery(dirIndex, somePredicate, true, null) or
-        //                r3.contentQuerySignal(dirIndex, propName, somePredicate, <flags>, <read>).
-        createStatements.push(createQueryCreateCall(query, constantPool, { nonSignal: Identifiers.contentQuery, signalBased: Identifiers.contentQuerySignal }, 
-        /* prependParams */ [variable('dirIndex')]).toStmt());
-        // Signal queries update lazily and we just advance the index.
-        if (query.isSignal) {
-            updateStatements.push(queryAdvancePlaceholder);
-            continue;
-        }
-        // update, e.g. (r3.queryRefresh(tmp = r3.loadQuery()) && (ctx.someDir = tmp));
-        const temporary = tempAllocator();
-        const getQueryList = importExpr(Identifiers.loadQuery).callFn([]);
-        const refresh = importExpr(Identifiers.queryRefresh).callFn([temporary.set(getQueryList)]);
-        const updateDirective = variable(CONTEXT_NAME)
-            .prop(query.propertyName)
-            .set(query.first ? temporary.prop('first') : temporary);
-        updateStatements.push(refresh.and(updateDirective).toStmt());
-    }
-    const contentQueriesFnName = name ? `${name}_ContentQueries` : null;
-    return fn([
-        new FnParam(RENDER_FLAGS, NUMBER_TYPE),
-        new FnParam(CONTEXT_NAME, null),
-        new FnParam('dirIndex', null),
-    ], [
-        renderFlagCheckIfStmt(1 /* core.RenderFlags.Create */, createStatements),
-        renderFlagCheckIfStmt(2 /* core.RenderFlags.Update */, collapseAdvanceStatements(updateStatements)),
-    ], INFERRED_TYPE, null, contentQueriesFnName);
-}
-
-class HtmlParser extends Parser$1 {
-    constructor() {
-        super(getHtmlTagDefinition);
-    }
-    parse(source, url, options) {
-        return super.parse(source, url, options);
-    }
-}
-
-const PROPERTY_PARTS_SEPARATOR = '.';
-const ATTRIBUTE_PREFIX = 'attr';
-const ANIMATE_PREFIX = 'animate';
-const CLASS_PREFIX = 'class';
-const STYLE_PREFIX = 'style';
-const TEMPLATE_ATTR_PREFIX$1 = '*';
-const LEGACY_ANIMATE_PROP_PREFIX = 'animate-';
-/**
- * Parses bindings in templates and in the directive host area.
- */
-class BindingParser {
-    _exprParser;
-    _interpolationConfig;
-    _schemaRegistry;
-    errors;
-    constructor(_exprParser, _interpolationConfig, _schemaRegistry, errors) {
-        this._exprParser = _exprParser;
-        this._interpolationConfig = _interpolationConfig;
-        this._schemaRegistry = _schemaRegistry;
-        this.errors = errors;
-    }
-    get interpolationConfig() {
-        return this._interpolationConfig;
-    }
-    createBoundHostProperties(properties, sourceSpan) {
-        const boundProps = [];
-        for (const propName of Object.keys(properties)) {
-            const expression = properties[propName];
-            if (typeof expression === 'string') {
-                this.parsePropertyBinding(propName, expression, true, false, sourceSpan, sourceSpan.start.offset, undefined, [], 
-                // Use the `sourceSpan` for  `keySpan`. This isn't really accurate, but neither is the
-                // sourceSpan, as it represents the sourceSpan of the host itself rather than the
-                // source of the host binding (which doesn't exist in the template). Regardless,
-                // neither of these values are used in Ivy but are only here to satisfy the function
-                // signature. This should likely be refactored in the future so that `sourceSpan`
-                // isn't being used inaccurately.
-                boundProps, sourceSpan);
-            }
-            else {
-                this._reportError(`Value of the host property binding "${propName}" needs to be a string representing an expression but got "${expression}" (${typeof expression})`, sourceSpan);
-            }
-        }
-        return boundProps;
-    }
-    createDirectiveHostEventAsts(hostListeners, sourceSpan) {
-        const targetEvents = [];
-        for (const propName of Object.keys(hostListeners)) {
-            const expression = hostListeners[propName];
-            if (typeof expression === 'string') {
-                // Use the `sourceSpan` for  `keySpan` and `handlerSpan`. This isn't really accurate, but
-                // neither is the `sourceSpan`, as it represents the `sourceSpan` of the host itself
-                // rather than the source of the host binding (which doesn't exist in the template).
-                // Regardless, neither of these values are used in Ivy but are only here to satisfy the
-                // function signature. This should likely be refactored in the future so that `sourceSpan`
-                // isn't being used inaccurately.
-                this.parseEvent(propName, expression, 
-                /* isAssignmentEvent */ false, sourceSpan, sourceSpan, [], targetEvents, sourceSpan);
-            }
-            else {
-                this._reportError(`Value of the host listener "${propName}" needs to be a string representing an expression but got "${expression}" (${typeof expression})`, sourceSpan);
-            }
-        }
-        return targetEvents;
-    }
-    parseInterpolation(value, sourceSpan, interpolatedTokens) {
-        const absoluteOffset = sourceSpan.fullStart.offset;
-        try {
-            const ast = this._exprParser.parseInterpolation(value, sourceSpan, absoluteOffset, interpolatedTokens, this._interpolationConfig);
-            if (ast) {
-                this.errors.push(...ast.errors);
-            }
-            return ast;
-        }
-        catch (e) {
-            this._reportError(`${e}`, sourceSpan);
-            return this._exprParser.wrapLiteralPrimitive('ERROR', sourceSpan, absoluteOffset);
-        }
-    }
-    /**
-     * Similar to `parseInterpolation`, but treats the provided string as a single expression
-     * element that would normally appear within the interpolation prefix and suffix (`{{` and `}}`).
-     * This is used for parsing the switch expression in ICUs.
-     */
-    parseInterpolationExpression(expression, sourceSpan) {
-        const absoluteOffset = sourceSpan.start.offset;
-        try {
-            const ast = this._exprParser.parseInterpolationExpression(expression, sourceSpan, absoluteOffset);
-            if (ast) {
-                this.errors.push(...ast.errors);
-            }
-            return ast;
-        }
-        catch (e) {
-            this._reportError(`${e}`, sourceSpan);
-            return this._exprParser.wrapLiteralPrimitive('ERROR', sourceSpan, absoluteOffset);
-        }
-    }
-    /**
-     * Parses the bindings in a microsyntax expression, and converts them to
-     * `ParsedProperty` or `ParsedVariable`.
-     *
-     * @param tplKey template binding name
-     * @param tplValue template binding value
-     * @param sourceSpan span of template binding relative to entire the template
-     * @param absoluteValueOffset start of the tplValue relative to the entire template
-     * @param targetMatchableAttrs potential attributes to match in the template
-     * @param targetProps target property bindings in the template
-     * @param targetVars target variables in the template
-     */
-    parseInlineTemplateBinding(tplKey, tplValue, sourceSpan, absoluteValueOffset, targetMatchableAttrs, targetProps, targetVars, isIvyAst) {
-        const absoluteKeyOffset = sourceSpan.start.offset + TEMPLATE_ATTR_PREFIX$1.length;
-        const bindings = this._parseTemplateBindings(tplKey, tplValue, sourceSpan, absoluteKeyOffset, absoluteValueOffset);
-        for (const binding of bindings) {
-            // sourceSpan is for the entire HTML attribute. bindingSpan is for a particular
-            // binding within the microsyntax expression so it's more narrow than sourceSpan.
-            const bindingSpan = moveParseSourceSpan(sourceSpan, binding.sourceSpan);
-            const key = binding.key.source;
-            const keySpan = moveParseSourceSpan(sourceSpan, binding.key.span);
-            if (binding instanceof VariableBinding) {
-                const value = binding.value ? binding.value.source : '$implicit';
-                const valueSpan = binding.value
-                    ? moveParseSourceSpan(sourceSpan, binding.value.span)
-                    : undefined;
-                targetVars.push(new ParsedVariable(key, value, bindingSpan, keySpan, valueSpan));
-            }
-            else if (binding.value) {
-                const srcSpan = isIvyAst ? bindingSpan : sourceSpan;
-                const valueSpan = moveParseSourceSpan(sourceSpan, binding.value.ast.sourceSpan);
-                this._parsePropertyAst(key, binding.value, false, srcSpan, keySpan, valueSpan, targetMatchableAttrs, targetProps);
-            }
-            else {
-                targetMatchableAttrs.push([key, '' /* value */]);
-                // Since this is a literal attribute with no RHS, source span should be
-                // just the key span.
-                this.parseLiteralAttr(key, null /* value */, keySpan, absoluteValueOffset, undefined /* valueSpan */, targetMatchableAttrs, targetProps, keySpan);
-            }
-        }
-    }
-    /**
-     * Parses the bindings in a microsyntax expression, e.g.
-     * ```html
-     *    <tag *tplKey="let value1 = prop; let value2 = localVar">
-     * ```
-     *
-     * @param tplKey template binding name
-     * @param tplValue template binding value
-     * @param sourceSpan span of template binding relative to entire the template
-     * @param absoluteKeyOffset start of the `tplKey`
-     * @param absoluteValueOffset start of the `tplValue`
-     */
-    _parseTemplateBindings(tplKey, tplValue, sourceSpan, absoluteKeyOffset, absoluteValueOffset) {
-        try {
-            const bindingsResult = this._exprParser.parseTemplateBindings(tplKey, tplValue, sourceSpan, absoluteKeyOffset, absoluteValueOffset);
-            bindingsResult.errors.forEach((e) => this.errors.push(e));
-            bindingsResult.warnings.forEach((warning) => {
-                this._reportError(warning, sourceSpan, ParseErrorLevel.WARNING);
-            });
-            return bindingsResult.templateBindings;
-        }
-        catch (e) {
-            this._reportError(`${e}`, sourceSpan);
-            return [];
-        }
-    }
-    parseLiteralAttr(name, value, sourceSpan, absoluteOffset, valueSpan, targetMatchableAttrs, targetProps, keySpan) {
-        if (isLegacyAnimationLabel(name)) {
-            name = name.substring(1);
-            if (keySpan !== undefined) {
-                keySpan = moveParseSourceSpan(keySpan, new AbsoluteSourceSpan(keySpan.start.offset + 1, keySpan.end.offset));
-            }
-            if (value) {
-                this._reportError(`Assigning animation triggers via @prop="exp" attributes with an expression is invalid.` +
-                    ` Use property bindings (e.g. [@prop]="exp") or use an attribute without a value (e.g. @prop) instead.`, sourceSpan, ParseErrorLevel.ERROR);
-            }
-            this._parseLegacyAnimation(name, value, sourceSpan, absoluteOffset, keySpan, valueSpan, targetMatchableAttrs, targetProps);
-        }
-        else {
-            targetProps.push(new ParsedProperty(name, this._exprParser.wrapLiteralPrimitive(value, '', absoluteOffset), ParsedPropertyType.LITERAL_ATTR, sourceSpan, keySpan, valueSpan));
-        }
-    }
-    parsePropertyBinding(name, expression, isHost, isPartOfAssignmentBinding, sourceSpan, absoluteOffset, valueSpan, targetMatchableAttrs, targetProps, keySpan) {
-        if (name.length === 0) {
-            this._reportError(`Property name is missing in binding`, sourceSpan);
-        }
-        let isLegacyAnimationProp = false;
-        if (name.startsWith(LEGACY_ANIMATE_PROP_PREFIX)) {
-            isLegacyAnimationProp = true;
-            name = name.substring(LEGACY_ANIMATE_PROP_PREFIX.length);
-            if (keySpan !== undefined) {
-                keySpan = moveParseSourceSpan(keySpan, new AbsoluteSourceSpan(keySpan.start.offset + LEGACY_ANIMATE_PROP_PREFIX.length, keySpan.end.offset));
-            }
-        }
-        else if (isLegacyAnimationLabel(name)) {
-            isLegacyAnimationProp = true;
-            name = name.substring(1);
-            if (keySpan !== undefined) {
-                keySpan = moveParseSourceSpan(keySpan, new AbsoluteSourceSpan(keySpan.start.offset + 1, keySpan.end.offset));
-            }
-        }
-        if (isLegacyAnimationProp) {
-            this._parseLegacyAnimation(name, expression, sourceSpan, absoluteOffset, keySpan, valueSpan, targetMatchableAttrs, targetProps);
-        }
-        else if (name.startsWith(`${ANIMATE_PREFIX}${PROPERTY_PARTS_SEPARATOR}`)) {
-            this._parseAnimation(name, this.parseBinding(expression, isHost, valueSpan || sourceSpan, absoluteOffset), sourceSpan, keySpan, valueSpan, targetMatchableAttrs, targetProps);
-        }
-        else {
-            this._parsePropertyAst(name, this.parseBinding(expression, isHost, valueSpan || sourceSpan, absoluteOffset), isPartOfAssignmentBinding, sourceSpan, keySpan, valueSpan, targetMatchableAttrs, targetProps);
-        }
-    }
-    parsePropertyInterpolation(name, value, sourceSpan, valueSpan, targetMatchableAttrs, targetProps, keySpan, interpolatedTokens) {
-        const expr = this.parseInterpolation(value, valueSpan || sourceSpan, interpolatedTokens);
-        if (expr) {
-            this._parsePropertyAst(name, expr, false, sourceSpan, keySpan, valueSpan, targetMatchableAttrs, targetProps);
-            return true;
-        }
-        return false;
-    }
-    _parsePropertyAst(name, ast, isPartOfAssignmentBinding, sourceSpan, keySpan, valueSpan, targetMatchableAttrs, targetProps) {
-        targetMatchableAttrs.push([name, ast.source]);
-        targetProps.push(new ParsedProperty(name, ast, isPartOfAssignmentBinding ? ParsedPropertyType.TWO_WAY : ParsedPropertyType.DEFAULT, sourceSpan, keySpan, valueSpan));
-    }
-    _parseAnimation(name, ast, sourceSpan, keySpan, valueSpan, targetMatchableAttrs, targetProps) {
-        targetMatchableAttrs.push([name, ast.source]);
-        targetProps.push(new ParsedProperty(name, ast, ParsedPropertyType.ANIMATION, sourceSpan, keySpan, valueSpan));
-    }
-    _parseLegacyAnimation(name, expression, sourceSpan, absoluteOffset, keySpan, valueSpan, targetMatchableAttrs, targetProps) {
-        if (name.length === 0) {
-            this._reportError('Animation trigger is missing', sourceSpan);
-        }
-        // 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);
-        targetMatchableAttrs.push([name, ast.source]);
-        targetProps.push(new ParsedProperty(name, ast, ParsedPropertyType.LEGACY_ANIMATION, sourceSpan, keySpan, valueSpan));
-    }
-    parseBinding(value, isHostBinding, sourceSpan, absoluteOffset) {
-        try {
-            const ast = isHostBinding
-                ? this._exprParser.parseSimpleBinding(value, sourceSpan, absoluteOffset, this._interpolationConfig)
-                : this._exprParser.parseBinding(value, sourceSpan, absoluteOffset, this._interpolationConfig);
-            if (ast) {
-                this.errors.push(...ast.errors);
-            }
-            return ast;
-        }
-        catch (e) {
-            this._reportError(`${e}`, sourceSpan);
-            return this._exprParser.wrapLiteralPrimitive('ERROR', sourceSpan, absoluteOffset);
-        }
-    }
-    createBoundElementProperty(elementSelector, boundProp, skipValidation = false, mapPropertyName = true) {
-        if (boundProp.isLegacyAnimation) {
-            return new BoundElementProperty(boundProp.name, BindingType.LegacyAnimation, SecurityContext$1.NONE, boundProp.expression, null, boundProp.sourceSpan, boundProp.keySpan, boundProp.valueSpan);
-        }
-        let unit = null;
-        let bindingType = undefined;
-        let boundPropertyName = null;
-        const parts = boundProp.name.split(PROPERTY_PARTS_SEPARATOR);
-        let securityContexts = undefined;
-        // Check for special cases (prefix style, attr, class)
-        if (parts.length > 1) {
-            if (parts[0] == ATTRIBUTE_PREFIX) {
-                boundPropertyName = parts.slice(1).join(PROPERTY_PARTS_SEPARATOR);
-                if (!skipValidation) {
-                    this._validatePropertyOrAttributeName(boundPropertyName, boundProp.sourceSpan, true);
-                }
-                securityContexts = calcPossibleSecurityContexts(this._schemaRegistry, elementSelector, boundPropertyName, true);
-                const nsSeparatorIdx = boundPropertyName.indexOf(':');
-                if (nsSeparatorIdx > -1) {
-                    const ns = boundPropertyName.substring(0, nsSeparatorIdx);
-                    const name = boundPropertyName.substring(nsSeparatorIdx + 1);
-                    boundPropertyName = mergeNsAndName(ns, name);
-                }
-                bindingType = BindingType.Attribute;
-            }
-            else if (parts[0] == CLASS_PREFIX) {
-                boundPropertyName = parts[1];
-                bindingType = BindingType.Class;
-                securityContexts = [SecurityContext$1.NONE];
-            }
-            else if (parts[0] == STYLE_PREFIX) {
-                unit = parts.length > 2 ? parts[2] : null;
-                boundPropertyName = parts[1];
-                bindingType = BindingType.Style;
-                securityContexts = [SecurityContext$1.STYLE];
-            }
-            else if (parts[0] == ANIMATE_PREFIX) {
-                boundPropertyName = boundProp.name;
-                bindingType = BindingType.Animation;
-                securityContexts = [SecurityContext$1.NONE];
-            }
-        }
-        // If not a special case, use the full property name
-        if (boundPropertyName === null) {
-            const mappedPropName = this._schemaRegistry.getMappedPropName(boundProp.name);
-            boundPropertyName = mapPropertyName ? mappedPropName : boundProp.name;
-            securityContexts = calcPossibleSecurityContexts(this._schemaRegistry, elementSelector, mappedPropName, false);
-            bindingType =
-                boundProp.type === ParsedPropertyType.TWO_WAY ? BindingType.TwoWay : BindingType.Property;
-            if (!skipValidation) {
-                this._validatePropertyOrAttributeName(mappedPropName, boundProp.sourceSpan, false);
-            }
-        }
-        return new BoundElementProperty(boundPropertyName, bindingType, securityContexts[0], boundProp.expression, unit, boundProp.sourceSpan, boundProp.keySpan, boundProp.valueSpan);
-    }
-    parseEvent(name, expression, isAssignmentEvent, sourceSpan, handlerSpan, targetMatchableAttrs, targetEvents, keySpan) {
-        if (name.length === 0) {
-            this._reportError(`Event name is missing in binding`, sourceSpan);
-        }
-        if (isLegacyAnimationLabel(name)) {
-            name = name.slice(1);
-            if (keySpan !== undefined) {
-                keySpan = moveParseSourceSpan(keySpan, new AbsoluteSourceSpan(keySpan.start.offset + 1, keySpan.end.offset));
-            }
-            this._parseLegacyAnimationEvent(name, expression, sourceSpan, handlerSpan, targetEvents, keySpan);
-        }
-        else {
-            this._parseRegularEvent(name, expression, isAssignmentEvent, sourceSpan, handlerSpan, targetMatchableAttrs, targetEvents, keySpan);
-        }
-    }
-    calcPossibleSecurityContexts(selector, propName, isAttribute) {
-        const prop = this._schemaRegistry.getMappedPropName(propName);
-        return calcPossibleSecurityContexts(this._schemaRegistry, selector, prop, isAttribute);
-    }
-    parseEventListenerName(rawName) {
-        const [target, eventName] = splitAtColon(rawName, [null, rawName]);
-        return { eventName: eventName, target };
-    }
-    parseLegacyAnimationEventName(rawName) {
-        const matches = splitAtPeriod(rawName, [rawName, null]);
-        return { eventName: matches[0], phase: matches[1] === null ? null : matches[1].toLowerCase() };
-    }
-    _parseLegacyAnimationEvent(name, expression, sourceSpan, handlerSpan, targetEvents, keySpan) {
-        const { eventName, phase } = this.parseLegacyAnimationEventName(name);
-        const ast = this._parseAction(expression, handlerSpan);
-        targetEvents.push(new ParsedEvent(eventName, phase, ParsedEventType.LegacyAnimation, ast, sourceSpan, handlerSpan, keySpan));
-        if (eventName.length === 0) {
-            this._reportError(`Animation event name is missing in binding`, sourceSpan);
-        }
-        if (phase) {
-            if (phase !== 'start' && phase !== 'done') {
-                this._reportError(`The provided animation output phase value "${phase}" for "@${eventName}" is not supported (use start or done)`, sourceSpan);
-            }
-        }
-        else {
-            this._reportError(`The animation trigger output event (@${eventName}) is missing its phase value name (start or done are currently supported)`, sourceSpan);
-        }
-    }
-    _parseRegularEvent(name, expression, isAssignmentEvent, sourceSpan, handlerSpan, targetMatchableAttrs, targetEvents, keySpan) {
-        // long format: 'target: eventName'
-        const { eventName, target } = this.parseEventListenerName(name);
-        const prevErrorCount = this.errors.length;
-        const ast = this._parseAction(expression, handlerSpan);
-        const isValid = this.errors.length === prevErrorCount;
-        targetMatchableAttrs.push([name, ast.source]);
-        // Don't try to validate assignment events if there were other
-        // parsing errors to avoid adding more noise to the error logs.
-        if (isAssignmentEvent && isValid && !this._isAllowedAssignmentEvent(ast)) {
-            this._reportError('Unsupported expression in a two-way binding', sourceSpan);
-        }
-        let eventType = ParsedEventType.Regular;
-        if (isAssignmentEvent) {
-            eventType = ParsedEventType.TwoWay;
-        }
-        if (name.startsWith(`${ANIMATE_PREFIX}${PROPERTY_PARTS_SEPARATOR}`)) {
-            eventType = ParsedEventType.Animation;
+        else {
+            return null;
         }
-        targetEvents.push(new ParsedEvent(eventName, target, eventType, ast, sourceSpan, handlerSpan, keySpan));
-        // Don't detect directives for event names for now,
-        // so don't add the event name to the matchableAttrs
     }
-    _parseAction(value, sourceSpan) {
-        const absoluteOffset = sourceSpan && sourceSpan.start ? sourceSpan.start.offset : 0;
-        try {
-            const ast = this._exprParser.parseAction(value, sourceSpan, absoluteOffset, this._interpolationConfig);
-            if (ast) {
-                this.errors.push(...ast.errors);
-            }
-            if (!ast || ast.ast instanceof EmptyExpr$1) {
-                this._reportError(`Empty expressions are not allowed`, sourceSpan);
-                return this._exprParser.wrapLiteralPrimitive('ERROR', sourceSpan, absoluteOffset);
+    // If we've found a single root node, its tag name and attributes can be
+    // copied to the surrounding template to be used for content projection.
+    if (root !== null) {
+        // Collect the static attributes for content projection purposes.
+        for (const attr of root.attributes) {
+            if (!attr.name.startsWith(ANIMATE_PREFIX)) {
+                const securityContext = domSchema.securityContext(NG_TEMPLATE_TAG_NAME, attr.name, true);
+                unit.update.push(createBindingOp(xref, BindingKind.Attribute, attr.name, literal(attr.value), null, securityContext, true, false, null, asMessage(attr.i18n), attr.sourceSpan));
             }
-            return ast;
         }
-        catch (e) {
-            this._reportError(`${e}`, sourceSpan);
-            return this._exprParser.wrapLiteralPrimitive('ERROR', sourceSpan, absoluteOffset);
+        // Also collect the inputs since they participate in content projection as well.
+        // Note that TDB used to collect the outputs as well, but it wasn't passing them into
+        // the template instruction. Here we just don't collect them.
+        for (const attr of root.inputs) {
+            if (attr.type !== BindingType.LegacyAnimation &&
+                attr.type !== BindingType.Animation &&
+                attr.type !== BindingType.Attribute) {
+                const securityContext = domSchema.securityContext(NG_TEMPLATE_TAG_NAME, attr.name, true);
+                unit.create.push(createExtractedAttributeOp(xref, BindingKind.Property, null, attr.name, null, null, null, securityContext));
+            }
         }
+        const tagName = root instanceof Element$1 ? root.name : root.tagName;
+        // Don't pass along `ng-template` tag name since it enables directive matching.
+        return tagName === NG_TEMPLATE_TAG_NAME ? null : tagName;
     }
-    _reportError(message, sourceSpan, level = ParseErrorLevel.ERROR) {
-        this.errors.push(new ParseError(sourceSpan, message, level));
-    }
-    /**
-     * @param propName the name of the property / attribute
-     * @param sourceSpan
-     * @param isAttr true when binding to an attribute
-     */
-    _validatePropertyOrAttributeName(propName, sourceSpan, isAttr) {
-        const report = isAttr
-            ? this._schemaRegistry.validateAttribute(propName)
-            : this._schemaRegistry.validateProperty(propName);
-        if (report.error) {
-            this._reportError(report.msg, sourceSpan, ParseErrorLevel.ERROR);
-        }
+    return null;
+}
+
+/*!
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+/**
+ * Whether to produce instructions that will attach the source location to each DOM node.
+ *
+ * !!!Important!!! at the time of writing this flag isn't exposed externally, but internal debug
+ * tools enable it via a local change. Any modifications to this flag need to update the
+ * internal tooling as well.
+ */
+let ENABLE_TEMPLATE_SOURCE_LOCATIONS = false;
+/** Gets whether template source locations are enabled. */
+function getTemplateSourceLocationsEnabled() {
+    return ENABLE_TEMPLATE_SOURCE_LOCATIONS;
+}
+
+//  if (rf & flags) { .. }
+function renderFlagCheckIfStmt(flags, statements) {
+    return ifStmt(variable(RENDER_FLAGS).bitwiseAnd(literal(flags), null), statements);
+}
+/**
+ * Translates query flags into `TQueryFlags` type in
+ * packages/core/src/render3/interfaces/query.ts
+ * @param query
+ */
+function toQueryFlags(query) {
+    return ((query.descendants ? 1 /* QueryFlags.descendants */ : 0 /* QueryFlags.none */) |
+        (query.static ? 2 /* QueryFlags.isStatic */ : 0 /* QueryFlags.none */) |
+        (query.emitDistinctChangesOnly ? 4 /* QueryFlags.emitDistinctChangesOnly */ : 0 /* QueryFlags.none */));
+}
+function getQueryPredicate(query, constantPool) {
+    if (Array.isArray(query.predicate)) {
+        let predicate = [];
+        query.predicate.forEach((selector) => {
+            // Each item in predicates array may contain strings with comma-separated refs
+            // (for ex. 'ref, ref1, ..., refN'), thus we extract individual refs and store them
+            // as separate array entities
+            const selectors = selector.split(',').map((token) => literal(token.trim()));
+            predicate.push(...selectors);
+        });
+        return constantPool.getConstLiteral(literalArr(predicate), true);
     }
-    /**
-     * Returns whether a parsed AST is allowed to be used within the event side of a two-way binding.
-     * @param ast Parsed AST to be checked.
-     */
-    _isAllowedAssignmentEvent(ast) {
-        if (ast instanceof ASTWithSource) {
-            return this._isAllowedAssignmentEvent(ast.ast);
-        }
-        if (ast instanceof NonNullAssert) {
-            return this._isAllowedAssignmentEvent(ast.expression);
-        }
-        if (ast instanceof Call &&
-            ast.args.length === 1 &&
-            ast.receiver instanceof PropertyRead &&
-            ast.receiver.name === '$any' &&
-            ast.receiver.receiver instanceof ImplicitReceiver &&
-            !(ast.receiver.receiver instanceof ThisReceiver)) {
-            return this._isAllowedAssignmentEvent(ast.args[0]);
-        }
-        if (ast instanceof PropertyRead || ast instanceof KeyedRead) {
-            if (!hasRecursiveSafeReceiver(ast)) {
-                return true;
-            }
+    else {
+        // The original predicate may have been wrapped in a `forwardRef()` call.
+        switch (query.predicate.forwardRef) {
+            case 0 /* ForwardRefHandling.None */:
+            case 2 /* ForwardRefHandling.Unwrapped */:
+                return query.predicate.expression;
+            case 1 /* ForwardRefHandling.Wrapped */:
+                return importExpr(Identifiers.resolveForwardRef).callFn([query.predicate.expression]);
         }
-        return false;
     }
 }
-function hasRecursiveSafeReceiver(ast) {
-    if (ast instanceof SafePropertyRead || ast instanceof SafeKeyedRead) {
-        return true;
+function createQueryCreateCall(query, constantPool, queryTypeFns, prependParams) {
+    const parameters = [];
+    if (prependParams !== undefined) {
+        parameters.push(...prependParams);
     }
-    if (ast instanceof ParenthesizedExpression) {
-        return hasRecursiveSafeReceiver(ast.expression);
+    if (query.isSignal) {
+        parameters.push(new ReadPropExpr(variable(CONTEXT_NAME), query.propertyName));
     }
-    if (ast instanceof PropertyRead || ast instanceof KeyedRead || ast instanceof Call) {
-        return hasRecursiveSafeReceiver(ast.receiver);
+    parameters.push(getQueryPredicate(query, constantPool), literal(toQueryFlags(query)));
+    if (query.read) {
+        parameters.push(query.read);
     }
-    return false;
-}
-function isLegacyAnimationLabel(name) {
-    return name[0] == '@';
+    const queryCreateFn = query.isSignal ? queryTypeFns.signalBased : queryTypeFns.nonSignal;
+    return importExpr(queryCreateFn).callFn(parameters);
 }
-function calcPossibleSecurityContexts(registry, selector, propName, isAttribute) {
-    let ctxs;
-    const nameToContext = (elName) => registry.securityContext(elName, propName, isAttribute);
-    if (selector === null) {
-        ctxs = registry.allKnownElementNames().map(nameToContext);
+const queryAdvancePlaceholder = Symbol('queryAdvancePlaceholder');
+/**
+ * Collapses query advance placeholders in a list of statements.
+ *
+ * This allows for less generated code because multiple sibling query advance
+ * statements can be collapsed into a single call with the count as argument.
+ *
+ * e.g.
+ *
+ * ```ts
+ *   bla();
+ *   queryAdvance();
+ *   queryAdvance();
+ *   bla();
+ * ```
+ *
+ *   --> will turn into
+ *
+ * ```ts
+ *   bla();
+ *   queryAdvance(2);
+ *   bla();
+ * ```
+ */
+function collapseAdvanceStatements(statements) {
+    const result = [];
+    let advanceCollapseCount = 0;
+    const flushAdvanceCount = () => {
+        if (advanceCollapseCount > 0) {
+            result.unshift(importExpr(Identifiers.queryAdvance)
+                .callFn(advanceCollapseCount === 1 ? [] : [literal(advanceCollapseCount)])
+                .toStmt());
+            advanceCollapseCount = 0;
+        }
+    };
+    // Iterate through statements in reverse and collapse advance placeholders.
+    for (let i = statements.length - 1; i >= 0; i--) {
+        const st = statements[i];
+        if (st === queryAdvancePlaceholder) {
+            advanceCollapseCount++;
+        }
+        else {
+            flushAdvanceCount();
+            result.unshift(st);
+        }
     }
-    else {
-        ctxs = [];
-        CssSelector.parse(selector).forEach((selector) => {
-            const elementNames = selector.element ? [selector.element] : registry.allKnownElementNames();
-            const notElementNames = new Set(selector.notSelectors
-                .filter((selector) => selector.isElementSelector())
-                .map((selector) => selector.element));
-            const possibleElementNames = elementNames.filter((elName) => !notElementNames.has(elName));
-            ctxs.push(...possibleElementNames.map(nameToContext));
+    flushAdvanceCount();
+    return result;
+}
+// Define and update any view queries
+function createViewQueriesFunction(viewQueries, constantPool, name) {
+    const createStatements = [];
+    const updateStatements = [];
+    const tempAllocator = temporaryAllocator((st) => updateStatements.push(st), TEMPORARY_NAME);
+    viewQueries.forEach((query) => {
+        // creation call, e.g. r3.viewQuery(somePredicate, true) or
+        //                r3.viewQuerySignal(ctx.prop, somePredicate, true);
+        const queryDefinitionCall = createQueryCreateCall(query, constantPool, {
+            signalBased: Identifiers.viewQuerySignal,
+            nonSignal: Identifiers.viewQuery,
         });
+        createStatements.push(queryDefinitionCall.toStmt());
+        // Signal queries update lazily and we just advance the index.
+        if (query.isSignal) {
+            updateStatements.push(queryAdvancePlaceholder);
+            return;
+        }
+        // update, e.g. (r3.queryRefresh(tmp = r3.loadQuery()) && (ctx.someDir = tmp));
+        const temporary = tempAllocator();
+        const getQueryList = importExpr(Identifiers.loadQuery).callFn([]);
+        const refresh = importExpr(Identifiers.queryRefresh).callFn([temporary.set(getQueryList)]);
+        const updateDirective = variable(CONTEXT_NAME)
+            .prop(query.propertyName)
+            .set(query.first ? temporary.prop('first') : temporary);
+        updateStatements.push(refresh.and(updateDirective).toStmt());
+    });
+    const viewQueryFnName = name ? `${name}_Query` : null;
+    return fn([new FnParam(RENDER_FLAGS, NUMBER_TYPE), new FnParam(CONTEXT_NAME, null)], [
+        renderFlagCheckIfStmt(1 /* core.RenderFlags.Create */, createStatements),
+        renderFlagCheckIfStmt(2 /* core.RenderFlags.Update */, collapseAdvanceStatements(updateStatements)),
+    ], INFERRED_TYPE, null, viewQueryFnName);
+}
+// Define and update any content queries
+function createContentQueriesFunction(queries, constantPool, name) {
+    const createStatements = [];
+    const updateStatements = [];
+    const tempAllocator = temporaryAllocator((st) => updateStatements.push(st), TEMPORARY_NAME);
+    for (const query of queries) {
+        // creation, e.g. r3.contentQuery(dirIndex, somePredicate, true, null) or
+        //                r3.contentQuerySignal(dirIndex, propName, somePredicate, <flags>, <read>).
+        createStatements.push(createQueryCreateCall(query, constantPool, { nonSignal: Identifiers.contentQuery, signalBased: Identifiers.contentQuerySignal }, 
+        /* prependParams */ [variable('dirIndex')]).toStmt());
+        // Signal queries update lazily and we just advance the index.
+        if (query.isSignal) {
+            updateStatements.push(queryAdvancePlaceholder);
+            continue;
+        }
+        // update, e.g. (r3.queryRefresh(tmp = r3.loadQuery()) && (ctx.someDir = tmp));
+        const temporary = tempAllocator();
+        const getQueryList = importExpr(Identifiers.loadQuery).callFn([]);
+        const refresh = importExpr(Identifiers.queryRefresh).callFn([temporary.set(getQueryList)]);
+        const updateDirective = variable(CONTEXT_NAME)
+            .prop(query.propertyName)
+            .set(query.first ? temporary.prop('first') : temporary);
+        updateStatements.push(refresh.and(updateDirective).toStmt());
     }
-    return ctxs.length === 0 ? [SecurityContext$1.NONE] : Array.from(new Set(ctxs)).sort();
+    const contentQueriesFnName = name ? `${name}_ContentQueries` : null;
+    return fn([
+        new FnParam(RENDER_FLAGS, NUMBER_TYPE),
+        new FnParam(CONTEXT_NAME, null),
+        new FnParam('dirIndex', null),
+    ], [
+        renderFlagCheckIfStmt(1 /* core.RenderFlags.Create */, createStatements),
+        renderFlagCheckIfStmt(2 /* core.RenderFlags.Update */, collapseAdvanceStatements(updateStatements)),
+    ], INFERRED_TYPE, null, contentQueriesFnName);
 }
-/**
- * Compute a new ParseSourceSpan based off an original `sourceSpan` by using
- * absolute offsets from the specified `absoluteSpan`.
- *
- * @param sourceSpan original source span
- * @param absoluteSpan absolute source span to move to
- */
-function moveParseSourceSpan(sourceSpan, absoluteSpan) {
-    // The difference of two absolute offsets provide the relative offset
-    const startDiff = absoluteSpan.start - sourceSpan.start.offset;
-    const endDiff = absoluteSpan.end - sourceSpan.end.offset;
-    return new ParseSourceSpan(sourceSpan.start.moveBy(startDiff), sourceSpan.end.moveBy(endDiff), sourceSpan.fullStart.moveBy(startDiff), sourceSpan.details);
+
+class HtmlParser extends Parser$1 {
+    constructor() {
+        super(getHtmlTagDefinition);
+    }
+    parse(source, url, options) {
+        return super.parse(source, url, options);
+    }
 }
 
 // Some of the code comes from WebComponents.JS
@@ -27494,7 +27616,7 @@ const LINK_STYLE_REL_ATTR = 'rel';
 const LINK_STYLE_HREF_ATTR = 'href';
 const LINK_STYLE_REL_VALUE = 'stylesheet';
 const STYLE_ELEMENT = 'style';
-const SCRIPT_ELEMENT = 'script';
+const SCRIPT_ELEMENTS = new Set([':svg:script', 'script']);
 const NG_NON_BINDABLE_ATTR = 'ngNonBindable';
 const NG_PROJECT_AS = 'ngProjectAs';
 function preparseElement(ast) {
@@ -27503,7 +27625,7 @@ function preparseElement(ast) {
     let relAttr = null;
     let nonBindable = false;
     let projectAs = '';
-    ast.attrs.forEach((attr) => {
+    for (const attr of ast.attrs) {
         const lcAttrName = attr.name.toLowerCase();
         if (lcAttrName == NG_CONTENT_SELECT_ATTR) {
             selectAttr = attr.value;
@@ -27522,17 +27644,18 @@ function preparseElement(ast) {
                 projectAs = attr.value;
             }
         }
-    });
-    selectAttr = normalizeNgContentSelect(selectAttr);
+    }
+    // Normalize selector to '*' if empty
+    selectAttr ||= '*';
     const nodeName = ast.name.toLowerCase();
     let type = PreparsedElementType.OTHER;
     if (isNgContent(nodeName)) {
         type = PreparsedElementType.NG_CONTENT;
     }
-    else if (nodeName == STYLE_ELEMENT) {
+    else if (STYLE_ELEMENT === nodeName) {
         type = PreparsedElementType.STYLE;
     }
-    else if (nodeName == SCRIPT_ELEMENT) {
+    else if (SCRIPT_ELEMENTS.has(nodeName)) {
         type = PreparsedElementType.SCRIPT;
     }
     else if (nodeName == LINK_ELEMENT && relAttr == LINK_STYLE_REL_VALUE) {
@@ -27562,12 +27685,6 @@ class PreparsedElement {
         this.projectAs = projectAs;
     }
 }
-function normalizeNgContentSelect(selectAttr) {
-    if (selectAttr === null || selectAttr.length === 0) {
-        return '*';
-    }
-    return selectAttr;
-}
 
 /** Pattern for the expression in a for loop block. */
 const FOR_LOOP_EXPRESSION_PATTERN = /^\s*([0-9A-Za-z_$]*)\s+of\s+([\S\s]*)/;
@@ -28855,8 +28972,9 @@ class HtmlAstToIvyAst {
                 // Note that validation is skipped and property mapping is disabled
                 // due to the fact that we need to make sure a given prop is not an
                 // input of a directive and directive matching happens at runtime.
+                const isAttrOn = prop.name.toLowerCase().startsWith('attr.on');
                 const bep = this.bindingParser.createBoundElementProperty(elementName, prop, 
-                /* skipValidation */ true, 
+                /* skipValidation */ !isAttrOn, 
                 /* mapPropertyName */ false);
                 bound.push(BoundAttribute.fromBoundElementProperty(bep, i18n));
             }
@@ -29752,8 +29870,30 @@ function verifyHostBindings(bindings, sourceSpan) {
     const bindingParser = makeBindingParser();
     bindingParser.createDirectiveHostEventAsts(bindings.listeners, sourceSpan);
     bindingParser.createBoundHostProperties(bindings.properties, sourceSpan);
+    validateNoEventBindings(bindings, bindingParser, sourceSpan);
     return bindingParser.errors;
 }
+/**
+ * Validates that there are no event attribute bindings in the host bindings.
+ * @param bindings - Map of host bindings for the component.
+ * @param bindingParser - Binding parser used to create the binding expression.
+ * @param sourceSpan - Source span where the host bindings were defined.
+ */
+function validateNoEventBindings(bindings, bindingParser, sourceSpan) {
+    for (const prop in bindings.properties) {
+        const isAttr = prop.startsWith('attr.');
+        const boundName = isAttr ? prop.slice(5) : prop;
+        if (boundName.toLowerCase().startsWith('on')) {
+            const errorType = isAttr ? 'attribute' : 'property';
+            const suggestion = `(${boundName.slice(2)})=...`;
+            let msg = `Binding to event ${errorType} '${boundName}' is disallowed for security reasons, please use ${suggestion}`;
+            if (!isAttr) {
+                msg += `\nIf '${prop}' is a directive input, make sure the directive is imported by the current module.`;
+            }
+            bindingParser.errors.push(new ParseError(sourceSpan, msg));
+        }
+    }
+}
 function compileStyles(styles, selector, hostSelector) {
     const shadowCss = new ShadowCss();
     return styles.map((style) => {
@@ -31357,11 +31497,6 @@ function createR3ComponentDeferMetadata(boundTarget, deferBlockDependencies) {
 function extractHostBindings(propMetadata, sourceSpan, host) {
     // First parse the declarations from the metadata.
     const bindings = parseHostBindings(host || {});
-    // After that check host bindings for errors
-    const errors = verifyHostBindings(bindings, sourceSpan);
-    if (errors.length) {
-        throw new Error(errors.map((error) => error.msg).join('\n'));
-    }
     // Next, loop over the properties of the object, looking for @HostBinding and @HostListener.
     for (const field in propMetadata) {
         if (propMetadata.hasOwnProperty(field)) {
@@ -31378,6 +31513,11 @@ function extractHostBindings(propMetadata, sourceSpan, host) {
             });
         }
     }
+    // After that check host bindings for errors
+    const errors = verifyHostBindings(bindings, sourceSpan);
+    if (errors.length) {
+        throw new Error(errors.map((error) => error.msg).join('\n'));
+    }
     return bindings;
 }
 function isHostBinding(value) {
@@ -31512,7 +31652,7 @@ var _VisitorMode;
  * @description
  * Entry point for all public APIs of the compiler package.
  */
-new Version$1('20.3.19');
+new Version$1('20.3.28');
 
 //////////////////////////////////////
 // THIS FILE HAS GLOBAL SIDE EFFECT //
@@ -40750,11 +40890,22 @@ function requireConventions () {
 		XMLNS: 'http://www.w3.org/2000/xmlns/',
 	});
 
+	//[4]   	NameStartChar	   ::=   	":" | [A-Z] | "_" | [a-z] | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x2FF] | [#x370-#x37D] | [#x37F-#x1FFF] | [#x200C-#x200D] | [#x2070-#x218F] | [#x2C00-#x2FEF] | [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]
+	//[4a]   	NameChar	   ::=   	NameStartChar | "-" | "." | [0-9] | #xB7 | [#x0300-#x036F] | [#x203F-#x2040]
+	//[5]   	Name	   ::=   	NameStartChar (NameChar)*
+	var nameStartChar = /[A-Z_a-z\xC0-\xD6\xD8-\xF6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/;//\u10000-\uEFFFF
+	var nameChar = new RegExp("[\\-\\.0-9"+nameStartChar.source.slice(1,-1)+"\\u00B7\\u0300-\\u036F\\u203F-\\u2040]");
+	var tagNamePattern = new RegExp('^'+nameStartChar.source+nameChar.source+'*(?:\:'+nameStartChar.source+nameChar.source+'*)?$');
+	//var tagNamePattern = /^[a-zA-Z_][\w\-\.]*(?:\:[a-zA-Z_][\w\-\.]*)?$/
+
 	conventions.assign = assign;
 	conventions.find = find;
 	conventions.freeze = freeze;
 	conventions.MIME_TYPE = MIME_TYPE;
 	conventions.NAMESPACE = NAMESPACE;
+	conventions.nameStartChar = nameStartChar;
+	conventions.nameChar = nameChar;
+	conventions.tagNamePattern = tagNamePattern;
 	return conventions;
 }
 
@@ -40767,6 +40918,7 @@ function requireDom () {
 
 	var find = conventions.find;
 	var NAMESPACE = conventions.NAMESPACE;
+	var tagNamePattern = conventions.tagNamePattern;
 
 	/**
 	 * A prerequisite for `[].filter`, to drop elements that are empty
@@ -40998,6 +41150,13 @@ function requireDom () {
 	 * used for attributes or DocumentType entities
 	 */
 	function NamedNodeMap() {
+		// nodeName -> Attr membership index; lets the parse-time de-duplication in
+		// setNamedItem resolve an existing attribute in O(1) instead of scanning the
+		// list, so building an element with M attributes costs O(M) rather than O(M^2).
+		// The numbered entries and length remain the sole authority for attribute order.
+		// Object.create(null) so an attribute named __proto__ or constructor is an
+		// ordinary key.
+		this._nameIndex = Object.create(null);
 	}
 	function _findNodeIndex(list,node){
 		var i = list.length;
@@ -41006,12 +41165,27 @@ function requireDom () {
 		}
 	}
 
+	function _nnmIndexAdd(list, attr) {
+		list._nameIndex[attr.nodeName] = attr;
+	}
+	function _nnmIndexRemove(list, attr) {
+		// Only drop the entry if it still points at this attribute; a replacement with
+		// a different nodeName may already have re-keyed it.
+		if (list._nameIndex[attr.nodeName] === attr) {
+			delete list._nameIndex[attr.nodeName];
+		}
+	}
+
 	function _addNamedNode(el,list,newAttr,oldAttr){
 		if(oldAttr){
 			list[_findNodeIndex(list,oldAttr)] = newAttr;
+			// oldAttr leaves the list; drop its index entry (its nodeName may differ
+			// from newAttr's when the replacement came via setNamedItemNS).
+			_nnmIndexRemove(list, oldAttr);
 		}else {
 			list[list.length++] = newAttr;
 		}
+		_nnmIndexAdd(list, newAttr);
 		if(el){
 			newAttr.ownerElement = el;
 			var doc = el.ownerDocument;
@@ -41030,6 +41204,7 @@ function requireDom () {
 				list[i] = list[++i];
 			}
 			list.length = lastIndex;
+			_nnmIndexRemove(list, attr);
 			if(el){
 				var doc = el.ownerDocument;
 				if(doc){
@@ -41063,7 +41238,11 @@ function requireDom () {
 			if(el && el!=this._ownerElement){
 				throw new DOMException(INUSE_ATTRIBUTE_ERR);
 			}
-			var oldAttr = this.getNamedItem(attr.nodeName);
+			// Resolve any existing attribute with the same nodeName through the O(1)
+			// membership index rather than an O(M) scan — this is the parse-dedup hot
+			// path (setAttributeNode per attribute during parse). Absent -> undefined,
+			// matching getNamedItem's contract.
+			var oldAttr = this._nameIndex[attr.nodeName];
 			_addNamedNode(this._ownerElement,this,attr,oldAttr);
 			return oldAttr;
 		},
@@ -41296,9 +41475,38 @@ function requireDom () {
 					while (child) {
 						var next = child.nextSibling;
 						if (next !== null && next.nodeType === TEXT_NODE && child.nodeType === TEXT_NODE) {
-							node.removeChild(next);
-							child.appendData(next.data);
-							// Do not advance child: re-check new nextSibling for another text run
+							// Merge the whole run of adjacent text nodes at once: gather the
+							// following text siblings' data, unlink them in a single pass, and
+							// re-index the child list a single time. Per-sibling `removeChild`
+							// (each an O(K) re-index) plus per-sibling `appendData` (each an O(K)
+							// string rebuild) is O(K^2) over a long run of single-character text
+							// nodes; this keeps it O(K). The first text node of the run survives
+							// and carries the concatenated data, preserving node identity and
+							// locator semantics.
+							var tail = [];
+							var sibling = next;
+							while (sibling !== null && sibling.nodeType === TEXT_NODE) {
+								tail.push(sibling.data);
+								sibling = sibling.nextSibling;
+							}
+							// `sibling` is now the first non-text node after the run, or null.
+							var removed = child.nextSibling;
+							while (removed !== sibling) {
+								var following = removed.nextSibling;
+								removed.parentNode = null;
+								removed.previousSibling = null;
+								removed.nextSibling = null;
+								removed = following;
+							}
+							child.nextSibling = sibling;
+							if (sibling !== null) {
+								sibling.previousSibling = child;
+							} else {
+								node.lastChild = child;
+							}
+							child.appendData(tail.join('')); // single O(K) string rebuild
+							_onUpdateChild(node.ownerDocument, node); // single O(K) re-index
+							child = sibling;
 						} else {
 							child = next;
 						}
@@ -42109,8 +42317,10 @@ function requireDom () {
 		 * - it does not do any input validation on the arguments and doesn't throw "InvalidCharacterError".
 		 *
 		 * Note: When the resulting document is serialized with `requireWellFormed: true`, the
-		 * serializer throws with code `INVALID_STATE_ERR` if `.data` contains `?>` (W3C DOM Parsing
-		 * §3.2.1.7). Without that option the data is emitted verbatim.
+		 * serializer throws with code `INVALID_STATE_ERR` if `.target` is not a valid XML `NCName`
+		 * (a `Name` with no colon) or is an ASCII case-insensitive match for `"xml"`, or if `.data`
+		 * contains `?>` (W3C DOM Parsing §3.2.1.7). Without that option the target and data are
+		 * emitted verbatim.
 		 *
 		 * @param {string} target
 		 * @param {string} data
@@ -42135,7 +42345,27 @@ function requireDom () {
 			node.specified = true;
 			return node;
 		},
+		/**
+		 * Creates an EntityReference object, serialized as `&name;`.
+		 *
+		 * The `name` is validated against the XML `Name` production at creation time; an invalid name
+		 * throws a `DOMException` with code `INVALID_CHARACTER_ERR`. When the resulting node is
+		 * serialized with `requireWellFormed: true`, the serializer re-validates `nodeName` and throws
+		 * a `DOMException` with code `INVALID_STATE_ERR` if a later `nodeName` mutation made it invalid;
+		 * without that option the name is emitted verbatim.
+		 *
+		 * Note: xmldom does not expand entities — the parser resolves entity references inline and never
+		 * constructs `EntityReference` nodes, so this method is the only producer.
+		 *
+		 * @param {string} name The name of the entity to reference.
+		 * @returns {EntityReference}
+		 * @throws {DOMException} With code `INVALID_CHARACTER_ERR` when `name` is not a valid XML `Name`.
+		 * @see https://www.w3.org/TR/DOM-Level-3-Core/core.html#ID-392B75AE
+		 */
 		createEntityReference :	function(name){
+			if (!tagNamePattern.test(name)) {
+				throw new DOMException(INVALID_CHARACTER_ERR, 'not a valid xml name "' + name + '"');
+			}
 			var node = new EntityReference();
 			node.ownerDocument	= this;
 			node.nodeName	= name;
@@ -42347,15 +42577,16 @@ function requireDom () {
 	/**
 	 * Represents a DocumentType node (the `<!DOCTYPE ...>` declaration).
 	 *
-	 * `publicId`, `systemId`, and `internalSubset` are plain own-property assignments.
+	 * `name`, `publicId`, `systemId`, and `internalSubset` are plain own-property assignments.
 	 * xmldom does not enforce the `readonly` constraint declared by the WHATWG DOM spec —
 	 * direct property writes succeed silently. Values are serialized verbatim when
 	 * `requireWellFormed` is false (the default). When the serializer is invoked with
 	 * `requireWellFormed: true` (via the 4th-parameter options object), it validates each
-	 * field and throws `DOMException` with code `INVALID_STATE_ERR` on invalid values.
+	 * field — including `name`, which is checked against the XML `Name` production — and throws
+	 * `DOMException` with code `INVALID_STATE_ERR` on invalid values.
 	 *
 	 * @class
-	 * @see https://developer.mozilla.org/en-US/docs/Web/API/DocumentType MDN
+	 * @see https://developer.mozilla.org/docs/Web/API/DocumentType MDN
 	 */
 	function DocumentType() {
 	}	DocumentType.prototype.nodeType = DOCUMENT_TYPE_NODE;
@@ -42369,6 +42600,20 @@ function requireDom () {
 	}	Entity.prototype.nodeType = ENTITY_NODE;
 	_extends(Entity,Node);
 
+	/**
+	 * Represents an EntityReference node, serialized as `&nodeName;`.
+	 *
+	 * `nodeName` is the referenced entity's name, stored verbatim. When serialized with
+	 * `requireWellFormed: true`, the serializer validates `nodeName` against the XML `Name` production
+	 * and throws a `DOMException` with code `INVALID_STATE_ERR` if it does not match; without that
+	 * option the name is emitted verbatim between `&` and `;`.
+	 *
+	 * Note: xmldom does not expand entities — the parser resolves entity references inline and never
+	 * constructs `EntityReference` nodes, so the only producer is `Document.createEntityReference`.
+	 *
+	 * @class
+	 * @see https://www.w3.org/TR/xml/#NT-Name
+	 */
 	function EntityReference() {
 	}	EntityReference.prototype.nodeType = ENTITY_REFERENCE_NODE;
 	_extends(EntityReference,Node);
@@ -42406,14 +42651,20 @@ function requireDom () {
 	 * @returns {string}
 	 * @throws {DOMException}
 	 * With code `INVALID_STATE_ERR` when `requireWellFormed` is `true` and:
+	 * - an Element's qualified name (including any namespace prefix) is not a valid XML QName,
+	 * - an attribute's qualified name (including a synthesized `xmlns:` namespace declaration) is
+	 *   not a valid XML QName,
 	 * - a CDATASection node's data contains `"]]>"`,
 	 * - a Comment node's data contains `"-->"` (bare `"--"` does not throw on this branch),
-	 * - a ProcessingInstruction's data contains `"?>"`,
+	 * - a ProcessingInstruction's target is not a valid XML `NCName` (a `Name` with no colon) or is
+	 *   an ASCII case-insensitive match for `"xml"`, or its data contains `"?>"`,
+	 * - a DocumentType's `name` is not a valid XML `Name` (XML 1.0 production [5]),
 	 * - a DocumentType's `publicId` is non-empty and does not match the XML `PubidLiteral`
 	 *   production,
 	 * - a DocumentType's `systemId` is non-empty and does not match the XML `SystemLiteral`
-	 *   production, or
-	 * - a DocumentType's `internalSubset` contains `"]>"`.
+	 *   production,
+	 * - a DocumentType's `internalSubset` contains `"]>"`, or
+	 * - an EntityReference's `nodeName` is not a valid XML `Name` (XML 1.0 production [5]).
 	 * Note: xmldom does not enforce `readonly` on DocumentType fields — direct property
 	 * writes succeed and are covered by the serializer-level checks above.
 	 * @see https://html.spec.whatwg.org/#dom-xmlserializer-serializetostring
@@ -42487,7 +42738,10 @@ function requireDom () {
 	 * @see https://www.w3.org/TR/xml11/#AVNormalize
 	 * @see https://w3c.github.io/DOM-Parsing/#serializing-an-element-s-attributes
 	 */
-	function addSerializedAttribute(buf, qualifiedName, value) {
+	function addSerializedAttribute(buf, qualifiedName, value, requireWellFormed) {
+		if (requireWellFormed && !tagNamePattern.test(qualifiedName)) {
+			throw new DOMException(INVALID_STATE_ERR, 'The attribute name "' + qualifiedName + '" is not a valid XML QName');
+		}
 		buf.push(' ', qualifiedName, '="', value.replace(/[<>&"\t\n\r]/g, _xmlEncoder), '"');
 	}
 
@@ -42553,6 +42807,9 @@ function requireDom () {
 							}
 						}
 
+						if (requireWellFormed && !tagNamePattern.test(prefixedNodeName)) {
+							throw new DOMException(INVALID_STATE_ERR, 'The element name "' + prefixedNodeName + '" is not a valid XML QName');
+						}
 						buf.push('<', prefixedNodeName);
 
 						// Build a fresh namespace snapshot for this element's children.
@@ -42572,7 +42829,7 @@ function requireDom () {
 							if (needNamespaceDefine(attr, html, childNs)) {
 								var attrPrefix = attr.prefix || '';
 								var uri = attr.namespaceURI;
-								addSerializedAttribute(buf, attrPrefix ? 'xmlns:' + attrPrefix : 'xmlns', uri);
+								addSerializedAttribute(buf, attrPrefix ? 'xmlns:' + attrPrefix : 'xmlns', uri, requireWellFormed);
 								childNs.push({ prefix: attrPrefix, namespace: uri });
 							}
 							// Apply nodeFilter and serialize the attribute.
@@ -42581,7 +42838,7 @@ function requireDom () {
 								if (typeof filteredAttr === 'string') {
 									buf.push(filteredAttr);
 								} else {
-									addSerializedAttribute(buf, filteredAttr.name, filteredAttr.value);
+									addSerializedAttribute(buf, filteredAttr.name, filteredAttr.value, requireWellFormed);
 								}
 							}
 						}
@@ -42590,7 +42847,7 @@ function requireDom () {
 						if (nodeName === prefixedNodeName && needNamespaceDefine(n, html, childNs)) {
 							var nodePrefix = n.prefix || '';
 							var uri = n.namespaceURI;
-							addSerializedAttribute(buf, nodePrefix ? 'xmlns:' + nodePrefix : 'xmlns', uri);
+							addSerializedAttribute(buf, nodePrefix ? 'xmlns:' + nodePrefix : 'xmlns', uri, requireWellFormed);
 							childNs.push({ prefix: nodePrefix, namespace: uri });
 						}
 
@@ -42623,7 +42880,7 @@ function requireDom () {
 						return { ns: ns.slice(), isHTML: html, tag: null };
 
 					case ATTRIBUTE_NODE:
-						addSerializedAttribute(buf, n.name, n.value);
+						addSerializedAttribute(buf, n.name, n.value, requireWellFormed);
 						return null;
 
 					case TEXT_NODE:
@@ -42662,6 +42919,9 @@ function requireDom () {
 
 					case DOCUMENT_TYPE_NODE:
 						if (requireWellFormed) {
+							if (!tagNamePattern.test(n.name)) {
+								throw new DOMException(INVALID_STATE_ERR, 'The doctype name "' + n.name + '" is not a valid XML Name');
+							}
 							if (n.publicId && !/^("[\x20\r\na-zA-Z0-9\-()+,.\/:=?;!*#@$_%']*"|'[\x20\r\na-zA-Z0-9\-()+,.\/:=?;!*#@$_%'"]*')$/.test(n.publicId)) {
 								throw new DOMException(INVALID_STATE_ERR, 'DocumentType publicId is not a valid PubidLiteral');
 							}
@@ -42693,13 +42953,27 @@ function requireDom () {
 						return null;
 
 					case PROCESSING_INSTRUCTION_NODE:
-						if (requireWellFormed && n.data.indexOf('?>') !== -1) {
-							throw new DOMException(INVALID_STATE_ERR, 'The ProcessingInstruction data contains "?>"');
+						if (requireWellFormed) {
+							if (!tagNamePattern.test(n.target) || n.target.indexOf(':') !== -1 || n.target.toLowerCase() === 'xml') {
+								throw new DOMException(
+									INVALID_STATE_ERR,
+									'The processing instruction target "' + n.target + '" is not a valid XML NCName or is reserved'
+								);
+							}
+							if (n.data.indexOf('?>') !== -1) {
+								throw new DOMException(INVALID_STATE_ERR, 'The ProcessingInstruction data contains "?>"');
+							}
 						}
 						buf.push('<?', n.target, ' ', n.data, '?>');
 						return null;
 
 					case ENTITY_REFERENCE_NODE:
+						if (requireWellFormed && !tagNamePattern.test(n.nodeName)) {
+							throw new DOMException(
+								INVALID_STATE_ERR,
+								'The entity reference name "' + n.nodeName + '" is not a valid XML Name'
+							);
+						}
 						buf.push('&', n.nodeName, ';');
 						return null;
 
@@ -45080,14 +45354,8 @@ function requireSax () {
 	if (hasRequiredSax) return sax;
 	hasRequiredSax = 1;
 	var NAMESPACE = requireConventions().NAMESPACE;
+	var tagNamePattern = requireConventions().tagNamePattern;
 
-	//[4]   	NameStartChar	   ::=   	":" | [A-Z] | "_" | [a-z] | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x2FF] | [#x370-#x37D] | [#x37F-#x1FFF] | [#x200C-#x200D] | [#x2070-#x218F] | [#x2C00-#x2FEF] | [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]
-	//[4a]   	NameChar	   ::=   	NameStartChar | "-" | "." | [0-9] | #xB7 | [#x0300-#x036F] | [#x203F-#x2040]
-	//[5]   	Name	   ::=   	NameStartChar (NameChar)*
-	var nameStartChar = /[A-Z_a-z\xC0-\xD6\xD8-\xF6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/;//\u10000-\uEFFFF
-	var nameChar = new RegExp("[\\-\\.0-9"+nameStartChar.source.slice(1,-1)+"\\u00B7\\u0300-\\u036F\\u203F-\\u2040]");
-	var tagNamePattern = new RegExp('^'+nameStartChar.source+nameChar.source+'*(?:\:'+nameStartChar.source+nameChar.source+'*)?$');
-	//var tagNamePattern = /^[a-zA-Z_][\w\-\.]*(?:\:[a-zA-Z_][\w\-\.]*)?$/
 	//var handlers = 'resolveEntity,getExternalSubset,characters,endDocument,endElement,endPrefixMapping,ignorableWhitespace,processingInstruction,setDocumentLocator,skippedEntity,startDocument,startElement,startPrefixMapping,notationDecl,unparsedEntityDecl,error,fatalError,warning,attributeDecl,elementDecl,externalEntityDecl,internalEntityDecl,comment,endCDATA,endDTD,endEntity,startCDATA,startDTD,startEntity'.split(',')
 
 	//S_TAG,	S_ATTR,	S_EQ,	S_ATTR_NOQUOT_VALUE
@@ -45198,7 +45466,13 @@ function requireSax () {
 				switch(source.charAt(tagStart+1)){
 				case '/':
 					var end = source.indexOf('>',tagStart+3);
-					var tagName = source.substring(tagStart + 2, end).replace(/[ \t\n\r]+$/g, '');
+					// Anchored trailing-whitespace trim. The former `/[ \t\n\r]+$/g` backtracked
+					// quadratically on a name shaped `whitespace-run + non-whitespace char`
+					// (an end tag `</   …   x>`): from every start position it extended `[ws]+`
+					// to the end and then failed the `$` anchor. This anchored form matches the
+					// whole string once and captures everything up to the last non-whitespace
+					// character, so it trims in linear time with byte-identical output.
+					var tagName = source.substring(tagStart + 2, end).replace(/^([\s\S]*?[^ \t\n\r])?[ \t\n\r]*$/, '$1');
 					var config = parseStack.pop();
 					if(end<0){
 
@@ -45209,6 +45483,14 @@ function requireSax () {
 		        		tagName = tagName.replace(/[\s<].*/,'');
 		        		errorHandler.error("end tag name: "+tagName+' maybe not complete');
 		        		end = tagStart+1+tagName.length;
+					}else if(/[ \t\n\r]/.test(tagName) && tagNamePattern.test(tagName.split(/[ \t\n\r]/)[0])){
+						// The XML `ETag` production is `'</' Name S? '>'`: only optional whitespace may follow
+						// the `Name`. A valid `Name` followed by whitespace and non-whitespace residue (e.g.
+						// `</a\nbogus>` or `</a bogus>`) is not well-formed, but historically it was silently
+						// accepted (the malformed end tag ignored, the residue dropped, the element left on the
+						// stack). Report it as a recoverable `error` (which a custom errorHandler may escalate to
+						// fatal) while keeping the existing recovery so the parsed DOM stays byte-identical.
+						errorHandler.error('end tag name is followed by whitespace and trailing content: "'+tagName+'"');
 					}
 					var localNSMap = config.localNSMap;
 					var endMatch = config.tagName == tagName;
@@ -45332,6 +45614,15 @@ function requireSax () {
 		var s = S_TAG;//status
 		while(true){
 			var c = source.charAt(p);
+			if (s === S_TAG && c === '<') {
+				// A `<` can never occur inside a tag name. Without this guard the scan runs
+				// on to the next `>` (or EOF) before the tag name is rejected, so a document
+				// with many `<` inside a malformed tag makes each one-character recovery step
+				// re-scan to the distant `>` — O(n^2). Stopping at the `<` keeps each recovery
+				// step bounded. The candidate scanned so far is reported raw, consistent with
+				// the sibling invalid-tag-name throw below.
+				throw new Error('unexpected < in tag name: ' + source.slice(start, p));
+			}
 			switch(c){
 			case '=':
 				if(s === S_ATTR){//attrName
@@ -45524,9 +45815,13 @@ function requireSax () {
 			if(nsPrefix !== false){//hack!!
 				if(localNSMap == null){
 					localNSMap = {};
-					//console.log(currentNSMap,0)
-					_copy(currentNSMap,currentNSMap={});
-					//console.log(currentNSMap,1)
+					// Derive the child scope's namespace map by prototype-chain inheritance
+					// instead of a flat copy: lookups inherit ancestor prefixes transparently,
+					// so a document nesting N scopes retains O(N) map entries rather than
+					// sum(1..N) = O(N^2). localNSMap stays a flat own-only record of the
+					// prefixes declared at THIS element, so own-property enumeration
+					// (endPrefixMapping below) still reports only local declarations.
+					currentNSMap = Object.create(currentNSMap);
 				}
 				currentNSMap[nsPrefix] = localNSMap[nsPrefix] = value;
 				a.uri = NAMESPACE.XMLNS;
@@ -53297,7 +53592,7 @@ var momentTimezoneExports = requireMomentTimezone();
 var momentTimezone = /*@__PURE__*/getDefaultExportFromCjs(momentTimezoneExports);
 
 /**
- * @license Angular v20.3.19
+ * @license Angular v20.3.28
  * (c) 2010-2025 Google LLC. https://angular.dev/
  * License: MIT
  */
@@ -53331,7 +53626,7 @@ function isNotFound(e) {
 }
 
 /**
- * @license Angular v20.3.19
+ * @license Angular v20.3.28
  * (c) 2010-2025 Google LLC. https://angular.dev/
  * License: MIT
  */
@@ -53876,7 +54171,7 @@ function signalValueChanged(node) {
 }
 
 /**
- * @license Angular v20.3.19
+ * @license Angular v20.3.28
  * (c) 2010-2025 Google LLC. https://angular.dev/
  * License: MIT
  */
@@ -54013,7 +54308,7 @@ function runEffect(node) {
 }
 
 /**
- * @license Angular v20.3.19
+ * @license Angular v20.3.28
  * (c) 2010-2025 Google LLC. https://angular.dev/
  * License: MIT
  */
@@ -54023,7 +54318,7 @@ function setAlternateWeakRefImpl(impl) {
 }
 
 /**
- * @license Angular v20.3.19
+ * @license Angular v20.3.28
  * (c) 2010-2025 Google LLC. https://angular.dev/
  * License: MIT
  */
@@ -54163,7 +54458,7 @@ if (typeof ngDevMode !== 'undefined' && ngDevMode) {
 }
 
 /**
- * @license Angular v20.3.19
+ * @license Angular v20.3.28
  * (c) 2010-2025 Google LLC. https://angular.dev/
  * License: MIT
  */
@@ -54190,7 +54485,7 @@ class Version {
 /**
  * @publicApi
  */
-const VERSION = /* @__PURE__ */ new Version('20.3.19');
+const VERSION = /* @__PURE__ */ new Version('20.3.28');
 
 /**
  * Base URL for the error details page.
@@ -56800,8 +57095,166 @@ function assertNodeInjector(lView, injectorIndex) {
     assertNumber(lView[injectorIndex + 8 /* NodeInjectorOffset.PARENT */], 'injectorIndex should point to parent injector');
 }
 
-const SVG_NAMESPACE = 'svg';
-const MATH_ML_NAMESPACE = 'math';
+/**
+ * A SecurityContext marks a location that has dangerous security implications, e.g. a DOM property
+ * like `innerHTML` that could cause Cross Site Scripting (XSS) security bugs when improperly
+ * handled.
+ *
+ * See DomSanitizer for more details on security in Angular applications.
+ *
+ * @publicApi
+ */
+var SecurityContext;
+(function (SecurityContext) {
+    SecurityContext[SecurityContext["NONE"] = 0] = "NONE";
+    SecurityContext[SecurityContext["HTML"] = 1] = "HTML";
+    SecurityContext[SecurityContext["STYLE"] = 2] = "STYLE";
+    SecurityContext[SecurityContext["SCRIPT"] = 3] = "SCRIPT";
+    SecurityContext[SecurityContext["URL"] = 4] = "URL";
+    SecurityContext[SecurityContext["RESOURCE_URL"] = 5] = "RESOURCE_URL";
+    SecurityContext[SecurityContext["ATTRIBUTE_NO_BINDING"] = 6] = "ATTRIBUTE_NO_BINDING";
+})(SecurityContext || (SecurityContext = {}));
+// =================================================================================================
+// =================================================================================================
+// =========== S T O P   -  S T O P   -  S T O P   -  S T O P   -  S T O P   -  S T O P  ===========
+// =================================================================================================
+// =================================================================================================
+//
+//        DO NOT EDIT THIS LIST OF SECURITY SENSITIVE PROPERTIES WITHOUT A SECURITY REVIEW!
+//
+// =================================================================================================
+/**
+ *  Map from tagName|propertyName to SecurityContext. Properties applying to all tags use '*'.
+ */
+let _SECURITY_SCHEMA;
+const SVG_NAMESPACE$1 = 'svg';
+const MATH_ML_NAMESPACE$1 = 'math';
+/**
+ * @remarks Keep is a copy of DOM Security Schema.
+ * @see [SECURITY_SCHEMA](../../../compiler/src/schema/dom_security_schema.ts)
+ */
+function SECURITY_SCHEMA() {
+    if (!_SECURITY_SCHEMA) {
+        _SECURITY_SCHEMA = {};
+        // Case is insignificant below, all element and attribute names are lower-cased for lookup.
+        registerContext(SecurityContext.HTML, /** Namespace */ undefined, [
+            ['iframe', ['srcdoc']],
+            ['*', ['innerHTML', 'outerHTML']],
+        ]);
+        registerContext(SecurityContext.STYLE, /** Namespace */ undefined, [['*', ['style']]]);
+        // NB: no SCRIPT contexts here, they are never allowed due to the parser stripping them.
+        registerContext(SecurityContext.URL, /** Namespace */ undefined, [
+            ['*', ['formAction']],
+            ['area', ['href']],
+            ['a', ['href', 'xlink:href']],
+            ['form', ['action']],
+            // The below two items are safe and should be removed but they require a G3 clean-up as a small number of tests fail.
+            ['img', ['src']],
+            ['video', ['src']],
+        ]);
+        registerContext(SecurityContext.URL, MATH_ML_NAMESPACE$1, [
+            // MathML namespace
+            // https://crsrc.org/c/third_party/blink/renderer/core/sanitizer/sanitizer.cc;l=753-768;drc=b3eb16372dcd3317d65e9e0265015e322494edcd;bpv=1;bpt=1
+            ['*', ['href', 'xlink:href']],
+            ['annotation', ['href', 'xlink:href']],
+            ['annotation-xml', ['href', 'xlink:href']],
+            ['maction', ['href', 'xlink:href']],
+            ['malignmark', ['href', 'xlink:href']],
+            ['math', ['href', 'xlink:href']],
+            ['mroot', ['href', 'xlink:href']],
+            ['msqrt', ['href', 'xlink:href']],
+            ['merror', ['href', 'xlink:href']],
+            ['mfrac', ['href', 'xlink:href']],
+            ['mglyph', ['href', 'xlink:href']],
+            ['msub', ['href', 'xlink:href']],
+            ['msup', ['href', 'xlink:href']],
+            ['msubsup', ['href', 'xlink:href']],
+            ['mmultiscripts', ['href', 'xlink:href']],
+            ['mprescripts', ['href', 'xlink:href']],
+            ['mi', ['href', 'xlink:href']],
+            ['mn', ['href', 'xlink:href']],
+            ['mo', ['href', 'xlink:href']],
+            ['mpadded', ['href', 'xlink:href']],
+            ['mphantom', ['href', 'xlink:href']],
+            ['mrow', ['href', 'xlink:href']],
+            ['ms', ['href', 'xlink:href']],
+            ['mspace', ['href', 'xlink:href']],
+            ['mstyle', ['href', 'xlink:href']],
+            ['mtable', ['href', 'xlink:href']],
+            ['mtd', ['href', 'xlink:href']],
+            ['mtr', ['href', 'xlink:href']],
+            ['mtext', ['href', 'xlink:href']],
+            ['mover', ['href', 'xlink:href']],
+            ['munder', ['href', 'xlink:href']],
+            ['munderover', ['href', 'xlink:href']],
+            ['semantics', ['href', 'xlink:href']],
+            ['none', ['href', 'xlink:href']],
+        ]);
+        registerContext(SecurityContext.RESOURCE_URL, /** Namespace */ undefined, [
+            ['base', ['href']],
+            ['embed', ['src']],
+            ['frame', ['src']],
+            ['iframe', ['src']],
+            ['link', ['href']],
+            ['object', ['codebase', 'data']],
+        ]);
+        registerContext(SecurityContext.URL, SVG_NAMESPACE$1, [['a', ['href', 'xlink:href']]]);
+        // Keep this in sync with SECURITY_SENSITIVE_ELEMENTS in packages/core/src/sanitization/sanitization.ts
+        // Unknown is the internal tag name for unknown elements example used for host-bindings.
+        // These are unsafe as `attributeName` can be `href` or `xlink:href`
+        // See: http://b/463880509#comment7
+        registerContext(SecurityContext.ATTRIBUTE_NO_BINDING, SVG_NAMESPACE$1, [
+            ['animate', ['attributeName', 'values', 'to', 'from']],
+            ['set', ['to', 'attributeName']],
+            ['animateMotion', ['attributeName']],
+            ['animateTransform', ['attributeName']],
+        ]);
+        registerContext(SecurityContext.ATTRIBUTE_NO_BINDING, /** Namespace */ undefined, [
+            [
+                'unknown',
+                [
+                    'attributeName',
+                    'values',
+                    'to',
+                    'from',
+                    'sandbox',
+                    'allow',
+                    'allowFullscreen',
+                    'referrerPolicy',
+                    'csp',
+                    'fetchPriority',
+                ],
+            ],
+            ['iframe', ['sandbox', 'allow', 'allowFullscreen', 'referrerPolicy', 'csp', 'fetchPriority']],
+        ]);
+    }
+    return _SECURITY_SCHEMA;
+}
+function registerContext(ctx, namespace, specs) {
+    for (const [element, attributeNames] of specs) {
+        let tagName = namespace && element !== 'unknown' ? `:${namespace}:${element}` : element;
+        tagName = tagName.toLowerCase();
+        for (const attr of attributeNames) {
+            _SECURITY_SCHEMA[`${tagName}|${attr.toLowerCase()}`] = ctx;
+        }
+    }
+}
+function checkSecurityContext(tagName, propName, namespace) {
+    const schema = SECURITY_SCHEMA();
+    const normalizedTagName = tagName.toLowerCase();
+    const normalizedPropName = propName.toLowerCase();
+    const namespacedContext = namespace && normalizedTagName !== '*' && normalizedTagName !== 'unknown'
+        ? schema[`:${namespace}:${normalizedTagName}|${normalizedPropName}`]
+        : undefined;
+    const namespacedWildcardContext = namespace
+        ? schema[`:${namespace}:*|${normalizedPropName}`]
+        : undefined;
+    return (namespacedContext ??
+        namespacedWildcardContext ??
+        schema[`${normalizedTagName}|${normalizedPropName}`] ??
+        schema[`*|${normalizedPropName}`] ??
+        SecurityContext.NONE);
+}
 
 /**
  * For efficiency reasons we often put several different data types (`RNode`, `LView`, `LContainer`)
@@ -57586,7 +58039,7 @@ function getSelectedTNode() {
  * @codeGenApi
  */
 function ɵɵnamespaceSVG() {
-    instructionState.lFrame.currentNamespace = SVG_NAMESPACE;
+    instructionState.lFrame.currentNamespace = SVG_NAMESPACE$1;
 }
 /**
  * Sets the namespace used to create elements to `'http://www.w3.org/1998/MathML/'` in global state.
@@ -57594,7 +58047,7 @@ function ɵɵnamespaceSVG() {
  * @codeGenApi
  */
 function ɵɵnamespaceMathML() {
-    instructionState.lFrame.currentNamespace = MATH_ML_NAMESPACE;
+    instructionState.lFrame.currentNamespace = MATH_ML_NAMESPACE$1;
 }
 /**
  * Sets the namespace used to create elements to `null`, which forces element creation to use
@@ -58209,7 +58662,7 @@ class ZoneAwareEffectScheduler {
 }
 
 /**
- * @license Angular v20.3.19
+ * @license Angular v20.3.28
  * (c) 2010-2025 Google LLC. https://angular.dev/
  * License: MIT
  */
@@ -58231,7 +58684,7 @@ const Attribute$1 = {
 };
 
 /**
- * @license Angular v20.3.19
+ * @license Angular v20.3.28
  * (c) 2010-2025 Google LLC. https://angular.dev/
  * License: MIT
  */
@@ -61997,7 +62450,7 @@ function retrieveTransferredState(doc, appId) {
     // Locate the script tag with the JSON data transferred from the server.
     // The id of the script tag is set to the Angular appId + 'state'.
     const script = doc.getElementById(appId + '-state');
-    if (script?.textContent) {
+    if (script?.tagName === 'SCRIPT' && script.textContent) {
         try {
             // Avoid using any here as it triggers lint errors in google3 (any is not allowed).
             // Decoding of `<` is done of the box by browsers and node.js, same behaviour as G3
@@ -63419,6 +63872,13 @@ function matchingSchemas(schemas, tagName) {
     return false;
 }
 
+const SVG_NAMESPACE = 'svg';
+const MATH_ML_NAMESPACE = 'math';
+const NAMESPACE_URIS = {
+    'http://www.w3.org/2000/svg': SVG_NAMESPACE,
+    'http://www.w3.org/1998/Math/MathML': MATH_ML_NAMESPACE,
+};
+
 /**
  * @fileoverview
  * A module to facilitate use of a Trusted Types policy internally within
@@ -63848,13 +64308,6 @@ const VALID_ATTRS = merge(URI_ATTRS, HTML_ATTRS, ARIA_ATTRS);
 // `Some content`, but strip `invalid-element` opening/closing tags. For some elements, though, we
 // don't want to preserve the content, if the elements themselves are going to be removed.
 const SKIP_TRAVERSING_CONTENT_IF_INVALID_ELEMENTS = tagSet('script,style,template');
-/**
- * Attributes that are potential attach vectors and may need to be sanitized.
- */
-const SENSITIVE_ATTRS = merge(URI_ATTRS, 
-// Note: we don't include these attributes in `URI_ATTRS`, because `URI_ATTRS` also
-// determines whether an attribute should be dropped when sanitizing an HTML string.
-tagSet('action,formaction,data,codebase'));
 /**
  * SanitizingHtmlSerializer serializes a DOM fragment, stripping out any unsafe elements and unsafe
  * attributes.
@@ -64242,23 +64695,27 @@ function enforceIframeSecurity(iframe) {
 }
 
 /**
- * A SecurityContext marks a location that has dangerous security implications, e.g. a DOM property
- * like `innerHTML` that could cause Cross Site Scripting (XSS) security bugs when improperly
- * handled.
+ * Splits an element name into its namespace and local name.
  *
- * See DomSanitizer for more details on security in Angular applications.
- *
- * @publicApi
+ * @param elementName The element name to split, in the format ":namespace:name".
+ * @param fatal If true, throws an error if the element name is not in the correct format.
+ * @returns A tuple containing the namespace and local name.
  */
-var SecurityContext;
-(function (SecurityContext) {
-    SecurityContext[SecurityContext["NONE"] = 0] = "NONE";
-    SecurityContext[SecurityContext["HTML"] = 1] = "HTML";
-    SecurityContext[SecurityContext["STYLE"] = 2] = "STYLE";
-    SecurityContext[SecurityContext["SCRIPT"] = 3] = "SCRIPT";
-    SecurityContext[SecurityContext["URL"] = 4] = "URL";
-    SecurityContext[SecurityContext["RESOURCE_URL"] = 5] = "RESOURCE_URL";
-})(SecurityContext || (SecurityContext = {}));
+function splitNsName(elementName, fatal = true) {
+    if (elementName[0] != ':') {
+        return [null, elementName];
+    }
+    const colonIndex = elementName.indexOf(':', 1);
+    if (colonIndex === -1) {
+        if (fatal) {
+            throw new Error(`Unsupported format "${elementName}" expecting ":namespace:name"`);
+        }
+        else {
+            return [null, elementName];
+        }
+    }
+    return [elementName.slice(1, colonIndex), elementName.slice(colonIndex + 1)];
+}
 
 /**
  * An `html` sanitizer which converts untrusted `html` **string** into trusted string by removing
@@ -64275,7 +64732,12 @@ var SecurityContext;
  *
  * @codeGenApi
  */
-function ɵɵsanitizeHtml(unsafeHtml) {
+function ɵɵsanitizeHtml(unsafeHtml, tagName, propName) {
+    if (tagName !== undefined &&
+        propName !== undefined &&
+        getSecurityContext(tagName, propName) !== SecurityContext.HTML) {
+        return unsafeHtml;
+    }
     const sanitizer = getSanitizer();
     if (sanitizer) {
         return trustedHTMLFromStringBypass(sanitizer.sanitize(SecurityContext.HTML, unsafeHtml) || '');
@@ -64425,21 +64887,22 @@ function ɵɵtrustConstantResourceUrl(url) {
     }
     return trustedScriptURLFromString(url[0]);
 }
-// Define sets outside the function for O(1) lookups and memory efficiency
-const SRC_RESOURCE_TAGS = new Set(['embed', 'frame', 'iframe', 'media', 'script']);
-const HREF_RESOURCE_TAGS = new Set(['base', 'link', 'script']);
 /**
  * Detects which sanitizer to use for URL property, based on tag name and prop name.
  *
- * The rules are based on the RESOURCE_URL context config from
+ * The rules are based on the URL and RESOURCE_URL context config from
  * `packages/compiler/src/schema/dom_security_schema.ts`.
- * If tag and prop names don't match Resource URL schema, use URL sanitizer.
+ * If tag and prop names don't match URL or Resource URL schema, no sanitizer is required.
  */
 function getUrlSanitizer(tag, prop) {
-    const isResource = (prop === 'src' && SRC_RESOURCE_TAGS.has(tag)) ||
-        (prop === 'href' && HREF_RESOURCE_TAGS.has(tag)) ||
-        (prop === 'xlink:href' && tag === 'script');
-    return isResource ? ɵɵsanitizeResourceUrl : ɵɵsanitizeUrl;
+    switch (getSecurityContext(tag, prop)) {
+        case SecurityContext.RESOURCE_URL:
+            return ɵɵsanitizeResourceUrl;
+        case SecurityContext.URL:
+            return ɵɵsanitizeUrl;
+        default:
+            return null;
+    }
 }
 /**
  * Sanitizes URL, selecting sanitizer function based on tag and property names.
@@ -64457,7 +64920,7 @@ function getUrlSanitizer(tag, prop) {
  * @codeGenApi
  */
 function ɵɵsanitizeUrlOrResourceUrl(unsafeUrl, tag, prop) {
-    return getUrlSanitizer(tag, prop)(unsafeUrl);
+    return getUrlSanitizer(tag, prop)?.(unsafeUrl) ?? unsafeUrl;
 }
 function validateAgainstEventProperties(name) {
     if (name.toLowerCase().startsWith('on')) {
@@ -64468,35 +64931,50 @@ function validateAgainstEventProperties(name) {
         throw new RuntimeError(306 /* RuntimeErrorCode.INVALID_EVENT_BINDING */, errorMessage);
     }
 }
-function validateAgainstEventAttributes(name) {
-    if (name.toLowerCase().startsWith('on')) {
-        const errorMessage = `Binding to event attribute '${name}' is disallowed for security reasons, ` +
-            `please use (${name.slice(2)})=...`;
-        throw new RuntimeError(306 /* RuntimeErrorCode.INVALID_EVENT_BINDING */, errorMessage);
-    }
-}
 function getSanitizer() {
     const lView = getLView();
     return lView && lView[ENVIRONMENT].sanitizer;
 }
-const attributeName = new Set(['attributename']);
+function getSecurityContext(tagName, propName) {
+    const [namespace, resolvedTagName] = resolveElement(tagName);
+    return checkSecurityContext(resolvedTagName, propName, namespace);
+}
+function resolveElement(tagName) {
+    tagName = tagName.toLowerCase();
+    const splitResult = splitNsName(tagName, false);
+    if (splitResult[0]) {
+        return splitResult;
+    }
+    const index = getSelectedIndex();
+    const tNode = index === -1 ? null : getSelectedTNode();
+    let namespace = tNode?.namespace;
+    if (tagName === "#host" /* TNodeName.DynamicHost */ && tNode?.type === 2 /* TNodeType.Element */) {
+        const element = getNativeByTNode(tNode, getLView());
+        if (element.tagName) {
+            tagName = element.tagName.toLowerCase();
+        }
+        if (namespace == null) {
+            const namespaceURI = element.namespaceURI;
+            namespace = namespaceURI && NAMESPACE_URIS[namespaceURI];
+        }
+    }
+    return [namespace, tagName];
+}
+/**
+ * Set of attributes that are sensitive and should be sanitized.
+ */
+const SECURITY_SENSITIVE_ATTRIBUTE_NAMES = new Set(['href', 'xlink:href']);
 /**
  * @remarks Keep this in sync with DOM Security Schema.
  * @see [SECURITY_SCHEMA](../../../compiler/src/schema/dom_security_schema.ts)
  */
-const SECURITY_SENSITIVE_ELEMENTS = {
-    'iframe': new Set([
-        'sandbox',
-        'allow',
-        'allowfullscreen',
-        'referrerpolicy',
-        'csp',
-        'fetchpriority',
-    ]),
-    'animate': attributeName,
-    'set': attributeName,
-    'animatemotion': attributeName,
-    'animatetransform': attributeName,
+const SVG_ANIMATION_SENSITIVE_STATIC_VALUES = {
+    'animate': {
+        'to': SECURITY_SENSITIVE_ATTRIBUTE_NAMES,
+        'values': SECURITY_SENSITIVE_ATTRIBUTE_NAMES,
+        'from': SECURITY_SENSITIVE_ATTRIBUTE_NAMES,
+    },
+    'set': { 'to': SECURITY_SENSITIVE_ATTRIBUTE_NAMES },
 };
 /**
  * Validates that the attribute binding is safe to use.
@@ -64506,29 +64984,62 @@ const SECURITY_SENSITIVE_ELEMENTS = {
  * @param attributeName The name of the attribute.
  */
 function ɵɵvalidateAttribute(value, tagName, attributeName) {
-    const lowerCaseTagName = tagName.toLowerCase();
-    const lowerCaseAttrName = attributeName.toLowerCase();
-    if (!SECURITY_SENSITIVE_ELEMENTS[lowerCaseTagName]?.has(lowerCaseAttrName)) {
+    const index = getSelectedIndex();
+    const tNode = index === -1 ? null : getSelectedTNode();
+    if (tNode && tNode.type !== 2 /* TNodeType.Element */) {
         return value;
     }
-    const tNode = getSelectedTNode();
-    if (tNode.type !== 2 /* TNodeType.Element */) {
+    const [namespace, resolvedTagName] = resolveElement(tagName);
+    const securityContext = checkSecurityContext(resolvedTagName, attributeName, namespace);
+    if (securityContext !== SecurityContext.ATTRIBUTE_NO_BINDING) {
         return value;
     }
     const lView = getLView();
-    if (lowerCaseTagName === 'iframe') {
-        const element = getNativeByTNode(tNode, lView);
-        enforceIframeSecurity(element);
+    if (tNode) {
+        if (resolvedTagName === 'iframe') {
+            const element = getNativeByTNode(tNode, lView);
+            enforceIframeSecurity(element);
+        }
+        else if (namespace === SVG_NAMESPACE$1) {
+            const config = SVG_ANIMATION_SENSITIVE_STATIC_VALUES[resolvedTagName]?.[attributeName.toLowerCase()];
+            if (config) {
+                const element = getNativeByTNode(tNode, lView);
+                const attributeNameValue = getSecuritySensitiveSVGAnimationAttributeName(element, config);
+                if (attributeNameValue) {
+                    const errorMessage = ngDevMode &&
+                        `Angular has detected that the \`${attributeName}\` was applied ` +
+                            `as a binding to the <${resolvedTagName}> element${getTemplateLocationDetails(lView)}. ` +
+                            `For security reasons, the \`${attributeName}\` can be set on the <${resolvedTagName}> element ` +
+                            `as a static attribute only when the "attributeName" is set to \'${attributeNameValue}\'. \n` +
+                            `To fix this, switch the \`${attributeNameValue}\` binding to a static attribute ` +
+                            `in a template or in host bindings section.`;
+                    throw new RuntimeError(-910 /* RuntimeErrorCode.UNSAFE_ATTRIBUTE_BINDING */, errorMessage);
+                }
+                return value;
+            }
+        }
     }
     const errorMessage = ngDevMode &&
         `Angular has detected that the \`${attributeName}\` was applied ` +
-            `as a binding to the <${tagName}> element${getTemplateLocationDetails(lView)}. ` +
-            `For security reasons, the \`${attributeName}\` can be set on the <${tagName}> element ` +
+            `as a binding to the <${resolvedTagName}> element${tNode ? getTemplateLocationDetails(lView) : ''}. ` +
+            `For security reasons, the \`${attributeName}\` can be set on the <${resolvedTagName}> element ` +
             `as a static attribute only. \n` +
             `To fix this, switch the \`${attributeName}\` binding to a static attribute ` +
             `in a template or in host bindings section.`;
     throw new RuntimeError(-910 /* RuntimeErrorCode.UNSAFE_ATTRIBUTE_BINDING */, errorMessage);
 }
+function getSecuritySensitiveSVGAnimationAttributeName(element, validationConfig) {
+    for (const attributeName of element.getAttributeNames()) {
+        if (attributeName.toLowerCase() !== 'attributename') {
+            continue;
+        }
+        const attributeNameValue = element.getAttribute(attributeName);
+        if (attributeNameValue !== null && validationConfig.has(attributeNameValue.toLowerCase())) {
+            return attributeNameValue;
+        }
+    }
+    return null;
+}
 
 /** Defines the default value of the `NG_REFLECT_ATTRS_FLAG` flag. */
 const NG_REFLECT_ATTRS_FLAG_DEFAULT = false;
@@ -67507,7 +68018,9 @@ function setDomProperty(tNode, lView, propName, value, renderer, sanitizer) {
     if (tNode.type & 3 /* TNodeType.AnyRNode */) {
         const element = getNativeByTNode(tNode, lView);
         if (ngDevMode) {
-            validateAgainstEventProperties(propName);
+            if (lView[TVIEW].firstUpdatePass) {
+                validateAgainstEventProperties(propName);
+            }
             if (!isPropertyValid(element, propName, tNode.value, lView[TVIEW].schemas)) {
                 handleUnknownPropertyError(propName, tNode.value, tNode.type, lView);
             }
@@ -67674,7 +68187,6 @@ function findDirectiveDefMatches(tView, tNode) {
 function elementAttributeInternal(tNode, lView, name, value, sanitizer, namespace) {
     if (ngDevMode) {
         assertNotSame(value, NO_CHANGE, 'Incoming value should never be NO_CHANGE.');
-        validateAgainstEventAttributes(name);
         assertTNodeType(tNode, 2 /* TNodeType.Element */, `Attempted to set attribute \`${name}\` on a container node. ` +
             `Host bindings are not valid on ng-container or ng-template.`);
     }
@@ -69830,6 +70342,7 @@ function createTNode(tView, tParent, type, index, value, attrs) {
         flags,
         providerIndexes: 0,
         value: value,
+        namespace: getNamespace(),
         attrs: attrs,
         mergedAttrs: null,
         localNames: null,
@@ -72845,9 +73358,14 @@ function createHostElement(componentDef, renderer) {
     // dynamically. Default to 'div' if this component did not specify any tag name in its
     // selector.
     const tagName = inferTagNameFromDefinition(componentDef);
-    const namespace = tagName === 'svg' ? SVG_NAMESPACE : tagName === 'math' ? MATH_ML_NAMESPACE : null;
+    const namespace = tagName === 'svg' ? SVG_NAMESPACE$1 : tagName === 'math' ? MATH_ML_NAMESPACE$1 : null;
     return createElementNode(renderer, tagName, namespace);
 }
+function assertNotScriptHostElement(tagName) {
+    if (tagName?.toLowerCase() === 'script') {
+        throw new RuntimeError(905 /* RuntimeErrorCode.UNSAFE_VALUE_IN_SCRIPT */, ngDevMode && `"<script>" tag is not allowed as a component host element.`);
+    }
+}
 /**
  * Infers the tag name that should be used for a component based on its definition.
  * @param componentDef Definition for which to resolve the tag name.
@@ -72903,6 +73421,7 @@ class ComponentFactory extends ComponentFactory$1 {
             const hostElement = rootSelectorOrNode
                 ? locateHostElement(hostRenderer, rootSelectorOrNode, cmpDef.encapsulation, rootViewInjector)
                 : createHostElement(cmpDef, hostRenderer);
+            assertNotScriptHostElement(hostElement?.tagName);
             const hasInputBindings = componentBindings?.some(isInputBinding) ||
                 directives?.some((d) => typeof d !== 'function' && d.bindings.some(isInputBinding));
             const rootLView = createLView(null, rootTView, null, 512 /* LViewFlags.IsRoot */ | getInitialLViewFlagsFromDef(cmpDef), null, null, environment, hostRenderer, rootViewInjector, null, retrieveHydrationInfo(hostElement, rootViewInjector, true /* isRootView */));
@@ -72915,7 +73434,7 @@ class ComponentFactory extends ComponentFactory$1 {
             enterView(rootLView);
             let componentView = null;
             try {
-                const hostTNode = directiveHostFirstCreatePass(HEADER_OFFSET, rootLView, 2 /* TNodeType.Element */, '#host', () => rootTView.directiveRegistry, true, 0);
+                const hostTNode = directiveHostFirstCreatePass(HEADER_OFFSET, rootLView, 2 /* TNodeType.Element */, "#host" /* TNodeName.DynamicHost */, () => rootTView.directiveRegistry, true, 0);
                 // ---- element instruction
                 setupStaticAttributes(hostRenderer, hostElement, hostTNode);
                 attachPatchData(hostElement, rootLView);
@@ -72953,7 +73472,7 @@ class ComponentFactory extends ComponentFactory$1 {
 }
 function createRootTView(rootSelectorOrNode, componentDef, componentBindings, directives) {
     const tAttributes = rootSelectorOrNode
-        ? ['ng-version', '20.3.19']
+        ? ['ng-version', '20.3.28']
         : // Extract attributes and classes from the first selector only to match VE behavior.
             extractAttrsAndClassesFromSelector(componentDef.selectors[0]);
     let creationBindings = null;
@@ -82146,11 +82665,19 @@ function getLocalePluralCase(locale) {
  */
 function getLocaleData(normalizedLocale) {
     if (!(normalizedLocale in LOCALE_DATA)) {
-        LOCALE_DATA[normalizedLocale] =
-            _global.ng &&
-                _global.ng.common &&
-                _global.ng.common.locales &&
-                _global.ng.common.locales[normalizedLocale];
+        const globalLocaleData = _global.ng &&
+            _global.ng.common &&
+            _global.ng.common.locales &&
+            _global.ng.common.locales[normalizedLocale];
+        // Only cache global locale data when an entry is actually found, to avoid
+        // caching missing lookups. In SSR this cache is process-wide across requests,
+        // so caching `undefined` would retain attacker-controlled locale identifiers
+        // indefinitely. It would also make the `in` check above short-circuit on
+        // subsequent lookups and skip the global fallback.
+        if (globalLocaleData !== undefined) {
+            LOCALE_DATA[normalizedLocale] = globalLocaleData;
+        }
+        return globalLocaleData;
     }
     return LOCALE_DATA[normalizedLocale];
 }
@@ -82570,7 +83097,14 @@ function applyUpdateOpCodes(tView, lView, updateOpCodes, bindingsStartIndex, cha
                                     setElementAttribute(lView[RENDERER], lView[nodeIndex], null, tNodeOrTagName, propName, value, sanitizeFn);
                                 }
                                 else {
-                                    setPropertyAndInputs(tNodeOrTagName, lView, propName, value, lView[RENDERER], sanitizeFn);
+                                    const prevSelectedIndex = getSelectedIndex();
+                                    setSelectedIndex(nodeIndex);
+                                    try {
+                                        setPropertyAndInputs(tNodeOrTagName, lView, propName, value, lView[RENDERER], sanitizeFn);
+                                    }
+                                    finally {
+                                        setSelectedIndex(prevSelectedIndex);
+                                    }
                                 }
                                 break;
                             case 0 /* I18nUpdateOpCode.Text */:
@@ -83150,7 +83684,10 @@ function i18nAttributesFirstPass(tView, index, values) {
                 // the compiler treats static i18n attributes as regular attribute bindings.
                 // Since this may not be the first i18n attribute on this element we need to pass in how
                 // many previous bindings there have already been.
-                generateBindingUpdateOpCodes(updateOpCodes, message, previousElementIndex, attrName, countBindings(updateOpCodes), SENSITIVE_ATTRS[attrName.toLowerCase()] ? _sanitizeUrl : null);
+                const tagName = previousElement.namespace
+                    ? `:${previousElement.namespace}:${previousElement.value}`
+                    : previousElement.value;
+                generateBindingUpdateOpCodes(updateOpCodes, message, previousElementIndex, attrName, countBindings(updateOpCodes), i18nResolveSanitizer(attrName, tagName));
             }
         }
         tView.data[index] = updateOpCodes;
@@ -83476,9 +84013,12 @@ function walkIcuTree(ast, tView, tIcu, lView, sharedUpdateOpCodes, create, remov
                         const attr = elAttrs.item(i);
                         const lowerAttrName = attr.name.toLowerCase();
                         const hasBinding = !!attr.value.match(BINDING_REGEXP);
+                        const namespaceUri = element.namespaceURI;
+                        const namespace = namespaceUri && NAMESPACE_URIS[namespaceUri];
+                        const tagNameWithNamespace = namespace ? `:${namespace}:${tagName}` : tagName;
                         if (hasBinding) {
                             if (VALID_ATTRS.hasOwnProperty(lowerAttrName)) {
-                                generateBindingUpdateOpCodes(update, attr.value, newIndex, attr.name, 0, SENSITIVE_ATTRS[lowerAttrName] ? _sanitizeUrl : null);
+                                generateBindingUpdateOpCodes(update, attr.value, newIndex, attr.name, 0, i18nResolveSanitizer(lowerAttrName, tagNameWithNamespace));
                             }
                             else {
                                 ngDevMode &&
@@ -83488,9 +84028,9 @@ function walkIcuTree(ast, tView, tIcu, lView, sharedUpdateOpCodes, create, remov
                             }
                         }
                         else if (VALID_ATTRS[lowerAttrName]) {
-                            if (SENSITIVE_ATTRS[lowerAttrName]) {
-                                // Don't sanitize, because no value is acceptable in sensitive attributes.
-                                // Translators are not allowed to create URIs.
+                            let val = attr.value;
+                            const sanitizer = i18nResolveSanitizer(lowerAttrName, tagNameWithNamespace);
+                            if (sanitizer) {
                                 if (typeof ngDevMode !== 'undefined' && ngDevMode) {
                                     console.warn(`WARNING: ignoring unsafe attribute ` +
                                         `${lowerAttrName} on element ${tagName} ` +
@@ -83499,7 +84039,7 @@ function walkIcuTree(ast, tView, tIcu, lView, sharedUpdateOpCodes, create, remov
                                 addCreateAttribute(create, newIndex, attr.name, 'unsafe:blocked');
                             }
                             else {
-                                addCreateAttribute(create, newIndex, attr.name, attr.value);
+                                addCreateAttribute(create, newIndex, attr.name, val);
                             }
                         }
                         else {
@@ -83579,6 +84119,37 @@ function addCreateNodeAndAppend(create, marker, text, appendToParentIdx, createA
 function addCreateAttribute(create, newIndex, attrName, attrValue) {
     create.push((newIndex << 1 /* IcuCreateOpCode.SHIFT_REF */) | 1 /* IcuCreateOpCode.Attr */, attrName, attrValue);
 }
+function normalizeTagName(tagName) {
+    const tagNameLower = tagName.toLowerCase();
+    const [ns, name] = splitNsName(tagNameLower, false);
+    return ns === SVG_NAMESPACE || ns === MATH_ML_NAMESPACE ? `:${ns}:${name}` : name;
+}
+function i18nResolveSanitizer(attrName, tagName) {
+    const lowerAttrName = attrName.toLowerCase();
+    const lowerTagName = tagName ? normalizeTagName(tagName) : '*';
+    const [namespace] = splitNsName(lowerTagName, false);
+    const schema = SECURITY_SCHEMA();
+    const schemaContext = schema[`${lowerTagName}|${lowerAttrName}`] ||
+        (namespace ? schema[`:${namespace}:*|${lowerAttrName}`] : undefined) ||
+        schema[`*|${lowerAttrName}`] ||
+        SecurityContext.NONE;
+    switch (schemaContext) {
+        case SecurityContext.HTML:
+            return ɵɵsanitizeHtml;
+        case SecurityContext.STYLE:
+            return ɵɵsanitizeStyle;
+        case SecurityContext.SCRIPT:
+            return ɵɵsanitizeScript;
+        case SecurityContext.URL:
+            return _sanitizeUrl;
+        case SecurityContext.RESOURCE_URL:
+            return ɵɵsanitizeResourceUrl;
+        case SecurityContext.ATTRIBUTE_NO_BINDING:
+            return ɵɵvalidateAttribute;
+        default:
+            return null;
+    }
+}
 
 // i18nPostprocess consts
 const ROOT_TEMPLATE_ID = 0;
@@ -90294,7 +90865,7 @@ function getDebugNode(nativeNode) {
 }
 
 /**
- * @license Angular v20.3.19
+ * @license Angular v20.3.28
  * (c) 2010-2025 Google LLC. https://angular.dev/
  * License: MIT
  */
@@ -90909,7 +91480,7 @@ class ResourceWrappedError extends Error {
 }
 
 /**
- * @license Angular v20.3.19
+ * @license Angular v20.3.28
  * (c) 2010-2025 Google LLC. https://angular.dev/
  * License: MIT
  */
@@ -92368,7 +92939,7 @@ function clearAppScopedEarlyEventContract(appId, dataContainer = window) {
 }
 
 /**
- * @license Angular v20.3.19
+ * @license Angular v20.3.28
  * (c) 2010-2025 Google LLC. https://angular.dev/
  * License: MIT
  */
@@ -97404,7 +97975,7 @@ var i0 = /*#__PURE__*/Object.freeze({
 });
 
 /**
- * @license Angular v20.3.19
+ * @license Angular v20.3.28
  * (c) 2010-2025 Google LLC. https://angular.dev/
  * License: MIT
  */
@@ -97430,7 +98001,7 @@ class XhrFactory {
 }
 
 /**
- * @license Angular v20.3.19
+ * @license Angular v20.3.28
  * (c) 2010-2025 Google LLC. https://angular.dev/
  * License: MIT
  */
@@ -97627,10 +98198,10 @@ class HttpHeaders {
     }
     copyFrom(other) {
         other.init();
-        Array.from(other.headers.keys()).forEach((key) => {
-            this.headers.set(key, other.headers.get(key));
+        for (const [key, values] of other.headers.entries()) {
+            this.headers.set(key, values);
             this.normalizedNames.set(key, other.normalizedNames.get(key));
-        });
+        }
     }
     clone(update) {
         const clone = new HttpHeaders();
@@ -97651,22 +98222,23 @@ class HttpHeaders {
                     return;
                 }
                 this.maybeSetNormalizedName(update.name, key);
-                const base = (update.op === 'a' ? this.headers.get(key) : undefined) || [];
+                const base = update.op === 'a' ? (this.headers.get(key) || []).slice() : [];
                 base.push(...value);
                 this.headers.set(key, base);
                 break;
             case 'd':
                 const toDelete = update.value;
-                if (!toDelete) {
+                if (toDelete === undefined) {
                     this.headers.delete(key);
                     this.normalizedNames.delete(key);
                 }
                 else {
+                    const valuesToDelete = Array.isArray(toDelete) ? toDelete : [toDelete];
                     let existing = this.headers.get(key);
                     if (!existing) {
                         return;
                     }
-                    existing = existing.filter((value) => toDelete.indexOf(value) === -1);
+                    existing = existing.filter((value) => valuesToDelete.indexOf(value) === -1);
                     if (existing.length === 0) {
                         this.headers.delete(key);
                         this.normalizedNames.delete(key);
@@ -97955,18 +98527,20 @@ class HttpParams {
         }
         if (this.cloneFrom !== null) {
             this.cloneFrom.init();
-            this.cloneFrom.keys().forEach((key) => this.map.set(key, this.cloneFrom.map.get(key)));
+            for (const [key, values] of this.cloneFrom.map.entries()) {
+                this.map.set(key, values);
+            }
             this.updates.forEach((update) => {
                 switch (update.op) {
                     case 'a':
                     case 's':
-                        const base = (update.op === 'a' ? this.map.get(update.param) : undefined) || [];
+                        const base = update.op === 'a' ? (this.map.get(update.param) || []).slice() : [];
                         base.push(valueToString(update.value));
                         this.map.set(update.param, base);
                         break;
                     case 'd':
                         if (update.value !== undefined) {
-                            let base = this.map.get(update.param) || [];
+                            const base = (this.map.get(update.param) || []).slice();
                             const idx = base.indexOf(valueToString(update.value));
                             if (idx !== -1) {
                                 base.splice(idx, 1);
@@ -98337,7 +98911,7 @@ class HttpRequest {
             if (options.integrity) {
                 this.integrity = options.integrity;
             }
-            if (options.referrer) {
+            if (options.referrer !== undefined) {
                 this.referrer = options.referrer;
             }
             // We do want to assign transferCache even if it's falsy (false is valid value)
@@ -98459,7 +99033,7 @@ class HttpRequest {
         const mode = update.mode || this.mode;
         const redirect = update.redirect || this.redirect;
         const credentials = update.credentials || this.credentials;
-        const referrer = update.referrer || this.referrer;
+        const referrer = update.referrer ?? this.referrer;
         const integrity = update.integrity || this.integrity;
         // Carefully handle the transferCache to differentiate between
         // `false` and `undefined` in the update args.
@@ -99108,8 +99682,8 @@ class HttpClient {
     put(url, body, options = {}) {
         return this.request('PUT', url, addBody(options, body));
     }
-    static ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: HttpClient, deps: [{ token: HttpHandler }], target: FactoryTarget.Injectable });
-    static ɵprov = ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: HttpClient });
+    static ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: HttpClient, deps: [{ token: HttpHandler }], target: FactoryTarget.Injectable });
+    static ɵprov = ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: HttpClient });
 }
 ɵɵngDeclareClassMetadata({ type: HttpClient, decorators: [{
             type: Injectable
@@ -99398,8 +99972,8 @@ class FetchBackend {
         }
         return chunksAll;
     }
-    static ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: FetchBackend, deps: [], target: FactoryTarget.Injectable });
-    static ɵprov = ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: FetchBackend });
+    static ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: FetchBackend, deps: [], target: FactoryTarget.Injectable });
+    static ɵprov = ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: FetchBackend });
 }
 ɵɵngDeclareClassMetadata({ type: FetchBackend, decorators: [{
             type: Injectable
@@ -99529,10 +100103,10 @@ class HttpInterceptorHandler extends HttpHandler {
     }
     handle(initialRequest) {
         if (this.chain === null) {
-            const dedupedInterceptorFns = Array.from(new Set([
-                ...this.injector.get(HTTP_INTERCEPTOR_FNS),
-                ...this.injector.get(HTTP_ROOT_INTERCEPTOR_FNS, []),
-            ]));
+            const parentHandler = this.injector.get(HttpHandler, null, { skipSelf: true });
+            const isDelegating = parentHandler !== null && this.backend === parentHandler;
+            const rootInterceptorFns = this.injector.get(HTTP_ROOT_INTERCEPTOR_FNS, [], isDelegating ? { self: true } : undefined);
+            const dedupedInterceptorFns = Array.from(new Set([...this.injector.get(HTTP_INTERCEPTOR_FNS), ...rootInterceptorFns]));
             // Note: interceptors are wrapped right-to-left so that final execution order is
             // left-to-right. That is, if `dedupedInterceptorFns` is the array `[a, b, c]`, we want to
             // produce a chain that is conceptually `c(b(a(end)))`, which we build from the inside
@@ -99547,8 +100121,8 @@ class HttpInterceptorHandler extends HttpHandler {
             return this.chain(initialRequest, (downstreamRequest) => this.backend.handle(downstreamRequest));
         }
     }
-    static ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: HttpInterceptorHandler, deps: [{ token: HttpBackend }, { token: EnvironmentInjector }], target: FactoryTarget.Injectable });
-    static ɵprov = ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: HttpInterceptorHandler });
+    static ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: HttpInterceptorHandler, deps: [{ token: HttpBackend }, { token: EnvironmentInjector }], target: FactoryTarget.Injectable });
+    static ɵprov = ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: HttpInterceptorHandler });
 }
 ɵɵngDeclareClassMetadata({ type: HttpInterceptorHandler, decorators: [{
             type: Injectable
@@ -99574,6 +100148,8 @@ const JSONP_ERR_WRONG_RESPONSE_TYPE = 'JSONP requests must use Json response typ
 // Error text given when a request is passed to the JsonpClientBackend that has
 // headers set
 const JSONP_ERR_HEADERS_NOT_SUPPORTED = 'JSONP requests do not support headers.';
+// Error text given when a JSONP request URL is not absolute HTTP(S).
+const JSONP_ERR_UNSAFE_URL = 'JSONP requests only support absolute URLs with HTTP(S) protocols.';
 /**
  * DI token/abstract type representing a map of JSONP callbacks.
  *
@@ -99642,6 +100218,9 @@ class JsonpClientBackend {
         if (req.headers.keys().length > 0) {
             throw new RuntimeError(2812 /* RuntimeErrorCode.JSONP_HEADERS_NOT_SUPPORTED */, ngDevMode && JSONP_ERR_HEADERS_NOT_SUPPORTED);
         }
+        if (!this.isAllowedJsonpUrl(req.urlWithParams)) {
+            throw new RuntimeError(2826 /* RuntimeErrorCode.JSONP_UNSAFE_URL */, ngDevMode && JSONP_ERR_UNSAFE_URL);
+        }
         // Everything else happens inside the Observable boundary.
         return new Observable((observer) => {
             // The first step to make a request is to generate the callback name, and replace the
@@ -99752,8 +100331,11 @@ class JsonpClientBackend {
         foreignDocument ??= this.document.implementation.createHTMLDocument();
         foreignDocument.adoptNode(script);
     }
-    static ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: JsonpClientBackend, deps: [{ token: JsonpCallbackContext }, { token: DOCUMENT$1 }], target: FactoryTarget.Injectable });
-    static ɵprov = ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: JsonpClientBackend });
+    isAllowedJsonpUrl(url) {
+        return /^https?:\/\//i.test(url);
+    }
+    static ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: JsonpClientBackend, deps: [{ token: JsonpCallbackContext }, { token: DOCUMENT$1 }], target: FactoryTarget.Injectable });
+    static ɵprov = ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: JsonpClientBackend });
 }
 ɵɵngDeclareClassMetadata({ type: JsonpClientBackend, decorators: [{
             type: Injectable
@@ -99794,8 +100376,8 @@ class JsonpInterceptor {
     intercept(initialRequest, next) {
         return runInInjectionContext(this.injector, () => jsonpInterceptorFn(initialRequest, (downstreamRequest) => next.handle(downstreamRequest)));
     }
-    static ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: JsonpInterceptor, deps: [{ token: EnvironmentInjector }], target: FactoryTarget.Injectable });
-    static ɵprov = ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: JsonpInterceptor });
+    static ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: JsonpInterceptor, deps: [{ token: EnvironmentInjector }], target: FactoryTarget.Injectable });
+    static ɵprov = ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: JsonpInterceptor });
 }
 ɵɵngDeclareClassMetadata({ type: JsonpInterceptor, decorators: [{
             type: Injectable
@@ -100149,8 +100731,8 @@ class HttpXhrBackend {
             });
         }));
     }
-    static ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: HttpXhrBackend, deps: [{ token: XhrFactory }], target: FactoryTarget.Injectable });
-    static ɵprov = ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: HttpXhrBackend });
+    static ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: HttpXhrBackend, deps: [{ token: XhrFactory }], target: FactoryTarget.Injectable });
+    static ɵprov = ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: HttpXhrBackend });
 }
 ɵɵngDeclareClassMetadata({ type: HttpXhrBackend, decorators: [{
             type: Injectable
@@ -100202,8 +100784,8 @@ class HttpXsrfCookieExtractor {
         }
         return this.lastToken;
     }
-    static ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: HttpXsrfCookieExtractor, deps: [{ token: DOCUMENT$1 }, { token: XSRF_COOKIE_NAME }], target: FactoryTarget.Injectable });
-    static ɵprov = ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: HttpXsrfCookieExtractor });
+    static ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: HttpXsrfCookieExtractor, deps: [{ token: DOCUMENT$1 }, { token: XSRF_COOKIE_NAME }], target: FactoryTarget.Injectable });
+    static ɵprov = ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: HttpXsrfCookieExtractor });
 }
 ɵɵngDeclareClassMetadata({ type: HttpXsrfCookieExtractor, decorators: [{
             type: Injectable
@@ -100248,8 +100830,8 @@ class HttpXsrfInterceptor {
     intercept(initialRequest, next) {
         return runInInjectionContext(this.injector, () => xsrfInterceptorFn(initialRequest, (downstreamRequest) => next.handle(downstreamRequest)));
     }
-    static ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: HttpXsrfInterceptor, deps: [{ token: EnvironmentInjector }], target: FactoryTarget.Injectable });
-    static ɵprov = ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: HttpXsrfInterceptor });
+    static ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: HttpXsrfInterceptor, deps: [{ token: EnvironmentInjector }], target: FactoryTarget.Injectable });
+    static ɵprov = ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: HttpXsrfInterceptor });
 }
 ɵɵngDeclareClassMetadata({ type: HttpXsrfInterceptor, decorators: [{
             type: Injectable
@@ -100310,9 +100892,11 @@ function provideHttpClient(...features) {
         const featureKinds = new Set(features.map((f) => f.ɵkind));
         if (featureKinds.has(HttpFeatureKind.NoXsrfProtection) &&
             featureKinds.has(HttpFeatureKind.CustomXsrfConfiguration)) {
-            throw new Error(ngDevMode
-                ? `Configuration error: found both withXsrfConfiguration() and withNoXsrfProtection() in the same call to provideHttpClient(), which is a contradiction.`
-                : '');
+            throw new Error(`Configuration error: found both withXsrfConfiguration() and withNoXsrfProtection() in the same call to provideHttpClient(), which is a contradiction.`);
+        }
+        if (featureKinds.has(HttpFeatureKind.RequestsMadeViaParent) &&
+            featureKinds.has(HttpFeatureKind.Fetch)) {
+            throw new Error(`Configuration error: withRequestsMadeViaParent() cannot be combined with withFetch() in the same call to provideHttpClient().`);
         }
     }
     const providers = [
@@ -100452,9 +101036,9 @@ class HttpClientXsrfModule {
             providers: withXsrfConfiguration(options).ɵproviders,
         };
     }
-    static ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: HttpClientXsrfModule, deps: [], target: FactoryTarget.NgModule });
-    static ɵmod = ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.19", ngImport: i0, type: HttpClientXsrfModule });
-    static ɵinj = ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: HttpClientXsrfModule, providers: [
+    static ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: HttpClientXsrfModule, deps: [], target: FactoryTarget.NgModule });
+    static ɵmod = ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.28", ngImport: i0, type: HttpClientXsrfModule });
+    static ɵinj = ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: HttpClientXsrfModule, providers: [
             HttpXsrfInterceptor,
             { provide: HTTP_INTERCEPTORS, useExisting: HttpXsrfInterceptor, multi: true },
             { provide: HttpXsrfTokenExtractor, useClass: HttpXsrfCookieExtractor },
@@ -100491,9 +101075,9 @@ class HttpClientXsrfModule {
  * @deprecated use `provideHttpClient(withInterceptorsFromDi())` as providers instead
  */
 class HttpClientModule {
-    static ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: HttpClientModule, deps: [], target: FactoryTarget.NgModule });
-    static ɵmod = ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.19", ngImport: i0, type: HttpClientModule });
-    static ɵinj = ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: HttpClientModule, providers: [provideHttpClient(withInterceptorsFromDi())] });
+    static ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: HttpClientModule, deps: [], target: FactoryTarget.NgModule });
+    static ɵmod = ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.28", ngImport: i0, type: HttpClientModule });
+    static ɵinj = ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: HttpClientModule, providers: [provideHttpClient(withInterceptorsFromDi())] });
 }
 ɵɵngDeclareClassMetadata({ type: HttpClientModule, decorators: [{
             type: NgModule,
@@ -100515,9 +101099,9 @@ class HttpClientModule {
  * @deprecated `withJsonpSupport()` as providers instead
  */
 class HttpClientJsonpModule {
-    static ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: HttpClientJsonpModule, deps: [], target: FactoryTarget.NgModule });
-    static ɵmod = ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.19", ngImport: i0, type: HttpClientJsonpModule });
-    static ɵinj = ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: HttpClientJsonpModule, providers: [withJsonpSupport().ɵproviders] });
+    static ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: HttpClientJsonpModule, deps: [], target: FactoryTarget.NgModule });
+    static ɵmod = ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.28", ngImport: i0, type: HttpClientJsonpModule });
+    static ɵinj = ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: HttpClientJsonpModule, providers: [withJsonpSupport().ɵproviders] });
 }
 ɵɵngDeclareClassMetadata({ type: HttpClientJsonpModule, decorators: [{
             type: NgModule,
@@ -103327,8 +103911,8 @@ class Viewport {
         }
         this.mediaQuery = null;
     }
-    static { this.ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: Viewport, deps: [], target: FactoryTarget.Injectable }); }
-    static { this.ɵprov = ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: Viewport, providedIn: 'root' }); }
+    static { this.ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: Viewport, deps: [], target: FactoryTarget.Injectable }); }
+    static { this.ɵprov = ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: Viewport, providedIn: 'root' }); }
 }
 ɵɵngDeclareClassMetadata({ type: Viewport, decorators: [{
             type: Injectable,
@@ -103349,8 +103933,8 @@ class ConstantService {
         };
         this.VALIDATOR = VALIDATOR;
     }
-    static { this.ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: ConstantService, deps: [], target: FactoryTarget.Injectable }); }
-    static { this.ɵprov = ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: ConstantService, providedIn: 'root' }); }
+    static { this.ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: ConstantService, deps: [], target: FactoryTarget.Injectable }); }
+    static { this.ɵprov = ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: ConstantService, providedIn: 'root' }); }
 }
 ɵɵngDeclareClassMetadata({ type: ConstantService, decorators: [{
             type: Injectable,
@@ -103361,8 +103945,8 @@ class UtilsService {
     constructor() {
         assign(this, Utils);
     }
-    static { this.ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: UtilsService, deps: [], target: FactoryTarget.Injectable }); }
-    static { this.ɵprov = ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: UtilsService, providedIn: 'root' }); }
+    static { this.ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: UtilsService, deps: [], target: FactoryTarget.Injectable }); }
+    static { this.ɵprov = ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: UtilsService, providedIn: 'root' }); }
 }
 ɵɵngDeclareClassMetadata({ type: UtilsService, decorators: [{
             type: Injectable,
@@ -103393,8 +103977,8 @@ class FieldTypeService {
             BLOB: 'blob'
         });
     }
-    static { this.ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: FieldTypeService, deps: [], target: FactoryTarget.Injectable }); }
-    static { this.ɵprov = ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: FieldTypeService, providedIn: 'root' }); }
+    static { this.ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: FieldTypeService, deps: [], target: FactoryTarget.Injectable }); }
+    static { this.ɵprov = ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: FieldTypeService, providedIn: 'root' }); }
 }
 ɵɵngDeclareClassMetadata({ type: FieldTypeService, decorators: [{
             type: Injectable,
@@ -103427,8 +104011,8 @@ class FieldWidgetService {
             COLORPICKER: 'colorpicker'
         });
     }
-    static { this.ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: FieldWidgetService, deps: [], target: FactoryTarget.Injectable }); }
-    static { this.ɵprov = ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: FieldWidgetService, providedIn: 'root' }); }
+    static { this.ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: FieldWidgetService, deps: [], target: FactoryTarget.Injectable }); }
+    static { this.ɵprov = ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: FieldWidgetService, providedIn: 'root' }); }
 }
 ɵɵngDeclareClassMetadata({ type: FieldWidgetService, decorators: [{
             type: Injectable,
@@ -103497,8 +104081,8 @@ class ScriptLoaderService {
             document.getElementsByTagName('head')[0].appendChild(script);
         });
     }
-    static { this.ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: ScriptLoaderService, deps: [{ token: HttpClient }], target: FactoryTarget.Injectable }); }
-    static { this.ɵprov = ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: ScriptLoaderService, providedIn: 'root' }); }
+    static { this.ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: ScriptLoaderService, deps: [{ token: HttpClient }], target: FactoryTarget.Injectable }); }
+    static { this.ɵprov = ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: ScriptLoaderService, providedIn: 'root' }); }
 }
 ɵɵngDeclareClassMetadata({ type: ScriptLoaderService, decorators: [{
             type: Injectable,
@@ -103518,8 +104102,8 @@ class CustomPipeManager {
     hasCustomPipe(key) {
         return this.customPipes.has(key);
     }
-    static { this.ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: CustomPipeManager, deps: [], target: FactoryTarget.Injectable }); }
-    static { this.ɵprov = ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: CustomPipeManager, providedIn: 'root' }); }
+    static { this.ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: CustomPipeManager, deps: [], target: FactoryTarget.Injectable }); }
+    static { this.ɵprov = ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: CustomPipeManager, providedIn: 'root' }); }
 }
 ɵɵngDeclareClassMetadata({ type: CustomPipeManager, decorators: [{
             type: Injectable,
@@ -103535,8 +104119,8 @@ class CustomIconsLoaderService {
             .map(font => font.csspath);
         loadStyleSheets(cssPaths);
     }
-    static { this.ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: CustomIconsLoaderService, deps: [], target: FactoryTarget.Injectable }); }
-    static { this.ɵprov = ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: CustomIconsLoaderService, providedIn: 'root' }); }
+    static { this.ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: CustomIconsLoaderService, deps: [], target: FactoryTarget.Injectable }); }
+    static { this.ɵprov = ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: CustomIconsLoaderService, providedIn: 'root' }); }
 }
 ɵɵngDeclareClassMetadata({ type: CustomIconsLoaderService, decorators: [{
             type: Injectable,
@@ -104032,8 +104616,8 @@ class StatePersistence {
         }
         return response;
     }
-    static { this.ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: StatePersistence, deps: [], target: FactoryTarget.Injectable }); }
-    static { this.ɵprov = ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: StatePersistence, providedIn: 'root' }); }
+    static { this.ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: StatePersistence, deps: [], target: FactoryTarget.Injectable }); }
+    static { this.ɵprov = ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: StatePersistence, providedIn: 'root' }); }
 }
 ɵɵngDeclareClassMetadata({ type: StatePersistence, decorators: [{
             type: Injectable,
@@ -104364,8 +104948,8 @@ class PaginationService {
             lastScrollTop = scrollTop;
         });
     }
-    static { this.ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: PaginationService, deps: [], target: FactoryTarget.Injectable }); }
-    static { this.ɵprov = ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.19", ngImport: i0, type: PaginationService, providedIn: 'root' }); }
+    static { this.ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: PaginationService, deps: [], target: FactoryTarget.Injectable }); }
+    static { this.ɵprov = ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.28", ngImport: i0, type: PaginationService, providedIn: 'root' }); }
 }
 ɵɵngDeclareClassMetadata({ type: PaginationService, decorators: [{
             type: Injectable,