use std::cell::RefCell;
use std::rc::Rc;
use muskitty_dom::{append_child, remove_child, Attribute, Node, NodeKind};
use crate::error::ParseError;
use muskitty_html5_tokenizer::{State, TagKind, Token, Tokenizer};
use super::helpers;
use super::insertion_mode::InsertionMode;
use super::{ActiveFormattingEntry, HtmlTreeConstructor};
pub enum Step {
Done,
Reprocess,
}
pub fn dispatch(
parser: &mut HtmlTreeConstructor,
token: &Token,
tokenizer: &mut dyn Tokenizer,
) -> Step {
let skip_foreign = parser.skip_foreign_dispatch_once;
parser.skip_foreign_dispatch_once = false;
if !skip_foreign && super::foreign::dispatcher_routes_to_foreign(parser, token) {
return super::foreign::process_in_foreign_content(parser, token, tokenizer);
}
dispatch_in_current_mode(parser, token, tokenizer)
}
pub(crate) fn dispatch_in_current_mode(
parser: &mut HtmlTreeConstructor,
token: &Token,
tokenizer: &mut dyn Tokenizer,
) -> Step {
match parser.insertion_mode {
InsertionMode::Initial => handle_initial(parser, token),
InsertionMode::BeforeHtml => handle_before_html(parser, token),
InsertionMode::BeforeHead => handle_before_head(parser, token, tokenizer),
InsertionMode::InHead => handle_in_head(parser, token, tokenizer),
InsertionMode::AfterHead => handle_after_head(parser, token, tokenizer),
InsertionMode::InBody => handle_in_body(parser, token, tokenizer),
InsertionMode::Text => handle_text(parser, token, tokenizer),
InsertionMode::AfterBody => handle_after_body(parser, token, tokenizer),
InsertionMode::AfterAfterBody => handle_after_after_body(parser, token, tokenizer),
InsertionMode::InTable => handle_in_table(parser, token, tokenizer),
InsertionMode::InTableText => handle_in_table_text(parser, token, tokenizer),
InsertionMode::InCaption => handle_in_caption(parser, token, tokenizer),
InsertionMode::InColumnGroup => handle_in_column_group(parser, token, tokenizer),
InsertionMode::InTableBody => handle_in_table_body(parser, token, tokenizer),
InsertionMode::InRow => handle_in_row(parser, token, tokenizer),
InsertionMode::InCell => handle_in_cell(parser, token, tokenizer),
InsertionMode::InHeadNoscript => handle_in_head_noscript(parser, token, tokenizer),
InsertionMode::InTemplate => handle_in_template(parser, token, tokenizer),
InsertionMode::InFrameset => handle_in_frameset(parser, token, tokenizer),
InsertionMode::AfterFrameset => handle_after_frameset(parser, token, tokenizer),
InsertionMode::AfterAfterFrameset => handle_after_after_frameset(parser, token, tokenizer),
}
}
fn is_whitespace(c: char) -> bool {
matches!(c, '\t' | '\n' | '\u{000C}' | '\r' | ' ')
}
fn create_and_push(parser: &mut HtmlTreeConstructor, name: &str) {
let element = Node::new_element_html(name, vec![], &parser.document);
helpers::insert_node(parser, &element);
helpers::push_open_element(parser, element);
}
fn handle_initial(parser: &mut HtmlTreeConstructor, token: &Token) -> Step {
match token {
Token::Character(c) if is_whitespace(*c) => Step::Done,
Token::Comment(data) => {
helpers::insert_comment_at(&parser.document, data, &parser.document);
Step::Done
}
Token::ProcessingInstruction { target, data } => {
helpers::insert_processing_instruction_at(
&parser.document,
target,
data,
&parser.document,
);
Step::Done
}
Token::Doctype(dt) => {
if dt.name.as_deref() != Some("html")
|| dt.public_id.is_some()
|| (dt.system_id.is_some()
&& dt.system_id.as_deref() != Some("about:legacy-compat"))
{
parser.errors.push(ParseError::InvalidDoctype);
}
if helpers::detect_quirks_mode(
dt.force_quirks,
dt.name.as_deref(),
dt.public_id.as_deref(),
dt.system_id.as_deref(),
) {
parser.quirks_mode = true;
}
let doctype_node = Node::new_document_type(
dt.name.as_deref().unwrap_or(""),
dt.public_id.as_deref().unwrap_or(""),
dt.system_id.as_deref().unwrap_or(""),
&parser.document,
);
let _ = append_child(&parser.document, doctype_node);
parser.insertion_mode = InsertionMode::BeforeHtml;
Step::Done
}
_ => {
parser.quirks_mode = true;
parser.insertion_mode = InsertionMode::BeforeHtml;
Step::Reprocess
}
}
}
fn handle_before_html(parser: &mut HtmlTreeConstructor, token: &Token) -> Step {
match token {
Token::Doctype(_) => {
parser
.errors
.push(ParseError::Generic("unexpected DOCTYPE in before html"));
Step::Done
}
Token::Comment(data) => {
helpers::insert_comment_at(&parser.document, data, &parser.document);
Step::Done
}
Token::ProcessingInstruction { target, data } => {
helpers::insert_processing_instruction_at(
&parser.document,
target,
data,
&parser.document,
);
Step::Done
}
Token::Character(c) if is_whitespace(*c) => Step::Done,
Token::Tag(tag) if tag.kind == TagKind::Start && tag.name == "html" => {
let element = helpers::create_element_for_token(parser, tag);
let _ = append_child(&parser.document, element.clone());
helpers::push_open_element(parser, element);
parser.insertion_mode = InsertionMode::BeforeHead;
Step::Done
}
Token::Tag(tag)
if tag.kind == TagKind::End
&& matches!(tag.name.as_str(), "head" | "body" | "html" | "br") =>
{
create_and_push(parser, "html");
parser.insertion_mode = InsertionMode::BeforeHead;
Step::Reprocess
}
_ => {
create_and_push(parser, "html");
parser.insertion_mode = InsertionMode::BeforeHead;
Step::Reprocess
}
}
}
fn handle_before_head(
parser: &mut HtmlTreeConstructor,
token: &Token,
tokenizer: &mut dyn Tokenizer,
) -> Step {
match token {
Token::Character(c) if is_whitespace(*c) => Step::Done,
Token::Comment(data) => {
helpers::insert_comment(parser, data);
Step::Done
}
Token::ProcessingInstruction { target, data } => {
helpers::insert_processing_instruction(parser, target, data);
Step::Done
}
Token::Doctype(_) => {
parser
.errors
.push(ParseError::Generic("unexpected DOCTYPE in before head"));
Step::Done
}
Token::Tag(tag) if tag.kind == TagKind::Start && tag.name == "html" => {
handle_in_body(parser, token, tokenizer)
}
Token::Tag(tag) if tag.kind == TagKind::Start && tag.name == "head" => {
let element = helpers::create_element_for_token(parser, tag);
let current = parser.current_node();
let _ = append_child(¤t, element.clone());
helpers::push_open_element(parser, element.clone());
parser.head_element = Some(element);
parser.insertion_mode = InsertionMode::InHead;
Step::Done
}
Token::Tag(tag)
if tag.kind == TagKind::End
&& matches!(tag.name.as_str(), "head" | "body" | "html" | "br") =>
{
create_and_push(parser, "head");
parser.head_element = parser.open_elements.last().cloned();
parser.insertion_mode = InsertionMode::InHead;
Step::Reprocess
}
Token::Tag(tag) if tag.kind == TagKind::End => {
parser
.errors
.push(ParseError::Generic("unexpected end tag in before head"));
Step::Done
}
_ => {
create_and_push(parser, "head");
parser.head_element = parser.open_elements.last().cloned();
parser.insertion_mode = InsertionMode::InHead;
Step::Reprocess
}
}
}
fn handle_in_head(
parser: &mut HtmlTreeConstructor,
token: &Token,
tokenizer: &mut dyn Tokenizer,
) -> Step {
match token {
Token::Character(c) if is_whitespace(*c) => {
helpers::insert_character(parser, *c);
Step::Done
}
Token::Comment(data) => {
helpers::insert_comment(parser, data);
Step::Done
}
Token::ProcessingInstruction { target, data } => {
helpers::insert_processing_instruction(parser, target, data);
Step::Done
}
Token::Doctype(_) => {
parser
.errors
.push(ParseError::Generic("unexpected DOCTYPE in head"));
Step::Done
}
Token::Tag(tag) if tag.kind == TagKind::Start && tag.name == "html" => {
handle_in_body(parser, token, tokenizer)
}
Token::Tag(tag)
if tag.kind == TagKind::Start
&& matches!(tag.name.as_str(), "base" | "basefont" | "bgsound" | "link") =>
{
helpers::insert_element(parser, tag);
parser.open_elements.pop();
Step::Done
}
Token::Tag(tag) if tag.kind == TagKind::Start && tag.name == "meta" => {
helpers::insert_element(parser, tag);
parser.open_elements.pop();
Step::Done
}
Token::Tag(tag) if tag.kind == TagKind::Start && tag.name == "title" => {
tokenizer.set_appropriate_end_tag_name(Some(&tag.name));
tokenizer.set_state(State::RCDATA);
helpers::insert_element(parser, tag);
parser.original_insertion_mode = Some(parser.insertion_mode);
parser.insertion_mode = InsertionMode::Text;
Step::Done
}
Token::Tag(tag)
if tag.kind == TagKind::Start && matches!(tag.name.as_str(), "noframes" | "style") =>
{
tokenizer.set_appropriate_end_tag_name(Some(&tag.name));
tokenizer.set_state(State::RAWTEXT);
helpers::insert_element(parser, tag);
parser.original_insertion_mode = Some(parser.insertion_mode);
parser.insertion_mode = InsertionMode::Text;
Step::Done
}
Token::Tag(tag) if tag.kind == TagKind::Start && tag.name == "noscript" => {
if !parser.scripting_flag {
helpers::insert_element(parser, tag);
parser.insertion_mode = InsertionMode::InHeadNoscript;
Step::Done
} else {
tokenizer.set_appropriate_end_tag_name(Some(&tag.name));
tokenizer.set_state(State::RAWTEXT);
helpers::insert_element(parser, tag);
parser.original_insertion_mode = Some(parser.insertion_mode);
parser.insertion_mode = InsertionMode::Text;
Step::Done
}
}
Token::Tag(tag) if tag.kind == TagKind::Start && tag.name == "script" => {
tokenizer.set_appropriate_end_tag_name(Some(&tag.name));
tokenizer.set_state(State::ScriptData);
helpers::insert_element(parser, tag);
parser.original_insertion_mode = Some(parser.insertion_mode);
parser.insertion_mode = InsertionMode::Text;
Step::Done
}
Token::Tag(tag) if tag.kind == TagKind::Start && tag.name == "template" => {
helpers::add_formatting_marker(parser);
helpers::insert_element(parser, tag);
parser.frameset_ok = false;
parser
.template_insertion_modes
.push(InsertionMode::InTemplate);
parser.insertion_mode = InsertionMode::InTemplate;
Step::Done
}
Token::Tag(tag) if tag.kind == TagKind::End && tag.name == "template" => {
if !helpers::has_element_in_stack(parser, "template") {
parser.errors.push(ParseError::Generic(
"end template without template in stack",
));
return Step::Done;
}
helpers::generate_implied_end_tags(parser, None);
while let Some(top) = parser.open_elements.pop() {
let is_html_template = top
.borrow()
.kind
.as_element()
.map(|e| {
e.local_name == "template" && e.namespace == muskitty_dom::Namespace::Html
})
.unwrap_or(false);
if is_html_template {
break;
}
}
helpers::clear_active_formatting_to_last_marker(parser);
parser.template_insertion_modes.pop();
reset_insertion_mode(parser);
Step::Done
}
Token::Tag(tag) if tag.kind == TagKind::Start && tag.name == "head" => {
parser
.errors
.push(ParseError::Generic("duplicate head start tag"));
Step::Done
}
Token::Tag(tag) if tag.kind == TagKind::End && tag.name == "head" => {
parser.open_elements.pop();
parser.insertion_mode = InsertionMode::AfterHead;
Step::Done
}
Token::Tag(tag)
if tag.kind == TagKind::End && matches!(tag.name.as_str(), "body" | "html" | "br") =>
{
parser.open_elements.pop();
parser.insertion_mode = InsertionMode::AfterHead;
Step::Reprocess
}
Token::Tag(tag) if tag.kind == TagKind::Start => {
let _ = tag;
parser.open_elements.pop();
parser.insertion_mode = InsertionMode::AfterHead;
Step::Reprocess
}
Token::Tag(tag) if tag.kind == TagKind::End => {
parser
.errors
.push(ParseError::UnexpectedEndTag(tag.name.clone()));
Step::Done
}
_ => {
parser.open_elements.pop();
parser.insertion_mode = InsertionMode::AfterHead;
Step::Reprocess
}
}
}
fn handle_after_head(
parser: &mut HtmlTreeConstructor,
token: &Token,
tokenizer: &mut dyn Tokenizer,
) -> Step {
match token {
Token::Character(c) if is_whitespace(*c) => {
helpers::insert_character(parser, *c);
Step::Done
}
Token::Comment(data) => {
helpers::insert_comment(parser, data);
Step::Done
}
Token::ProcessingInstruction { target, data } => {
helpers::insert_processing_instruction(parser, target, data);
Step::Done
}
Token::Doctype(_) => {
parser
.errors
.push(ParseError::Generic("unexpected DOCTYPE after head"));
Step::Done
}
Token::Tag(tag) if tag.kind == TagKind::Start && tag.name == "html" => {
let _ = tag;
handle_in_body(parser, token, tokenizer)
}
Token::Tag(tag) if tag.kind == TagKind::Start && tag.name == "body" => {
let element = helpers::create_element_for_token(parser, tag);
let current = parser.current_node();
let _ = append_child(¤t, element.clone());
helpers::push_open_element(parser, element);
parser.frameset_ok = false;
parser.insertion_mode = InsertionMode::InBody;
Step::Done
}
Token::Tag(tag) if tag.kind == TagKind::Start && tag.name == "frameset" => {
let element = helpers::create_element_for_token(parser, tag);
let current = parser.current_node();
let _ = append_child(¤t, element.clone());
helpers::push_open_element(parser, element);
parser.insertion_mode = InsertionMode::InFrameset;
Step::Done
}
Token::Tag(tag)
if tag.kind == TagKind::Start
&& matches!(
tag.name.as_str(),
"base"
| "basefont"
| "bgsound"
| "link"
| "meta"
| "noframes"
| "script"
| "style"
| "template"
| "title"
) =>
{
parser
.errors
.push(ParseError::UnexpectedStartTag(tag.name.clone()));
if let Some(head) = parser.head_element.clone() {
let head_ptr = Rc::as_ptr(&head);
helpers::push_open_element(parser, head);
let step = handle_in_head(parser, token, tokenizer);
parser.open_elements.retain(|n| Rc::as_ptr(n) != head_ptr);
step
} else {
Step::Done
}
}
Token::Tag(tag) if tag.kind == TagKind::Start && tag.name == "head" => {
parser
.errors
.push(ParseError::Generic("unexpected head start tag after head"));
Step::Done
}
Token::Tag(tag)
if tag.kind == TagKind::End && matches!(tag.name.as_str(), "body" | "html" | "br") =>
{
create_and_push(parser, "body");
parser.insertion_mode = InsertionMode::InBody;
Step::Reprocess
}
Token::Tag(tag) if tag.kind == TagKind::End && tag.name == "template" => {
let _ = tag;
handle_in_head(parser, token, tokenizer)
}
Token::Tag(tag) if tag.kind == TagKind::End => {
parser
.errors
.push(ParseError::Generic("unexpected end tag after head"));
let _ = tag;
Step::Done
}
_ => {
create_and_push(parser, "body");
parser.insertion_mode = InsertionMode::InBody;
Step::Reprocess
}
}
}
fn handle_text(
parser: &mut HtmlTreeConstructor,
token: &Token,
_tokenizer: &mut dyn Tokenizer,
) -> Step {
match token {
Token::Character(c) => {
helpers::insert_character(parser, *c);
Step::Done
}
Token::EOF => {
parser
.errors
.push(ParseError::Generic("unexpected EOF in text mode"));
parser.open_elements.pop();
if let Some(orig) = parser.original_insertion_mode.take() {
parser.insertion_mode = orig;
}
Step::Reprocess
}
Token::Tag(tag) if tag.kind == TagKind::End => {
let _ = tag;
parser.open_elements.pop();
if let Some(orig) = parser.original_insertion_mode.take() {
parser.insertion_mode = orig;
}
_tokenizer.set_state(State::Data);
_tokenizer.set_appropriate_end_tag_name(None);
Step::Done
}
_ => {
parser
.errors
.push(ParseError::Generic("unexpected token in text mode"));
Step::Done
}
}
}
const BLOCK_LEVEL_START_TAGS: &[&str] = &[
"address",
"article",
"aside",
"blockquote",
"center",
"details",
"dialog",
"dir",
"div",
"dl",
"fieldset",
"figcaption",
"figure",
"footer",
"header",
"hgroup",
"main",
"menu",
"nav",
"ol",
"p",
"search",
"section",
"summary",
"ul",
];
const BLOCK_LEVEL_END_TAGS: &[&str] = &[
"address",
"article",
"aside",
"blockquote",
"button",
"center",
"details",
"dialog",
"dir",
"div",
"dl",
"fieldset",
"figcaption",
"figure",
"footer",
"header",
"hgroup",
"listing",
"main",
"menu",
"nav",
"ol",
"pre",
"search",
"section",
"select",
"summary",
"ul",
];
const VOID_ELEMENTS: &[&str] = &[
"area", "base", "br", "col", "embed", "img", "keygen", "link", "meta", "param", "source",
"track", "wbr",
];
fn handle_in_body(
parser: &mut HtmlTreeConstructor,
token: &Token,
tokenizer: &mut dyn Tokenizer,
) -> Step {
match token {
Token::EOF => {
if !parser.template_insertion_modes.is_empty() {
return handle_in_template(parser, token, tokenizer);
}
let unexpected = parser.open_elements.iter().any(|n| {
let borrowed = n.borrow();
let local = borrowed
.kind
.as_element()
.map(|e| e.local_name.as_str())
.unwrap_or("");
!matches!(
local,
"dd" | "dt"
| "li"
| "optgroup"
| "option"
| "p"
| "rb"
| "rp"
| "rt"
| "rtc"
| "tbody"
| "td"
| "tfoot"
| "th"
| "thead"
| "tr"
| "body"
| "html"
)
});
if unexpected {
parser
.errors
.push(ParseError::Generic("unexpected open element at EOF"));
}
Step::Done
}
Token::Character(c) if is_whitespace(*c) => {
helpers::reconstruct_active_formatting_elements(parser);
helpers::insert_character(parser, *c);
Step::Done
}
Token::Character('\0') => {
parser
.errors
.push(ParseError::Generic("unexpected null character in body"));
Step::Done
}
Token::Character(c) => {
helpers::reconstruct_active_formatting_elements(parser);
parser.frameset_ok = false;
helpers::insert_character(parser, *c);
Step::Done
}
Token::Comment(data) => {
helpers::insert_comment(parser, data);
Step::Done
}
Token::ProcessingInstruction { target, data } => {
helpers::insert_processing_instruction(parser, target, data);
Step::Done
}
Token::Doctype(_) => {
parser
.errors
.push(ParseError::Generic("unexpected DOCTYPE in body"));
Step::Done
}
Token::Tag(tag) if tag.kind == TagKind::Start => {
handle_in_body_start_tag(parser, tag, tokenizer)
}
Token::Tag(tag) if tag.kind == TagKind::End => {
if tag.name == "br" {
parser
.errors
.push(ParseError::Generic("end tag br treated as start tag"));
let br_tag = muskitty_html5_tokenizer::TagToken {
kind: TagKind::Start,
name: "br".to_string(),
attrs: vec![],
self_closing: false,
};
return handle_in_body_start_tag(parser, &br_tag, tokenizer);
}
handle_in_body_end_tag(parser, tag)
}
_ => Step::Done,
}
}
fn handle_in_body_start_tag(
parser: &mut HtmlTreeConstructor,
tag: &muskitty_html5_tokenizer::TagToken,
tokenizer: &mut dyn Tokenizer,
) -> Step {
let name = tag.name.as_str();
if name == "image" {
parser
.errors
.push(ParseError::Generic("image start tag treated as img"));
let img_tag = muskitty_html5_tokenizer::TagToken {
kind: tag.kind,
name: "img".to_string(),
attrs: tag.attrs.clone(),
self_closing: tag.self_closing,
};
return handle_in_body_start_tag(parser, &img_tag, tokenizer);
}
if name == "html" {
parser
.errors
.push(ParseError::Generic("unexpected <html> start tag in body"));
if !template_in_stack(parser) {
if let Some(html) = parser.open_elements.first().cloned() {
merge_attributes(&html, tag);
}
}
return Step::Done;
}
if matches!(
name,
"base"
| "basefont"
| "bgsound"
| "link"
| "meta"
| "noframes"
| "script"
| "style"
| "title"
) {
if matches!(name, "base" | "basefont" | "bgsound" | "link" | "meta") {
helpers::insert_element(parser, tag);
parser.open_elements.pop();
} else if name == "title" {
tokenizer.set_appropriate_end_tag_name(Some(name));
tokenizer.set_state(State::RCDATA);
helpers::insert_element(parser, tag);
parser.original_insertion_mode = Some(parser.insertion_mode);
parser.insertion_mode = InsertionMode::Text;
} else if matches!(name, "noframes" | "style") {
tokenizer.set_appropriate_end_tag_name(Some(name));
tokenizer.set_state(State::RAWTEXT);
helpers::insert_element(parser, tag);
parser.original_insertion_mode = Some(parser.insertion_mode);
parser.insertion_mode = InsertionMode::Text;
} else {
tokenizer.set_appropriate_end_tag_name(Some(name));
tokenizer.set_state(State::ScriptData);
helpers::insert_element(parser, tag);
parser.original_insertion_mode = Some(parser.insertion_mode);
parser.insertion_mode = InsertionMode::Text;
}
return Step::Done;
}
if name == "textarea" {
tokenizer.set_appropriate_end_tag_name(Some(name));
tokenizer.set_state(State::RCDATA);
helpers::insert_element(parser, tag);
parser.skip_next_lf = true;
parser.frameset_ok = false;
parser.original_insertion_mode = Some(parser.insertion_mode);
parser.insertion_mode = InsertionMode::Text;
return Step::Done;
}
if name == "template" {
helpers::add_formatting_marker(parser);
helpers::insert_element(parser, tag);
parser.frameset_ok = false;
parser
.template_insertion_modes
.push(InsertionMode::InTemplate);
parser.insertion_mode = InsertionMode::InTemplate;
return Step::Done;
}
if name == "body" {
parser
.errors
.push(ParseError::Generic("unexpected <body> start tag in body"));
let should_ignore = parser.open_elements.len() < 2
|| !parser
.open_elements
.get(1)
.and_then(|n| n.borrow().kind.as_element().map(|e| e.local_name == "body"))
.unwrap_or(false)
|| template_in_stack(parser);
if !should_ignore {
if let Some(body) = parser.open_elements.get(1).cloned() {
merge_attributes(&body, tag);
}
parser.frameset_ok = false;
}
return Step::Done;
}
if name == "frameset" {
if parser.open_elements.len() < 2 {
parser
.errors
.push(ParseError::Generic("frameset with no body on stack"));
return Step::Done;
}
let second_is_body = parser
.open_elements
.get(1)
.map(|n| {
n.borrow()
.kind
.as_element()
.map(|e| e.local_name == "body")
.unwrap_or(false)
})
.unwrap_or(false);
if !second_is_body {
parser
.errors
.push(ParseError::Generic("frameset with non-body second element"));
return Step::Done;
}
if !parser.frameset_ok {
parser
.errors
.push(ParseError::Generic("frameset after non-whitespace content"));
return Step::Done;
}
if let (Some(html), Some(body)) = (
parser.open_elements.first().cloned(),
parser.open_elements.get(1).cloned(),
) {
let _ = remove_child(&html, &body);
}
while parser.open_elements.len() > 1 {
parser.open_elements.pop();
}
helpers::insert_element(parser, tag);
parser.insertion_mode = InsertionMode::InFrameset;
return Step::Done;
}
if matches!(
name,
"caption"
| "col"
| "colgroup"
| "frame"
| "head"
| "tbody"
| "td"
| "tfoot"
| "th"
| "thead"
| "tr"
) {
parser
.errors
.push(ParseError::UnexpectedStartTag(tag.name.clone()));
return Step::Done;
}
if BLOCK_LEVEL_START_TAGS.contains(&name) {
if helpers::has_element_in_button_scope(parser, "p") {
helpers::close_p_element(parser);
}
helpers::insert_element(parser, tag);
return Step::Done;
}
if matches!(name, "h1" | "h2" | "h3" | "h4" | "h5" | "h6") {
if helpers::has_element_in_button_scope(parser, "p") {
helpers::close_p_element(parser);
}
if let Some(top) = parser.open_elements.last() {
let top_name = top.borrow().kind.as_element().map(|e| e.local_name.clone());
if matches!(
top_name.as_deref(),
Some("h1" | "h2" | "h3" | "h4" | "h5" | "h6")
) {
parser
.errors
.push(ParseError::Generic("heading nested in heading"));
parser.open_elements.pop();
}
}
helpers::insert_element(parser, tag);
return Step::Done;
}
if matches!(name, "pre" | "listing") {
if helpers::has_element_in_button_scope(parser, "p") {
helpers::close_p_element(parser);
}
helpers::insert_element(parser, tag);
parser.skip_next_lf = true;
parser.frameset_ok = false;
return Step::Done;
}
if name == "form" {
if parser.form_element.is_some() && !template_in_stack(parser) {
parser
.errors
.push(ParseError::Generic("nested form element"));
return Step::Done;
}
if helpers::has_element_in_button_scope(parser, "p") {
helpers::close_p_element(parser);
}
let element = helpers::create_element_for_token(parser, tag);
helpers::insert_node(parser, &element);
helpers::push_open_element(parser, element.clone());
parser.form_element = Some(element);
return Step::Done;
}
if name == "li" {
parser.frameset_ok = false;
helpers::close_list_item(parser, &["li"]);
if helpers::has_element_in_button_scope(parser, "p") {
helpers::close_p_element(parser);
}
helpers::insert_element(parser, tag);
return Step::Done;
}
if matches!(name, "dd" | "dt") {
parser.frameset_ok = false;
helpers::close_list_item(parser, &["dd", "dt"]);
if helpers::has_element_in_button_scope(parser, "p") {
helpers::close_p_element(parser);
}
helpers::insert_element(parser, tag);
return Step::Done;
}
if name == "plaintext" {
if helpers::has_element_in_button_scope(parser, "p") {
helpers::close_p_element(parser);
}
helpers::insert_element(parser, tag);
tokenizer.set_state(State::PLAINTEXT);
return Step::Done;
}
if name == "iframe" {
parser.frameset_ok = false;
tokenizer.set_appropriate_end_tag_name(Some(name));
tokenizer.set_state(State::RAWTEXT);
helpers::insert_element(parser, tag);
parser.original_insertion_mode = Some(parser.insertion_mode);
parser.insertion_mode = InsertionMode::Text;
return Step::Done;
}
if name == "xmp" {
if helpers::has_element_in_button_scope(parser, "p") {
helpers::close_p_element(parser);
}
helpers::reconstruct_active_formatting_elements(parser);
parser.frameset_ok = false;
tokenizer.set_appropriate_end_tag_name(Some(name));
tokenizer.set_state(State::RAWTEXT);
helpers::insert_element(parser, tag);
parser.original_insertion_mode = Some(parser.insertion_mode);
parser.insertion_mode = InsertionMode::Text;
return Step::Done;
}
if name == "noembed" {
tokenizer.set_appropriate_end_tag_name(Some(name));
tokenizer.set_state(State::RAWTEXT);
helpers::insert_element(parser, tag);
parser.original_insertion_mode = Some(parser.insertion_mode);
parser.insertion_mode = InsertionMode::Text;
return Step::Done;
}
if name == "button" {
if helpers::has_element_in_scope(parser, "button") {
parser.errors.push(ParseError::Generic("nested button"));
helpers::generate_implied_end_tags(parser, None);
while let Some(top) = parser.open_elements.last() {
let is_button = top
.borrow()
.kind
.as_element()
.map(|e| e.local_name.as_str())
== Some("button");
parser.open_elements.pop();
if is_button {
break;
}
}
return Step::Reprocess;
}
helpers::reconstruct_active_formatting_elements(parser);
helpers::insert_element(parser, tag);
parser.frameset_ok = false;
return Step::Done;
}
if name == "hr" {
if helpers::has_element_in_button_scope(parser, "p") {
helpers::close_p_element(parser);
}
if helpers::has_element_in_scope(parser, "select") {
helpers::generate_implied_end_tags(parser, None);
if helpers::has_element_in_scope(parser, "option")
|| helpers::has_element_in_scope(parser, "optgroup")
{
parser
.errors
.push(ParseError::Generic("hr when option/optgroup in scope"));
}
}
helpers::insert_element(parser, tag);
parser.open_elements.pop();
parser.frameset_ok = false;
return Step::Done;
}
if matches!(name, "rb" | "rtc") {
if helpers::has_element_in_scope(parser, "ruby") {
helpers::generate_implied_end_tags(parser, None);
let is_ruby = parser
.open_elements
.last()
.and_then(|n| n.borrow().kind.as_element().map(|e| e.local_name == "ruby"))
.unwrap_or(false);
if !is_ruby {
parser
.errors
.push(ParseError::Generic("rb/rtc not directly in ruby"));
}
}
helpers::insert_element(parser, tag);
return Step::Done;
}
if matches!(name, "rp" | "rt") {
if helpers::has_element_in_scope(parser, "ruby") {
helpers::generate_implied_end_tags(parser, Some("rtc"));
let is_rtc_or_ruby = parser
.open_elements
.last()
.and_then(|n| {
n.borrow()
.kind
.as_element()
.map(|e| matches!(e.local_name.as_str(), "rtc" | "ruby"))
})
.unwrap_or(false);
if !is_rtc_or_ruby {
parser
.errors
.push(ParseError::Generic("rp/rt not directly in rtc/ruby"));
}
}
helpers::insert_element(parser, tag);
return Step::Done;
}
if name == "input" {
if helpers::has_element_in_scope(parser, "select") {
parser.errors.push(ParseError::Generic(
"unexpected <input> when select in scope",
));
while let Some(top) = parser.open_elements.pop() {
let is_select = top
.borrow()
.kind
.as_element()
.map(|e| e.local_name == "select")
.unwrap_or(false);
if is_select {
break;
}
}
}
helpers::reconstruct_active_formatting_elements(parser);
helpers::insert_element(parser, tag);
parser.open_elements.pop();
let is_hidden = tag
.attrs
.iter()
.any(|(k, v)| k.eq_ignore_ascii_case("type") && v.eq_ignore_ascii_case("hidden"));
if !is_hidden {
parser.frameset_ok = false;
}
return Step::Done;
}
if VOID_ELEMENTS.contains(&name) {
helpers::reconstruct_active_formatting_elements(parser);
helpers::insert_element(parser, tag);
parser.open_elements.pop();
if matches!(name, "area" | "br" | "embed" | "img" | "keygen" | "wbr") {
parser.frameset_ok = false;
}
return Step::Done;
}
if matches!(
name,
"a" | "b"
| "big"
| "code"
| "em"
| "font"
| "i"
| "nobr"
| "s"
| "small"
| "strike"
| "strong"
| "tt"
| "u"
) {
if name == "a" {
let a_element = parser
.active_formatting_elements
.iter()
.rev()
.take_while(|e| !matches!(e, ActiveFormattingEntry::Marker))
.find_map(|e| match e {
ActiveFormattingEntry::Element(el) => {
let is_a = el
.borrow()
.kind
.as_element()
.map(|e| e.local_name.as_str() == "a")
.unwrap_or(false);
if is_a {
Some(el.clone())
} else {
None
}
}
_ => None,
});
if let Some(a_el) = a_element {
helpers::adoption_agency(parser, "a");
parser.active_formatting_elements.retain(
|e| !matches!(e, ActiveFormattingEntry::Element(el) if Rc::ptr_eq(el, &a_el)),
);
parser.open_elements.retain(|n| !Rc::ptr_eq(n, &a_el));
}
}
if name == "nobr" && helpers::has_element_in_scope(parser, "nobr") {
parser
.errors
.push(ParseError::Generic("nested nobr element"));
helpers::adoption_agency(parser, "nobr");
}
helpers::reconstruct_active_formatting_elements(parser);
let element = helpers::create_element_for_token(parser, tag);
helpers::insert_node(parser, &element);
helpers::push_open_element(parser, element.clone());
helpers::push_formatting_element(parser, element);
return Step::Done;
}
if matches!(name, "applet" | "marquee" | "object") {
helpers::reconstruct_active_formatting_elements(parser);
helpers::insert_element(parser, tag);
helpers::add_formatting_marker(parser);
parser.frameset_ok = false;
return Step::Done;
}
if name == "table" {
if !parser.quirks_mode && helpers::has_element_in_button_scope(parser, "p") {
helpers::close_p_element(parser);
}
helpers::insert_element(parser, tag);
parser.insertion_mode = InsertionMode::InTable;
parser.frameset_ok = false;
return Step::Done;
}
if name == "select" {
if helpers::has_element_in_scope(parser, "select") {
parser.errors.push(ParseError::Generic(
"unexpected <select> when select in scope",
));
loop {
let popped = helpers::pop_open_element(parser);
match popped {
Some(top) => {
let is_select = top
.borrow()
.kind
.as_element()
.map(|e| e.local_name == "select")
.unwrap_or(false);
if is_select {
break;
}
}
None => break,
}
}
return Step::Done;
}
helpers::reconstruct_active_formatting_elements(parser);
helpers::insert_element(parser, tag);
helpers::add_formatting_marker(parser);
parser.frameset_ok = false;
return Step::Done;
}
if name == "option" {
if helpers::has_element_in_scope(parser, "select") {
helpers::generate_implied_end_tags(parser, Some("optgroup"));
if helpers::has_element_in_scope(parser, "option") {
parser
.errors
.push(ParseError::Generic("option when option in scope"));
}
} else {
if let Some(top) = parser.open_elements.last() {
let is_option = top
.borrow()
.kind
.as_element()
.map(|e| e.local_name == "option")
.unwrap_or(false);
if is_option {
helpers::pop_open_element(parser);
}
}
}
helpers::reconstruct_active_formatting_elements(parser);
helpers::insert_element(parser, tag);
return Step::Done;
}
if name == "optgroup" {
if helpers::has_element_in_scope(parser, "select") {
helpers::generate_implied_end_tags(parser, None);
if helpers::has_element_in_scope(parser, "option")
|| helpers::has_element_in_scope(parser, "optgroup")
{
parser.errors.push(ParseError::Generic(
"optgroup when option/optgroup in scope",
));
}
} else {
if let Some(top) = parser.open_elements.last() {
let is_option = top
.borrow()
.kind
.as_element()
.map(|e| e.local_name == "option")
.unwrap_or(false);
if is_option {
helpers::pop_open_element(parser);
}
}
}
helpers::reconstruct_active_formatting_elements(parser);
helpers::insert_element(parser, tag);
return Step::Done;
}
if name == "frameset" {
if !parser.frameset_ok {
parser
.errors
.push(ParseError::Generic("frameset after non-frameset-ok token"));
return Step::Done;
}
if parser.open_elements.len() < 2 {
parser
.errors
.push(ParseError::Generic("frameset without body"));
return Step::Done;
}
let second_is_body = parser
.open_elements
.get(1)
.and_then(|n| n.borrow().kind.as_element().map(|e| e.local_name == "body"))
.unwrap_or(false);
if !second_is_body {
parser
.errors
.push(ParseError::Generic("frameset with non-body current node"));
return Step::Done;
}
let body = parser.open_elements.remove(1);
if let Some(parent) = parser.open_elements.first() {
let body_ptr = Rc::as_ptr(&body);
muskitty_dom::retain_children(parent, |c| Rc::as_ptr(c) != body_ptr);
}
helpers::insert_element(parser, tag);
parser.insertion_mode = InsertionMode::InFrameset;
return Step::Done;
}
if name == "math" {
helpers::reconstruct_active_formatting_elements(parser);
let mut adjusted = tag.clone();
super::foreign::adjust_mathml_attributes(&mut adjusted);
super::foreign::adjust_foreign_attributes(&mut adjusted);
super::foreign::insert_foreign_element(
parser,
&adjusted,
muskitty_dom::Namespace::MathMl,
false,
);
if tag.self_closing {
parser.open_elements.pop();
}
return Step::Done;
}
if name == "svg" {
helpers::reconstruct_active_formatting_elements(parser);
let mut adjusted = tag.clone();
super::foreign::adjust_svg_attributes(&mut adjusted);
super::foreign::adjust_foreign_attributes(&mut adjusted);
super::foreign::insert_foreign_element(
parser,
&adjusted,
muskitty_dom::Namespace::Svg,
false,
);
if tag.self_closing {
parser.open_elements.pop();
}
return Step::Done;
}
helpers::reconstruct_active_formatting_elements(parser);
helpers::insert_element(parser, tag);
Step::Done
}
fn handle_in_body_end_tag(
parser: &mut HtmlTreeConstructor,
tag: &muskitty_html5_tokenizer::TagToken,
) -> Step {
let name = tag.name.as_str();
if name == "template" {
if !helpers::has_element_in_stack(parser, "template") {
parser.errors.push(ParseError::Generic(
"end template without template in stack",
));
return Step::Done;
}
helpers::generate_implied_end_tags(parser, None);
while let Some(top) = parser.open_elements.pop() {
let is_html_template = top
.borrow()
.kind
.as_element()
.map(|e| e.local_name == "template" && e.namespace == muskitty_dom::Namespace::Html)
.unwrap_or(false);
if is_html_template {
break;
}
}
helpers::clear_active_formatting_to_last_marker(parser);
parser.template_insertion_modes.pop();
reset_insertion_mode(parser);
return Step::Done;
}
if name == "p" {
if !helpers::has_element_in_button_scope(parser, "p") {
parser
.errors
.push(ParseError::Generic("end tag p without open p"));
let p = muskitty_dom::Node::new_element_html("p", vec![], &parser.document);
helpers::insert_node(parser, &p);
helpers::push_open_element(parser, p);
}
helpers::close_p_element(parser);
return Step::Done;
}
if matches!(name, "applet" | "marquee" | "object") {
if !helpers::has_element_in_scope(parser, name) {
parser
.errors
.push(ParseError::UnexpectedEndTag(name.to_string()));
return Step::Done;
}
helpers::generate_implied_end_tags(parser, None);
let current_is_target = parser
.open_elements
.last()
.map(|n| {
n.borrow()
.kind
.as_element()
.map(|e| e.namespace == muskitty_dom::Namespace::Html && e.local_name == name)
.unwrap_or(false)
})
.unwrap_or(false);
if !current_is_target {
parser
.errors
.push(ParseError::Generic("end tag not at current node"));
}
while let Some(top) = parser.open_elements.pop() {
let is_target = top
.borrow()
.kind
.as_element()
.map(|e| e.namespace == muskitty_dom::Namespace::Html && e.local_name == name)
.unwrap_or(false);
if is_target {
break;
}
}
helpers::clear_active_formatting_to_last_marker(parser);
return Step::Done;
}
if name == "body" {
if !helpers::has_element_in_scope(parser, "body") {
parser
.errors
.push(ParseError::Generic("end tag body without body in scope"));
return Step::Done;
}
parser.insertion_mode = InsertionMode::AfterBody;
return Step::Done;
}
if name == "html" {
if !helpers::has_element_in_scope(parser, "body") {
parser
.errors
.push(ParseError::Generic("end tag html without body in scope"));
return Step::Done;
}
parser.insertion_mode = InsertionMode::AfterBody;
return Step::Reprocess;
}
if BLOCK_LEVEL_END_TAGS.contains(&name) {
if !helpers::has_element_in_scope(parser, name) {
parser
.errors
.push(ParseError::UnexpectedEndTag(name.to_string()));
return Step::Done;
}
helpers::generate_implied_end_tags(parser, Some(name));
while let Some(top) = parser.open_elements.last() {
let top_name = top.borrow().kind.as_element().map(|e| e.local_name.clone());
let is_target = top_name.as_deref() == Some(name);
helpers::pop_open_element(parser);
if is_target {
break;
}
}
return Step::Done;
}
if name == "form" {
let has_template = helpers::has_element_in_stack(parser, "template");
if !has_template {
let node = parser.form_element.clone();
parser.form_element = None;
let node = match node {
Some(n) => n,
None => {
parser
.errors
.push(ParseError::Generic("end tag form without open form"));
return Step::Done;
}
};
let node_ptr = Rc::as_ptr(&node);
let in_scope = parser.open_elements.iter().any(|n| {
Rc::as_ptr(n) == node_ptr
&& n.borrow()
.kind
.as_element()
.map(|e| e.local_name == "form")
.unwrap_or(false)
});
let on_stack = parser
.open_elements
.iter()
.any(|n| Rc::as_ptr(n) == node_ptr);
if !on_stack {
parser
.errors
.push(ParseError::Generic("end tag form without form in scope"));
return Step::Done;
}
let _ = in_scope;
helpers::generate_implied_end_tags(parser, None);
let current_is_node = parser
.open_elements
.last()
.map(|n| Rc::as_ptr(n) == node_ptr)
.unwrap_or(false);
if !current_is_node {
parser
.errors
.push(ParseError::Generic("end tag form not at current node"));
}
parser.open_elements.retain(|n| Rc::as_ptr(n) != node_ptr);
return Step::Done;
}
if !helpers::has_element_in_scope(parser, "form") {
parser
.errors
.push(ParseError::Generic("end tag form without form in scope"));
return Step::Done;
}
helpers::generate_implied_end_tags(parser, None);
let current_is_form = parser
.open_elements
.last()
.and_then(|n| n.borrow().kind.as_element().map(|e| e.local_name == "form"))
.unwrap_or(false);
if !current_is_form {
parser
.errors
.push(ParseError::Generic("end tag form not at current node"));
}
while let Some(top) = parser.open_elements.last() {
let is_form = top
.borrow()
.kind
.as_element()
.map(|e| e.local_name.as_str())
== Some("form");
parser.open_elements.pop();
if is_form {
break;
}
}
return Step::Done;
}
if matches!(name, "li") {
if !helpers::has_element_in_list_scope(parser, "li") {
parser
.errors
.push(ParseError::UnexpectedEndTag(name.to_string()));
return Step::Done;
}
helpers::generate_implied_end_tags(parser, Some("li"));
while let Some(top) = parser.open_elements.last() {
let is_target = top
.borrow()
.kind
.as_element()
.map(|e| e.local_name.as_str())
== Some("li");
parser.open_elements.pop();
if is_target {
break;
}
}
return Step::Done;
}
if matches!(name, "dd" | "dt") {
if !helpers::has_element_in_scope(parser, name) {
parser
.errors
.push(ParseError::UnexpectedEndTag(name.to_string()));
return Step::Done;
}
helpers::generate_implied_end_tags(parser, Some(name));
while let Some(top) = parser.open_elements.last() {
let top_name = top.borrow().kind.as_element().map(|e| e.local_name.clone());
let is_target = top_name.as_deref() == Some(name);
parser.open_elements.pop();
if is_target {
break;
}
}
return Step::Done;
}
if matches!(name, "h1" | "h2" | "h3" | "h4" | "h5" | "h6") {
let heading_in_scope = ["h1", "h2", "h3", "h4", "h5", "h6"]
.iter()
.any(|h| helpers::has_element_in_scope(parser, h));
if !heading_in_scope {
parser
.errors
.push(ParseError::UnexpectedEndTag(name.to_string()));
return Step::Done;
}
helpers::generate_implied_end_tags(parser, None);
while let Some(top) = parser.open_elements.last() {
let top_name = top.borrow().kind.as_element().map(|e| e.local_name.clone());
let is_heading = matches!(
top_name.as_deref(),
Some("h1" | "h2" | "h3" | "h4" | "h5" | "h6")
);
parser.open_elements.pop();
if is_heading {
break;
}
}
return Step::Done;
}
if matches!(
name,
"a" | "b"
| "big"
| "code"
| "em"
| "font"
| "i"
| "nobr"
| "s"
| "small"
| "strike"
| "strong"
| "tt"
| "u"
) {
helpers::adoption_agency(parser, name);
return Step::Done;
}
for (i, node) in parser.open_elements.iter().enumerate().rev() {
let node_name = node
.borrow()
.kind
.as_element()
.map(|e| e.local_name.clone());
if node_name.as_deref() == Some(name) {
helpers::generate_implied_end_tags(parser, Some(name));
while parser.open_elements.len() > i {
helpers::pop_open_element(parser);
}
return Step::Done;
}
if let Some(n) = node_name.as_deref() {
if helpers::SPECIAL_ELEMENTS.contains(&n) {
parser
.errors
.push(ParseError::UnexpectedEndTag(name.to_string()));
return Step::Done;
}
}
}
parser
.errors
.push(ParseError::UnexpectedEndTag(name.to_string()));
Step::Done
}
fn merge_attributes(
element: &Rc<RefCell<muskitty_dom::Node>>,
tag: &muskitty_html5_tokenizer::TagToken,
) {
let mut e = element.borrow_mut();
if let NodeKind::Element(ref mut data) = e.kind {
for (name, value) in &tag.attrs {
let exists = data
.attributes
.iter()
.any(|a| a.local_name.eq_ignore_ascii_case(name));
if !exists {
data.attributes.push(Attribute::new(name, value));
}
}
}
}
fn handle_after_body(
parser: &mut HtmlTreeConstructor,
token: &Token,
tokenizer: &mut dyn Tokenizer,
) -> Step {
match token {
Token::Character(c) if is_whitespace(*c) => {
handle_in_body(parser, token, tokenizer)
}
Token::Comment(data) => {
let html = parser
.open_elements
.first()
.cloned()
.unwrap_or_else(|| parser.document.clone());
helpers::insert_comment_at(&html, data, &parser.document);
Step::Done
}
Token::ProcessingInstruction { target, data } => {
let html = parser
.open_elements
.first()
.cloned()
.unwrap_or_else(|| parser.document.clone());
helpers::insert_processing_instruction_at(&html, target, data, &parser.document);
Step::Done
}
Token::Doctype(_) => {
parser
.errors
.push(ParseError::Generic("unexpected DOCTYPE after body"));
Step::Done
}
Token::Tag(tag) if tag.kind == TagKind::Start && tag.name == "html" => {
handle_in_body(parser, token, tokenizer)
}
Token::Tag(tag) if tag.kind == TagKind::End && tag.name == "body" => {
if !helpers::has_element_in_scope(parser, "body") {
parser
.errors
.push(ParseError::Generic("end tag body without body in scope"));
return Step::Done;
}
parser.insertion_mode = InsertionMode::AfterAfterBody;
Step::Done
}
Token::Tag(tag) if tag.kind == TagKind::End && tag.name == "html" => {
if !helpers::has_element_in_scope(parser, "body") {
parser
.errors
.push(ParseError::Generic("end tag html without body in scope"));
return Step::Done;
}
if parser.fragment_context.is_some() {
parser.errors.push(ParseError::Generic(
"unexpected end tag html after body in fragment",
));
return Step::Done;
}
parser.insertion_mode = InsertionMode::AfterAfterBody;
Step::Done
}
Token::EOF => Step::Done,
_ => {
parser
.errors
.push(ParseError::Generic("unexpected token after body"));
parser.insertion_mode = InsertionMode::InBody;
Step::Reprocess
}
}
}
fn handle_after_after_body(
parser: &mut HtmlTreeConstructor,
token: &Token,
tokenizer: &mut dyn Tokenizer,
) -> Step {
match token {
Token::Comment(data) => {
helpers::insert_comment_at(&parser.document, data, &parser.document);
Step::Done
}
Token::ProcessingInstruction { target, data } => {
helpers::insert_processing_instruction_at(
&parser.document,
target,
data,
&parser.document,
);
Step::Done
}
Token::Doctype(_) => {
handle_in_body(parser, token, tokenizer)
}
Token::Character(c) if is_whitespace(*c) => {
handle_in_body(parser, token, tokenizer)
}
Token::EOF => Step::Done,
_ => {
parser
.errors
.push(ParseError::Generic("unexpected token after after body"));
parser.insertion_mode = InsertionMode::InBody;
Step::Reprocess
}
}
}
fn clear_stack_to_table_context(parser: &mut HtmlTreeConstructor) {
const TABLE_CONTEXT: &[&str] = &["table", "template", "html"];
while let Some(top) = parser.open_elements.last() {
let is_ctx = top
.borrow()
.kind
.as_element()
.map(|e| TABLE_CONTEXT.contains(&e.local_name.as_str()))
.unwrap_or(false);
if is_ctx {
break;
}
parser.open_elements.pop();
}
}
fn clear_stack_to_table_body_context(parser: &mut HtmlTreeConstructor) {
const BODY_CONTEXT: &[&str] = &["tbody", "tfoot", "thead", "html", "template"];
while let Some(top) = parser.open_elements.last() {
let is_ctx = top
.borrow()
.kind
.as_element()
.map(|e| BODY_CONTEXT.contains(&e.local_name.as_str()))
.unwrap_or(false);
if is_ctx {
break;
}
parser.open_elements.pop();
}
}
fn clear_stack_to_row_context(parser: &mut HtmlTreeConstructor) {
const ROW_CONTEXT: &[&str] = &["tr", "html", "template"];
while let Some(top) = parser.open_elements.last() {
let is_ctx = top
.borrow()
.kind
.as_element()
.map(|e| ROW_CONTEXT.contains(&e.local_name.as_str()))
.unwrap_or(false);
if is_ctx {
break;
}
parser.open_elements.pop();
}
}
fn handle_in_table(
parser: &mut HtmlTreeConstructor,
token: &Token,
tokenizer: &mut dyn Tokenizer,
) -> Step {
match token {
Token::Character(c) => {
let current_is_table_context = parser
.open_elements
.last()
.and_then(|n| {
n.borrow().kind.as_element().map(|e| {
matches!(
e.local_name.as_str(),
"table" | "tbody" | "template" | "tfoot" | "thead" | "tr"
)
})
})
.unwrap_or(false);
if current_is_table_context {
parser.pending_table_text.push(*c);
let prev_mode = parser.insertion_mode;
parser.insertion_mode = InsertionMode::InTableText;
parser.original_insertion_mode = Some(prev_mode);
Step::Done
} else {
parser.foster_parenting = true;
let step = handle_in_body(parser, token, tokenizer);
parser.foster_parenting = false;
step
}
}
Token::Comment(data) => {
helpers::insert_comment(parser, data);
Step::Done
}
Token::ProcessingInstruction { target, data } => {
helpers::insert_processing_instruction(parser, target, data);
Step::Done
}
Token::Doctype(_) => {
parser
.errors
.push(ParseError::Generic("unexpected DOCTYPE in table"));
Step::Done
}
Token::Tag(tag) if tag.kind == TagKind::Start => {
let name = tag.name.as_str();
match name {
"caption" => {
clear_stack_to_table_context(parser);
helpers::add_formatting_marker(parser);
helpers::insert_element(parser, tag);
parser.insertion_mode = InsertionMode::InCaption;
Step::Done
}
"colgroup" => {
clear_stack_to_table_context(parser);
helpers::insert_element(parser, tag);
parser.insertion_mode = InsertionMode::InColumnGroup;
Step::Done
}
"col" => {
clear_stack_to_table_context(parser);
create_and_push(parser, "colgroup");
parser.insertion_mode = InsertionMode::InColumnGroup;
Step::Reprocess
}
"tbody" | "tfoot" | "thead" => {
clear_stack_to_table_context(parser);
helpers::insert_element(parser, tag);
parser.insertion_mode = InsertionMode::InTableBody;
Step::Done
}
"td" | "th" | "tr" => {
clear_stack_to_table_context(parser);
create_and_push(parser, "tbody");
parser.insertion_mode = InsertionMode::InTableBody;
Step::Reprocess
}
"style" | "script" | "template" => {
handle_in_head(parser, token, tokenizer)
}
"input" => {
let is_hidden = tag.attrs.iter().any(|(k, v)| {
k.eq_ignore_ascii_case("type") && v.eq_ignore_ascii_case("hidden")
});
if is_hidden {
parser
.errors
.push(ParseError::Generic("hidden input in table"));
helpers::insert_element(parser, tag);
parser.open_elements.pop();
Step::Done
} else {
foster_parent_in_body(parser, token, tokenizer)
}
}
"table" => {
parser
.errors
.push(ParseError::Generic("unexpected table start tag in table"));
if helpers::has_element_in_table_scope(parser, "table") {
while let Some(top) = parser.open_elements.pop() {
let is_table = top
.borrow()
.kind
.as_element()
.map(|e| e.local_name == "table")
.unwrap_or(false);
if is_table {
break;
}
}
reset_insertion_mode(parser);
Step::Reprocess
} else {
Step::Done
}
}
"form" => {
parser
.errors
.push(ParseError::Generic("unexpected form start tag in table"));
let has_template = helpers::has_element_in_stack(parser, "template");
if has_template || parser.form_element.is_some() {
Step::Done
} else {
let element = helpers::create_element_for_token(parser, tag);
helpers::insert_node(parser, &element);
helpers::push_open_element(parser, element.clone());
parser.form_element = Some(element);
parser.open_elements.pop();
Step::Done
}
}
_ => foster_parent_in_body(parser, token, tokenizer),
}
}
Token::Tag(tag) if tag.kind == TagKind::End => match tag.name.as_str() {
"table" => {
if !helpers::has_element_in_table_scope(parser, "table") {
parser.errors.push(ParseError::Generic(
"end table without table in table scope",
));
return Step::Done;
}
while let Some(top) = parser.open_elements.pop() {
let is_table = top
.borrow()
.kind
.as_element()
.map(|e| e.local_name == "table")
.unwrap_or(false);
if is_table {
break;
}
}
reset_insertion_mode(parser);
Step::Done
}
"body" | "caption" | "col" | "colgroup" | "html" | "tbody" | "td" | "tfoot" | "th"
| "thead" | "tr" => {
parser
.errors
.push(ParseError::Generic("unexpected end tag in table"));
Step::Done
}
"template" => handle_in_head(parser, token, tokenizer),
_ => foster_parent_in_body(parser, token, tokenizer),
},
Token::EOF => {
parser.insertion_mode = InsertionMode::InBody;
Step::Reprocess
}
_ => foster_parent_in_body(parser, token, tokenizer),
}
}
fn foster_parent_in_body(
parser: &mut HtmlTreeConstructor,
token: &Token,
tokenizer: &mut dyn Tokenizer,
) -> Step {
parser
.errors
.push(ParseError::Generic("foster parenting in table"));
parser.foster_parenting = true;
let step = handle_in_body(parser, token, tokenizer);
parser.foster_parenting = false;
step
}
fn handle_in_table_text(
parser: &mut HtmlTreeConstructor,
token: &Token,
tokenizer: &mut dyn Tokenizer,
) -> Step {
match token {
Token::Character('\0') => {
parser
.errors
.push(ParseError::Generic("unexpected null in table text"));
Step::Done
}
Token::Character(c) => {
parser.pending_table_text.push(*c);
Step::Done
}
_ => {
let pending = std::mem::take(&mut parser.pending_table_text);
let has_non_ws = pending.chars().any(|c| !is_whitespace(c));
if has_non_ws {
parser.foster_parenting = true;
for c in pending.chars() {
handle_in_body(parser, &Token::Character(c), tokenizer);
}
parser.foster_parenting = false;
} else {
for c in pending.chars() {
helpers::insert_character(parser, c);
}
}
parser.insertion_mode = parser
.original_insertion_mode
.take()
.unwrap_or(InsertionMode::InTable);
Step::Reprocess
}
}
}
fn handle_in_caption(
parser: &mut HtmlTreeConstructor,
token: &Token,
tokenizer: &mut dyn Tokenizer,
) -> Step {
match token {
Token::Tag(tag) if tag.kind == TagKind::End && tag.name == "caption" => {
if !helpers::has_element_in_scope(parser, "caption") {
parser
.errors
.push(ParseError::Generic("end caption without caption in scope"));
return Step::Done;
}
helpers::generate_implied_end_tags(parser, None);
while let Some(top) = parser.open_elements.pop() {
let is_caption = top
.borrow()
.kind
.as_element()
.map(|e| e.local_name == "caption")
.unwrap_or(false);
if is_caption {
break;
}
}
helpers::clear_active_formatting_to_last_marker(parser);
parser.insertion_mode = InsertionMode::InTable;
Step::Done
}
Token::Tag(tag)
if tag.kind == TagKind::Start
&& matches!(
tag.name.as_str(),
"caption"
| "col"
| "colgroup"
| "tbody"
| "td"
| "tfoot"
| "th"
| "thead"
| "tr"
) =>
{
parser
.errors
.push(ParseError::Generic("unexpected table start tag in caption"));
close_caption(parser);
Step::Reprocess
}
Token::Tag(tag)
if tag.kind == TagKind::End
&& matches!(
tag.name.as_str(),
"table" | "tbody" | "tfoot" | "thead" | "tr" | "td" | "th"
) =>
{
parser
.errors
.push(ParseError::Generic("unexpected table end tag in caption"));
close_caption(parser);
Step::Reprocess
}
_ => {
handle_in_body(parser, token, tokenizer)
}
}
}
fn close_caption(parser: &mut HtmlTreeConstructor) {
if helpers::has_element_in_scope(parser, "caption") {
helpers::generate_implied_end_tags(parser, None);
while let Some(top) = parser.open_elements.pop() {
let is_caption = top
.borrow()
.kind
.as_element()
.map(|e| e.local_name == "caption")
.unwrap_or(false);
if is_caption {
break;
}
}
helpers::clear_active_formatting_to_last_marker(parser);
parser.insertion_mode = InsertionMode::InTable;
}
}
fn handle_in_column_group(
parser: &mut HtmlTreeConstructor,
token: &Token,
tokenizer: &mut dyn Tokenizer,
) -> Step {
match token {
Token::Character(c) if is_whitespace(*c) => {
helpers::insert_character(parser, *c);
Step::Done
}
Token::Comment(data) => {
helpers::insert_comment(parser, data);
Step::Done
}
Token::ProcessingInstruction { target, data } => {
helpers::insert_processing_instruction(parser, target, data);
Step::Done
}
Token::Doctype(_) => {
parser
.errors
.push(ParseError::Generic("unexpected DOCTYPE in colgroup"));
Step::Done
}
Token::Tag(tag) if tag.kind == TagKind::Start => match tag.name.as_str() {
"html" => handle_in_body(parser, token, tokenizer),
"col" => {
helpers::insert_element(parser, tag);
parser.open_elements.pop();
Step::Done
}
"template" => handle_in_head(parser, token, tokenizer),
_ => close_colgroup_and_reprocess(parser),
},
Token::Tag(tag) if tag.kind == TagKind::End => match tag.name.as_str() {
"colgroup" => {
if !helpers::has_element_in_scope(parser, "colgroup") {
parser.errors.push(ParseError::Generic(
"end colgroup without colgroup in scope",
));
return Step::Done;
}
parser.open_elements.pop();
parser.insertion_mode = InsertionMode::InTable;
Step::Done
}
"col" => {
parser.errors.push(ParseError::Generic("end col; ignored"));
Step::Done
}
"template" => handle_in_head(parser, token, tokenizer),
_ => close_colgroup_and_reprocess(parser),
},
Token::EOF => handle_in_body(parser, token, tokenizer),
_ => close_colgroup_and_reprocess(parser),
}
}
fn close_colgroup_and_reprocess(parser: &mut HtmlTreeConstructor) -> Step {
if helpers::has_element_in_scope(parser, "colgroup") {
parser.open_elements.pop();
parser.insertion_mode = InsertionMode::InTable;
Step::Reprocess
} else {
parser.errors.push(ParseError::Generic(
"unexpected token; no colgroup in scope",
));
Step::Done
}
}
fn handle_in_table_body(
parser: &mut HtmlTreeConstructor,
token: &Token,
tokenizer: &mut dyn Tokenizer,
) -> Step {
match token {
Token::Tag(tag) if tag.kind == TagKind::Start && tag.name == "tr" => {
clear_stack_to_table_body_context(parser);
helpers::insert_element(parser, tag);
parser.insertion_mode = InsertionMode::InRow;
Step::Done
}
Token::Tag(tag)
if tag.kind == TagKind::Start && matches!(tag.name.as_str(), "td" | "th") =>
{
clear_stack_to_table_body_context(parser);
create_and_push(parser, "tr");
parser.insertion_mode = InsertionMode::InRow;
Step::Reprocess
}
Token::Tag(tag)
if tag.kind == TagKind::End
&& matches!(tag.name.as_str(), "tbody" | "tfoot" | "thead") =>
{
let name = tag.name.clone();
if !helpers::has_element_in_table_scope(parser, &name) {
parser.errors.push(ParseError::Generic(
"end tag without element in table scope",
));
return Step::Done;
}
clear_stack_to_table_body_context(parser);
parser.open_elements.pop();
parser.insertion_mode = InsertionMode::InTable;
Step::Done
}
Token::Tag(tag)
if (tag.kind == TagKind::Start
&& matches!(
tag.name.as_str(),
"caption" | "col" | "colgroup" | "tbody" | "tfoot" | "thead"
))
|| (tag.kind == TagKind::End
&& matches!(tag.name.as_str(), "table" | "tbody" | "tfoot" | "thead")) =>
{
if !helpers::has_element_in_table_scope(parser, "tbody")
&& !helpers::has_element_in_table_scope(parser, "tfoot")
&& !helpers::has_element_in_table_scope(parser, "thead")
{
parser.errors.push(ParseError::Generic(
"unexpected token; no table body in scope",
));
return Step::Done;
}
clear_stack_to_table_body_context(parser);
parser.open_elements.pop();
parser.insertion_mode = InsertionMode::InTable;
Step::Reprocess
}
_ => {
handle_in_table(parser, token, tokenizer)
}
}
}
fn handle_in_row(
parser: &mut HtmlTreeConstructor,
token: &Token,
tokenizer: &mut dyn Tokenizer,
) -> Step {
match token {
Token::Tag(tag)
if tag.kind == TagKind::Start && matches!(tag.name.as_str(), "td" | "th") =>
{
clear_stack_to_row_context(parser);
helpers::insert_element(parser, tag);
parser.insertion_mode = InsertionMode::InCell;
helpers::add_formatting_marker(parser);
Step::Done
}
Token::Tag(tag) if tag.kind == TagKind::End && tag.name == "tr" => {
if !helpers::has_element_in_table_scope(parser, "tr") {
parser
.errors
.push(ParseError::Generic("end tr without tr in table scope"));
return Step::Done;
}
clear_stack_to_row_context(parser);
parser.open_elements.pop();
parser.insertion_mode = InsertionMode::InTableBody;
Step::Done
}
Token::Tag(tag)
if (tag.kind == TagKind::Start
&& matches!(
tag.name.as_str(),
"caption" | "col" | "colgroup" | "tbody" | "tfoot" | "thead" | "tr"
))
|| (tag.kind == TagKind::End
&& matches!(tag.name.as_str(), "table" | "tbody" | "tfoot" | "thead")) =>
{
if !helpers::has_element_in_table_scope(parser, "tr") {
parser.errors.push(ParseError::Generic(
"unexpected token; no tr in table scope",
));
return Step::Done;
}
clear_stack_to_row_context(parser);
parser.open_elements.pop();
parser.insertion_mode = InsertionMode::InTableBody;
Step::Reprocess
}
_ => {
handle_in_table(parser, token, tokenizer)
}
}
}
fn close_cell_and_switch_to_in_row(parser: &mut HtmlTreeConstructor) {
helpers::generate_implied_end_tags(parser, None);
while let Some(top) = parser.open_elements.pop() {
let is_cell = top
.borrow()
.kind
.as_element()
.map(|e| matches!(e.local_name.as_str(), "td" | "th"))
.unwrap_or(false);
if is_cell {
break;
}
}
helpers::clear_active_formatting_to_last_marker(parser);
parser.insertion_mode = InsertionMode::InRow;
}
fn handle_in_cell(
parser: &mut HtmlTreeConstructor,
token: &Token,
tokenizer: &mut dyn Tokenizer,
) -> Step {
match token {
Token::Tag(tag) if tag.kind == TagKind::End && matches!(tag.name.as_str(), "td" | "th") => {
let name = tag.name.clone();
if !helpers::has_element_in_table_scope(parser, &name) {
parser
.errors
.push(ParseError::Generic("end cell without cell in table scope"));
return Step::Done;
}
helpers::generate_implied_end_tags(parser, None);
while let Some(top) = parser.open_elements.pop() {
let is_target = top
.borrow()
.kind
.as_element()
.map(|e| e.namespace == muskitty_dom::Namespace::Html && e.local_name == name)
.unwrap_or(false);
if is_target {
break;
}
}
helpers::clear_active_formatting_to_last_marker(parser);
parser.insertion_mode = InsertionMode::InRow;
Step::Done
}
Token::Tag(tag)
if tag.kind == TagKind::Start
&& matches!(
tag.name.as_str(),
"caption"
| "col"
| "colgroup"
| "tbody"
| "td"
| "tfoot"
| "th"
| "thead"
| "tr"
) =>
{
let _ = tag;
close_cell_and_switch_to_in_row(parser);
Step::Reprocess
}
Token::Tag(tag)
if tag.kind == TagKind::End
&& matches!(
tag.name.as_str(),
"table" | "tbody" | "tfoot" | "thead" | "tr"
) =>
{
let name = tag.name.clone();
if !helpers::has_element_in_table_scope(parser, &name) {
parser
.errors
.push(ParseError::Generic("end tag not in table scope in cell"));
Step::Done
} else {
close_cell_and_switch_to_in_row(parser);
Step::Reprocess
}
}
_ => {
handle_in_body(parser, token, tokenizer)
}
}
}
fn handle_in_head_noscript(
parser: &mut HtmlTreeConstructor,
token: &Token,
tokenizer: &mut dyn Tokenizer,
) -> Step {
match token {
Token::Doctype(_) => {
parser
.errors
.push(ParseError::Generic("unexpected DOCTYPE in noscript"));
Step::Done
}
Token::Tag(tag) if tag.kind == TagKind::Start && tag.name == "html" => {
handle_in_body(parser, token, tokenizer)
}
Token::Tag(tag) if tag.kind == TagKind::End && tag.name == "noscript" => {
parser.open_elements.pop();
parser.insertion_mode = InsertionMode::InHead;
Step::Done
}
Token::Character(c) if is_whitespace(*c) => handle_in_head(parser, token, tokenizer),
Token::Comment(data) => handle_in_head(parser, &Token::Comment(data.clone()), tokenizer),
Token::ProcessingInstruction { target, data } => handle_in_head(
parser,
&Token::ProcessingInstruction {
target: target.clone(),
data: data.clone(),
},
tokenizer,
),
Token::Tag(tag)
if tag.kind == TagKind::Start
&& matches!(
tag.name.as_str(),
"basefont" | "bgsound" | "link" | "meta" | "noframes" | "style"
) =>
{
handle_in_head(parser, token, tokenizer)
}
Token::Tag(tag)
if tag.kind == TagKind::Start && matches!(tag.name.as_str(), "head" | "noscript") =>
{
parser
.errors
.push(ParseError::Generic("unexpected head/noscript in noscript"));
Step::Done
}
Token::Tag(tag) if tag.kind == TagKind::End && tag.name == "br" => {
handle_anything_else_in_head_noscript(parser, token)
}
Token::Tag(tag) if tag.kind == TagKind::End => {
let _ = tag;
parser
.errors
.push(ParseError::Generic("unexpected end tag in noscript"));
Step::Done
}
Token::EOF => {
parser
.errors
.push(ParseError::Generic("unexpected EOF in noscript"));
parser.open_elements.pop();
parser.insertion_mode = InsertionMode::InHead;
Step::Reprocess
}
_ => handle_anything_else_in_head_noscript(parser, token),
}
}
fn handle_anything_else_in_head_noscript(parser: &mut HtmlTreeConstructor, _token: &Token) -> Step {
parser
.errors
.push(ParseError::Generic("unexpected token in noscript"));
parser.open_elements.pop();
parser.insertion_mode = InsertionMode::InHead;
Step::Reprocess
}
fn handle_in_template(
parser: &mut HtmlTreeConstructor,
token: &Token,
tokenizer: &mut dyn Tokenizer,
) -> Step {
match token {
Token::Character(_)
| Token::Comment(_)
| Token::ProcessingInstruction { .. }
| Token::Doctype(_) => handle_in_body(parser, token, tokenizer),
Token::Tag(tag)
if tag.kind == TagKind::Start
&& matches!(
tag.name.as_str(),
"base"
| "basefont"
| "bgsound"
| "link"
| "meta"
| "noframes"
| "script"
| "style"
| "template"
| "title"
) =>
{
handle_in_head(parser, token, tokenizer)
}
Token::Tag(tag) if tag.kind == TagKind::End && tag.name == "template" => {
let _ = tag;
handle_in_head(parser, token, tokenizer)
}
Token::Tag(tag)
if tag.kind == TagKind::Start
&& matches!(
tag.name.as_str(),
"caption" | "colgroup" | "tbody" | "tfoot" | "thead"
) =>
{
let _ = tag;
parser.template_insertion_modes.pop();
parser.template_insertion_modes.push(InsertionMode::InTable);
parser.insertion_mode = InsertionMode::InTable;
Step::Reprocess
}
Token::Tag(tag) if tag.kind == TagKind::Start && tag.name == "col" => {
let _ = tag;
parser.template_insertion_modes.pop();
parser
.template_insertion_modes
.push(InsertionMode::InColumnGroup);
parser.insertion_mode = InsertionMode::InColumnGroup;
Step::Reprocess
}
Token::Tag(tag) if tag.kind == TagKind::Start && tag.name == "tr" => {
let _ = tag;
parser.template_insertion_modes.pop();
parser
.template_insertion_modes
.push(InsertionMode::InTableBody);
parser.insertion_mode = InsertionMode::InTableBody;
Step::Reprocess
}
Token::Tag(tag)
if tag.kind == TagKind::Start && matches!(tag.name.as_str(), "td" | "th") =>
{
let _ = tag;
parser.template_insertion_modes.pop();
parser.template_insertion_modes.push(InsertionMode::InRow);
parser.insertion_mode = InsertionMode::InRow;
Step::Reprocess
}
Token::Tag(tag) if tag.kind == TagKind::Start => {
let _ = tag;
parser.template_insertion_modes.pop();
parser.template_insertion_modes.push(InsertionMode::InBody);
parser.insertion_mode = InsertionMode::InBody;
Step::Reprocess
}
Token::Tag(tag) if tag.kind == TagKind::End => {
parser
.errors
.push(ParseError::Generic("unexpected end tag in template"));
let _ = tag;
Step::Done
}
Token::EOF => {
if !template_in_stack(parser) {
Step::Done
} else {
parser
.errors
.push(ParseError::Generic("unexpected EOF in template"));
while let Some(top) = parser.open_elements.pop() {
let is_html_template = top
.borrow()
.kind
.as_element()
.map(|e| {
e.local_name == "template"
&& e.namespace == muskitty_dom::Namespace::Html
})
.unwrap_or(false);
if is_html_template {
break;
}
}
helpers::clear_active_formatting_to_last_marker(parser);
parser.template_insertion_modes.pop();
reset_insertion_mode(parser);
Step::Reprocess
}
}
_ => Step::Done,
}
}
fn template_in_stack(parser: &HtmlTreeConstructor) -> bool {
parser.open_elements.iter().any(|n| {
n.borrow()
.kind
.as_element()
.map(|e| e.local_name == "template" && e.namespace == muskitty_dom::Namespace::Html)
.unwrap_or(false)
})
}
fn handle_in_frameset(
parser: &mut HtmlTreeConstructor,
token: &Token,
tokenizer: &mut dyn Tokenizer,
) -> Step {
match token {
Token::Character(c) if is_whitespace(*c) => {
helpers::insert_character(parser, *c);
Step::Done
}
Token::Comment(data) => {
helpers::insert_comment(parser, data);
Step::Done
}
Token::ProcessingInstruction { target, data } => {
helpers::insert_processing_instruction(parser, target, data);
Step::Done
}
Token::Doctype(_) => {
parser
.errors
.push(ParseError::Generic("unexpected DOCTYPE in frameset"));
Step::Done
}
Token::Tag(tag) if tag.kind == TagKind::Start && tag.name == "html" => {
handle_in_body(parser, token, tokenizer)
}
Token::Tag(tag) if tag.kind == TagKind::Start && tag.name == "frameset" => {
helpers::insert_element(parser, tag);
Step::Done
}
Token::Tag(tag) if tag.kind == TagKind::End && tag.name == "frameset" => {
if parser.open_elements.len() == 1 {
parser
.errors
.push(ParseError::Generic("unexpected </frameset> at root"));
return Step::Done;
}
parser.open_elements.pop();
let is_frameset = parser
.open_elements
.last()
.and_then(|n| {
n.borrow()
.kind
.as_element()
.map(|e| e.local_name == "frameset")
})
.unwrap_or(false);
if !is_frameset {
parser.insertion_mode = InsertionMode::AfterFrameset;
}
Step::Done
}
Token::Tag(tag) if tag.kind == TagKind::Start && tag.name == "frame" => {
helpers::insert_element(parser, tag);
parser.open_elements.pop();
parser.frameset_ok = false;
Step::Done
}
Token::Tag(tag) if tag.kind == TagKind::Start && tag.name == "noframes" => {
handle_in_head(parser, token, tokenizer)
}
Token::EOF => {
if parser.open_elements.len() != 1 {
parser
.errors
.push(ParseError::Generic("unexpected EOF in frameset"));
}
Step::Done
}
_ => {
parser
.errors
.push(ParseError::Generic("unexpected token in frameset"));
Step::Done
}
}
}
fn handle_after_frameset(
parser: &mut HtmlTreeConstructor,
token: &Token,
tokenizer: &mut dyn Tokenizer,
) -> Step {
match token {
Token::Character(c) if is_whitespace(*c) => {
helpers::insert_character(parser, *c);
Step::Done
}
Token::Character('\0') => {
parser.errors.push(ParseError::Generic(
"unexpected null character after frameset",
));
helpers::insert_character(parser, '\u{FFFD}');
Step::Done
}
Token::Comment(data) => {
helpers::insert_comment(parser, data);
Step::Done
}
Token::ProcessingInstruction { target, data } => {
helpers::insert_processing_instruction(parser, target, data);
Step::Done
}
Token::Doctype(_) => {
parser
.errors
.push(ParseError::Generic("unexpected DOCTYPE after frameset"));
Step::Done
}
Token::Tag(tag) if tag.kind == TagKind::Start && tag.name == "html" => {
handle_in_body(parser, token, tokenizer)
}
Token::Tag(tag) if tag.kind == TagKind::End && tag.name == "html" => {
parser.insertion_mode = InsertionMode::AfterAfterFrameset;
Step::Done
}
Token::Tag(tag) if tag.kind == TagKind::Start && tag.name == "noframes" => {
handle_in_head(parser, token, tokenizer)
}
Token::EOF => Step::Done,
_ => {
parser
.errors
.push(ParseError::Generic("unexpected token after frameset"));
Step::Done
}
}
}
fn handle_after_after_frameset(
parser: &mut HtmlTreeConstructor,
token: &Token,
tokenizer: &mut dyn Tokenizer,
) -> Step {
match token {
Token::Comment(data) => {
helpers::insert_comment_at(&parser.document, data, &parser.document);
Step::Done
}
Token::ProcessingInstruction { target, data } => {
helpers::insert_processing_instruction_at(
&parser.document,
target,
data,
&parser.document,
);
Step::Done
}
Token::Doctype(_) | Token::Character(_) if matches!(token, Token::Character(c) if is_whitespace(*c)) => {
handle_in_body(parser, token, tokenizer)
}
Token::Tag(tag) if tag.kind == TagKind::Start && tag.name == "html" => {
handle_in_body(parser, token, tokenizer)
}
Token::EOF => Step::Done,
Token::Tag(tag) if tag.kind == TagKind::Start && tag.name == "noframes" => {
handle_in_head(parser, token, tokenizer)
}
_ => {
parser
.errors
.push(ParseError::Generic("unexpected token after after frameset"));
Step::Done
}
}
}
pub fn reset_insertion_mode(parser: &mut HtmlTreeConstructor) {
for (i, node) in parser.open_elements.iter().enumerate().rev() {
let is_last = i == 0;
let effective: Rc<RefCell<Node>> = if is_last {
match &parser.fragment_context {
Some(ctx) => ctx.clone(),
None => node.clone(),
}
} else {
node.clone()
};
let local = effective
.borrow()
.kind
.as_element()
.map(|e| e.local_name.clone());
let local = local.as_deref().unwrap_or("");
match local {
"td" | "th" if !is_last => {
parser.insertion_mode = InsertionMode::InCell;
return;
}
"tr" => {
parser.insertion_mode = InsertionMode::InRow;
return;
}
"tbody" | "thead" | "tfoot" => {
parser.insertion_mode = InsertionMode::InTableBody;
return;
}
"caption" => {
parser.insertion_mode = InsertionMode::InCaption;
return;
}
"colgroup" => {
parser.insertion_mode = InsertionMode::InColumnGroup;
return;
}
"table" => {
parser.insertion_mode = InsertionMode::InTable;
return;
}
"template" => {
let is_html_template = effective
.borrow()
.kind
.as_element()
.map(|e| e.namespace == muskitty_dom::Namespace::Html)
.unwrap_or(false);
if is_html_template {
if let Some(&mode) = parser.template_insertion_modes.last() {
parser.insertion_mode = mode;
} else {
parser.insertion_mode = InsertionMode::InTemplate;
}
return;
}
}
"head" if !is_last => {
parser.insertion_mode = InsertionMode::InHead;
return;
}
"body" => {
parser.insertion_mode = InsertionMode::InBody;
return;
}
"frameset" => {
parser.insertion_mode = InsertionMode::InFrameset;
return;
}
"html" => {
if parser.head_element.is_none() {
parser.insertion_mode = InsertionMode::BeforeHead;
} else {
parser.insertion_mode = InsertionMode::AfterHead;
}
return;
}
_ => {}
}
}
parser.insertion_mode = InsertionMode::InBody;
}