fix(security): align sanitizer sinks with Angular v22

Issue #315 is still open on main, which vendors @angular/compiler v22.0.0.
The previous branch pinned v21.2.7 and stripped namespaces before lookup.
v22 keeps :svg: and :math: in the security key and strips script elements
instead of treating script|src as a resource URL.

- Register the v22 DOM security schema, including SVG animation attributes
  as ATTRIBUTE_NO_BINDING and namespaced MathML hrefs.
- Compute host-binding security from the directive selector, including
  :not() and svg/math promotion of unknown element names.
- Map ATTRIBUTE_NO_BINDING to ɵɵvalidateAttribute.
- Reject i18n of Trusted Types sinks without stripping a namespace prefix.
- Drop script and :svg:script while lowering templates, and look security
  up on the qualified element name.

Author: Brooooooklyn

crates/oxc_angular_compiler/src/i18n/extractor_merger.rs

@@ -17,6 +17,7 @@ use crate::i18n::ast::{
 };
 use crate::i18n::parser::{I18nMessageFactory, create_i18n_message_factory};
 use crate::i18n::translation_bundle::TranslationBundle;
+use crate::schema::is_trusted_types_sink;
 use crate::util::{ParseSourceFile, ParseSourceSpan};
 
 // ============================================================================
@@ -1083,7 +1084,7 @@ impl<'a> I18nVisitor<'a> {
 
     /// Translates attributes for merge mode, handling i18n-* attributes.
     fn translate_attributes_for_merge(
-        &self,
+        &mut self,
         element_name: &str,
         attrs: &[HtmlAttrRef<'_>],
     ) -> Vec<TranslatedAttribute> {
@@ -1095,6 +1096,15 @@ impl<'a> I18nVisitor<'a> {
         for attr in attrs {
             if attr.name.starts_with(I18N_ATTR_PREFIX) {
                 let target_name = &attr.name[I18N_ATTR_PREFIX.len()..];
+                if is_trusted_types_sink(element_name, target_name) {
+                    self.report_error(
+                        attr.span,
+                        &format!(
+                            "Translating attribute '{target_name}' is disallowed for security reasons."
+                        ),
+                    );
+                    continue;
+                }
                 explicit_attr_meta.insert(target_name.to_string(), attr.value.to_string());
             }
         }
@@ -1235,10 +1245,20 @@ impl<'a> I18nVisitor<'a> {
         let implicit_attr_names =
             self.implicit_attrs.get(element_name).cloned().unwrap_or_default();
 
-        // Collect explicit i18n-* attributes
+        // Collect explicit i18n-* attributes. Trusted Types sinks are rejected
+        // and not extracted (`i18n/meta.ts`).
         for attr in attrs {
             if attr.name.starts_with(I18N_ATTR_PREFIX) {
                 let target_name = &attr.name[I18N_ATTR_PREFIX.len()..];
+                if is_trusted_types_sink(element_name, target_name) {
+                    self.report_error(
+                        attr.span,
+                        &format!(
+                            "Translating attribute '{target_name}' is disallowed for security reasons."
+                        ),
+                    );
+                    continue;
+                }
                 explicit_attr_names.insert(target_name.to_string(), attr.value.to_string());
             }
         }
@@ -1794,6 +1814,61 @@ mod tests {
         assert!(result.errors.is_empty());
     }
 
+    #[test]
+    fn test_iframe_src_i18n_is_rejected() {
+        let source_file = Arc::new(ParseSourceFile::new("", "<test>"));
+        let span = Span::default();
+        let nodes = vec![HtmlNodeRef::Element {
+            name: "iframe",
+            attrs: vec![
+                HtmlAttrRef {
+                    name: "i18n-src",
+                    value: "translated url",
+                    span,
+                    is_interpolation_only: false,
+                },
+                HtmlAttrRef {
+                    name: "src",
+                    value: "https://example.com",
+                    span,
+                    is_interpolation_only: false,
+                },
+            ],
+            children: vec![],
+            span,
+            start_span: span,
+            end_span: None,
+        }];
+        let result = extract_messages(&nodes, &[], &FxHashMap::default(), true, source_file);
+        assert!(result.messages.is_empty());
+        assert!(result.errors.iter().any(|err| err.message.contains("disallowed")));
+    }
+
+    #[test]
+    fn test_plain_title_i18n_is_still_extracted() {
+        let source_file = Arc::new(ParseSourceFile::new("", "<test>"));
+        let span = Span::default();
+        let nodes = vec![HtmlNodeRef::Element {
+            name: "div",
+            attrs: vec![
+                HtmlAttrRef {
+                    name: "i18n-title",
+                    value: "meaning|desc",
+                    span,
+                    is_interpolation_only: false,
+                },
+                HtmlAttrRef { name: "title", value: "Hello", span, is_interpolation_only: false },
+            ],
+            children: vec![],
+            span,
+            start_span: span,
+            end_span: None,
+        }];
+        let result = extract_messages(&nodes, &[], &FxHashMap::default(), true, source_file);
+        assert!(result.errors.is_empty());
+        assert!(!result.messages.is_empty());
+    }
+
     #[test]
     fn test_parse_translated_text_plain() {
         let nodes = parse_translated_text("Hello World", Span::default());

crates/oxc_angular_compiler/src/pipeline/ingest.rs

@@ -4122,66 +4122,29 @@ fn ingest_host_dom_property<'a>(
         name,
         expression,
         unit: property.unit,
-        security_context: property.security_context,
+        // Host property bindings recompute the context from the selector.
+        // `style` / `class` / animation ops are specialized before sanitizers run.
+        security_context: match binding_kind {
+            BindingKind::Attribute | BindingKind::Property | BindingKind::TwoWayProperty => {
+                crate::schema::host_binding_security_context(
+                    job.component_selector.as_str(),
+                    name.as_str(),
+                )
+            }
+            _ => SecurityContext::None,
+        },
         i18n_message: None,
         is_text_attribute: false,
     });
 
     job.root.update.push(op);
 }
 
-/// Computes the security context for an attribute binding.
+/// Security context for a static host attribute.
 ///
-/// This is a simplified implementation of Angular's `calcPossibleSecurityContexts`
-/// that handles the most common cases based on element and property names.
-///
-/// Ported from Angular's `binding_parser.ts` and `dom_security_schema.ts`.
+/// Same selector rules as host property bindings (`calcPossibleSecurityContexts`).
 fn compute_security_context(selector: &str, attr_name: &str) -> SecurityContext {
-    use crate::schema::{calc_security_context_for_unknown_element, get_security_context};
-
-    // Extract element name from selector if present (e.g., "a[myDirective]" → "a")
-    let element = extract_element_from_selector(selector);
-
-    match element {
-        Some(element_name) => {
-            // Element is known - use the specific lookup
-            get_security_context(&element_name, attr_name)
-        }
-        None => {
-            // Element is unknown (e.g., attribute-only directive like [myDirective])
-            // Use the ambiguous lookup that checks all possible elements
-            calc_security_context_for_unknown_element(attr_name)
-        }
-    }
-}
-
-/// Extracts the element name from a CSS selector.
-///
-/// Examples:
-/// - "a[myDirective]" → Some("a")
-/// - "div.my-class" → Some("div")
-/// - "[myDirective]" → None
-/// - ".my-class" → None
-fn extract_element_from_selector(selector: &str) -> Option<String> {
-    // Skip leading whitespace
-    let s = selector.trim();
-
-    // If starts with [, ., or :, there's no element
-    if s.starts_with('[') || s.starts_with('.') || s.starts_with(':') || s.starts_with('#') {
-        return None;
-    }
-
-    // Find the element name (alphanumeric and hyphens until a special char)
-    let mut element_end = 0;
-    for (i, c) in s.char_indices() {
-        if c.is_alphanumeric() || c == '-' || c == '_' {
-            element_end = i + c.len_utf8();
-        } else {
-            break;
-        }
-    }
-
-    if element_end > 0 { Some(s[..element_end].to_lowercase()) } else { None }
+    crate::schema::host_binding_security_context(selector, attr_name)
 }
 
 /// Ingests a static host attribute.

crates/oxc_angular_compiler/src/pipeline/phases/resolve_sanitizers.rs

@@ -27,10 +27,8 @@ fn get_sanitizer_fn(security_context: SecurityContext) -> Option<&'static str> {
         // selects the actual sanitizer at runtime based on the tag name.
         SecurityContext::UrlOrResourceUrl => Some(Identifiers::SANITIZE_URL_OR_RESOURCE_URL),
         SecurityContext::None => None,
-        // AttributeNoBinding means the attribute should not be bound at all.
-        // This should produce a compile-time error in the HTML-to-R3 transform.
-        // For now, return None but the binding should have been rejected earlier.
-        SecurityContext::AttributeNoBinding => None,
+        // `resolve_sanitizers.ts` maps ATTRIBUTE_NO_BINDING to `ɵɵvalidateAttribute`.
+        SecurityContext::AttributeNoBinding => Some(Identifiers::VALIDATE_ATTRIBUTE),
     }
 }