use std::cell::RefCell;
use std::rc::{Rc, Weak};
use muskitty_dom::{append_child, Attribute, Node, NodeKind, NodeType};
use super::ActiveFormattingEntry;
use super::HtmlTreeConstructor;
use super::SelectSelectedcontentMemo;
use super::SelectSelectednessMemo;
use super::SelectedcontentLookup;
use crate::error::ParseError;
use muskitty_html5_tokenizer::TagToken;
pub fn create_element_for_token(
parser: &HtmlTreeConstructor,
token: &TagToken,
) -> Rc<RefCell<Node>> {
let attrs: Vec<Attribute> = token
.attrs
.iter()
.map(|(name, value)| Attribute::new(name, value))
.collect();
let element = Node::new_element_html(&token.name, attrs, &parser.document);
if token.name == "template" {
let content = Node::new_document_fragment(&parser.document);
if let NodeKind::Element(ref mut e) = element.borrow_mut().kind {
e.set_template_content(content);
}
}
if token.name == "option" {
let has_selected = token
.attrs
.iter()
.any(|(k, _)| k.eq_ignore_ascii_case("selected"));
if has_selected {
if let NodeKind::Element(ref mut e) = element.borrow_mut().kind {
e.selectedness = true;
}
}
}
element
}
fn insertion_target(parser: &HtmlTreeConstructor) -> Rc<RefCell<Node>> {
let current = parser.current_node();
let target = {
let current_ref = current.borrow();
match ¤t_ref.kind {
NodeKind::Element(e) if e.local_name == "template" => e.template_content.clone(),
_ => None,
}
};
target.unwrap_or_else(|| current.clone())
}
fn foster_parenting_active(parser: &HtmlTreeConstructor) -> bool {
if !parser.foster_parenting {
return false;
}
parser
.open_elements
.last()
.and_then(|n| {
n.borrow().kind.as_element().map(|e| {
matches!(
e.local_name.as_str(),
"table" | "tbody" | "tfoot" | "thead" | "tr"
)
})
})
.unwrap_or(false)
}
enum FosterLocation {
Append(Rc<RefCell<Node>>),
Before {
parent: Rc<RefCell<Node>>,
before: Rc<RefCell<Node>>,
},
}
fn foster_parent_location(parser: &HtmlTreeConstructor) -> FosterLocation {
let last_template_idx = parser
.open_elements
.iter()
.enumerate()
.rev()
.find(|(_, n)| {
n.borrow()
.kind
.as_element()
.map(|e| e.local_name == "template")
.unwrap_or(false)
})
.map(|(i, _)| i);
let last_table_idx = parser
.open_elements
.iter()
.enumerate()
.rev()
.find(|(_, n)| {
n.borrow()
.kind
.as_element()
.map(|e| e.local_name == "table")
.unwrap_or(false)
})
.map(|(i, _)| i);
if let Some(tmpl_idx) = last_template_idx {
let template_above_table = match last_table_idx {
Some(tbl_idx) => tmpl_idx > tbl_idx,
None => true,
};
if template_above_table {
let template = &parser.open_elements[tmpl_idx];
let content = template
.borrow()
.kind
.as_element()
.and_then(|e| e.template_content.clone())
.unwrap_or_else(|| template.clone());
return FosterLocation::Append(content);
}
}
if last_table_idx.is_none() {
let html = parser
.open_elements
.first()
.cloned()
.unwrap_or_else(|| parser.document.clone());
return FosterLocation::Append(html);
}
let table_idx = last_table_idx.unwrap();
let table_node = parser.open_elements[table_idx].clone();
let table_parent = table_node.borrow().parent_node.upgrade();
if let Some(parent) = table_parent {
return FosterLocation::Before {
parent,
before: table_node,
};
}
if table_idx > 0 {
let prev = parser.open_elements[table_idx - 1].clone();
return FosterLocation::Append(prev);
}
FosterLocation::Append(parser.current_node())
}
pub fn push_open_element(parser: &mut HtmlTreeConstructor, node: Rc<RefCell<Node>>) {
let is_selectedcontent = node
.borrow()
.kind
.as_element()
.map(|e| e.namespace == muskitty_dom::Namespace::Html && e.local_name == "selectedcontent")
.unwrap_or(false);
if is_selectedcontent {
if let Some(select) = find_nearest_ancestor_select(&node) {
let already_present = parser
.select_selectedcontent_memo
.as_ref()
.and_then(|m| m.select.upgrade())
.is_some_and(|s| Rc::ptr_eq(&s, &select))
&& matches!(
parser.select_selectedcontent_memo.as_ref().unwrap().lookup,
SelectedcontentLookup::Present(_)
);
if !already_present {
parser.select_selectedcontent_memo = Some(SelectSelectedcontentMemo {
select: Rc::downgrade(&select),
lookup: SelectedcontentLookup::Present(Rc::downgrade(&node)),
});
}
}
}
if parser.open_elements.len() >= parser.max_open_elements {
parser.errors.push(ParseError::DomDepthExceeded {
depth: parser.open_elements.len(),
limit: parser.max_open_elements,
});
return;
}
parser.open_elements.push(node);
}
pub fn insert_node(parser: &HtmlTreeConstructor, node: &Rc<RefCell<Node>>) {
if foster_parenting_active(parser) {
match foster_parent_location(parser) {
FosterLocation::Append(parent) => {
let _ = append_child(&parent, node.clone());
}
FosterLocation::Before { parent, before } => {
let _ = muskitty_dom::insert_before(&parent, node.clone(), Some(&before));
}
}
} else {
let target = insertion_target(parser);
let _ = append_child(&target, node.clone());
}
}
#[allow(dead_code)]
pub fn insert_element(parser: &mut HtmlTreeConstructor, token: &TagToken) {
let element = create_element_for_token(parser, token);
insert_node(parser, &element);
push_open_element(parser, element.clone());
let is_option = element
.borrow()
.kind
.as_element()
.map(|e| e.namespace == muskitty_dom::Namespace::Html && e.local_name == "option")
.unwrap_or(false);
if is_option {
on_option_inserted_with_memo(parser, &element);
}
}
pub fn insert_character(parser: &HtmlTreeConstructor, c: char) {
if foster_parenting_active(parser) {
match foster_parent_location(parser) {
FosterLocation::Before { parent, before } => {
let prev_sibling = {
let parent_node = parent.borrow();
let idx = parent_node
.child_nodes()
.iter()
.position(|n| Rc::ptr_eq(n, &before));
idx.and_then(|i| {
if i > 0 {
Some(parent_node.child_nodes()[i - 1].clone())
} else {
None
}
})
};
if let Some(prev) = prev_sibling {
if prev.borrow().node_type == NodeType::Text {
if let NodeKind::Text(ref mut t) = prev.borrow_mut().kind {
t.data.push(c);
return;
}
}
}
let text = Node::new_text(&c.to_string(), &parser.document);
let _ = muskitty_dom::insert_before(&parent, text, Some(&before));
}
FosterLocation::Append(parent) => {
let last_child = parent.borrow().last_child();
if let Some(child) = last_child {
if child.borrow().node_type == NodeType::Text {
if let NodeKind::Text(ref mut t) = child.borrow_mut().kind {
t.data.push(c);
return;
}
}
}
let text = Node::new_text(&c.to_string(), &parser.document);
let _ = append_child(&parent, text);
}
}
return;
}
let target = insertion_target(parser);
let last_child = target.borrow().last_child();
if let Some(child) = last_child {
let is_text = child.borrow().node_type == NodeType::Text;
if is_text {
if let NodeKind::Text(ref mut t) = child.borrow_mut().kind {
t.data.push(c);
return;
}
}
}
let text = Node::new_text(&c.to_string(), &parser.document);
let _ = append_child(&target, text);
}
pub fn insert_comment(parser: &HtmlTreeConstructor, data: &str) {
let comment = Node::new_comment(data, &parser.document);
insert_node(parser, &comment);
}
pub fn insert_comment_at(target: &Rc<RefCell<Node>>, data: &str, document: &Rc<RefCell<Node>>) {
let comment = Node::new_comment(data, document);
let _ = append_child(target, comment);
}
pub fn insert_processing_instruction(parser: &HtmlTreeConstructor, target: &str, data: &str) {
let pi = Node::new_processing_instruction(target, data, &parser.document);
insert_node(parser, &pi);
}
pub fn insert_processing_instruction_at(
target: &Rc<RefCell<Node>>,
target_name: &str,
data: &str,
document: &Rc<RefCell<Node>>,
) {
let pi = Node::new_processing_instruction(target_name, data, document);
let _ = append_child(target, pi);
}
fn ascii_starts_with(haystack: &str, needle: &str) -> bool {
if needle.len() > haystack.len() {
return false;
}
haystack[..needle.len()].eq_ignore_ascii_case(needle)
}
const QUIRKS_PUBLIC_ID_EXACT: &[&str] = &[
"-//W3O//DTD W3 HTML Strict 3.0//EN//",
"-/W3C/DTD HTML 4.0 Transitional/EN",
"HTML",
];
const QUIRKS_SYSTEM_ID_EXACT: &str = "http://www.ibm.com/data/dtd/v11/ibmxhtml1-transitional.dtd";
const QUIRKS_PUBLIC_ID_PREFIX: &[&str] = &[
"+//Silmaril//dtd html Pro v0r11 19970101//",
"-//AS//DTD HTML 3.0 asWedit + extensions//",
"-//AdvaSoft Ltd//DTD HTML 3.0 asWedit + extensions//",
"-//IETF//DTD HTML 2.0 Level 1//",
"-//IETF//DTD HTML 2.0 Level 2//",
"-//IETF//DTD HTML 2.0 Strict Level 1//",
"-//IETF//DTD HTML 2.0 Strict Level 2//",
"-//IETF//DTD HTML 2.0 Strict//",
"-//IETF//DTD HTML 2.0//",
"-//IETF//DTD HTML 2.1E//",
"-//IETF//DTD HTML 3.0//",
"-//IETF//DTD HTML 3.2 Final//",
"-//IETF//DTD HTML 3.2//",
"-//IETF//DTD HTML 3//",
"-//IETF//DTD HTML Level 0//",
"-//IETF//DTD HTML Level 1//",
"-//IETF//DTD HTML Level 2//",
"-//IETF//DTD HTML Level 3//",
"-//IETF//DTD HTML Strict Level 0//",
"-//IETF//DTD HTML Strict Level 1//",
"-//IETF//DTD HTML Strict Level 2//",
"-//IETF//DTD HTML Strict Level 3//",
"-//IETF//DTD HTML Strict//",
"-//IETF//DTD HTML//",
"-//Metrius//DTD Metrius Presentational//",
"-//Microsoft//DTD Internet Explorer 2.0 HTML Strict//",
"-//Microsoft//DTD Internet Explorer 2.0 HTML//",
"-//Microsoft//DTD Internet Explorer 2.0 Tables//",
"-//Microsoft//DTD Internet Explorer 3.0 HTML Strict//",
"-//Microsoft//DTD Internet Explorer 3.0 HTML//",
"-//Microsoft//DTD Internet Explorer 3.0 Tables//",
"-//Netscape Comm. Corp.//DTD HTML//",
"-//Netscape Comm. Corp.//DTD Strict HTML//",
"-//O'Reilly and Associates//DTD HTML 2.0//",
"-//O'Reilly and Associates//DTD HTML Extended 1.0//",
"-//O'Reilly and Associates//DTD HTML Extended Relaxed 1.0//",
"-//SQ//DTD HTML 2.0 HoTMetaL + extensions//",
"-//SoftQuad Software//DTD HoTMetaL PRO 6.0::19990601::extensions to HTML 4.0//",
"-//SoftQuad//DTD HoTMetaL PRO 4.0::19971010::extensions to HTML 4.0//",
"-//Spyglass//DTD HTML 2.0 Extended//",
"-//Sun Microsystems Corp.//DTD HotJava HTML//",
"-//Sun Microsystems Corp.//DTD HotJava Strict HTML//",
"-//W3C//DTD HTML 3 1995-03-24//",
"-//W3C//DTD HTML 3.2 Draft//",
"-//W3C//DTD HTML 3.2 Final//",
"-//W3C//DTD HTML 3.2//",
"-//W3C//DTD HTML 3.2S Draft//",
"-//W3C//DTD HTML 4.0 Frameset//",
"-//W3C//DTD HTML 4.0 Transitional//",
"-//W3C//DTD HTML Experimental 19960712//",
"-//W3C//DTD HTML Experimental 970421//",
"-//W3C//DTD W3 HTML//",
"-//W3O//DTD W3 HTML 3.0//",
"-//WebTechs//DTD Mozilla HTML 2.0//",
"-//WebTechs//DTD Mozilla HTML//",
];
const QUIRKS_PUBLIC_ID_PREFIX_WHEN_SYS_MISSING: &[&str] = &[
"-//W3C//DTD HTML 4.01 Frameset//",
"-//W3C//DTD HTML 4.01 Transitional//",
];
pub fn detect_quirks_mode(
force_quirks: bool,
name: Option<&str>,
public_id: Option<&str>,
system_id: Option<&str>,
) -> bool {
if force_quirks || name != Some("html") {
return true;
}
let pid = public_id.unwrap_or("");
let sid = system_id.unwrap_or("");
let sid_missing_or_empty = system_id.map(|s| s.is_empty()).unwrap_or(true);
if QUIRKS_PUBLIC_ID_EXACT
.iter()
.any(|p| pid.eq_ignore_ascii_case(p))
{
return true;
}
if sid.eq_ignore_ascii_case(QUIRKS_SYSTEM_ID_EXACT) {
return true;
}
if QUIRKS_PUBLIC_ID_PREFIX
.iter()
.any(|p| ascii_starts_with(pid, p))
{
return true;
}
if sid_missing_or_empty
&& QUIRKS_PUBLIC_ID_PREFIX_WHEN_SYS_MISSING
.iter()
.any(|p| ascii_starts_with(pid, p))
{
return true;
}
false
}
const DEFAULT_SCOPE: &[&str] = &[
"applet",
"caption",
"html",
"table",
"td",
"th",
"marquee",
"object",
"template",
"mi",
"mo",
"mn",
"ms",
"mtext",
"annotation-xml",
"foreignobject",
"desc",
"title",
];
const LIST_SCOPE_EXTRA: &[&str] = &["ol", "ul"];
fn html_local_name(node: &Rc<RefCell<Node>>) -> Option<String> {
let n = node.borrow();
if let NodeKind::Element(ref e) = n.kind {
if e.namespace == muskitty_dom::Namespace::Html {
return Some(e.local_name.clone());
}
}
None
}
fn local_name_for_boundary(node: &Rc<RefCell<Node>>) -> Option<String> {
let n = node.borrow();
if let NodeKind::Element(ref e) = n.kind {
return Some(e.local_name.to_ascii_lowercase());
}
None
}
pub fn has_element_in_scope(parser: &HtmlTreeConstructor, name: &str) -> bool {
has_element_in_scope_with(parser, name, DEFAULT_SCOPE, &[])
}
pub fn has_element_in_button_scope(parser: &HtmlTreeConstructor, name: &str) -> bool {
has_element_in_scope_with(parser, name, DEFAULT_SCOPE, &["button"])
}
pub fn has_element_in_list_scope(parser: &HtmlTreeConstructor, name: &str) -> bool {
has_element_in_scope_with(parser, name, DEFAULT_SCOPE, LIST_SCOPE_EXTRA)
}
const TABLE_SCOPE: &[&str] = &["html", "table", "template"];
pub fn has_element_in_table_scope(parser: &HtmlTreeConstructor, name: &str) -> bool {
for node in parser.open_elements.iter().rev() {
let local = match html_local_name(node) {
Some(l) => l,
None => continue,
};
if local == name {
return true;
}
if TABLE_SCOPE.contains(&local.as_str()) {
return false;
}
}
false
}
pub fn has_element_in_stack(parser: &HtmlTreeConstructor, name: &str) -> bool {
parser
.open_elements
.iter()
.any(|n| html_local_name(n).as_deref() == Some(name))
}
pub fn close_list_item(parser: &mut HtmlTreeConstructor, targets: &[&str]) -> bool {
for i in (0..parser.open_elements.len()).rev() {
let local = match html_local_name(&parser.open_elements[i]) {
Some(l) => l,
None => continue,
};
let target = targets.iter().find(|t| local == **t);
if let Some(target) = target {
let target = target.to_string();
generate_implied_end_tags(parser, Some(&target));
let current_is_target = parser
.open_elements
.last()
.and_then(html_local_name)
.map(|l| l == target)
.unwrap_or(false);
if !current_is_target {
parser
.errors
.push(ParseError::Generic("list item not at current node"));
}
while let Some(top) = parser.open_elements.last() {
let top_name = html_local_name(top);
parser.open_elements.pop();
if top_name.as_deref() == Some(target.as_str()) {
break;
}
}
return true;
}
if SPECIAL_ELEMENTS.contains(&local.as_str())
&& !matches!(local.as_str(), "address" | "div" | "p")
{
return false;
}
}
false
}
fn has_element_in_scope_with(
parser: &HtmlTreeConstructor,
name: &str,
base_scope: &[&str],
extra: &[&str],
) -> bool {
for node in parser.open_elements.iter().rev() {
if html_local_name(node).as_deref() == Some(name) {
return true;
}
let boundary_local = match local_name_for_boundary(node) {
Some(l) => l,
None => continue,
};
if base_scope.contains(&boundary_local.as_str()) || extra.contains(&boundary_local.as_str())
{
return false;
}
}
false
}
pub fn generate_implied_end_tags(parser: &mut HtmlTreeConstructor, except: Option<&str>) {
const IMPLIED_END: &[&str] = &[
"dd", "dt", "li", "optgroup", "option", "p", "rb", "rp", "rt", "rtc",
];
loop {
let top_name = parser.open_elements.last().and_then(html_local_name);
match top_name.as_deref() {
Some(n) if IMPLIED_END.contains(&n) && Some(n) != except => {
pop_open_element(parser);
}
_ => break,
}
}
}
pub fn pop_open_element(parser: &mut HtmlTreeConstructor) -> Option<Rc<RefCell<Node>>> {
let node = parser.open_elements.pop();
if let Some(ref n) = node {
let is_option = n
.borrow()
.kind
.as_element()
.map(|e| e.namespace == muskitty_dom::Namespace::Html && e.local_name == "option")
.unwrap_or(false);
if is_option {
maybe_clone_option_into_selectedcontent(parser, n);
}
}
node
}
pub fn close_p_element(parser: &mut HtmlTreeConstructor) {
generate_implied_end_tags(parser, Some("p"));
while let Some(top) = parser.open_elements.last() {
let local = html_local_name(top);
if local.as_deref() == Some("html") {
break;
}
let is_p = local.as_deref() == Some("p");
parser.open_elements.pop();
if is_p {
break;
}
}
}
pub fn push_formatting_element(parser: &mut HtmlTreeConstructor, element: Rc<RefCell<Node>>) {
let mut count = 0;
let mut earliest_match_index: Option<usize> = None;
for (i, entry) in parser.active_formatting_elements.iter().enumerate().rev() {
match entry {
ActiveFormattingEntry::Marker => break,
ActiveFormattingEntry::Element(e) => {
if elements_match_for_noahs_ark(e, &element) {
count += 1;
earliest_match_index = Some(i);
if count == 3 {
break;
}
}
}
}
}
if count >= 3 {
if let Some(idx) = earliest_match_index {
parser.active_formatting_elements.remove(idx);
}
}
if parser.active_formatting_elements.len() >= crate::parser::MAX_ACTIVE_FORMATTING_ELEMENTS {
let section_start = parser
.active_formatting_elements
.iter()
.rposition(|e| matches!(e, ActiveFormattingEntry::Marker))
.map_or(0, |m| m + 1);
let remove_idx = if section_start < parser.active_formatting_elements.len() {
section_start
} else {
0
};
parser.active_formatting_elements.remove(remove_idx);
}
parser
.active_formatting_elements
.push(ActiveFormattingEntry::Element(element));
}
#[allow(dead_code)]
pub fn add_formatting_marker(parser: &mut HtmlTreeConstructor) {
parser
.active_formatting_elements
.push(ActiveFormattingEntry::Marker);
}
#[allow(dead_code)]
pub fn clear_active_formatting_to_last_marker(parser: &mut HtmlTreeConstructor) {
while let Some(entry) = parser.active_formatting_elements.pop() {
if matches!(entry, ActiveFormattingEntry::Marker) {
break;
}
}
}
fn elements_match_for_noahs_ark(a: &Rc<RefCell<Node>>, b: &Rc<RefCell<Node>>) -> bool {
let a = a.borrow();
let b = b.borrow();
let (ea, eb) = match (a.kind.as_element(), b.kind.as_element()) {
(Some(ea), Some(eb)) => (ea, eb),
_ => return false,
};
if ea.namespace != eb.namespace {
return false;
}
if ea.local_name != eb.local_name {
return false;
}
if ea.attributes.len() != eb.attributes.len() {
return false;
}
ea.attributes
.iter()
.zip(eb.attributes.iter())
.all(|(x, y)| x.local_name == y.local_name && x.value == y.value)
}
pub fn reconstruct_active_formatting_elements(parser: &mut HtmlTreeConstructor) {
if parser.active_formatting_elements.is_empty() {
return;
}
if matches!(
parser.active_formatting_elements.last(),
Some(ActiveFormattingEntry::Marker)
) {
return;
}
if let Some(ActiveFormattingEntry::Element(el)) = parser.active_formatting_elements.last() {
if let Some(top) = parser.open_elements.last() {
if Rc::ptr_eq(el, top) {
return;
}
}
}
let mut index = parser.active_formatting_elements.len();
loop {
if index == 0 {
break;
}
index -= 1;
let on_stack_or_marker = match &parser.active_formatting_elements[index] {
ActiveFormattingEntry::Marker => true,
ActiveFormattingEntry::Element(el) => {
parser.open_elements.iter().any(|o| Rc::ptr_eq(o, el))
}
};
if on_stack_or_marker {
index += 1;
break;
}
}
while index < parser.active_formatting_elements.len() {
let entry = parser.active_formatting_elements[index].clone();
let old_element = match entry {
ActiveFormattingEntry::Element(e) => e,
ActiveFormattingEntry::Marker => {
index += 1;
continue;
}
};
let (local_name, attrs) = {
let o = old_element.borrow();
let e = o
.kind
.as_element()
.expect("formatting entry not an element");
(
e.local_name.clone(),
e.attributes
.iter()
.map(|a| Attribute::new(&a.local_name, &a.value))
.collect::<Vec<_>>(),
)
};
let new_element = Node::new_element_html(&local_name, attrs, &parser.document);
insert_node(parser, &new_element);
push_open_element(parser, new_element.clone());
parser.active_formatting_elements[index] = ActiveFormattingEntry::Element(new_element);
index += 1;
}
}
pub const SPECIAL_ELEMENTS: &[&str] = &[
"address",
"applet",
"area",
"article",
"aside",
"base",
"basefont",
"bgsound",
"blockquote",
"body",
"br",
"button",
"caption",
"center",
"col",
"colgroup",
"dd",
"details",
"dialog",
"dir",
"div",
"dl",
"dt",
"embed",
"fieldset",
"figcaption",
"figure",
"footer",
"form",
"frame",
"frameset",
"h1",
"h2",
"h3",
"h4",
"h5",
"h6",
"head",
"header",
"hgroup",
"hr",
"html",
"iframe",
"img",
"input",
"keygen",
"li",
"link",
"listing",
"main",
"marquee",
"menu",
"meta",
"nav",
"noembed",
"noframes",
"noscript",
"object",
"ol",
"p",
"param",
"plaintext",
"pre",
"search",
"script",
"section",
"select",
"source",
"style",
"summary",
"table",
"tbody",
"td",
"template",
"textarea",
"tfoot",
"th",
"thead",
"title",
"tr",
"track",
"ul",
"wbr",
"xmp",
];
fn find_formatting_element(parser: &HtmlTreeConstructor, name: &str) -> Option<usize> {
for (i, entry) in parser.active_formatting_elements.iter().enumerate().rev() {
match entry {
ActiveFormattingEntry::Marker => return None,
ActiveFormattingEntry::Element(el) => {
let is_match = el
.borrow()
.kind
.as_element()
.map(|e| e.local_name == name)
.unwrap_or(false);
if is_match {
return Some(i);
}
}
}
}
None
}
fn stack_index_of(parser: &HtmlTreeConstructor, node: &Rc<RefCell<Node>>) -> Option<usize> {
parser
.open_elements
.iter()
.position(|n| Rc::ptr_eq(n, node))
}
fn stack_index_of_afe(parser: &HtmlTreeConstructor, afe_index: usize) -> Option<usize> {
match &parser.active_formatting_elements[afe_index] {
ActiveFormattingEntry::Element(el) => stack_index_of(parser, el),
ActiveFormattingEntry::Marker => None,
}
}
fn clone_element(parser: &HtmlTreeConstructor, src: &Rc<RefCell<Node>>) -> Rc<RefCell<Node>> {
let (local_name, attrs) = {
let s = src.borrow();
let e = s
.kind
.as_element()
.expect("formatting entry not an element");
(
e.local_name.clone(),
e.attributes
.iter()
.map(|a| Attribute::new(&a.local_name, &a.value))
.collect::<Vec<_>>(),
)
};
Node::new_element_html(&local_name, attrs, &parser.document)
}
pub fn adoption_agency(parser: &mut HtmlTreeConstructor, subject: &str) {
if let Some(top) = parser.open_elements.last() {
let is_subject = top
.borrow()
.kind
.as_element()
.map(|e| e.local_name == subject)
.unwrap_or(false);
if is_subject {
let in_afe = parser
.active_formatting_elements
.iter()
.any(|e| matches!(e, ActiveFormattingEntry::Element(el) if Rc::ptr_eq(el, top)));
if !in_afe {
parser.open_elements.pop();
return;
}
}
}
for _ in 0..8 {
let mut formatting_afe_index = match find_formatting_element(parser, subject) {
Some(i) => i,
None => {
run_any_other_end_tag(parser, subject);
return;
}
};
let mut fmt_stack_index = match stack_index_of_afe(parser, formatting_afe_index) {
Some(i) => i,
None => {
parser.errors.push(ParseError::Generic(
"adoption agency: formatting element not on stack",
));
parser
.active_formatting_elements
.remove(formatting_afe_index);
return;
}
};
if !has_element_in_scope(parser, subject) {
parser.errors.push(ParseError::Generic(
"adoption agency: formatting element not in scope",
));
return;
}
if let Some(top) = parser.open_elements.last() {
let is_fmt = match &parser.active_formatting_elements[formatting_afe_index] {
ActiveFormattingEntry::Element(el) => Rc::ptr_eq(el, top),
_ => false,
};
if !is_fmt {
parser.errors.push(ParseError::Generic(
"adoption agency: formatting element not current",
));
}
}
let furthest_block_index = parser.open_elements[fmt_stack_index + 1..]
.iter()
.enumerate()
.find(|(_, n)| {
n.borrow()
.kind
.as_element()
.map(|e| {
e.namespace == muskitty_dom::Namespace::Html
&& SPECIAL_ELEMENTS.contains(&e.local_name.as_str())
})
.unwrap_or(false)
})
.map(|(i, _)| fmt_stack_index + 1 + i);
let mut furthest_block_index = match furthest_block_index {
Some(i) => i,
None => {
while let Some(top) = parser.open_elements.pop() {
let is_fmt = match &parser.active_formatting_elements[formatting_afe_index] {
ActiveFormattingEntry::Element(el) => Rc::ptr_eq(el, &top),
_ => false,
};
if is_fmt {
break;
}
}
parser
.active_formatting_elements
.remove(formatting_afe_index);
return;
}
};
let common_ancestor = parser
.open_elements
.get(fmt_stack_index.wrapping_sub(1))
.cloned();
let mut bookmark = formatting_afe_index;
let mut node_index = furthest_block_index;
let furthest_block_node = parser.open_elements[furthest_block_index].clone();
let mut last_node = furthest_block_node.clone();
let mut inner_iterations = 0;
loop {
inner_iterations += 1;
if inner_iterations > 64 {
break;
}
if node_index == 0 {
break;
}
node_index -= 1;
let node = parser.open_elements[node_index].clone();
let is_fmt = match &parser.active_formatting_elements[formatting_afe_index] {
ActiveFormattingEntry::Element(el) => Rc::ptr_eq(el, &node),
_ => false,
};
if is_fmt {
break;
}
let node_afe_index = parser.active_formatting_elements.iter().position(
|e| matches!(e, ActiveFormattingEntry::Element(el) if Rc::ptr_eq(el, &node)),
);
match node_afe_index {
None => {
parser.open_elements.remove(node_index);
if node_index < fmt_stack_index {
fmt_stack_index_will_decrement(&mut fmt_stack_index);
}
if node_index < furthest_block_index {
furthest_block_index -= 1;
}
}
Some(afe_idx) => {
if inner_iterations > 3 {
parser.active_formatting_elements.remove(afe_idx);
if afe_idx < bookmark {
bookmark -= 1;
}
if afe_idx < formatting_afe_index {
formatting_afe_index -= 1;
}
parser.open_elements.remove(node_index);
if node_index < fmt_stack_index {
fmt_stack_index_will_decrement(&mut fmt_stack_index);
}
if node_index < furthest_block_index {
furthest_block_index -= 1;
}
continue;
}
let new_element = clone_element(parser, &node);
let _ = append_child(&new_element, last_node.clone());
parser.open_elements[node_index] = new_element.clone();
parser.active_formatting_elements[afe_idx] =
ActiveFormattingEntry::Element(new_element.clone());
if Rc::ptr_eq(&last_node, &furthest_block_node) {
bookmark = afe_idx + 1;
}
last_node = new_element;
}
}
}
if let Some(ancestor) = common_ancestor {
let is_table_like = ancestor
.borrow()
.kind
.as_element()
.map(|e| {
matches!(
e.local_name.as_str(),
"table" | "tbody" | "tfoot" | "thead" | "tr"
)
})
.unwrap_or(false);
if parser.foster_parenting && is_table_like {
match foster_parent_location(parser) {
FosterLocation::Append(parent) => {
let _ = append_child(&parent, last_node.clone());
}
FosterLocation::Before { parent, before } => {
let _ =
muskitty_dom::insert_before(&parent, last_node.clone(), Some(&before));
}
}
} else {
let target = {
let anc_ref = ancestor.borrow();
match &anc_ref.kind {
NodeKind::Element(e) if e.local_name == "template" => e
.template_content
.clone()
.unwrap_or_else(|| ancestor.clone()),
_ => ancestor.clone(),
}
};
let _ = append_child(&target, last_node.clone());
}
}
let formatting_element = match &parser.active_formatting_elements[formatting_afe_index] {
ActiveFormattingEntry::Element(el) => el.clone(),
_ => unreachable!("formatting element entry is always Element here"),
};
let new_formatting = clone_element(parser, &formatting_element);
let furthest_block = parser.open_elements[furthest_block_index].clone();
let children: Vec<Rc<RefCell<Node>>> = furthest_block.borrow().child_nodes().to_vec();
for child in &children {
let _ = muskitty_dom::remove_child(&furthest_block, child);
let _ = append_child(&new_formatting, child.clone());
}
let _ = append_child(&furthest_block, new_formatting.clone());
parser
.active_formatting_elements
.remove(formatting_afe_index);
if bookmark > formatting_afe_index {
bookmark -= 1;
}
let insert_at = bookmark.min(parser.active_formatting_elements.len());
parser.active_formatting_elements.insert(
insert_at,
ActiveFormattingEntry::Element(new_formatting.clone()),
);
let fmt_stack_idx = stack_index_of(parser, &formatting_element);
if let Some(i) = fmt_stack_idx {
parser.open_elements.remove(i);
}
let fb_idx = stack_index_of(parser, &furthest_block);
if let Some(i) = fb_idx {
parser.open_elements.insert(i + 1, new_formatting);
}
}
}
fn fmt_stack_index_will_decrement(idx: &mut usize) {
*idx = idx.saturating_sub(1);
}
fn run_any_other_end_tag(parser: &mut HtmlTreeConstructor, name: &str) {
for (i, node) in parser.open_elements.iter().enumerate().rev() {
let node_name = html_local_name(node);
if node_name.as_deref() == Some(name) {
generate_implied_end_tags(parser, Some(name));
while parser.open_elements.len() > i {
parser.open_elements.pop();
}
return;
}
if let Some(n) = node_name.as_deref() {
if SPECIAL_ELEMENTS.contains(&n) {
parser
.errors
.push(ParseError::UnexpectedEndTag(name.to_string()));
return;
}
}
}
}
fn deep_clone_node(
node: &Rc<RefCell<Node>>,
owner_document: &Rc<RefCell<Node>>,
) -> Rc<RefCell<Node>> {
let n = node.borrow();
let clone = match &n.kind {
NodeKind::Element(e) => {
Node::new_element_html(&e.local_name, e.attributes.clone(), owner_document)
}
NodeKind::Text(t) => Node::new_text(&t.data, owner_document),
NodeKind::Comment(c) => Node::new_comment(&c.data, owner_document),
_ => {
Node::new_text("", owner_document)
}
};
let child_nodes: Vec<Rc<RefCell<Node>>> = n.child_nodes().to_vec();
for child in &child_nodes {
let child_clone = deep_clone_node(child, owner_document);
muskitty_dom::push_child_raw(&clone, child_clone);
}
clone
}
fn find_nearest_ancestor_select(element: &Rc<RefCell<Node>>) -> Option<Rc<RefCell<Node>>> {
let mut ancestor_optgroup: Option<Rc<RefCell<Node>>> = None;
let mut current = element.borrow().parent_node.upgrade();
while let Some(node) = current {
let is_element = node.borrow().node_type == NodeType::Element;
if !is_element {
current = node.borrow().parent_node.upgrade();
continue;
}
let local_name = node
.borrow()
.kind
.as_element()
.map(|e| e.local_name.clone());
match local_name.as_deref() {
Some("datalist") | Some("hr") | Some("option") => return None,
Some("optgroup") => {
if ancestor_optgroup.is_some() {
return None;
}
ancestor_optgroup = Some(node.clone());
}
Some("select") => return Some(node),
_ => {}
}
current = node.borrow().parent_node.upgrade();
}
None
}
fn get_list_of_options(select: &Rc<RefCell<Node>>) -> Vec<Rc<RefCell<Node>>> {
let mut options: Vec<Rc<RefCell<Node>>> = Vec::new();
fn walk(
node: &Rc<RefCell<Node>>,
select: &Rc<RefCell<Node>>,
options: &mut Vec<Rc<RefCell<Node>>>,
) {
let children: Vec<Rc<RefCell<Node>>> = {
let n = node.borrow();
n.child_nodes().to_vec()
};
for child in &children {
let local = child
.borrow()
.kind
.as_element()
.map(|e| e.local_name.clone());
match local.as_deref() {
Some("option") => {
options.push(child.clone());
}
Some("select") | Some("datalist") | Some("hr") => {
}
Some("optgroup") => {
let mut has_ancestor_optgroup = false;
let mut walker = child.borrow().parent_node.upgrade();
while let Some(w) = walker {
if Rc::ptr_eq(&w, select) {
break;
}
let w_local = w.borrow().kind.as_element().map(|e| e.local_name.clone());
if w_local.as_deref() == Some("optgroup") {
has_ancestor_optgroup = true;
break;
}
walker = w.borrow().parent_node.upgrade();
}
if has_ancestor_optgroup {
} else {
walk(child, select, options);
}
}
_ => {
walk(child, select, options);
}
}
}
}
walk(select, select, &mut options);
options
}
fn get_select_enabled_selectedcontent(
parser: &mut HtmlTreeConstructor,
select: &Rc<RefCell<Node>>,
) -> Option<Rc<RefCell<Node>>> {
let has_multiple = select
.borrow()
.kind
.as_element()
.and_then(|e| e.get_attribute("multiple"))
.is_some();
if has_multiple {
return None;
}
let memo_hits_same_select = parser
.select_selectedcontent_memo
.as_ref()
.and_then(|m| m.select.upgrade())
.is_some_and(|s| Rc::ptr_eq(&s, select));
if memo_hits_same_select {
match &parser.select_selectedcontent_memo.as_ref().unwrap().lookup {
SelectedcontentLookup::Absent => return None,
SelectedcontentLookup::Present(w) => {
if let Some(sc) = w.upgrade() {
return Some(sc);
}
}
}
}
fn find(node: &Rc<RefCell<Node>>) -> Option<Rc<RefCell<Node>>> {
let children: Vec<Rc<RefCell<Node>>> = {
let n = node.borrow();
n.child_nodes().to_vec()
};
for child in &children {
let is_sc = child
.borrow()
.kind
.as_element()
.map(|e| {
e.namespace == muskitty_dom::Namespace::Html
&& e.local_name == "selectedcontent"
})
.unwrap_or(false);
if is_sc {
return Some(child.clone());
}
if let Some(found) = find(child) {
return Some(found);
}
}
None
}
let found = find(select);
parser.select_selectedcontent_memo = Some(SelectSelectedcontentMemo {
select: Rc::downgrade(select),
lookup: match &found {
Some(sc) => SelectedcontentLookup::Present(Rc::downgrade(sc)),
None => SelectedcontentLookup::Absent,
},
});
found
}
fn selectedness_setting_algorithm(
select: &Rc<RefCell<Node>>,
) -> (bool, bool, Option<Rc<RefCell<Node>>>) {
let has_multiple = select
.borrow()
.kind
.as_element()
.and_then(|e| e.get_attribute("multiple"))
.is_some();
if has_multiple {
return (false, false, None);
}
let display_size: u32 = select
.borrow()
.kind
.as_element()
.and_then(|e| e.get_attribute("size"))
.and_then(|s| s.parse::<u32>().ok())
.unwrap_or(1);
let options = get_list_of_options(select);
if display_size == 1 {
let any_selected = options.iter().any(|opt| {
opt.borrow()
.kind
.as_element()
.map(|e| e.selectedness)
.unwrap_or(false)
});
if !any_selected {
for opt in &options {
let is_disabled = opt
.borrow()
.kind
.as_element()
.and_then(|e| e.get_attribute("disabled"))
.is_some();
if !is_disabled {
if let NodeKind::Element(ref mut e) = opt.borrow_mut().kind {
e.selectedness = true;
}
return (true, true, Some(opt.clone()));
}
}
return (false, false, None);
}
let selected_indices: Vec<usize> = options
.iter()
.enumerate()
.filter(|(_, opt)| {
opt.borrow()
.kind
.as_element()
.map(|e| e.selectedness)
.unwrap_or(false)
})
.map(|(i, _)| i)
.collect();
let last = *selected_indices.last().unwrap();
if selected_indices.len() >= 2 {
for &i in &selected_indices {
if i != last {
if let NodeKind::Element(ref mut e) = options[i].borrow_mut().kind {
e.selectedness = false;
}
}
}
}
return (true, false, Some(options[last].clone()));
}
let selected_indices: Vec<usize> = options
.iter()
.enumerate()
.filter(|(_, opt)| {
opt.borrow()
.kind
.as_element()
.map(|e| e.selectedness)
.unwrap_or(false)
})
.map(|(i, _)| i)
.collect();
if selected_indices.len() >= 2 {
let last = *selected_indices.last().unwrap();
for &i in &selected_indices {
if i != last {
if let NodeKind::Element(ref mut e) = options[i].borrow_mut().kind {
e.selectedness = false;
}
}
}
return (true, false, Some(options[last].clone()));
}
if let Some(&only) = selected_indices.first() {
return (true, false, Some(options[only].clone()));
}
(false, false, None)
}
fn clone_option_into_selectedcontent(
option: &Rc<RefCell<Node>>,
selectedcontent: &Rc<RefCell<Node>>,
owner_document: &Rc<RefCell<Node>>,
) {
let old_children = muskitty_dom::drain_children(selectedcontent);
for c in &old_children {
c.borrow_mut().parent_node = Weak::new();
}
let option_children: Vec<Rc<RefCell<Node>>> = {
let o = option.borrow();
o.child_nodes().to_vec()
};
for child in &option_children {
let clone = deep_clone_node(child, owner_document);
muskitty_dom::push_child_raw(selectedcontent, clone);
}
}
pub fn maybe_clone_option_into_selectedcontent(
parser: &mut HtmlTreeConstructor,
option: &Rc<RefCell<Node>>,
) {
let select = match find_nearest_ancestor_select(option) {
Some(s) => s,
None => return,
};
let selectedness = option
.borrow()
.kind
.as_element()
.map(|e| e.selectedness)
.unwrap_or(false);
if !selectedness {
return;
}
let selectedcontent = match get_select_enabled_selectedcontent(parser, &select) {
Some(sc) => sc,
None => return,
};
let owner_document = option
.borrow()
.owner_document
.upgrade()
.unwrap_or_else(|| option.clone());
clone_option_into_selectedcontent(option, &selectedcontent, &owner_document);
}
pub(crate) fn on_option_inserted_with_memo(
parser: &mut HtmlTreeConstructor,
option: &Rc<RefCell<Node>>,
) {
let Some(select) = find_nearest_ancestor_select(option) else {
return;
};
let (has_multiple, display_size_1) = {
let sb = select.borrow();
let e = sb.kind.as_element();
(
e.and_then(|e| e.get_attribute("multiple")).is_some(),
e.and_then(|e| e.get_attribute("size"))
.and_then(|s| s.parse::<u32>().ok())
.unwrap_or(1)
== 1,
)
};
if has_multiple {
return;
}
let (o_selected, o_disabled) = match option.borrow().kind.as_element() {
Some(e) => (e.selectedness, e.get_attribute("disabled").is_some()),
None => return,
};
let memo_hits_same_select = parser
.select_selectedness_memo
.as_ref()
.and_then(|m| m.select.upgrade())
.is_some_and(|s| Rc::ptr_eq(&s, &select));
if memo_hits_same_select {
if !o_selected {
let (has_selected, all_disabled) = {
let memo = parser.select_selectedness_memo.as_ref().unwrap();
(memo.has_selected, memo.all_disabled)
};
let skip = !display_size_1 || has_selected || (o_disabled && all_disabled);
if skip {
let memo = parser.select_selectedness_memo.as_mut().unwrap();
memo.all_disabled = memo.all_disabled && o_disabled;
return;
}
} else {
let (has_selected, last_selected) = {
let memo = parser.select_selectedness_memo.as_ref().unwrap();
(memo.has_selected, memo.last_selected.clone())
};
if !has_selected {
let memo = parser.select_selectedness_memo.as_mut().unwrap();
memo.has_selected = true;
memo.last_selected = Rc::downgrade(option);
return;
}
if let Some(prev) = last_selected.upgrade() {
if let NodeKind::Element(ref mut e) = prev.borrow_mut().kind {
e.selectedness = false;
}
let memo = parser.select_selectedness_memo.as_mut().unwrap();
memo.last_selected = Rc::downgrade(option);
return;
}
}
}
let (has_selected_after, has_non_disabled, selected_node) =
selectedness_setting_algorithm(&select);
parser.select_selectedness_memo = Some(SelectSelectednessMemo {
select: Rc::downgrade(&select),
has_selected: has_selected_after,
all_disabled: !has_non_disabled,
last_selected: selected_node
.map(|n| Rc::downgrade(&n))
.unwrap_or_else(Weak::new),
});
}