mirror of
https://github.com/lexmount/moli.git
synced 2026-11-21 00:03:15 +00:00
fix(dom): parse XML markup fragments with native namespace contexts
Share a strict XML fragment parser across Range.createContextualFragment, innerHTML, outerHTML and insertAdjacentHTML. Carry native in-scope namespace bindings without inherited DTD entities, preserve XML node kinds and UTF-16 TrustedHTML inputs, and keep parsed scripts inert after adoption. Validate the complete fragment before replacing existing children and expose syntax failures as DOMExceptions in the callee realm. Keep setHTMLUnsafe on its HTML parser path. Cover native Proxies, ShadowRoot and template contexts, cross-realm calls, mutation atomicity and malformed namespace declarations.
This commit is contained in:
@@ -41,7 +41,7 @@ pub use script_planning::{
|
||||
PreparedImportMapSource, PreparedScript, ScriptFetchMetadata, ScriptFilterSkipReason,
|
||||
ScriptSource, build_prepared_import_map, build_prepared_script, classify_parser_script,
|
||||
};
|
||||
pub use xml::XmlParser;
|
||||
pub use xml::{ParsedXmlFragment, XmlFragmentParseError, XmlParser};
|
||||
pub use xml_stream::XmlDocumentStream;
|
||||
|
||||
const STREAM_CHUNK_BYTES: usize = 8 * 1024;
|
||||
|
||||
+132
-45
@@ -26,6 +26,12 @@ use moli_dom::native::{
|
||||
Attribute as NativeAttribute, DomHost, NativeDom, NativeNodeId, Node, ParserConstruction,
|
||||
};
|
||||
|
||||
mod fragment;
|
||||
pub use fragment::{ParsedXmlFragment, XmlFragmentParseError};
|
||||
|
||||
const XML_NAMESPACE: &str = "http://www.w3.org/XML/1998/namespace";
|
||||
const XMLNS_NAMESPACE: &str = "http://www.w3.org/2000/xmlns/";
|
||||
|
||||
#[derive(Debug, Clone, Default)]
|
||||
pub struct XmlParser;
|
||||
|
||||
@@ -168,12 +174,15 @@ impl XmlParser {
|
||||
}
|
||||
}
|
||||
|
||||
type XmlNamespaceBindings = HashMap<String, Vec<String>>;
|
||||
|
||||
fn xml_element_stack_error(xml: &str) -> Option<XmlPrepassError> {
|
||||
let mut pending_start_name = None;
|
||||
let mut pending_used_prefixes = Vec::new();
|
||||
let mut pending_declared_prefixes = Vec::new();
|
||||
let mut pending_attributes = Vec::new();
|
||||
let mut open_elements = Vec::new();
|
||||
let mut active_prefixes = HashMap::from([("xml".to_owned(), 1usize)]);
|
||||
let mut active_prefixes = HashMap::from([("xml".to_owned(), vec![XML_NAMESPACE.to_owned()])]);
|
||||
|
||||
for token in XmlTokenizer::from(xml) {
|
||||
match token {
|
||||
@@ -191,53 +200,61 @@ fn xml_element_stack_error(xml: &str) -> Option<XmlPrepassError> {
|
||||
..
|
||||
}) => {
|
||||
let prefix = prefix.as_str();
|
||||
if prefix == "xmlns" {
|
||||
if !value.as_str().is_empty() {
|
||||
pending_declared_prefixes.push(local.as_str().to_owned());
|
||||
if prefix == "xmlns" || (prefix.is_empty() && local.as_str() == "xmlns") {
|
||||
let Some(namespace) = xml_namespace_attribute_value(value.as_str()) else {
|
||||
return Some(XmlPrepassError::namespace("Invalid XML namespace value"));
|
||||
};
|
||||
let declared_prefix = if prefix == "xmlns" {
|
||||
local.as_str()
|
||||
} else {
|
||||
""
|
||||
};
|
||||
if !xml_namespace_declaration_is_valid(declared_prefix, &namespace) {
|
||||
return Some(XmlPrepassError::namespace(
|
||||
"Invalid XML namespace declaration",
|
||||
));
|
||||
}
|
||||
pending_declared_prefixes.push((declared_prefix.to_owned(), namespace));
|
||||
} else if !prefix.is_empty() {
|
||||
pending_used_prefixes.push(prefix.to_owned());
|
||||
pending_attributes.push((prefix.to_owned(), local.as_str().to_owned()));
|
||||
}
|
||||
}
|
||||
Ok(XmlTokenizerToken::ElementEnd { end, .. }) => match end {
|
||||
XmlElementEnd::Open => {
|
||||
end @ (XmlElementEnd::Open | XmlElementEnd::Empty) => {
|
||||
let is_open = matches!(end, XmlElementEnd::Open);
|
||||
let Some(name) = pending_start_name.take() else {
|
||||
return Some(XmlPrepassError::tree("XML start tag is missing a name"));
|
||||
return Some(XmlPrepassError::tree(if is_open {
|
||||
"XML start tag is missing a name"
|
||||
} else {
|
||||
"XML empty-element tag is missing a name"
|
||||
}));
|
||||
};
|
||||
for prefix in &pending_declared_prefixes {
|
||||
*active_prefixes.entry(prefix.clone()).or_default() += 1;
|
||||
for (prefix, namespace) in &pending_declared_prefixes {
|
||||
active_prefixes
|
||||
.entry(prefix.clone())
|
||||
.or_default()
|
||||
.push(namespace.clone());
|
||||
}
|
||||
if let Some(prefix) = pending_used_prefixes
|
||||
.iter()
|
||||
.find(|prefix| !active_prefixes.contains_key(*prefix))
|
||||
{
|
||||
return Some(XmlPrepassError::namespace(format!(
|
||||
"XML namespace prefix `{prefix}` is not declared"
|
||||
)));
|
||||
if let Some(error) = xml_start_namespace_error(
|
||||
&active_prefixes,
|
||||
&pending_used_prefixes,
|
||||
&pending_attributes,
|
||||
) {
|
||||
return Some(error);
|
||||
}
|
||||
pending_used_prefixes.clear();
|
||||
open_elements.push((name, std::mem::take(&mut pending_declared_prefixes)));
|
||||
}
|
||||
XmlElementEnd::Empty => {
|
||||
if pending_start_name.take().is_none() {
|
||||
return Some(XmlPrepassError::tree(
|
||||
"XML empty-element tag is missing a name",
|
||||
));
|
||||
}
|
||||
for prefix in &pending_declared_prefixes {
|
||||
*active_prefixes.entry(prefix.clone()).or_default() += 1;
|
||||
}
|
||||
if let Some(prefix) = pending_used_prefixes
|
||||
.iter()
|
||||
.find(|prefix| !active_prefixes.contains_key(*prefix))
|
||||
{
|
||||
return Some(XmlPrepassError::namespace(format!(
|
||||
"XML namespace prefix `{prefix}` is not declared"
|
||||
)));
|
||||
}
|
||||
pending_used_prefixes.clear();
|
||||
for prefix in pending_declared_prefixes.drain(..) {
|
||||
decrement_xml_prefix_count(&mut active_prefixes, &prefix);
|
||||
pending_attributes.clear();
|
||||
if is_open {
|
||||
let prefixes = pending_declared_prefixes
|
||||
.drain(..)
|
||||
.map(|(prefix, _)| prefix)
|
||||
.collect::<Vec<_>>();
|
||||
open_elements.push((name, prefixes));
|
||||
} else {
|
||||
for (prefix, _) in pending_declared_prefixes.drain(..) {
|
||||
pop_xml_namespace_binding(&mut active_prefixes, &prefix);
|
||||
}
|
||||
}
|
||||
}
|
||||
XmlElementEnd::Close(prefix, local) => {
|
||||
@@ -253,7 +270,7 @@ fn xml_element_stack_error(xml: &str) -> Option<XmlPrepassError> {
|
||||
)));
|
||||
}
|
||||
for prefix in declared_prefixes {
|
||||
decrement_xml_prefix_count(&mut active_prefixes, &prefix);
|
||||
pop_xml_namespace_binding(&mut active_prefixes, &prefix);
|
||||
}
|
||||
}
|
||||
},
|
||||
@@ -273,16 +290,86 @@ fn xml_element_stack_error(xml: &str) -> Option<XmlPrepassError> {
|
||||
}
|
||||
}
|
||||
|
||||
fn decrement_xml_prefix_count(active_prefixes: &mut HashMap<String, usize>, prefix: &str) {
|
||||
let Some(count) = active_prefixes.get_mut(prefix) else {
|
||||
return;
|
||||
};
|
||||
*count -= 1;
|
||||
if *count == 0 {
|
||||
active_prefixes.remove(prefix);
|
||||
fn xml_namespace_declaration_is_valid(prefix: &str, namespace: &str) -> bool {
|
||||
match prefix {
|
||||
"xmlns" => false,
|
||||
"xml" => namespace == XML_NAMESPACE,
|
||||
_ => {
|
||||
namespace != XML_NAMESPACE
|
||||
&& namespace != XMLNS_NAMESPACE
|
||||
&& (prefix.is_empty() || !namespace.is_empty())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn xml_start_namespace_error(
|
||||
namespaces: &XmlNamespaceBindings,
|
||||
used_prefixes: &[String],
|
||||
attributes: &[(String, String)],
|
||||
) -> Option<XmlPrepassError> {
|
||||
for prefix in used_prefixes {
|
||||
if namespaces
|
||||
.get(prefix)
|
||||
.and_then(|values| values.last())
|
||||
.is_none_or(String::is_empty)
|
||||
{
|
||||
return Some(XmlPrepassError::namespace(format!(
|
||||
"XML namespace prefix `{prefix}` is not declared"
|
||||
)));
|
||||
}
|
||||
}
|
||||
// xml5ever drops attributes with duplicate expanded names without an
|
||||
// error. Validate before that recovery loses their original identities.
|
||||
let mut expanded_names = std::collections::HashSet::new();
|
||||
for (prefix, local) in attributes {
|
||||
let namespace = namespaces
|
||||
.get(prefix)
|
||||
.and_then(|values| values.last())
|
||||
.map(String::as_str)
|
||||
.unwrap_or("");
|
||||
if !expanded_names.insert((namespace, local)) {
|
||||
return Some(XmlPrepassError::namespace(format!(
|
||||
"Duplicate XML attribute {{{namespace}}}{local}"
|
||||
)));
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
fn pop_xml_namespace_binding(namespaces: &mut XmlNamespaceBindings, prefix: &str) {
|
||||
if let Some(values) = namespaces.get_mut(prefix) {
|
||||
values.pop();
|
||||
if values.is_empty() {
|
||||
namespaces.remove(prefix);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn xml_namespace_attribute_value(mut input: &str) -> Option<String> {
|
||||
let mut value = String::new();
|
||||
while let Some(character) = input.chars().next() {
|
||||
if character == '&' {
|
||||
let mut stream = xmlparser::Stream::from(input);
|
||||
let xmlparser::Reference::Char(character) = stream.consume_reference().ok()? else {
|
||||
return None;
|
||||
};
|
||||
value.push(character);
|
||||
input = &input[stream.pos()..];
|
||||
} else {
|
||||
input = &input[character.len_utf8()..];
|
||||
match character {
|
||||
'\r' => {
|
||||
input = input.strip_prefix('\n').unwrap_or(input);
|
||||
value.push(' ');
|
||||
}
|
||||
'\n' | '\t' => value.push(' '),
|
||||
_ => value.push(character),
|
||||
}
|
||||
}
|
||||
}
|
||||
Some(value)
|
||||
}
|
||||
|
||||
fn qualified_xml_name(prefix: &str, local_name: &str) -> String {
|
||||
if prefix.is_empty() {
|
||||
local_name.to_owned()
|
||||
|
||||
@@ -0,0 +1,453 @@
|
||||
use std::{collections::BTreeMap, error::Error, fmt};
|
||||
|
||||
use moli_dom::native::{DomHost, DomStringValue, NativeDom, NativeNodeId, Node};
|
||||
|
||||
use super::{XML_NAMESPACE, XMLNS_NAMESPACE, XmlParser};
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct XmlFragmentParseError(String);
|
||||
|
||||
impl fmt::Display for XmlFragmentParseError {
|
||||
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
self.0.fmt(formatter)
|
||||
}
|
||||
}
|
||||
|
||||
impl Error for XmlFragmentParseError {}
|
||||
|
||||
/// A validated XML fragment. The context wrapper is private and is never
|
||||
/// imported into the receiving Document.
|
||||
#[derive(Debug)]
|
||||
pub struct ParsedXmlFragment {
|
||||
document: NativeDom,
|
||||
children: Vec<NativeNodeId>,
|
||||
}
|
||||
|
||||
impl ParsedXmlFragment {
|
||||
pub fn document(&self) -> &NativeDom {
|
||||
&self.document
|
||||
}
|
||||
|
||||
pub fn children(&self) -> &[NativeNodeId] {
|
||||
&self.children
|
||||
}
|
||||
}
|
||||
|
||||
impl XmlParser {
|
||||
/// Parse an XML fragment without mutating its context Document. The XML
|
||||
/// Standard's context wrapper carries namespace bindings, never its DTD.
|
||||
pub fn parse_fragment(
|
||||
&self,
|
||||
host: &DomHost,
|
||||
context: NativeNodeId,
|
||||
markup: &DomStringValue,
|
||||
) -> Result<ParsedXmlFragment, XmlFragmentParseError> {
|
||||
let element = host
|
||||
.node(context)
|
||||
.and_then(Node::as_element)
|
||||
.ok_or_else(|| XmlFragmentParseError("XML context must be an Element.".into()))?;
|
||||
let document = host
|
||||
.owner_document_handle(context)
|
||||
.and_then(|document| host.node(document))
|
||||
.and_then(Node::as_document)
|
||||
.ok_or_else(|| XmlFragmentParseError("XML context has no Document.".into()))?;
|
||||
let markup = markup.as_str().ok_or_else(|| {
|
||||
XmlFragmentParseError("XML markup contains an unpaired surrogate.".into())
|
||||
})?;
|
||||
let name = match element.prefix().filter(|prefix| !prefix.is_empty()) {
|
||||
Some(prefix) => format!("{prefix}:{}", element.local_name()),
|
||||
None => element.local_name().to_owned(),
|
||||
};
|
||||
let mut input = String::new();
|
||||
input.push('<');
|
||||
input.push_str(&name);
|
||||
for (prefix, value) in namespaces_in_scope(host, context) {
|
||||
let value = value.as_str().ok_or_else(|| {
|
||||
XmlFragmentParseError("XML namespace contains an unpaired surrogate.".into())
|
||||
})?;
|
||||
if prefix.is_some() && value.is_empty() {
|
||||
// An empty declaration masks ancestors, but lookupNamespaceURI
|
||||
// returns null, so this prefix is not declared in the wrapper.
|
||||
continue;
|
||||
}
|
||||
input.push_str(" xmlns");
|
||||
if let Some(prefix) = prefix {
|
||||
input.push(':');
|
||||
input.push_str(&prefix);
|
||||
}
|
||||
input.push_str("=\"");
|
||||
append_namespace_value(&mut input, value);
|
||||
input.push('"');
|
||||
}
|
||||
input.push('>');
|
||||
input.push_str(markup);
|
||||
input.push_str("</");
|
||||
input.push_str(&name);
|
||||
input.push('>');
|
||||
|
||||
let parsed = self.parse(document.url().clone(), input);
|
||||
if let Some(error) = parsed.parse_errors().first() {
|
||||
return Err(XmlFragmentParseError(error.clone()));
|
||||
}
|
||||
let mut parsed = DomHost::from_dom(parsed);
|
||||
let root = {
|
||||
let mut document_children = parsed.child_handles(parsed.document_handle());
|
||||
let root = document_children
|
||||
.next()
|
||||
.filter(|root| parsed.node(*root).is_some_and(Node::is_element))
|
||||
.ok_or_else(|| {
|
||||
XmlFragmentParseError("XML fragment has no context element.".into())
|
||||
})?;
|
||||
// A context name containing "--" can let a trailing comment swallow
|
||||
// the generated end tag. XML well-formedness alone does not catch it.
|
||||
if document_children.next().is_some() {
|
||||
return Err(XmlFragmentParseError(
|
||||
"XML fragment escapes its context element.".into(),
|
||||
));
|
||||
}
|
||||
root
|
||||
};
|
||||
let content = parsed
|
||||
.node(root)
|
||||
.and_then(Node::as_element)
|
||||
.and_then(|element| element.template_contents())
|
||||
.unwrap_or(root);
|
||||
let children = parsed.child_handles(content).collect();
|
||||
let scripts = parsed
|
||||
.nodes()
|
||||
.iter()
|
||||
.filter(|node| node.is_script_element())
|
||||
.map(Node::id)
|
||||
.collect::<Vec<_>>();
|
||||
for script in scripts {
|
||||
// XML fragments stay inert even when subsequently adopted into
|
||||
// an HTML Document, including scripts inside template contents.
|
||||
parsed.set_script_already_started(script, true);
|
||||
}
|
||||
Ok(ParsedXmlFragment {
|
||||
document: parsed.into_dom(),
|
||||
children,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
fn namespaces_in_scope(
|
||||
host: &DomHost,
|
||||
context: NativeNodeId,
|
||||
) -> BTreeMap<Option<String>, DomStringValue> {
|
||||
let mut namespaces = BTreeMap::from([(Some("xml".into()), XML_NAMESPACE.into())]);
|
||||
let mut current = Some(context);
|
||||
while let Some(node) = current.and_then(|handle| host.node(handle)) {
|
||||
let Some(element) = node.as_element() else {
|
||||
break;
|
||||
};
|
||||
if !element.namespace().is_empty() {
|
||||
namespaces
|
||||
.entry(
|
||||
element
|
||||
.prefix()
|
||||
.filter(|prefix| !prefix.is_empty())
|
||||
.map(str::to_owned),
|
||||
)
|
||||
.or_insert_with(|| element.namespace().into());
|
||||
}
|
||||
for attribute in element.attributes() {
|
||||
if attribute.namespace() != XMLNS_NAMESPACE {
|
||||
continue;
|
||||
}
|
||||
let prefix = match attribute.prefix().filter(|prefix| !prefix.is_empty()) {
|
||||
Some("xmlns") if attribute.local_name() != "xmlns" => {
|
||||
Some(attribute.local_name().to_owned())
|
||||
}
|
||||
None if attribute.local_name() == "xmlns" => None,
|
||||
_ => continue,
|
||||
};
|
||||
// Keep an empty declaration: it masks an ancestor binding.
|
||||
namespaces.entry(prefix).or_insert_with(|| {
|
||||
element
|
||||
.attribute_ns_utf16_units(XMLNS_NAMESPACE, attribute.local_name())
|
||||
.map(DomStringValue::from_utf16)
|
||||
.unwrap_or_else(|| attribute.value().into())
|
||||
});
|
||||
}
|
||||
current = node.parent_node();
|
||||
}
|
||||
namespaces
|
||||
}
|
||||
|
||||
fn append_namespace_value(output: &mut String, value: &str) {
|
||||
for character in value.chars() {
|
||||
output.push_str(match character {
|
||||
'&' => "&",
|
||||
'<' => "<",
|
||||
'>' => ">",
|
||||
'"' => """,
|
||||
'\t' => "	",
|
||||
'\n' => " ",
|
||||
'\r' => " ",
|
||||
_ => {
|
||||
output.push(character);
|
||||
continue;
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use moli_dom::native::NodeType;
|
||||
use url::Url;
|
||||
|
||||
fn context(source: &str) -> (DomHost, NativeNodeId) {
|
||||
let document = XmlParser.parse(
|
||||
Url::parse("https://xml-fragment.test/context.xml").unwrap(),
|
||||
source.into(),
|
||||
);
|
||||
assert!(
|
||||
document.parse_errors().is_empty(),
|
||||
"{:?}",
|
||||
document.parse_errors()
|
||||
);
|
||||
let host = DomHost::from_dom(document);
|
||||
let context = host
|
||||
.nodes()
|
||||
.iter()
|
||||
.find(|node| node.local_name() == Some("Context"))
|
||||
.map(Node::id)
|
||||
.unwrap_or_else(|| host.dom().document_element_node_id().unwrap());
|
||||
(host, context)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn xml_fragments_preserve_namespaces_case_and_xml_node_kinds() {
|
||||
let (host, context) = context(
|
||||
"<Root xmlns='urn:outer'><p:Parent xmlns:p='urn:local'><Context/></p:Parent></Root>",
|
||||
);
|
||||
let parsed = XmlParser
|
||||
.parse_fragment(
|
||||
&host,
|
||||
context,
|
||||
&"<Mixed p:Token='v'/><p:Item/>tail<![CDATA[a<b]]><!--end--><?target data?>".into(),
|
||||
)
|
||||
.unwrap();
|
||||
let nodes = parsed
|
||||
.children()
|
||||
.iter()
|
||||
.map(|handle| parsed.document().node(*handle).unwrap())
|
||||
.collect::<Vec<_>>();
|
||||
assert_eq!(
|
||||
nodes
|
||||
.iter()
|
||||
.map(|node| node.node_type())
|
||||
.collect::<Vec<_>>(),
|
||||
[
|
||||
NodeType::Element,
|
||||
NodeType::Element,
|
||||
NodeType::Text,
|
||||
NodeType::CDataSection,
|
||||
NodeType::Comment,
|
||||
NodeType::ProcessingInstruction
|
||||
]
|
||||
);
|
||||
assert_eq!(nodes[0].local_name(), Some("Mixed"));
|
||||
assert_eq!(nodes[0].namespace(), Some("urn:outer"));
|
||||
assert_eq!(
|
||||
nodes[0]
|
||||
.as_element()
|
||||
.unwrap()
|
||||
.attribute_ns("urn:local", "Token"),
|
||||
Some("v")
|
||||
);
|
||||
assert_eq!(nodes[1].namespace(), Some("urn:local"));
|
||||
assert_eq!(nodes[1].prefix(), Some("p"));
|
||||
assert_eq!(nodes[3].node_value(), Some("a<b"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn xml_fragments_reject_grammar_namespace_and_context_escape_errors() {
|
||||
let (host, context) = context("<Context xmlns:p='urn:p'/>");
|
||||
let failures = [
|
||||
"<Item>",
|
||||
"<A></B>",
|
||||
"&unknown;",
|
||||
"<Item x='1' x='2'/>",
|
||||
"<Item xmlns:q='urn:p' p:x='1' q:x='2'/>",
|
||||
"<Item x=value/>",
|
||||
"<?xml version='1.0'?>",
|
||||
"<!DOCTYPE Item><Item/>",
|
||||
"\0",
|
||||
"\u{b}",
|
||||
"\u{fffe}",
|
||||
"�",
|
||||
"</Context><!--escape--><Context>",
|
||||
"<missing:Item/>",
|
||||
"<p:Item xmlns:p=''/>",
|
||||
"<Item xmlns:xml='urn:wrong'/>",
|
||||
"<Item xmlns:xmlns='urn:wrong'/>",
|
||||
"<Item xmlns:p=''/>",
|
||||
"<Item xmlns:q='http://www.w3.org/XML/1998/namespace'/>",
|
||||
"<Item xmlns='http://www.w3.org/XML/1998/namespace'/>",
|
||||
"<Item xmlns:q='http://www.w3.org/2000/xmlns/'/>",
|
||||
"<Item xmlns='http://www.w3.org/2000/xmlns/'/>",
|
||||
]
|
||||
.into_iter()
|
||||
.filter(|markup| {
|
||||
XmlParser
|
||||
.parse_fragment(&host, context, &(*markup).into())
|
||||
.is_ok()
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
assert!(failures.is_empty(), "accepted malformed XML: {failures:?}");
|
||||
for units in [vec![0xd800], vec![0xdc00]] {
|
||||
assert!(
|
||||
XmlParser
|
||||
.parse_fragment(&host, context, &DomStringValue::from_utf16(&units))
|
||||
.is_err()
|
||||
);
|
||||
}
|
||||
let (host, context) = self::context("<foo--/>");
|
||||
assert!(
|
||||
XmlParser
|
||||
.parse_fragment(&host, context, &"x</foo--><!--y".into())
|
||||
.is_err()
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn xml_fragments_escape_and_mask_native_namespace_declarations() {
|
||||
let (mut host, context) = context(
|
||||
"<Root xmlns='urn:outer' xmlns:p='urn:parent'><Context xmlns='' xmlns:p='urn:a&b"c<d>e'/></Root>",
|
||||
);
|
||||
let parsed = XmlParser
|
||||
.parse_fragment(&host, context, &"<Item/><p:Item/>".into())
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
parsed
|
||||
.document()
|
||||
.node(parsed.children()[0])
|
||||
.unwrap()
|
||||
.as_element()
|
||||
.unwrap()
|
||||
.namespace(),
|
||||
""
|
||||
);
|
||||
assert_eq!(
|
||||
parsed
|
||||
.document()
|
||||
.node(parsed.children()[1])
|
||||
.unwrap()
|
||||
.namespace(),
|
||||
Some("urn:a&b\"c<d>e")
|
||||
);
|
||||
host.set_attribute_ns(
|
||||
context,
|
||||
Some(XMLNS_NAMESPACE),
|
||||
Some("xmlns"),
|
||||
"p",
|
||||
"urn:new",
|
||||
);
|
||||
let parsed = XmlParser
|
||||
.parse_fragment(&host, context, &"<p:Item/>".into())
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
parsed
|
||||
.document()
|
||||
.node(parsed.children()[0])
|
||||
.unwrap()
|
||||
.namespace(),
|
||||
Some("urn:new")
|
||||
);
|
||||
host.set_attribute_ns(context, Some(XMLNS_NAMESPACE), Some("xmlns"), "p", "");
|
||||
assert!(
|
||||
XmlParser
|
||||
.parse_fragment(&host, context, &"<Item/>".into())
|
||||
.is_ok()
|
||||
);
|
||||
assert!(
|
||||
XmlParser
|
||||
.parse_fragment(&host, context, &"<p:Item/>".into())
|
||||
.is_err()
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn xml_fragments_use_only_predefined_entities_and_keep_scripts_inert() {
|
||||
let (host, context) =
|
||||
context("<!DOCTYPE Root [<!ENTITY inherited 'secret'>]><Root><Context/></Root>");
|
||||
assert!(
|
||||
XmlParser
|
||||
.parse_fragment(&host, context, &"&inherited;".into())
|
||||
.is_err()
|
||||
);
|
||||
let parsed = XmlParser.parse_fragment(&host, context, &"<&"'>🦊<script xmlns='http://www.w3.org/1999/xhtml'>1</script><template xmlns='http://www.w3.org/1999/xhtml'><script>2</script></template>".into()).unwrap();
|
||||
assert_eq!(
|
||||
parsed
|
||||
.document()
|
||||
.node(parsed.children()[0])
|
||||
.unwrap()
|
||||
.node_value(),
|
||||
Some("<&\"'>🦊")
|
||||
);
|
||||
let scripts = parsed
|
||||
.document()
|
||||
.nodes()
|
||||
.filter(|node| node.is_script_element())
|
||||
.collect::<Vec<_>>();
|
||||
assert_eq!(scripts.len(), 2);
|
||||
assert!(
|
||||
scripts
|
||||
.iter()
|
||||
.all(|node| node.as_element().unwrap().script_already_started())
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn xml_fragments_validate_expanded_names_and_restore_namespace_bindings() {
|
||||
let (mut host, context) = context("<Context xmlns:p='urn:parent'/>");
|
||||
let duplicate = "<Item xmlns:p='urn:a&b' xmlns:q='urn:a&b' p:x='1' q:x='2'/>";
|
||||
assert!(
|
||||
XmlParser
|
||||
.parse_fragment(&host, context, &duplicate.into())
|
||||
.is_err()
|
||||
);
|
||||
let markup = "<Item xmlns:p='urn:child'><p:Child/></Item><p:Sibling/><Item xmlns:p='urn:other'/><p:Last/>";
|
||||
let parsed = XmlParser
|
||||
.parse_fragment(&host, context, &markup.into())
|
||||
.unwrap();
|
||||
for index in [1, 3] {
|
||||
assert_eq!(
|
||||
parsed
|
||||
.document()
|
||||
.node(parsed.children()[index])
|
||||
.unwrap()
|
||||
.namespace(),
|
||||
Some("urn:parent")
|
||||
);
|
||||
}
|
||||
host.set_attribute_ns(
|
||||
context,
|
||||
Some(XMLNS_NAMESPACE),
|
||||
Some("xmlns"),
|
||||
"p",
|
||||
"urn:a\tb\nc\rd",
|
||||
);
|
||||
let parsed = XmlParser
|
||||
.parse_fragment(&host, context, &"<p:Item/>".into())
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
parsed
|
||||
.document()
|
||||
.node(parsed.children()[0])
|
||||
.unwrap()
|
||||
.namespace(),
|
||||
Some("urn:a\tb\nc\rd")
|
||||
);
|
||||
host.set_attribute_utf16_units(context, "xmlns:p", "\u{fffd}", vec![0xd800]);
|
||||
assert!(
|
||||
XmlParser
|
||||
.parse_fragment(&host, context, &"<p:Item/>".into())
|
||||
.is_err()
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -611,7 +611,7 @@ pub(crate) use self::trusted_types::trusted_types_lazy_state_materialized;
|
||||
pub(crate) use self::trusted_types::{
|
||||
TrustedTypeKind, TrustedTypesCodeGenerationCheck, check_javascript_url_trusted_types,
|
||||
install_trusted_types_eval_runtime_state, install_trusted_types_runtime_state,
|
||||
trusted_html_string_or_throw, trusted_html_value_string,
|
||||
trusted_html_dom_string_or_throw, trusted_html_string_or_throw, trusted_html_value_string,
|
||||
trusted_script_string_for_script_element_execution, trusted_script_string_or_type_error,
|
||||
trusted_script_url_string_or_throw, trusted_type_kind, trusted_type_string_or_throw,
|
||||
trusted_type_string16, trusted_type_string16_or_throw, trusted_types_code_generation_check,
|
||||
|
||||
@@ -1,10 +1,11 @@
|
||||
use super::*;
|
||||
use crate::dom::native::DomStringValue;
|
||||
use crate::util::utf16_slice_lossy;
|
||||
|
||||
pub(in crate::context_bootstrap) fn create_contextual_fragment_internal<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
receiver: v8::Local<'s, v8::Object>,
|
||||
html: &str,
|
||||
markup: &DomStringValue,
|
||||
) -> Option<v8::Local<'s, v8::Object>> {
|
||||
let start = native_range_boundary_point(scope, receiver, RangeBoundarySide::Start)?.container();
|
||||
let host_ptr = context_host_ptr_from_global_bridge(scope)?;
|
||||
@@ -34,13 +35,24 @@ pub(in crate::context_bootstrap) fn create_contextual_fragment_internal<'s>(
|
||||
});
|
||||
// Context selection uses the actual tree, including for windowless documents
|
||||
// and registered native Proxies. Public Node properties are author-controlled.
|
||||
let fragment = runtime.build_range_contextual_fragment_from_html(
|
||||
let fragment = match runtime.build_range_contextual_fragment(
|
||||
scope,
|
||||
host_ptr,
|
||||
document_handle,
|
||||
element,
|
||||
html,
|
||||
)?;
|
||||
markup,
|
||||
) {
|
||||
Ok(Some(fragment)) => fragment,
|
||||
Ok(None) => return None,
|
||||
Err(error) => {
|
||||
crate::context_bootstrap::throw_dom_exception_value(
|
||||
scope,
|
||||
&error.to_string(),
|
||||
"SyntaxError",
|
||||
);
|
||||
return None;
|
||||
}
|
||||
};
|
||||
runtime
|
||||
.native_bridge_mut()
|
||||
.wrap_handle_for_receiver(scope, host_ptr, receiver, fragment)
|
||||
|
||||
@@ -80,7 +80,7 @@ pub(super) fn range_create_contextual_fragment_callback<'s>(
|
||||
let requirements = context_host_ptr_from_global_bridge(scope)
|
||||
.map(|host_ptr| unsafe { &*host_ptr }.trusted_types_for_script_requirements(scope))
|
||||
.unwrap_or_default();
|
||||
let Some(markup) = crate::context_bootstrap::trusted_html_string_or_throw(
|
||||
let Some(markup) = crate::context_bootstrap::trusted_html_dom_string_or_throw(
|
||||
scope,
|
||||
parsed.markup,
|
||||
requirements,
|
||||
|
||||
@@ -257,6 +257,25 @@ pub(crate) fn trusted_html_string_or_throw<'s>(
|
||||
)
|
||||
}
|
||||
|
||||
pub(crate) fn trusted_html_dom_string_or_throw<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
value: v8::Local<'s, v8::Value>,
|
||||
requirements: TrustedTypesForScriptRequirements,
|
||||
sink: &str,
|
||||
api_name: &'static str,
|
||||
) -> Option<DomStringValue> {
|
||||
trusted_type_string16_or_throw(
|
||||
scope,
|
||||
value,
|
||||
TrustedTypeKind::Html,
|
||||
requirements,
|
||||
sink,
|
||||
api_name,
|
||||
None,
|
||||
)
|
||||
.map(|units| DomStringValue::from_utf16(&units))
|
||||
}
|
||||
|
||||
pub(crate) fn trusted_html_value_string<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
value: v8::Local<'s, v8::Value>,
|
||||
|
||||
@@ -3,6 +3,7 @@ use super::*;
|
||||
use crate::document_script_scheduler::{
|
||||
DocumentScriptExecutionLane, MainParserAsyncModuleAdmission, PageOwnedDocumentScriptWork,
|
||||
};
|
||||
use crate::dom::native::DomStringValue;
|
||||
use crate::frame_owner_model::MainDocumentScriptLoadDelayKind;
|
||||
use crate::host::{ScriptEventKind, ScriptEventTask};
|
||||
use crate::live_document_parser::LiveDocumentParserOwner;
|
||||
@@ -17,7 +18,7 @@ use html5ever::tree_builder::QuirksMode;
|
||||
use moli_parser::{
|
||||
HtmlFragmentContext, ParserDomMutation, ParserDomMutationConsumer, ParserDomReadConsumer,
|
||||
ParserElementCreationConsumer, ParserElementCreationRequest, ParserMutationEffectConsumer,
|
||||
ParserPumpOutcome,
|
||||
ParserPumpOutcome, XmlFragmentParseError, XmlParser,
|
||||
};
|
||||
use std::collections::HashSet;
|
||||
use tracing::debug;
|
||||
@@ -35,12 +36,6 @@ enum DocumentWriteParserPumpInput<'a> {
|
||||
QueuedOrBuffered,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Eq, PartialEq)]
|
||||
enum HtmlFragmentParserContextMode {
|
||||
Standard,
|
||||
SiblingInsertion,
|
||||
}
|
||||
|
||||
struct DocumentWriteParserMutationOwner<'a, 'scope, 'pin> {
|
||||
runtime: &'a mut DocumentRuntime,
|
||||
scope: &'a mut v8::PinScope<'scope, 'pin>,
|
||||
@@ -599,7 +594,7 @@ impl DocumentRuntime {
|
||||
}
|
||||
}
|
||||
|
||||
fn build_fragment_from_html_with_context_mode(
|
||||
fn build_html_fragment(
|
||||
&mut self,
|
||||
scope: &mut v8::PinScope<'_, '_>,
|
||||
host_ptr: *mut PageScriptHost,
|
||||
@@ -608,7 +603,6 @@ impl DocumentRuntime {
|
||||
html: &str,
|
||||
scripts_already_started: bool,
|
||||
custom_element_upgrade_timing: HtmlFragmentCustomElementUpgradeTiming,
|
||||
context_mode: HtmlFragmentParserContextMode,
|
||||
scripting_enabled: bool,
|
||||
allow_declarative_shadow_roots: bool,
|
||||
) -> Option<DomHandle> {
|
||||
@@ -619,17 +613,12 @@ impl DocumentRuntime {
|
||||
.and_then(Node::namespace)
|
||||
.unwrap_or("http://www.w3.org/1999/xhtml")
|
||||
.to_owned();
|
||||
let mut context_local_name = context_node
|
||||
let context_local_name = context_node
|
||||
.and_then(Node::local_name)
|
||||
.unwrap_or("body")
|
||||
.to_owned();
|
||||
if context_mode == HtmlFragmentParserContextMode::SiblingInsertion
|
||||
&& context_namespace == "http://www.w3.org/1999/xhtml"
|
||||
&& context_local_name.eq_ignore_ascii_case("html")
|
||||
{
|
||||
context_local_name = "body".to_owned();
|
||||
}
|
||||
let context = HtmlFragmentContext::new(context_handle, &context_namespace, &context_local_name);
|
||||
let context =
|
||||
HtmlFragmentContext::new(context_handle, &context_namespace, &context_local_name);
|
||||
let is_frameset_context = context_namespace == "http://www.w3.org/1999/xhtml"
|
||||
&& context_local_name.eq_ignore_ascii_case("frameset");
|
||||
let registry_association = match context_handle {
|
||||
@@ -698,6 +687,25 @@ impl DocumentRuntime {
|
||||
host_ptr,
|
||||
&finish_signals.parser_created_null_registry_elements,
|
||||
);
|
||||
self.finish_fragment_parsing(
|
||||
scope,
|
||||
host_ptr,
|
||||
fragment,
|
||||
fragment_roots,
|
||||
custom_element_upgrade_timing,
|
||||
first_node_index,
|
||||
)
|
||||
}
|
||||
|
||||
fn finish_fragment_parsing(
|
||||
&mut self,
|
||||
scope: &mut v8::PinScope<'_, '_>,
|
||||
host_ptr: *mut PageScriptHost,
|
||||
fragment: DomHandle,
|
||||
fragment_roots: Vec<DomHandle>,
|
||||
custom_element_upgrade_timing: HtmlFragmentCustomElementUpgradeTiming,
|
||||
first_node_index: usize,
|
||||
) -> Option<DomHandle> {
|
||||
if custom_element_upgrade_timing
|
||||
== HtmlFragmentCustomElementUpgradeTiming::InReturnedFragment
|
||||
{
|
||||
@@ -718,52 +726,112 @@ impl DocumentRuntime {
|
||||
Some(fragment)
|
||||
}
|
||||
|
||||
pub(crate) fn build_range_contextual_fragment_from_html(
|
||||
pub(crate) fn build_range_contextual_fragment(
|
||||
&mut self,
|
||||
scope: &mut v8::PinScope<'_, '_>,
|
||||
host_ptr: *mut PageScriptHost,
|
||||
document_handle: DomHandle,
|
||||
context_handle: Option<DomHandle>,
|
||||
html: &str,
|
||||
) -> Option<DomHandle> {
|
||||
let scripting_enabled = unsafe { &*host_ptr }.document_scripting_enabled(document_handle);
|
||||
self.build_fragment_from_html_with_context_mode(
|
||||
markup: &DomStringValue,
|
||||
) -> Result<Option<DomHandle>, XmlFragmentParseError> {
|
||||
self.build_fragment_from_markup(
|
||||
scope,
|
||||
host_ptr,
|
||||
document_handle,
|
||||
context_handle,
|
||||
html,
|
||||
markup,
|
||||
false,
|
||||
HtmlFragmentCustomElementUpgradeTiming::InReturnedFragment,
|
||||
HtmlFragmentParserContextMode::Standard,
|
||||
scripting_enabled,
|
||||
false,
|
||||
)
|
||||
}
|
||||
|
||||
pub(crate) fn build_fragment_from_html(
|
||||
fn build_fragment_from_markup(
|
||||
&mut self,
|
||||
scope: &mut v8::PinScope<'_, '_>,
|
||||
host_ptr: *mut PageScriptHost,
|
||||
document_handle: DomHandle,
|
||||
context_handle: Option<DomHandle>,
|
||||
markup: &DomStringValue,
|
||||
scripts_already_started: bool,
|
||||
custom_element_upgrade_timing: HtmlFragmentCustomElementUpgradeTiming,
|
||||
) -> Result<Option<DomHandle>, XmlFragmentParseError> {
|
||||
let Some(is_html_document) = self
|
||||
.dom_host()
|
||||
.node_document_is_html_document(document_handle)
|
||||
else {
|
||||
return Ok(None);
|
||||
};
|
||||
if !is_html_document {
|
||||
let context_handle = context_handle
|
||||
.unwrap_or_else(|| self.create_fragment_body_context(document_handle));
|
||||
return self.build_xml_fragment(
|
||||
scope,
|
||||
host_ptr,
|
||||
document_handle,
|
||||
context_handle,
|
||||
markup,
|
||||
custom_element_upgrade_timing,
|
||||
);
|
||||
}
|
||||
let scripting_enabled = unsafe { &*host_ptr }.document_scripting_enabled(document_handle);
|
||||
Ok(self.build_html_fragment(
|
||||
scope,
|
||||
host_ptr,
|
||||
document_handle,
|
||||
context_handle,
|
||||
markup.as_str_lossy(),
|
||||
scripts_already_started,
|
||||
custom_element_upgrade_timing,
|
||||
scripting_enabled,
|
||||
false,
|
||||
))
|
||||
}
|
||||
|
||||
fn build_xml_fragment(
|
||||
&mut self,
|
||||
scope: &mut v8::PinScope<'_, '_>,
|
||||
host_ptr: *mut PageScriptHost,
|
||||
document_handle: DomHandle,
|
||||
context_handle: DomHandle,
|
||||
html: &str,
|
||||
scripts_already_started: bool,
|
||||
markup: &DomStringValue,
|
||||
custom_element_upgrade_timing: HtmlFragmentCustomElementUpgradeTiming,
|
||||
) -> Option<DomHandle> {
|
||||
let scripting_enabled = unsafe { &*host_ptr }.document_scripting_enabled(document_handle);
|
||||
self.build_fragment_from_html_with_context_mode(
|
||||
) -> Result<Option<DomHandle>, XmlFragmentParseError> {
|
||||
let parsed = XmlParser.parse_fragment(self.dom_host(), context_handle, markup)?;
|
||||
let first_node_index = self.dom_host().dom().len();
|
||||
let registry_association =
|
||||
self.fragment_context_custom_element_registry_association(host_ptr, context_handle);
|
||||
let fragment = self.create_document_fragment_for_document(document_handle);
|
||||
let mut roots = Vec::with_capacity(parsed.children().len());
|
||||
for &source in parsed.children() {
|
||||
let Some(child) = self.dom_host_mut().import_foreign_node(
|
||||
document_handle,
|
||||
parsed.document(),
|
||||
source,
|
||||
true,
|
||||
) else {
|
||||
return Ok(None);
|
||||
};
|
||||
if !self
|
||||
.dom_host_mut()
|
||||
.append_child_without_mutation_effects(fragment, child)
|
||||
{
|
||||
return Ok(None);
|
||||
}
|
||||
self.set_fragment_root_custom_element_registry_association(
|
||||
host_ptr,
|
||||
child,
|
||||
registry_association,
|
||||
);
|
||||
roots.push(child);
|
||||
}
|
||||
Ok(self.finish_fragment_parsing(
|
||||
scope,
|
||||
host_ptr,
|
||||
document_handle,
|
||||
Some(context_handle),
|
||||
html,
|
||||
scripts_already_started,
|
||||
fragment,
|
||||
roots,
|
||||
custom_element_upgrade_timing,
|
||||
HtmlFragmentParserContextMode::Standard,
|
||||
scripting_enabled,
|
||||
false,
|
||||
)
|
||||
first_node_index,
|
||||
))
|
||||
}
|
||||
|
||||
pub(crate) fn build_unsafe_fragment_from_html(
|
||||
@@ -776,7 +844,7 @@ impl DocumentRuntime {
|
||||
custom_element_upgrade_timing: HtmlFragmentCustomElementUpgradeTiming,
|
||||
) -> Option<DomHandle> {
|
||||
let scripting_enabled = unsafe { &*host_ptr }.document_scripting_enabled(document_handle);
|
||||
self.build_fragment_from_html_with_context_mode(
|
||||
self.build_html_fragment(
|
||||
scope,
|
||||
host_ptr,
|
||||
document_handle,
|
||||
@@ -784,7 +852,6 @@ impl DocumentRuntime {
|
||||
html,
|
||||
true,
|
||||
custom_element_upgrade_timing,
|
||||
HtmlFragmentParserContextMode::Standard,
|
||||
scripting_enabled,
|
||||
true,
|
||||
)
|
||||
@@ -835,9 +902,9 @@ impl DocumentRuntime {
|
||||
scope: &mut v8::PinScope<'_, '_>,
|
||||
host_ptr: *mut PageScriptHost,
|
||||
handle: DomHandle,
|
||||
html: &str,
|
||||
) -> bool {
|
||||
let context = handle;
|
||||
html: &DomStringValue,
|
||||
) -> Result<bool, XmlFragmentParseError> {
|
||||
let context = self.dom_host().shadow_root_host(handle).unwrap_or(handle);
|
||||
let target = self
|
||||
.dom_host()
|
||||
.node(handle)
|
||||
@@ -845,7 +912,7 @@ impl DocumentRuntime {
|
||||
.and_then(|element| element.template_contents())
|
||||
.unwrap_or(handle);
|
||||
let Some(document_handle) = self.inner_html_document_handle(target) else {
|
||||
return false;
|
||||
return Ok(false);
|
||||
};
|
||||
let existing_children = self
|
||||
.dom_host()
|
||||
@@ -856,22 +923,27 @@ impl DocumentRuntime {
|
||||
.dom_host()
|
||||
.node(context)
|
||||
.is_some_and(|node| node.is_html_element_named("html"));
|
||||
if html.is_empty()
|
||||
if self
|
||||
.dom_host()
|
||||
.node_document_is_html_document(document_handle)
|
||||
== Some(true)
|
||||
&& html.is_empty()
|
||||
&& existing_children.is_empty()
|
||||
&& !empty_html_context_creates_document_wrappers
|
||||
{
|
||||
return false;
|
||||
return Ok(false);
|
||||
}
|
||||
let Some(fragment) = self.build_fragment_from_html(
|
||||
let Some(fragment) = self.build_fragment_from_markup(
|
||||
scope,
|
||||
host_ptr,
|
||||
document_handle,
|
||||
context,
|
||||
Some(context),
|
||||
html,
|
||||
true,
|
||||
HtmlFragmentCustomElementUpgradeTiming::AfterInsertion,
|
||||
) else {
|
||||
return false;
|
||||
)?
|
||||
else {
|
||||
return Ok(false);
|
||||
};
|
||||
let added_children = self.dom_host().child_handles(fragment).collect::<Vec<_>>();
|
||||
let records_enabled = self.dom_host().mutation_records_enabled();
|
||||
@@ -891,7 +963,7 @@ impl DocumentRuntime {
|
||||
&added_children,
|
||||
)
|
||||
{
|
||||
return false;
|
||||
return Ok(false);
|
||||
}
|
||||
if changed && records_enabled {
|
||||
crate::observer_runtime::coalesce_child_list_replacement_records(
|
||||
@@ -903,7 +975,7 @@ impl DocumentRuntime {
|
||||
None,
|
||||
);
|
||||
}
|
||||
changed
|
||||
Ok(changed)
|
||||
}
|
||||
|
||||
pub(crate) fn set_html_unsafe(
|
||||
@@ -964,37 +1036,53 @@ impl DocumentRuntime {
|
||||
scope: &mut v8::PinScope<'_, '_>,
|
||||
host_ptr: *mut PageScriptHost,
|
||||
handle: DomHandle,
|
||||
html: &str,
|
||||
) -> bool {
|
||||
let Some(parent) = self.dom_host().node(handle).and_then(Node::parent_node) else {
|
||||
return false;
|
||||
markup: &DomStringValue,
|
||||
) -> Result<bool, XmlFragmentParseError> {
|
||||
let Some(parent) = self.dom_host().parent_node(handle) else {
|
||||
return Ok(false);
|
||||
};
|
||||
let Some(document_handle) = self.inner_html_document_handle(handle) else {
|
||||
return false;
|
||||
return Ok(false);
|
||||
};
|
||||
let previous_sibling = self.dom_host().node(handle).and_then(Node::prev_sibling);
|
||||
let next_sibling = self.dom_host().node(handle).and_then(Node::next_sibling);
|
||||
let records_enabled = self.dom_host().mutation_records_enabled();
|
||||
let removed =
|
||||
self.remove_child_appending_to_current_reaction_queue(scope, host_ptr, parent, handle);
|
||||
if !removed {
|
||||
return false;
|
||||
if markup.is_empty()
|
||||
&& self
|
||||
.dom_host()
|
||||
.node_document_is_html_document(document_handle)
|
||||
== Some(true)
|
||||
{
|
||||
return Ok(self.remove_child_appending_to_current_reaction_queue(
|
||||
scope, host_ptr, parent, handle,
|
||||
));
|
||||
}
|
||||
if html.is_empty() {
|
||||
return true;
|
||||
}
|
||||
let Some(fragment) = self.build_fragment_from_html(
|
||||
let context = if self.dom_host().node(parent).is_some_and(Node::is_element) {
|
||||
parent
|
||||
} else {
|
||||
self.create_fragment_body_context(document_handle)
|
||||
};
|
||||
// Parsing can fail without disconnecting the old node or invoking its
|
||||
// lifecycle callbacks. Replacement begins only after a complete fragment.
|
||||
let Some(fragment) = self.build_fragment_from_markup(
|
||||
scope,
|
||||
host_ptr,
|
||||
document_handle,
|
||||
parent,
|
||||
html,
|
||||
Some(context),
|
||||
markup,
|
||||
true,
|
||||
HtmlFragmentCustomElementUpgradeTiming::AfterInsertion,
|
||||
) else {
|
||||
return false;
|
||||
)?
|
||||
else {
|
||||
return Ok(false);
|
||||
};
|
||||
let added_children = self.dom_host().child_handles(fragment).collect::<Vec<_>>();
|
||||
let previous_sibling = self.dom_host().node(handle).and_then(Node::prev_sibling);
|
||||
let next_sibling = self.dom_host().node(handle).and_then(Node::next_sibling);
|
||||
let records_enabled = self.dom_host().mutation_records_enabled();
|
||||
if !self.remove_child_appending_to_current_reaction_queue(scope, host_ptr, parent, handle) {
|
||||
return Ok(false);
|
||||
}
|
||||
if added_children.is_empty() {
|
||||
return Ok(true);
|
||||
}
|
||||
let changed = self.insert_html_fragment_child_appending_to_current_reaction_queue(
|
||||
scope,
|
||||
host_ptr,
|
||||
@@ -1010,7 +1098,7 @@ impl DocumentRuntime {
|
||||
&added_children,
|
||||
)
|
||||
{
|
||||
return false;
|
||||
return Ok(false);
|
||||
}
|
||||
if changed && records_enabled {
|
||||
crate::observer_runtime::coalesce_child_list_replacement_records(
|
||||
@@ -1022,43 +1110,61 @@ impl DocumentRuntime {
|
||||
next_sibling,
|
||||
);
|
||||
}
|
||||
changed
|
||||
Ok(changed)
|
||||
}
|
||||
|
||||
fn create_fragment_body_context(&mut self, document_handle: DomHandle) -> DomHandle {
|
||||
self.dom_host_mut()
|
||||
.create_element_without_attributes_for_document(
|
||||
document_handle,
|
||||
"body".into(),
|
||||
"http://www.w3.org/1999/xhtml".into(),
|
||||
None,
|
||||
)
|
||||
}
|
||||
|
||||
pub(crate) fn insert_adjacent_html(
|
||||
&mut self,
|
||||
scope: &mut v8::PinScope<'_, '_>,
|
||||
host_ptr: *mut PageScriptHost,
|
||||
target: DomHandle,
|
||||
document_handle: DomHandle,
|
||||
context_handle: DomHandle,
|
||||
html: &str,
|
||||
markup: &DomStringValue,
|
||||
insert: impl FnOnce(
|
||||
&mut Self,
|
||||
&mut v8::PinScope<'_, '_>,
|
||||
*mut PageScriptHost,
|
||||
DomHandle,
|
||||
) -> bool,
|
||||
) -> bool {
|
||||
let scripting_enabled = unsafe { &*host_ptr }.document_scripting_enabled(document_handle);
|
||||
let context_mode = if context_handle == target {
|
||||
HtmlFragmentParserContextMode::Standard
|
||||
) -> Result<bool, XmlFragmentParseError> {
|
||||
let context_is_element = self
|
||||
.dom_host()
|
||||
.node(context_handle)
|
||||
.is_some_and(Node::is_element);
|
||||
let context_is_html_root = self
|
||||
.dom_host()
|
||||
.node_document_is_html_document(document_handle)
|
||||
== Some(true)
|
||||
&& self
|
||||
.dom_host()
|
||||
.node(context_handle)
|
||||
.is_some_and(|node| node.is_html_element_named("html"));
|
||||
let context_handle = if !context_is_element || context_is_html_root {
|
||||
self.create_fragment_body_context(document_handle)
|
||||
} else {
|
||||
HtmlFragmentParserContextMode::SiblingInsertion
|
||||
context_handle
|
||||
};
|
||||
let Some(fragment) = self.build_fragment_from_html_with_context_mode(
|
||||
let Some(fragment) = self.build_fragment_from_markup(
|
||||
scope,
|
||||
host_ptr,
|
||||
document_handle,
|
||||
context_handle,
|
||||
html,
|
||||
Some(context_handle),
|
||||
markup,
|
||||
true,
|
||||
HtmlFragmentCustomElementUpgradeTiming::AfterInsertion,
|
||||
context_mode,
|
||||
scripting_enabled,
|
||||
false,
|
||||
) else {
|
||||
return false;
|
||||
)?
|
||||
else {
|
||||
return Ok(false);
|
||||
};
|
||||
let added_children = self.dom_host().child_handles(fragment).collect::<Vec<_>>();
|
||||
let changed = insert(self, scope, host_ptr, fragment);
|
||||
@@ -1070,9 +1176,9 @@ impl DocumentRuntime {
|
||||
&added_children,
|
||||
)
|
||||
{
|
||||
return false;
|
||||
return Ok(false);
|
||||
}
|
||||
changed
|
||||
Ok(changed)
|
||||
}
|
||||
|
||||
pub(crate) fn has_pending_document_write_external_script_load(&self) -> bool {
|
||||
|
||||
@@ -4,7 +4,7 @@ pub(crate) fn throw_dom_exception(
|
||||
scope: &mut v8::PinScope<'_, '_>,
|
||||
name: &'static str,
|
||||
_code: i32,
|
||||
message: &'static str,
|
||||
message: &str,
|
||||
) {
|
||||
let exception = new_most_derived_dom_exception_value(scope, message, name);
|
||||
scope.throw_exception(exception);
|
||||
|
||||
@@ -25,7 +25,7 @@ use super::{
|
||||
rendered_child_participates_in_flat_tree,
|
||||
},
|
||||
styles::StyleObservation,
|
||||
trusted_types::{TrustedHtmlSink, trusted_html_sink_string},
|
||||
trusted_types::{TrustedHtmlSink, trusted_html_sink_dom_string, trusted_html_sink_string},
|
||||
};
|
||||
|
||||
#[derive(webidl::WebIdlArgs)]
|
||||
@@ -954,7 +954,7 @@ pub(in crate::native_bridge) fn node_outer_html_setter_function<'s>(
|
||||
}
|
||||
let value = args.get(0);
|
||||
let Some(html) =
|
||||
trusted_html_sink_string(scope, runtime_ptr, value, TrustedHtmlSink::ElementOuterHtml)
|
||||
trusted_html_sink_dom_string(scope, runtime_ptr, value, TrustedHtmlSink::ElementOuterHtml)
|
||||
else {
|
||||
return;
|
||||
};
|
||||
@@ -975,7 +975,9 @@ pub(in crate::native_bridge) fn node_outer_html_setter_function<'s>(
|
||||
}
|
||||
custom_elements::with_custom_element_reaction_scope(scope, runtime_ptr, |scope| {
|
||||
let runtime = unsafe { &mut *runtime_ptr };
|
||||
let _ = runtime.set_outer_html(scope, runtime_ptr, handle, &html);
|
||||
if let Err(error) = runtime.set_outer_html(scope, runtime_ptr, handle, &html) {
|
||||
throw_dom_exception(scope, "SyntaxError", 12, &error.to_string());
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
@@ -1001,12 +1003,14 @@ pub(in crate::native_bridge) fn node_inner_html_setter_function<'s>(
|
||||
} else {
|
||||
TrustedHtmlSink::ElementInnerHtml
|
||||
};
|
||||
let Some(html) = trusted_html_sink_string(scope, runtime_ptr, value, sink) else {
|
||||
let Some(html) = trusted_html_sink_dom_string(scope, runtime_ptr, value, sink) else {
|
||||
return;
|
||||
};
|
||||
custom_elements::with_custom_element_reaction_scope(scope, runtime_ptr, |scope| {
|
||||
let runtime = unsafe { &mut *runtime_ptr };
|
||||
let _ = runtime.set_inner_html(scope, runtime_ptr, handle, &html);
|
||||
if let Err(error) = runtime.set_inner_html(scope, runtime_ptr, handle, &html) {
|
||||
throw_dom_exception(scope, "SyntaxError", 12, &error.to_string());
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
@@ -9,7 +9,7 @@ use super::super::super::{
|
||||
},
|
||||
throw_dom_exception,
|
||||
};
|
||||
use super::super::trusted_types::{TrustedHtmlSink, trusted_html_sink_string};
|
||||
use super::super::trusted_types::{TrustedHtmlSink, trusted_html_sink_dom_string};
|
||||
use super::{
|
||||
insertion::{
|
||||
insert_adjacent_context_handle, insert_adjacent_document_handle, insert_adjacent_handle,
|
||||
@@ -263,7 +263,7 @@ pub(in crate::native_bridge) fn node_insert_adjacent_html_callback<'s>(
|
||||
let Some(parsed) = webidl::parse_args::<InsertAdjacentHtmlArgs<'s>>(scope, &args) else {
|
||||
return;
|
||||
};
|
||||
let Some(text) = trusted_html_sink_string(
|
||||
let Some(text) = trusted_html_sink_dom_string(
|
||||
scope,
|
||||
runtime_ptr,
|
||||
parsed.text,
|
||||
@@ -316,7 +316,6 @@ pub(in crate::native_bridge) fn node_insert_adjacent_html_callback<'s>(
|
||||
unsafe { &mut *runtime_ptr }.insert_adjacent_html(
|
||||
scope,
|
||||
runtime_ptr,
|
||||
target,
|
||||
document_handle,
|
||||
context_handle,
|
||||
&text,
|
||||
@@ -327,6 +326,13 @@ pub(in crate::native_bridge) fn node_insert_adjacent_html_callback<'s>(
|
||||
},
|
||||
)
|
||||
});
|
||||
let inserted = match inserted {
|
||||
Ok(inserted) => inserted,
|
||||
Err(error) => {
|
||||
throw_dom_exception(scope, "SyntaxError", 12, &error.to_string());
|
||||
return;
|
||||
}
|
||||
};
|
||||
if !inserted {
|
||||
throw_dom_exception(scope, "HierarchyRequestError", 3, "Hierarchy Error");
|
||||
return;
|
||||
|
||||
@@ -198,6 +198,18 @@ impl TrustedHtmlSink {
|
||||
Self::ElementInnerHtml | Self::ShadowRootInnerHtml | Self::ElementOuterHtml
|
||||
)
|
||||
}
|
||||
|
||||
fn normalize_input<'s>(
|
||||
self,
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
value: v8::Local<'s, v8::Value>,
|
||||
) -> v8::Local<'s, v8::Value> {
|
||||
if self.uses_legacy_null_to_empty_string() && value.is_null() {
|
||||
v8::String::empty(scope).into()
|
||||
} else {
|
||||
value
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(in crate::native_bridge::element) fn trusted_html_sink_string<'s>(
|
||||
@@ -206,11 +218,7 @@ pub(in crate::native_bridge::element) fn trusted_html_sink_string<'s>(
|
||||
value: v8::Local<'s, v8::Value>,
|
||||
sink: TrustedHtmlSink,
|
||||
) -> Option<String> {
|
||||
let value = if sink.uses_legacy_null_to_empty_string() && value.is_null() {
|
||||
v8::String::empty(scope).into()
|
||||
} else {
|
||||
value
|
||||
};
|
||||
let value = sink.normalize_input(scope, value);
|
||||
let requirements = unsafe { &*runtime_ptr }.trusted_types_for_script_requirements(scope);
|
||||
crate::context_bootstrap::trusted_html_string_or_throw(
|
||||
scope,
|
||||
@@ -221,6 +229,23 @@ pub(in crate::native_bridge::element) fn trusted_html_sink_string<'s>(
|
||||
)
|
||||
}
|
||||
|
||||
pub(in crate::native_bridge::element) fn trusted_html_sink_dom_string<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
runtime_ptr: *mut PageScriptHost,
|
||||
value: v8::Local<'s, v8::Value>,
|
||||
sink: TrustedHtmlSink,
|
||||
) -> Option<crate::dom::native::DomStringValue> {
|
||||
let value = sink.normalize_input(scope, value);
|
||||
let requirements = unsafe { &*runtime_ptr }.trusted_types_for_script_requirements(scope);
|
||||
crate::context_bootstrap::trusted_html_dom_string_or_throw(
|
||||
scope,
|
||||
value,
|
||||
requirements,
|
||||
sink.name(),
|
||||
sink.api_name(),
|
||||
)
|
||||
}
|
||||
|
||||
pub(in crate::native_bridge::element) fn trusted_script_element_sink_string<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
runtime_ptr: *mut PageScriptHost,
|
||||
|
||||
@@ -462,6 +462,7 @@ fn run_dom_inspector_edit(
|
||||
}
|
||||
}
|
||||
DomInspectorEdit::SetOuterHtml { node, outer_html } => {
|
||||
let outer_html = crate::dom::native::DomStringValue::from(outer_html);
|
||||
let runtime = unsafe { &*host_ptr };
|
||||
if runtime.dom_host().node(node).is_none() {
|
||||
return DomInspectorEditOutcome::NodeNotFound;
|
||||
@@ -479,7 +480,7 @@ fn run_dom_inspector_edit(
|
||||
unsafe { &mut *host_ptr }.set_outer_html(scope, host_ptr, node, &outer_html)
|
||||
},
|
||||
);
|
||||
if changed {
|
||||
if matches!(changed, Ok(true)) {
|
||||
DomInspectorEditOutcome::Applied { result_node: None }
|
||||
} else {
|
||||
DomInspectorEditOutcome::MutationFailed
|
||||
|
||||
@@ -175,6 +175,8 @@ mod window_open_special_targets;
|
||||
mod worker_listener_invocation;
|
||||
mod worker_options;
|
||||
|
||||
mod xml_fragments;
|
||||
|
||||
mod video_codec_support;
|
||||
|
||||
mod event_target_identity;
|
||||
|
||||
@@ -226,14 +226,12 @@ fn range_registered_native_proxies_share_boundaries_and_selection_identity() {
|
||||
check(clone !== target && clone.startContainer === text && clone.startOffset === 2, 'cloneRange');
|
||||
const fragment = methods.cloneContents.call(proxy);
|
||||
check(fragment.textContent === 'c' && fragment.ownerDocument === text.ownerDocument, 'cloneContents');
|
||||
if (flavor !== 'xml') {
|
||||
for (const name of ['nodeType', 'parentNode', 'ownerDocument'])
|
||||
Object.defineProperty(text, name, {configurable: true, get() {throw Error('public ' + name);}});
|
||||
const parsed = methods.createContextualFragment.call(proxy, '<b>parsed</b>');
|
||||
for (const name of ['nodeType', 'parentNode', 'ownerDocument']) delete text[name];
|
||||
check(parsed.firstChild.localName === 'b' && parsed.textContent === 'parsed' &&
|
||||
parsed.ownerDocument === text.ownerDocument, 'native contextual fragment');
|
||||
}
|
||||
for (const name of ['nodeType', 'parentNode', 'ownerDocument'])
|
||||
Object.defineProperty(text, name, {configurable: true, get() {throw Error('public ' + name);}});
|
||||
const parsed = methods.createContextualFragment.call(proxy, '<b>parsed</b>');
|
||||
for (const name of ['nodeType', 'parentNode', 'ownerDocument']) delete text[name];
|
||||
check(parsed.firstChild.localName === 'b' && parsed.textContent === 'parsed' &&
|
||||
parsed.ownerDocument === text.ownerDocument, 'native contextual fragment');
|
||||
methods.collapse.call(proxy, false);
|
||||
check(get('collapsed') && get('startOffset') === 3 && target.startOffset === 3, 'collapse');
|
||||
if (selected) {
|
||||
|
||||
@@ -0,0 +1,41 @@
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn xml_fragments_preserve_native_context_and_reject_errors_before_mutation() {
|
||||
let mut vm = new_parsed_test_vm(
|
||||
"https://xml-fragments.test/",
|
||||
"<!doctype html><iframe id=child></iframe>",
|
||||
);
|
||||
let result = vm
|
||||
.eval(include_str!("../../../../tests/fixtures/xml-fragments.js"))
|
||||
.expect("XML fragment matrix should complete");
|
||||
assert_eq!(vm.eval("__uiEventResults.total").unwrap(), "2970");
|
||||
assert_eq!(
|
||||
result,
|
||||
"true",
|
||||
"{}",
|
||||
vm.eval("JSON.stringify(__uiEventResults.rows.filter(row => !row.passed))")
|
||||
.unwrap(),
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn xml_fragments_support_shadow_roots_templates_and_native_trusted_html() {
|
||||
let mut vm = new_parsed_test_vm(
|
||||
"https://xml-fragment-special-contexts.test/",
|
||||
"<!doctype html><iframe id=child></iframe>",
|
||||
);
|
||||
let result = vm
|
||||
.eval(include_str!(
|
||||
"../../../../tests/fixtures/xml-fragment-special-contexts.js"
|
||||
))
|
||||
.expect("XML fragment special context matrix should complete");
|
||||
assert_eq!(vm.eval("__uiEventResults.total").unwrap(), "124");
|
||||
assert_eq!(
|
||||
result,
|
||||
"true",
|
||||
"{}",
|
||||
vm.eval("JSON.stringify(__uiEventResults.rows.filter(row => !row.passed))")
|
||||
.unwrap(),
|
||||
);
|
||||
}
|
||||
@@ -497,18 +497,22 @@ fn insert_adjacent_html_enforces_sibling_context_rules() {
|
||||
sources.map(source => probe(() => root.insertAdjacentHTML(position, source)))
|
||||
);
|
||||
|
||||
while (root.firstChild) {
|
||||
root.removeChild(root.firstChild);
|
||||
}
|
||||
root.insertAdjacentHTML(
|
||||
'afterbegin',
|
||||
'<head id="inside-head"></head><body id="inside-body"></body>'
|
||||
);
|
||||
const preservedInnerHtmlContext =
|
||||
document.head?.id === 'inside-head' &&
|
||||
document.body?.id === 'inside-body' &&
|
||||
root.firstChild === document.head &&
|
||||
root.lastChild === document.body;
|
||||
const rootBodyContexts = ['afterbegin', 'beforeend'].map(position => {
|
||||
while (root.firstChild) root.removeChild(root.firstChild);
|
||||
root.insertAdjacentHTML(
|
||||
position,
|
||||
'<head id="inside-head"></head><body id="inside-body"></body>'
|
||||
);
|
||||
return root.childNodes.length === 0 && document.head === null && document.body === null;
|
||||
});
|
||||
const xml = document.implementation.createDocument('http://www.w3.org/1999/xhtml', 'html');
|
||||
xml.documentElement.insertAdjacentHTML('afterbegin', '<head id="xml-head"/><body id="xml-body"/>');
|
||||
const xmlRootContext =
|
||||
xml.documentElement.childNodes.length === 2 &&
|
||||
xml.documentElement.firstChild.localName === 'head' &&
|
||||
xml.documentElement.firstChild.id === 'xml-head' &&
|
||||
xml.documentElement.lastChild.localName === 'body' &&
|
||||
xml.documentElement.lastChild.id === 'xml-body';
|
||||
const head = document.head ||
|
||||
root.insertBefore(document.createElement('head'), root.firstChild);
|
||||
const body = document.body || root.appendChild(document.createElement('body'));
|
||||
@@ -520,7 +524,8 @@ fn insert_adjacent_html_enforces_sibling_context_rules() {
|
||||
return JSON.stringify({
|
||||
detachedErrors,
|
||||
documentErrors,
|
||||
preservedInnerHtmlContext,
|
||||
rootBodyContexts,
|
||||
xmlRootContext,
|
||||
counts: [
|
||||
document.getElementsByTagName('html').length,
|
||||
document.getElementsByTagName('head').length,
|
||||
@@ -540,7 +545,7 @@ fn insert_adjacent_html_enforces_sibling_context_rules() {
|
||||
|
||||
assert_eq!(
|
||||
result,
|
||||
r#"{"detachedErrors":["NoModificationAllowedError:7","NoModificationAllowedError:7","NoModificationAllowedError:7","NoModificationAllowedError:7","NoModificationAllowedError:7","NoModificationAllowedError:7","NoModificationAllowedError:7","NoModificationAllowedError:7"],"documentErrors":["NoModificationAllowedError:7","NoModificationAllowedError:7","NoModificationAllowedError:7","NoModificationAllowedError:7","NoModificationAllowedError:7","NoModificationAllowedError:7","NoModificationAllowedError:7","NoModificationAllowedError:7"],"preservedInnerHtmlContext":true,"counts":[1,1,1],"placement":[true,true,true,true]}"#
|
||||
r#"{"detachedErrors":["NoModificationAllowedError:7","NoModificationAllowedError:7","NoModificationAllowedError:7","NoModificationAllowedError:7","NoModificationAllowedError:7","NoModificationAllowedError:7","NoModificationAllowedError:7","NoModificationAllowedError:7"],"documentErrors":["NoModificationAllowedError:7","NoModificationAllowedError:7","NoModificationAllowedError:7","NoModificationAllowedError:7","NoModificationAllowedError:7","NoModificationAllowedError:7","NoModificationAllowedError:7","NoModificationAllowedError:7"],"rootBodyContexts":[true,true],"xmlRootContext":true,"counts":[1,1,1],"placement":[true,true,true,true]}"#
|
||||
);
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,71 @@
|
||||
(() => {
|
||||
const H = 'http://www.w3.org/1999/xhtml', N = 'http://www.w3.org/2000/xmlns/';
|
||||
const rows = [], realms = [['main', globalThis], ['child', document.querySelector('#child').contentWindow]];
|
||||
const check = (name, body) => {
|
||||
try {rows.push({name, passed: body() === true});}
|
||||
catch (error) {rows.push({name, passed: false, error: String(error)});}
|
||||
};
|
||||
const makeDocument = (owner, flavor) => flavor === 'impl' ? owner.document.implementation.createDocument('urn:root', 'Root') :
|
||||
new owner.DOMParser().parseFromString(flavor === 'xml' ? '<Root/>' : '<html xmlns="'+H+'"/>', flavor === 'xml' ? 'application/xml' : 'application/xhtml+xml');
|
||||
for (const [ownerName, owner] of realms) for (const flavor of ['impl', 'xml', 'xhtml']) for (const [calleeName, callee] of realms) {
|
||||
const doc = makeDocument(owner, flavor), label = `${calleeName}/${ownerName}/${flavor}`;
|
||||
const host = doc.createElementNS(H, 'div'); host.setAttributeNS(N, 'xmlns:p', 'urn:local'); doc.documentElement.appendChild(host);
|
||||
const shadow = host.attachShadow({mode: 'open'});
|
||||
const setter = Object.getOwnPropertyDescriptor(callee.ShadowRoot.prototype, 'innerHTML').set;
|
||||
check(label+'/ShadowRoot uses native host namespaces', () => {
|
||||
setter.call(shadow, '<MixedCase p:Token="v"/><p:Item/>');
|
||||
return shadow.childNodes.length === 2 && shadow.firstChild.localName === 'MixedCase' && shadow.firstChild.namespaceURI === H &&
|
||||
shadow.firstChild.getAttributeNS('urn:local', 'Token') === 'v' && shadow.lastChild.namespaceURI === 'urn:local' && shadow.firstChild.ownerDocument === doc;
|
||||
});
|
||||
for (const [name, markup] of [['unclosed', '<Item>'], ['surrogate', '\ud800']]) check(label+'/ShadowRoot rejects '+name+' atomically', () => {
|
||||
const before = [...shadow.childNodes], observer = new owner.MutationObserver(() => {});
|
||||
observer.observe(shadow, {childList: true, subtree: true}); let error;
|
||||
try {setter.call(shadow, markup);} catch (caught) {error = caught;}
|
||||
const records = observer.takeRecords(); observer.disconnect();
|
||||
return error?.name === 'SyntaxError' && Object.getPrototypeOf(error) === callee.DOMException.prototype && !records.length &&
|
||||
shadow.childNodes.length === before.length && before.every((node, index) => shadow.childNodes[index] === node);
|
||||
});
|
||||
check(label+'/ShadowRoot legacy null clears', () => {setter.call(shadow, null); return shadow.childNodes.length === 0;});
|
||||
check(label+'/template innerHTML uses template contents', () => {
|
||||
const template = doc.createElementNS(H, 'template'); doc.documentElement.appendChild(template);
|
||||
Object.getOwnPropertyDescriptor(callee.Element.prototype, 'innerHTML').set.call(template, '<MixedCase/>tail');
|
||||
return template.childNodes.length === 0 && template.content.childNodes.length === 2 && template.content.firstChild.localName === 'MixedCase' && template.content.firstChild.namespaceURI === H;
|
||||
});
|
||||
check(label+'/template Range returns children', () => {
|
||||
const template = doc.createElementNS(H, 'template'); doc.documentElement.appendChild(template);
|
||||
const range = doc.createRange(); range.selectNodeContents(template);
|
||||
const fragment = callee.Range.prototype.createContextualFragment.call(range, '<MixedCase/>tail');
|
||||
return fragment.childNodes.length === 2 && fragment.firstChild.localName === 'MixedCase' && fragment.firstChild.namespaceURI === H && fragment.ownerDocument === doc;
|
||||
});
|
||||
for (const kind of ['Document', 'DocumentFragment']) check(label+'/'+kind+' Range uses fallback body', () => {
|
||||
const range = doc.createRange(); range.selectNodeContents(kind === 'Document' ? doc : doc.createDocumentFragment());
|
||||
const fragment = callee.Range.prototype.createContextualFragment.call(range, '<Item/>');
|
||||
return fragment.firstChild.localName === 'Item' && fragment.firstChild.namespaceURI === H && fragment.ownerDocument === doc;
|
||||
});
|
||||
check(label+'/outerHTML fragment parent uses fallback body', () => {
|
||||
const fragment = doc.createDocumentFragment(), marker = doc.createElementNS('urn:other', 'Marker'); fragment.appendChild(marker);
|
||||
Object.getOwnPropertyDescriptor(callee.Element.prototype, 'outerHTML').set.call(marker, '<Item/>');
|
||||
return marker.parentNode === null && fragment.childNodes.length === 1 && fragment.firstChild.localName === 'Item' && fragment.firstChild.namespaceURI === H && fragment.firstChild.ownerDocument === doc;
|
||||
});
|
||||
}
|
||||
for (const [ownerName, owner] of realms) {
|
||||
const policy = owner.trustedTypes.createPolicy('xml-fragment-special-contexts-'+ownerName, {createHTML: value => value});
|
||||
for (const kind of ['inner', 'outer', 'adjacent', 'range']) for (const markup of ['<MixedCase/>', '\ud800']) check(ownerName+'/'+kind+'/native TrustedHTML '+(markup.length === 1 ? 'surrogate' : 'value'), () => {
|
||||
const doc = makeDocument(owner, 'impl'), parent = doc.createElementNS('urn:parent', 'Parent'), target = doc.createElementNS('urn:target', 'Target');
|
||||
doc.documentElement.appendChild(parent); parent.appendChild(target);
|
||||
const value = policy.createHTML(markup); Object.defineProperty(value, 'toString', {value() {throw Error('author toString');}});
|
||||
let result, error;
|
||||
try {
|
||||
if (kind === 'inner') target.innerHTML = value;
|
||||
else if (kind === 'outer') target.outerHTML = value;
|
||||
else if (kind === 'adjacent') target.insertAdjacentHTML('beforeend', value);
|
||||
else {const range = doc.createRange(); range.selectNodeContents(target); result = range.createContextualFragment(value);}
|
||||
} catch (caught) {error = caught;}
|
||||
if (markup.length === 1) return error?.name === 'SyntaxError' && target.parentNode === parent && target.childNodes.length === 0;
|
||||
const node = kind === 'outer' ? parent.firstChild : kind === 'range' ? result?.firstChild : target.firstChild;
|
||||
return !error && node?.localName === 'MixedCase' && node.namespaceURI === (kind === 'outer' ? 'urn:parent' : 'urn:target');
|
||||
});
|
||||
}
|
||||
globalThis.__uiEventResults = {complete: true, total: rows.length, passed: rows.filter(row => row.passed).length, rows};
|
||||
return rows.every(row => row.passed);
|
||||
})()
|
||||
+152
@@ -0,0 +1,152 @@
|
||||
(() => {
|
||||
const rows = [];
|
||||
const check = (name, category, body) => {
|
||||
try { rows.push({name, category, passed: body() === true}); }
|
||||
catch (error) { rows.push({name, category, passed: false, error: String(error)}); }
|
||||
};
|
||||
const H = 'http://www.w3.org/1999/xhtml', N = 'http://www.w3.org/2000/xmlns/';
|
||||
const realms = [['main', globalThis], ['child', document.querySelector('#child').contentWindow]];
|
||||
const sinks = ['range', 'inner', 'outer', 'beforebegin', 'afterbegin', 'beforeend', 'afterend'];
|
||||
const makeDocument = (owner, flavor) => flavor === 'impl' ?
|
||||
owner.document.implementation.createDocument('urn:root', 'r:Root') :
|
||||
new owner.DOMParser().parseFromString(flavor === 'xml' ? '<Root xmlns="urn:root"/>' :
|
||||
'<html xmlns="http://www.w3.org/1999/xhtml"/>', flavor === 'xml' ? 'application/xml' : 'application/xhtml+xml');
|
||||
const withContext = (doc, settings, body) => {
|
||||
const section = doc.createElementNS('urn:local', 'p:Section');
|
||||
section.setAttributeNS(N, 'xmlns:p', 'urn:local');
|
||||
const context = doc.createElementNS(settings.reset ? null : settings.prefixed ? 'urn:context' : 'urn:outer',
|
||||
settings.prefixed ? 'p:Context' : settings.name || 'Context');
|
||||
if (settings.reset) context.setAttributeNS(N, 'xmlns', '');
|
||||
if (settings.prefixUri) context.setAttributeNS(N, 'xmlns:q', settings.prefixUri);
|
||||
section.appendChild(context); doc.documentElement.appendChild(section);
|
||||
try { return body(context); }
|
||||
finally { doc.documentElement.removeChild(section); }
|
||||
};
|
||||
const prepare = (owner, callee, doc, context, sink) => {
|
||||
const marker = doc.createElementNS('urn:marker', 'Marker'); marker.textContent = 'keep';
|
||||
context.appendChild(marker);
|
||||
const range = doc.createRange(); range.selectNodeContents(context);
|
||||
const inner = Object.getOwnPropertyDescriptor(callee.Element.prototype, 'innerHTML').set;
|
||||
const outer = Object.getOwnPropertyDescriptor(callee.Element.prototype, 'outerHTML').set;
|
||||
const insert = callee.Element.prototype.insertAdjacentHTML;
|
||||
return {
|
||||
marker, range,
|
||||
invoke(value) {
|
||||
if (sink === 'range') {
|
||||
const fragment = callee.Range.prototype.createContextualFragment.call(range, value);
|
||||
return {nodes: [...fragment.childNodes], fragment};
|
||||
}
|
||||
if (sink === 'inner') inner.call(context, value);
|
||||
else if (sink === 'outer') outer.call(marker, value);
|
||||
else insert.call(sink === 'beforebegin' || sink === 'afterend' ? marker : context, sink, value);
|
||||
return {nodes: [...context.childNodes].filter(node => node !== marker), fragment: null};
|
||||
},
|
||||
rejects(value, exceptionName = 'SyntaxError') {
|
||||
const before = [...context.childNodes];
|
||||
const observer = new owner.MutationObserver(() => {});
|
||||
observer.observe(context, {subtree: true, childList: true, attributes: true, characterData: true});
|
||||
let error;
|
||||
try { this.invoke(value); } catch (caught) { error = caught; }
|
||||
const records = observer.takeRecords(); observer.disconnect();
|
||||
return error?.name === exceptionName && Object.getPrototypeOf(error) === callee.DOMException.prototype &&
|
||||
records.length === 0 && context.childNodes.length === before.length &&
|
||||
before.every((node, index) => context.childNodes[index] === node) && marker.textContent === 'keep';
|
||||
}
|
||||
};
|
||||
};
|
||||
for (const [ownerName, owner] of realms) for (const flavor of ['impl', 'xml', 'xhtml']) {
|
||||
const doc = makeDocument(owner, flavor);
|
||||
for (const [calleeName, callee] of realms) for (const sink of sinks) {
|
||||
const label = `${calleeName}/${ownerName}/${flavor}/${sink}`;
|
||||
const sample = (name, category, body, settings = {}) => check(label+'/'+name, category, () =>
|
||||
withContext(doc, settings, context => body(prepare(owner, callee, doc, context, sink), context)));
|
||||
sample('case namespace and node kinds', 'valid', ({invoke}) => {
|
||||
const {nodes, fragment} = invoke('<MixedCase p:Token="v"/><p:Item/>tail<![CDATA[a<b]]><!--end--><?target data?>');
|
||||
return nodes.length === 6 && nodes.map(node => node.nodeType).join() === '1,1,3,4,8,7' &&
|
||||
nodes[0].localName === 'MixedCase' && nodes[0].namespaceURI === 'urn:outer' &&
|
||||
nodes[0].getAttributeNS('urn:local', 'Token') === 'v' && nodes[1].localName === 'Item' &&
|
||||
nodes[1].prefix === 'p' && nodes[1].namespaceURI === 'urn:local' &&
|
||||
nodes[2].data === 'tail' && nodes[3].data === 'a<b' && nodes[4].data === 'end' &&
|
||||
nodes[5].target === 'target' && nodes[5].data === 'data' &&
|
||||
nodes.every(node => node.ownerDocument === doc) &&
|
||||
(!fragment || Object.getPrototypeOf(fragment) === owner.DocumentFragment.prototype);
|
||||
});
|
||||
sample('context prefix wins', 'valid', ({invoke}) => {
|
||||
const {nodes} = invoke('<p:Item/>');
|
||||
return nodes[0].namespaceURI === 'urn:context' && nodes[0].prefix === 'p';
|
||||
}, {prefixed: true});
|
||||
sample('default namespace reset', 'valid', ({invoke}) => {
|
||||
const {nodes} = invoke('<Item/>'); return nodes[0].namespaceURI === null && nodes[0].localName === 'Item';
|
||||
}, {reset: true});
|
||||
sample('namespace declaration escaping', 'valid', ({invoke}) => {
|
||||
const {nodes} = invoke('<q:Item/>'); return nodes[0].namespaceURI === 'urn:a&b"c<d>e';
|
||||
}, {prefixUri: 'urn:a&b"c<d>e'});
|
||||
sample('predefined and numeric entities', 'valid', ({invoke}) => {
|
||||
const {nodes} = invoke('<&"'>🦊');
|
||||
return nodes.length === 1 && nodes[0].data === '<&\"\'>🦊';
|
||||
});
|
||||
sample('empty markup', 'valid', ({invoke}) => invoke('').nodes.length === 0);
|
||||
sample('conversion changes namespace', 'conversion', ({invoke}, context) => {
|
||||
let conversions = 0;
|
||||
const {nodes} = invoke({toString() {conversions++; context.setAttributeNS(N, 'xmlns:q', 'urn:changed'); return '<q:Item/>';}});
|
||||
return conversions === 1 && nodes[0].namespaceURI === 'urn:changed';
|
||||
});
|
||||
sample('conversion exception identity', 'conversion', ({invoke}) => {
|
||||
const sentinel = {}; let conversions = 0;
|
||||
try {invoke({toString() {conversions++; throw sentinel;}}); return false;}
|
||||
catch (error) {return error === sentinel && conversions === 1;}
|
||||
});
|
||||
sample('native context ignores public getters', 'native', ({invoke}, context) => {
|
||||
const names = ['nodeType', 'localName', 'namespaceURI', 'prefix', 'parentNode', 'ownerDocument', 'attributes', 'lookupNamespaceURI'];
|
||||
let reads = 0;
|
||||
for (const name of names) Object.defineProperty(context, name, {configurable: true, get() {reads++; throw Error('public '+name);}});
|
||||
try {const {nodes} = invoke('<p:Item/>'); return reads === 0 && nodes[0].namespaceURI === 'urn:local';}
|
||||
finally {for (const name of names) delete context[name];}
|
||||
});
|
||||
for (const [name, markup] of [
|
||||
['unclosed', '<Item>'], ['mismatched', '<A></B>'], ['unknown entity', '&unknown;'],
|
||||
['duplicate attribute', '<Item x="1" x="2"/>'],
|
||||
['duplicate expanded attribute', '<Item xmlns:q="urn:local" p:x="1" q:x="2"/>'],
|
||||
['unquoted attribute', '<Item x=value/>'], ['xml declaration', '<?xml version="1.0"?>'],
|
||||
['doctype', '<!DOCTYPE Item><Item/>'], ['nul', '\u0000'], ['vertical tab', '\u000b'],
|
||||
['high surrogate', '\ud800'], ['low surrogate', '\udc00'], ['noncharacter', '\ufffe'],
|
||||
['invalid character reference', '�'], ['root escape', '</Context><!--escape--><Context>']
|
||||
]) sample('reject '+name, 'malformed', sample => sample.rejects(markup));
|
||||
sample('reject swallowed context end tag', 'malformed', sample => sample.rejects('x</foo--><!--y'), {name: 'foo--'});
|
||||
for (const [name, markup] of [
|
||||
['unbound prefix', '<missing:Item/>'], ['empty prefix binding', '<p:Item xmlns:p=""/>'],
|
||||
['xml prefix binding', '<Item xmlns:xml="urn:wrong"/>'],
|
||||
['xmlns prefix binding', '<Item xmlns:xmlns="urn:wrong"/>'],
|
||||
['unused empty prefix', '<Item xmlns:q=""/>'],
|
||||
['reserved XML URI prefix', '<Item xmlns:q="http://www.w3.org/XML/1998/namespace"/>'],
|
||||
['reserved XML URI default', '<Item xmlns="http://www.w3.org/XML/1998/namespace"/>'],
|
||||
['reserved XMLNS URI prefix', '<Item xmlns:q="http://www.w3.org/2000/xmlns/"/>'],
|
||||
['reserved XMLNS URI default', '<Item xmlns="http://www.w3.org/2000/xmlns/"/>']
|
||||
]) sample('reject '+name, 'strict-namespace', sample => sample.rejects(markup));
|
||||
sample('XML scripts remain inert after adoption', 'script', ({invoke}) => {
|
||||
owner.__xmlFragmentScriptRuns = 0;
|
||||
const {nodes} = invoke('<script xmlns="'+H+'">globalThis.__xmlFragmentScriptRuns++;</script>');
|
||||
const before = owner.__xmlFragmentScriptRuns;
|
||||
const holder = owner.document.createElement('div'); owner.document.body.appendChild(holder);
|
||||
holder.append(...nodes);
|
||||
const after = owner.__xmlFragmentScriptRuns; holder.remove();
|
||||
return before === 0 && after === 0 && nodes[0].namespaceURI === H &&
|
||||
Object.getPrototypeOf(nodes[0]) === owner.HTMLScriptElement.prototype;
|
||||
});
|
||||
}
|
||||
}
|
||||
for (const [ownerName, owner] of realms) {
|
||||
const doc = new owner.DOMParser().parseFromString('<!DOCTYPE Root [<!ENTITY inherited "secret">]><Root/>', 'application/xml');
|
||||
for (const [calleeName, callee] of realms) for (const sink of sinks) {
|
||||
check(`${calleeName}/${ownerName}/${sink}/no inherited doctype entities`, 'malformed', () =>
|
||||
withContext(doc, {}, context => prepare(owner, callee, doc, context, sink).rejects('&inherited;')));
|
||||
}
|
||||
const control = makeDocument(owner, 'impl').documentElement;
|
||||
check(ownerName+'/setHTMLUnsafe uses HTML parser in XML documents', 'control', () => {
|
||||
control.setHTMLUnsafe('<MixedCase>');
|
||||
return control.firstChild.localName === 'mixedcase';
|
||||
});
|
||||
}
|
||||
globalThis.__uiEventResults = {complete: true, total: rows.length, passed: rows.filter(row => row.passed).length, rows};
|
||||
return rows.every(row => row.passed);
|
||||
})()
|
||||
Reference in New Issue
Block a user