pub mod error;
pub mod parser;
pub mod serialize;
use std::cell::RefCell;
use std::rc::Rc;
use crate::error::ParseError;
use crate::parser::{HtmlTreeConstructor, InsertionMode};
use muskitty_dom::{append_child, drain_children, remove_child, Node};
use muskitty_html5_tokenizer::{HtmlTokenizer, State, Token, Tokenizer};
pub const MAX_INPUT_BYTES: usize = 64 * 1024 * 1024;
pub const MAX_OPEN_ELEMENTS: usize = 512;
pub struct ParseOutput {
pub document: Rc<RefCell<Node>>,
pub errors: Vec<ParseError>,
}
pub fn parse(input: &str) -> Rc<RefCell<Node>> {
parse_with_limits(input, MAX_INPUT_BYTES, MAX_OPEN_ELEMENTS).document
}
pub fn parse_with_limits(input: &str, max_bytes: usize, max_open_elements: usize) -> ParseOutput {
let document = Node::new_document();
if input.len() > max_bytes {
return ParseOutput {
document,
errors: vec![ParseError::InputTooLarge {
actual: input.len(),
limit: max_bytes,
}],
};
}
let mut tokenizer = HtmlTokenizer::new(input);
let mut constructor = HtmlTreeConstructor::new(document.clone());
constructor.max_open_elements = max_open_elements;
run_tokenizer_loop(&mut constructor, &mut tokenizer);
constructor.finalize();
ParseOutput {
document,
errors: constructor.errors,
}
}
fn run_tokenizer_loop(constructor: &mut HtmlTreeConstructor, tokenizer: &mut dyn Tokenizer) {
loop {
let in_foreign = constructor.current_node_in_foreign_content();
tokenizer.set_foreign_content(in_foreign);
let Some(token) = tokenizer.next_token() else {
break;
};
constructor.run(&token, tokenizer);
if matches!(token, Token::EOF) {
break;
}
}
}
pub fn parse_fragment(input: &str, context_element: &Rc<RefCell<Node>>) -> Rc<RefCell<Node>> {
let doc = Node::new_document();
let fragment = Node::new_document_fragment(&doc);
if input.len() > MAX_INPUT_BYTES {
return fragment;
}
let context = match recreate_context_element(context_element, &doc) {
Some(c) => c,
None => {
Node::new_element_html("div", vec![], &doc)
}
};
let mut constructor = HtmlTreeConstructor::new(doc);
constructor.fragment_context = Some(context.clone());
constructor.fragment_root = Some(fragment.clone());
let root = Node::new_element_html("html", vec![], &constructor.document);
let _ = append_child(&fragment, root.clone());
constructor.open_elements.push(root.clone());
if is_html_template(context_element) {
constructor
.template_insertion_modes
.push(InsertionMode::InTemplate);
}
crate::parser::dispatch::reset_insertion_mode(&mut constructor);
let mut tokenizer = HtmlTokenizer::new(input);
if let Some(state) = fragment_tokenizer_state(context_element) {
tokenizer.set_state(state);
}
run_tokenizer_loop(&mut constructor, &mut tokenizer);
constructor.finalize();
let children = drain_children(&root);
for child in children {
let _ = append_child(&fragment, child);
}
let _ = remove_child(&fragment, &root);
fragment
}
fn recreate_context_element(
context_element: &Rc<RefCell<Node>>,
doc: &Rc<RefCell<Node>>,
) -> Option<Rc<RefCell<Node>>> {
let borrowed = context_element.borrow();
let e = borrowed.kind.as_element()?;
let attrs = e.attributes.clone();
Some(match e.namespace {
muskitty_dom::Namespace::Html => Node::new_element_html(&e.local_name, attrs, doc),
ns => Node::new_element_ns(e.local_name.clone(), ns, e.prefix.clone(), attrs, doc),
})
}
fn is_html_template(context_element: &Rc<RefCell<Node>>) -> bool {
context_element
.borrow()
.kind
.as_element()
.is_some_and(|e| e.namespace == muskitty_dom::Namespace::Html && e.local_name == "template")
}
fn fragment_tokenizer_state(context_element: &Rc<RefCell<Node>>) -> Option<State> {
let borrowed = context_element.borrow();
let e = borrowed.kind.as_element()?;
if e.namespace != muskitty_dom::Namespace::Html {
return None;
}
match e.local_name.as_str() {
"title" | "textarea" => Some(State::RCDATA),
"style" | "xmp" | "iframe" | "noembed" | "noframes" => Some(State::RAWTEXT),
"script" => Some(State::ScriptData),
"plaintext" => Some(State::PLAINTEXT),
_ => None,
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn parse_returns_document_for_normal_input() {
let doc = parse("<div>hello</div>");
assert!(!doc.borrow().child_nodes().is_empty());
}
#[test]
fn input_too_large_returns_empty_document_and_error() {
let huge: String = "x".repeat(1024 * 1024);
let out = parse_with_limits(&huge, 1024, MAX_OPEN_ELEMENTS);
assert!(matches!(
out.errors.first(),
Some(ParseError::InputTooLarge { actual, limit })
if *actual == 1024 * 1024 && *limit == 1024
));
assert!(out.document.borrow().child_nodes().is_empty());
}
#[test]
fn dom_depth_exceeded_skips_push_but_continues() {
let html = "<div>".repeat(100);
let out = parse_with_limits(&html, MAX_INPUT_BYTES, 50);
assert!(
out.errors
.iter()
.any(|e| matches!(e, ParseError::DomDepthExceeded { .. })),
"expected DomDepthExceeded error"
);
assert!(!out.document.borrow().child_nodes().is_empty());
}
#[test]
fn normal_input_within_limits_no_errors() {
let out = parse_with_limits("<div></div>", MAX_INPUT_BYTES, MAX_OPEN_ELEMENTS);
assert!(out.errors.is_empty(), "expected no errors");
}
fn context_element(local_name: &str) -> Rc<RefCell<Node>> {
let doc = Node::new_document();
Node::new_element_html(local_name, vec![], &doc)
}
fn fragment_child_names(fragment: &Rc<RefCell<Node>>) -> Vec<String> {
fragment
.borrow()
.child_nodes()
.iter()
.map(|n| {
let borrowed = n.borrow();
borrowed
.kind
.as_element()
.map(|e| e.local_name.clone())
.unwrap_or_else(|| borrowed.node_name.clone())
})
.collect()
}
#[test]
fn parse_fragment_returns_document_fragment() {
let frag = parse_fragment("<b>x</b>", &context_element("div"));
assert_eq!(
frag.borrow().node_type,
muskitty_dom::NodeType::DocumentFragment
);
assert_eq!(fragment_child_names(&frag), vec!["b"]);
}
#[test]
fn parse_fragment_div_context_uses_in_body() {
let frag = parse_fragment("<span>hi</span>", &context_element("div"));
assert_eq!(fragment_child_names(&frag), vec!["span"]);
assert!(fragment_child_names(&frag).iter().all(|n| n != "html"));
}
#[test]
fn parse_fragment_table_context_uses_in_table() {
let frag = parse_fragment("<tr><td>x</td></tr>", &context_element("table"));
assert_eq!(fragment_child_names(&frag), vec!["tbody"]);
}
#[test]
fn parse_fragment_title_context_uses_rcdata() {
let frag = parse_fragment("<b>bold</b>", &context_element("title"));
assert_eq!(fragment_child_names(&frag), vec!["#text"]);
assert_eq!(
crate::serialize::inner_html(&frag),
"<b>bold</b>"
);
}
#[test]
fn parse_fragment_script_context_uses_script_data() {
let frag = parse_fragment("if (a<b) {}", &context_element("script"));
assert_eq!(fragment_child_names(&frag), vec!["#text"]);
assert_eq!(crate::serialize::inner_html(&frag), "if (a<b) {}");
}
#[test]
fn parse_fragment_text_context_degrades_not_panics() {
let doc = Node::new_document();
let text = Node::new_text("hello", &doc);
let frag = parse_fragment("<b>x</b>", &text);
assert_eq!(fragment_child_names(&frag), vec!["b"]);
}
#[test]
fn parse_fragment_document_context_degrades_not_panics() {
let doc = Node::new_document();
let frag = parse_fragment("<b>x</b>", &doc);
assert_eq!(fragment_child_names(&frag), vec!["b"]);
}
#[test]
fn set_inner_html_on_text_node_does_not_panic() {
let doc = Node::new_document();
let text = Node::new_text("old", &doc);
crate::serialize::set_inner_html(&text, "<b>x</b>");
let children = text.borrow().child_nodes().to_vec();
assert_eq!(children.len(), 1, "content must be replaced");
assert_eq!(children[0].borrow().node_name, "B");
}
}