muskitty_html5_parser/
lib.rs1pub mod error;
18pub mod parser;
19pub mod serialize;
20
21use std::cell::RefCell;
22use std::rc::Rc;
23
24use crate::error::ParseError;
25use crate::parser::{HtmlTreeConstructor, InsertionMode};
26use muskitty_dom::{append_child, drain_children, remove_child, Node};
27use muskitty_html5_tokenizer::{HtmlTokenizer, State, Token, Tokenizer};
28
29pub const MAX_INPUT_BYTES: usize = 64 * 1024 * 1024;
31
32pub const MAX_OPEN_ELEMENTS: usize = 512;
35
36pub struct ParseOutput {
38 pub document: Rc<RefCell<Node>>,
42 pub errors: Vec<ParseError>,
44}
45
46pub fn parse(input: &str) -> Rc<RefCell<Node>> {
55 parse_with_limits(input, MAX_INPUT_BYTES, MAX_OPEN_ELEMENTS).document
56}
57
58pub fn parse_with_limits(input: &str, max_bytes: usize, max_open_elements: usize) -> ParseOutput {
68 let document = Node::new_document();
69
70 if input.len() > max_bytes {
72 return ParseOutput {
73 document,
74 errors: vec![ParseError::InputTooLarge {
75 actual: input.len(),
76 limit: max_bytes,
77 }],
78 };
79 }
80
81 let mut tokenizer = HtmlTokenizer::new(input);
82 let mut constructor = HtmlTreeConstructor::new(document.clone());
83 constructor.max_open_elements = max_open_elements;
84 run_tokenizer_loop(&mut constructor, &mut tokenizer);
85 constructor.finalize();
89 ParseOutput {
90 document,
91 errors: constructor.errors,
92 }
93}
94
95fn run_tokenizer_loop(constructor: &mut HtmlTreeConstructor, tokenizer: &mut dyn Tokenizer) {
102 loop {
103 let in_foreign = constructor.current_node_in_foreign_content();
110 tokenizer.set_foreign_content(in_foreign);
111 let Some(token) = tokenizer.next_token() else {
112 break;
113 };
114 constructor.run(&token, tokenizer);
115 if matches!(token, Token::EOF) {
116 break;
117 }
118 }
119}
120
121pub fn parse_fragment(input: &str, context_element: &Rc<RefCell<Node>>) -> Rc<RefCell<Node>> {
134 let doc = Node::new_document();
135 let fragment = Node::new_document_fragment(&doc);
136 if input.len() > MAX_INPUT_BYTES {
137 return fragment;
138 }
139 let context = match recreate_context_element(context_element, &doc) {
140 Some(c) => c,
141 None => {
142 Node::new_element_html("div", vec![], &doc)
150 }
151 };
152 let mut constructor = HtmlTreeConstructor::new(doc);
153 constructor.fragment_context = Some(context.clone());
154 constructor.fragment_root = Some(fragment.clone());
155
156 let root = Node::new_element_html("html", vec![], &constructor.document);
159 let _ = append_child(&fragment, root.clone());
160 constructor.open_elements.push(root.clone());
161
162 if is_html_template(context_element) {
164 constructor
165 .template_insertion_modes
166 .push(InsertionMode::InTemplate);
167 }
168 crate::parser::dispatch::reset_insertion_mode(&mut constructor);
171
172 let mut tokenizer = HtmlTokenizer::new(input);
173 if let Some(state) = fragment_tokenizer_state(context_element) {
174 tokenizer.set_state(state);
175 }
176 run_tokenizer_loop(&mut constructor, &mut tokenizer);
183 constructor.finalize();
184
185 let children = drain_children(&root);
187 for child in children {
188 let _ = append_child(&fragment, child);
189 }
190 let _ = remove_child(&fragment, &root);
191 fragment
192}
193
194fn recreate_context_element(
200 context_element: &Rc<RefCell<Node>>,
201 doc: &Rc<RefCell<Node>>,
202) -> Option<Rc<RefCell<Node>>> {
203 let borrowed = context_element.borrow();
204 let e = borrowed.kind.as_element()?;
205 let attrs = e.attributes.clone();
206 Some(match e.namespace {
207 muskitty_dom::Namespace::Html => Node::new_element_html(&e.local_name, attrs, doc),
208 ns => Node::new_element_ns(e.local_name.clone(), ns, e.prefix.clone(), attrs, doc),
209 })
210}
211
212fn is_html_template(context_element: &Rc<RefCell<Node>>) -> bool {
214 context_element
215 .borrow()
216 .kind
217 .as_element()
218 .is_some_and(|e| e.namespace == muskitty_dom::Namespace::Html && e.local_name == "template")
219}
220
221fn fragment_tokenizer_state(context_element: &Rc<RefCell<Node>>) -> Option<State> {
228 let borrowed = context_element.borrow();
229 let e = borrowed.kind.as_element()?;
231 if e.namespace != muskitty_dom::Namespace::Html {
232 return None;
233 }
234 match e.local_name.as_str() {
235 "title" | "textarea" => Some(State::RCDATA),
236 "style" | "xmp" | "iframe" | "noembed" | "noframes" => Some(State::RAWTEXT),
237 "script" => Some(State::ScriptData),
238 "plaintext" => Some(State::PLAINTEXT),
239 _ => None,
242 }
243}
244
245#[cfg(test)]
246mod tests {
247 use super::*;
248
249 #[test]
250 fn parse_returns_document_for_normal_input() {
251 let doc = parse("<div>hello</div>");
253 assert!(!doc.borrow().child_nodes().is_empty());
255 }
256
257 #[test]
258 fn input_too_large_returns_empty_document_and_error() {
259 let huge: String = "x".repeat(1024 * 1024);
261 let out = parse_with_limits(&huge, 1024, MAX_OPEN_ELEMENTS);
262 assert!(matches!(
263 out.errors.first(),
264 Some(ParseError::InputTooLarge { actual, limit })
265 if *actual == 1024 * 1024 && *limit == 1024
266 ));
267 assert!(out.document.borrow().child_nodes().is_empty());
269 }
270
271 #[test]
272 fn dom_depth_exceeded_skips_push_but_continues() {
273 let html = "<div>".repeat(100);
275 let out = parse_with_limits(&html, MAX_INPUT_BYTES, 50);
276 assert!(
278 out.errors
279 .iter()
280 .any(|e| matches!(e, ParseError::DomDepthExceeded { .. })),
281 "expected DomDepthExceeded error"
282 );
283 assert!(!out.document.borrow().child_nodes().is_empty());
285 }
286
287 #[test]
288 fn normal_input_within_limits_no_errors() {
289 let out = parse_with_limits("<div></div>", MAX_INPUT_BYTES, MAX_OPEN_ELEMENTS);
290 assert!(out.errors.is_empty(), "expected no errors");
291 }
292
293 fn context_element(local_name: &str) -> Rc<RefCell<Node>> {
296 let doc = Node::new_document();
297 Node::new_element_html(local_name, vec![], &doc)
298 }
299
300 fn fragment_child_names(fragment: &Rc<RefCell<Node>>) -> Vec<String> {
302 fragment
303 .borrow()
304 .child_nodes()
305 .iter()
306 .map(|n| {
307 let borrowed = n.borrow();
308 borrowed
309 .kind
310 .as_element()
311 .map(|e| e.local_name.clone())
312 .unwrap_or_else(|| borrowed.node_name.clone())
313 })
314 .collect()
315 }
316
317 #[test]
318 fn parse_fragment_returns_document_fragment() {
319 let frag = parse_fragment("<b>x</b>", &context_element("div"));
320 assert_eq!(
321 frag.borrow().node_type,
322 muskitty_dom::NodeType::DocumentFragment
323 );
324 assert_eq!(fragment_child_names(&frag), vec!["b"]);
325 }
326
327 #[test]
328 fn parse_fragment_div_context_uses_in_body() {
329 let frag = parse_fragment("<span>hi</span>", &context_element("div"));
330 assert_eq!(fragment_child_names(&frag), vec!["span"]);
331 assert!(fragment_child_names(&frag).iter().all(|n| n != "html"));
333 }
334
335 #[test]
336 fn parse_fragment_table_context_uses_in_table() {
337 let frag = parse_fragment("<tr><td>x</td></tr>", &context_element("table"));
341 assert_eq!(fragment_child_names(&frag), vec!["tbody"]);
342 }
343
344 #[test]
345 fn parse_fragment_title_context_uses_rcdata() {
346 let frag = parse_fragment("<b>bold</b>", &context_element("title"));
349 assert_eq!(fragment_child_names(&frag), vec!["#text"]);
350 assert_eq!(
351 crate::serialize::inner_html(&frag),
352 "<b>bold</b>"
353 );
354 }
355
356 #[test]
357 fn parse_fragment_script_context_uses_script_data() {
358 let frag = parse_fragment("if (a<b) {}", &context_element("script"));
361 assert_eq!(fragment_child_names(&frag), vec!["#text"]);
362 assert_eq!(crate::serialize::inner_html(&frag), "if (a<b) {}");
363 }
364
365 #[test]
368 fn parse_fragment_text_context_degrades_not_panics() {
369 let doc = Node::new_document();
372 let text = Node::new_text("hello", &doc);
373 let frag = parse_fragment("<b>x</b>", &text);
374 assert_eq!(fragment_child_names(&frag), vec!["b"]);
375 }
376
377 #[test]
378 fn parse_fragment_document_context_degrades_not_panics() {
379 let doc = Node::new_document();
380 let frag = parse_fragment("<b>x</b>", &doc);
381 assert_eq!(fragment_child_names(&frag), vec!["b"]);
382 }
383
384 #[test]
385 fn set_inner_html_on_text_node_does_not_panic() {
386 let doc = Node::new_document();
388 let text = Node::new_text("old", &doc);
389 crate::serialize::set_inner_html(&text, "<b>x</b>");
390 let children = text.borrow().child_nodes().to_vec();
391 assert_eq!(children.len(), 1, "content must be replaced");
392 assert_eq!(children[0].borrow().node_name, "B");
394 }
395}