html-to-markdown 2.25.1 → 2.26.2

data/rust-vendor/html5ever/Cargo.toml

@@ -13,7 +13,7 @@
 edition = "2021"
 rust-version = "1.71.0"
 name = "html5ever"
-version = "0.36.1"
+version = "0.38.0"
 authors = ["The html5ever Project Developers"]
 build = false
 autolib = false
@@ -37,9 +37,6 @@ categories = [
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/servo/html5ever"
 
-[features]
-trace_tokenizer = []
-
 [lib]
 name = "html5ever"
 path = "src/lib.rs"
@@ -64,6 +61,10 @@ path = "examples/print-tree-actions.rs"
 name = "tokenize"
 path = "examples/tokenize.rs"
 
+[[test]]
+name = "driver"
+path = "tests/driver.rs"
+
 [[bench]]
 name = "html5ever"
 path = "benches/html5ever.rs"
@@ -73,10 +74,14 @@ harness = false
 version = "0.4"
 
 [dependencies.markup5ever]
-version = "0.36.1"
+version = "0.38"
 
 [dev-dependencies.criterion]
-version = "0.7"
+version = "0.8"
 
 [dev-dependencies.typed-arena]
 version = "2.0.2"
+
+[features]
+serde = ["markup5ever/serde"]
+trace_tokenizer = []

data/rust-vendor/html5ever/Cargo.toml.orig

@@ -14,6 +14,7 @@ rust-version.workspace = true
 
 [features]
 trace_tokenizer = []
+serde = ["markup5ever/serde"]
 
 [dependencies]
 markup5ever = { workspace = true }

data/rust-vendor/html5ever/examples/arena.rs

@@ -55,6 +55,7 @@ pub struct Node<'arena> {
 }
 
 /// HTML node data which can be an element, a comment, a string, a DOCTYPE, etc...
+#[derive(Clone)]
 pub enum NodeData<'arena> {
     Document,
     Doctype {
@@ -352,5 +353,33 @@ fn main() {
     io::stdin().read_to_end(&mut bytes).unwrap();
 
     let arena = typed_arena::Arena::new();
-    html5ever_parse_slice_into_arena(&bytes, &arena);
+    let dom = html5ever_parse_slice_into_arena(&bytes, &arena);
+
+    // Print the DOM structure
+    print_node(dom, 0);
+}
+
+fn print_node<'arena>(node: &Node<'arena>, depth: usize) {
+    let indent = "  ".repeat(depth);
+
+    match &node.data {
+        NodeData::Document => println!("{}Document", indent),
+        NodeData::Doctype { name, .. } => println!("{}<!DOCTYPE {}>", indent, name),
+        NodeData::Text { contents } => {
+            let text = contents.borrow();
+            if !text.trim().is_empty() {
+                println!("{}\"{}\"", indent, text.trim());
+            }
+        },
+        NodeData::Comment { contents } => println!("{}<!-- {} -->", indent, contents),
+        NodeData::Element { name, .. } => println!("{}<{}>", indent, name.local),
+        NodeData::ProcessingInstruction { target, .. } => println!("{}<?{}>", indent, target),
+    }
+
+    // Print all children
+    let mut child = node.first_child.get();
+    while let Some(current_child) = child {
+        print_node(current_child, depth + 1);
+        child = current_child.next_sibling.get();
+    }
 }

data/rust-vendor/html5ever/src/driver.rs

@@ -116,8 +116,7 @@ where
 impl<Sink: TreeSink> TendrilSink<tendril::fmt::UTF8> for Parser<Sink> {
     fn process(&mut self, t: StrTendril) {
         self.input_buffer.push_back(t);
-        // FIXME: Properly support </script> somehow.
-        while let TokenizerResult::Script(_) = self.tokenizer.feed(&self.input_buffer) {}
+        self.loop_until_done();
     }
 
     // FIXME: Is it too noisy to report every character decoding error?
@@ -128,9 +127,12 @@ impl<Sink: TreeSink> TendrilSink<tendril::fmt::UTF8> for Parser<Sink> {
     type Output = Sink::Output;
 
     fn finish(self) -> Self::Output {
-        // FIXME: Properly support </script> somehow.
-        while let TokenizerResult::Script(_) = self.tokenizer.feed(&self.input_buffer) {}
-        assert!(self.input_buffer.is_empty());
+        self.loop_until_done();
+
+        assert!(
+            self.input_buffer.is_empty(),
+            "parser finished with remaining input"
+        );
         self.tokenizer.end();
         self.tokenizer.sink.sink.finish()
     }
@@ -145,4 +147,16 @@ impl<Sink: TreeSink> Parser<Sink> {
     pub fn from_utf8(self) -> Utf8LossyDecoder<Self> {
         Utf8LossyDecoder::new(self)
     }
+
+    fn loop_until_done(&self) {
+        // FIXME: Properly support </script> and encoding indicators somehow.
+        loop {
+            if matches!(
+                self.tokenizer.feed(&self.input_buffer),
+                TokenizerResult::Done
+            ) {
+                break;
+            }
+        }
+    }
 }

data/rust-vendor/html5ever/src/encoding.rs

@@ -0,0 +1,173 @@
+// Copyright 2014-2025 The html5ever Project Developers. See the
+// COPYRIGHT file at the top-level directory of this distribution.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use crate::tendril::StrTendril;
+
+/// <https://html.spec.whatwg.org/multipage/#algorithm-for-extracting-a-character-encoding-from-a-meta-element>
+pub(crate) fn extract_a_character_encoding_from_a_meta_element(
+    input: StrTendril,
+) -> Option<StrTendril> {
+    // Step 1. Let position be a pointer into s, initially pointing at the start of the string.
+    let mut position = 0;
+    loop {
+        // Step 2. Loop: Find the first seven characters in s after position that are an ASCII
+        // case-insensitive match for the word "charset". If no such match is found, return nothing.
+        loop {
+            let candidate = input.as_bytes().get(position..position + "charset".len())?;
+            if candidate.eq_ignore_ascii_case(b"charset") {
+                break;
+            }
+
+            position += 1;
+        }
+        position += "charset".len();
+
+        // Step 3. Skip any ASCII whitespace that immediately follow the word "charset" (there might not be any).
+        position += input.as_bytes()[position..]
+            .iter()
+            .take_while(|byte| byte.is_ascii_whitespace())
+            .count();
+
+        // Step 4. If the next character is not a U+003D EQUALS SIGN (=), then move position to point just before
+        // that next character, and jump back to the step labeled loop.
+        if input.as_bytes()[position] == b'=' {
+            break;
+        }
+    }
+    // Skip the "="
+    position += 1;
+
+    // Step 5. Skip any ASCII whitespace that immediately follow the equals sign (there might not be any).
+    position += input.as_bytes()[position..]
+        .iter()
+        .take_while(|byte| byte.is_ascii_whitespace())
+        .count();
+
+    // Step 6. Process the next character as follows:
+    match input.as_bytes().get(position)? {
+        quote @ (b'"' | b'\'') => {
+            // Return the result of getting an encoding from the substring that is between this character
+            // and the next earliest occurrence of this character.
+            let length = input.as_bytes()[position + 1..]
+                .iter()
+                .position(|byte| byte == quote)?;
+            Some(input.subtendril(position as u32 + 1, length as u32))
+        },
+        _ => {
+            // Return the result of getting an encoding from the substring that consists of this character
+            // up to but not including the first ASCII whitespace or U+003B SEMICOLON character (;),
+            // or the end of s, whichever comes first.
+            let length = input.as_bytes()[position..]
+                .iter()
+                .position(|byte| byte.is_ascii_whitespace() || *byte == b';');
+            if let Some(length) = length {
+                Some(input.subtendril(position as u32, length as u32))
+            } else {
+                Some(input.subtendril(position as u32, (input.len() - position) as u32))
+            }
+        },
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn meta_element_without_charset() {
+        assert_eq!(
+            extract_a_character_encoding_from_a_meta_element(StrTendril::from_slice("foobar")),
+            None
+        );
+    }
+
+    #[test]
+    fn meta_element_with_capitalized_charset() {
+        assert_eq!(
+            extract_a_character_encoding_from_a_meta_element(StrTendril::from_slice(
+                "cHarSet=utf8"
+            )),
+            Some(StrTendril::from_slice("utf8"))
+        );
+    }
+
+    #[test]
+    fn meta_element_with_no_equals_after_charset() {
+        assert_eq!(
+            extract_a_character_encoding_from_a_meta_element(StrTendril::from_slice(
+                "charset utf8"
+            )),
+            None
+        );
+    }
+
+    #[test]
+    fn meta_element_with_whitespace_around_equals() {
+        assert_eq!(
+            extract_a_character_encoding_from_a_meta_element(StrTendril::from_slice(
+                "charset \t=\tutf8"
+            )),
+            Some(StrTendril::from_slice("utf8"))
+        );
+    }
+
+    #[test]
+    fn meta_element_with_quoted_value() {
+        assert_eq!(
+            extract_a_character_encoding_from_a_meta_element(StrTendril::from_slice(
+                "charset='utf8'"
+            )),
+            Some(StrTendril::from_slice("utf8"))
+        );
+        assert_eq!(
+            extract_a_character_encoding_from_a_meta_element(StrTendril::from_slice(
+                "charset=\"utf8\""
+            )),
+            Some(StrTendril::from_slice("utf8"))
+        );
+        assert_eq!(
+            extract_a_character_encoding_from_a_meta_element(StrTendril::from_slice(
+                "charset='utf8"
+            )),
+            None
+        );
+        assert_eq!(
+            extract_a_character_encoding_from_a_meta_element(StrTendril::from_slice(
+                "charset=\"utf8"
+            )),
+            None
+        );
+    }
+
+    #[test]
+    fn meta_element_with_implicit_terminator() {
+        assert_eq!(
+            extract_a_character_encoding_from_a_meta_element(StrTendril::from_slice(
+                "charset=utf8 foo"
+            )),
+            Some(StrTendril::from_slice("utf8"))
+        );
+        assert_eq!(
+            extract_a_character_encoding_from_a_meta_element(StrTendril::from_slice(
+                "charset=utf8;foo"
+            )),
+            Some(StrTendril::from_slice("utf8"))
+        );
+    }
+
+    #[test]
+    fn meta_element_with_content_type() {
+        assert_eq!(
+            extract_a_character_encoding_from_a_meta_element(StrTendril::from_slice(
+                "text/html; charset=utf8"
+            )),
+            Some(StrTendril::from_slice("utf8"))
+        );
+    }
+}

data/rust-vendor/html5ever/src/lib.rs

@@ -22,6 +22,7 @@ mod util {
     pub(crate) mod str;
 }
 
+pub(crate) mod encoding;
 pub(crate) mod macros;
 
 pub mod driver;

data/rust-vendor/html5ever/src/serialize/mod.rs

@@ -107,8 +107,8 @@ impl<Wr: Write> HtmlSerializer<Wr> {
                 '&' => self.writer.write_all(b"&amp;"),
                 '\u{00A0}' => self.writer.write_all(b"&nbsp;"),
                 '"' if attr_mode => self.writer.write_all(b"&quot;"),
-                '<' if !attr_mode => self.writer.write_all(b"&lt;"),
-                '>' if !attr_mode => self.writer.write_all(b"&gt;"),
+                '<' => self.writer.write_all(b"&lt;"),
+                '>' => self.writer.write_all(b"&gt;"),
                 c => self.writer.write_fmt(format_args!("{c}")),
             }?;
         }

data/rust-vendor/html5ever/src/tokenizer/interface.rs

@@ -7,6 +7,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use markup5ever::ns;
+
 use crate::interface::Attribute;
 use crate::tendril::StrTendril;
 use crate::tokenizer::states;
@@ -18,15 +20,18 @@ pub use self::Token::{CharacterTokens, CommentToken, DoctypeToken, TagToken};
 pub use self::Token::{EOFToken, NullCharacterToken, ParseError};
 
 /// A `DOCTYPE` token.
-// FIXME: already exists in Servo DOM
 #[derive(PartialEq, Eq, Clone, Debug, Default)]
 pub struct Doctype {
     pub name: Option<StrTendril>,
     pub public_id: Option<StrTendril>,
     pub system_id: Option<StrTendril>,
+    /// Indicates if this DOCTYPE token should put the document in [quirks mode].
+    ///
+    /// [quirks mode]: https://dom.spec.whatwg.org/#concept-document-quirks
     pub force_quirks: bool,
 }
 
+/// Whether the tag is a start or an end tag.
 #[derive(PartialEq, Eq, Hash, Copy, Clone, Debug)]
 pub enum TagKind {
     StartTag,
@@ -36,8 +41,12 @@ pub enum TagKind {
 /// A tag token.
 #[derive(PartialEq, Eq, Clone, Debug)]
 pub struct Tag {
+    /// Whether the tag is a start or an end tag.
     pub kind: TagKind,
     pub name: LocalName,
+    /// Whether the tag closes itself.
+    ///
+    /// An example of a self closing tag is `<foo />`.
     pub self_closing: bool,
     pub attrs: Vec<Attribute>,
 }
@@ -57,42 +66,71 @@ impl Tag {
 
         self_attrs == other_attrs
     }
+
+    pub(crate) fn get_attribute(&self, name: &LocalName) -> Option<StrTendril> {
+        self.attrs
+            .iter()
+            .find(|attribute| attribute.name.ns == *ns!() && attribute.name.local == *name)
+            .map(|attribute| attribute.value.clone())
+    }
 }
 
 #[derive(PartialEq, Eq, Debug)]
 pub enum Token {
+    /// A DOCTYPE declaration like `<!DOCTYPE html>`
     DoctypeToken(Doctype),
+    /// A opening or closing tag, like `<foo>` or `</bar>`
     TagToken(Tag),
+    /// A comment like `<!-- foo -->`.
     CommentToken(StrTendril),
+    /// A sequence of characters.
     CharacterTokens(StrTendril),
+    /// A `U+0000 NULL` character in the input.
     NullCharacterToken,
     EOFToken,
     ParseError(Cow<'static, str>),
 }
 
+/// The result of a [TokenSink] consuming a single token.
 #[derive(Debug, PartialEq)]
 #[must_use]
 pub enum TokenSinkResult<Handle> {
+    /// The tokenizer can continue parsing the input as usual.
     Continue,
+    /// The token sink has completed parsing a `<script>` tag, blocking the tokenizer
+    /// until the script is executed.
     Script(Handle),
+    /// The tokenizer should set its state to the [PLAINTEXT state](https://html.spec.whatwg.org/#plaintext-state).
     Plaintext,
+    /// The tokenizer should set its state to the given rawdata state.
     RawData(states::RawKind),
+    /// The document indicated that the given encoding should be used to parse it.
+    ///
+    /// HTML5-compatible implementations should parse the encoding label using the algorithm
+    /// described in <https://encoding.spec.whatwg.org/#concept-encoding-get>. The label
+    /// has not been validated by html5ever. Invalid or unknown encodings can be ignored.
+    ///
+    /// If the decoder is confident that the current encoding is correct then this message
+    /// can safely be ignored.
+    EncodingIndicator(StrTendril),
 }
 
 /// Types which can receive tokens from the tokenizer.
 pub trait TokenSink {
+    /// The type of a DOM node.
     type Handle;
 
     /// Process a token.
     fn process_token(&self, token: Token, line_number: u64) -> TokenSinkResult<Self::Handle>;
 
-    // Signal sink that tokenization reached the end.
+    /// Signal that tokenization reached the end of the document.
     fn end(&self) {}
 
-    /// Used in the markup declaration open state. By default, this always
+    /// Used in the [markup declaration open state]. By default, this always
     /// returns false and thus all CDATA sections are tokenized as bogus
     /// comments.
-    /// <https://html.spec.whatwg.org/multipage/#markup-declaration-open-state>
+    ///
+    /// [markup declaration open state]: https://html.spec.whatwg.org/multipage/#markup-declaration-open-state
     fn adjusted_current_node_present_but_not_in_html_namespace(&self) -> bool {
         false
     }

data/rust-vendor/html5ever/src/tokenizer/mod.rs

@@ -39,10 +39,24 @@ mod char_ref;
 mod interface;
 pub mod states;
 
+/// The result of invoking the tokenizer once.
 pub enum ProcessResult<Handle> {
+    /// The tokenizer should be re-invoked immediately.
     Continue,
+    /// The tokenizer has not finished, but it needs to wait for more
+    /// input to arrive before it can continue.
     Suspend,
+    /// The tokenizer was blocked by a `<script>`.
+    ///
+    /// This `<script>` needs to be executed before tokenization
+    /// can continue, as it might invoke `document.write`.
     Script(Handle),
+    /// The tokenizer was blocked because it found a `<meta charset>` tag.
+    ///
+    /// Such tags may force the user agent to re-parse the document with the new
+    /// encoding, but non-conformant implementations can reasonably treat
+    /// this as [Self::Continue].
+    EncodingIndicator(StrTendril),
 }
 
 fn option_push(opt_str: &mut Option<StrTendril>, c: char) {
@@ -357,6 +371,9 @@ impl<Sink: TokenSink> Tokenizer<Sink> {
                     ProcessResult::Continue => (),
                     ProcessResult::Suspend => break,
                     ProcessResult::Script(node) => return TokenizerResult::Script(node),
+                    ProcessResult::EncodingIndicator(encoding) => {
+                        return TokenizerResult::EncodingIndicator(encoding)
+                    },
                 }
             }
         } else {
@@ -365,6 +382,9 @@ impl<Sink: TokenSink> Tokenizer<Sink> {
                     ProcessResult::Continue => (),
                     ProcessResult::Suspend => break,
                     ProcessResult::Script(node) => return TokenizerResult::Script(node),
+                    ProcessResult::EncodingIndicator(encoding) => {
+                        return TokenizerResult::EncodingIndicator(encoding)
+                    },
                 }
             }
         }
@@ -456,6 +476,9 @@ impl<Sink: TokenSink> Tokenizer<Sink> {
                 self.state.set(states::RawData(kind));
                 ProcessResult::Continue
             },
+            TokenSinkResult::EncodingIndicator(encoding) => {
+                ProcessResult::EncodingIndicator(encoding)
+            },
         }
     }
 
@@ -1726,7 +1749,7 @@ impl<Sink: TokenSink> Tokenizer<Sink> {
             match self.eof_step() {
                 ProcessResult::Continue => (),
                 ProcessResult::Suspend => break,
-                ProcessResult::Script(_) => unreachable!(),
+                ProcessResult::Script(_) | ProcessResult::EncodingIndicator(_) => unreachable!(),
             }
         }
 

data/rust-vendor/html5ever/src/tokenizer/states.rs

@@ -47,51 +47,85 @@ pub enum AttrValueKind {
 
 #[derive(PartialEq, Eq, PartialOrd, Ord, Copy, Clone, Hash, Debug)]
 pub enum State {
+    /// <https://html.spec.whatwg.org/#data-state>
     Data,
+    /// <https://html.spec.whatwg.org/#plaintext-state>
     Plaintext,
+    /// <https://html.spec.whatwg.org/#tag-open-state>
     TagOpen,
+    /// <https://html.spec.whatwg.org/#tag-open-state>
     EndTagOpen,
+    /// <https://html.spec.whatwg.org/#tag-name-state>
     TagName,
     RawData(RawKind),
     RawLessThanSign(RawKind),
     RawEndTagOpen(RawKind),
     RawEndTagName(RawKind),
     ScriptDataEscapeStart(ScriptEscapeKind),
+    /// <https://html.spec.whatwg.org/#script-data-escape-start-dash-state>
     ScriptDataEscapeStartDash,
     ScriptDataEscapedDash(ScriptEscapeKind),
     ScriptDataEscapedDashDash(ScriptEscapeKind),
+    /// <https://html.spec.whatwg.org/#script-data-double-escape-end-state>
     ScriptDataDoubleEscapeEnd,
+    /// <https://html.spec.whatwg.org/#before-attribute-name-state>
     BeforeAttributeName,
+    /// <https://html.spec.whatwg.org/#attribute-name-state>
     AttributeName,
+    /// <https://html.spec.whatwg.org/#after-attribute-name-state>
     AfterAttributeName,
+    /// <https://html.spec.whatwg.org/#before-attribute-value-state>
     BeforeAttributeValue,
     AttributeValue(AttrValueKind),
+    /// <https://html.spec.whatwg.org/#after-attribute-value-(quoted)-state>
     AfterAttributeValueQuoted,
+    /// <https://html.spec.whatwg.org/#self-closing-start-tag-state>
     SelfClosingStartTag,
+    /// <https://html.spec.whatwg.org/#bogus-comment-state>
     BogusComment,
+    /// <https://html.spec.whatwg.org/#markup-declaration-open-state>
     MarkupDeclarationOpen,
+    /// <https://html.spec.whatwg.org/#comment-start-state>
     CommentStart,
+    /// <https://html.spec.whatwg.org/#comment-start-dash-state>
     CommentStartDash,
+    /// <https://html.spec.whatwg.org/#comment-state>
     Comment,
+    /// <https://html.spec.whatwg.org/#comment-less-than-sign-state>
     CommentLessThanSign,
+    /// <https://html.spec.whatwg.org/#comment-less-than-sign-bang-state>
     CommentLessThanSignBang,
+    /// <https://html.spec.whatwg.org/#comment-less-than-sign-bang-dash-state>
     CommentLessThanSignBangDash,
+    /// <https://html.spec.whatwg.org/#comment-less-than-sign-bang-dash-dash-state>
     CommentLessThanSignBangDashDash,
+    /// <https://html.spec.whatwg.org/#comment-end-dash-state>
     CommentEndDash,
+    /// <https://html.spec.whatwg.org/#comment-end-state>
     CommentEnd,
+    /// <https://html.spec.whatwg.org/#comment-end-bang-state>
     CommentEndBang,
+    /// <https://html.spec.whatwg.org/#doctype-state>
     Doctype,
+    /// <https://html.spec.whatwg.org/#before-doctype-name-state>
     BeforeDoctypeName,
+    /// <https://html.spec.whatwg.org/#doctype-name-state>
     DoctypeName,
+    /// <https://html.spec.whatwg.org/#after-doctype-name-state>
     AfterDoctypeName,
     AfterDoctypeKeyword(DoctypeIdKind),
     BeforeDoctypeIdentifier(DoctypeIdKind),
     DoctypeIdentifierDoubleQuoted(DoctypeIdKind),
     DoctypeIdentifierSingleQuoted(DoctypeIdKind),
     AfterDoctypeIdentifier(DoctypeIdKind),
+    /// <https://html.spec.whatwg.org/#between-doctype-public-and-system-identifiers-state>
     BetweenDoctypePublicAndSystemIdentifiers,
+    /// <https://html.spec.whatwg.org/#bogus-doctype-state>
     BogusDoctype,
+    /// <https://html.spec.whatwg.org/#cdata-section-state>
     CdataSection,
+    /// <https://html.spec.whatwg.org/#cdata-section-bracket-state>
     CdataSectionBracket,
+    /// <https://html.spec.whatwg.org/#cdata-section-end-state>
     CdataSectionEnd,
 }

data/rust-vendor/html5ever/src/tree_builder/mod.rs

@@ -118,7 +118,7 @@ pub struct TreeBuilder<Handle, Sink> {
 
     /// Form element pointer.
     form_elem: RefCell<Option<Handle>>,
-    //§ END
+
     /// Frameset-ok flag.
     frameset_ok: Cell<bool>,
 
@@ -264,7 +264,7 @@ where
     }
 
     /// Call the `Tracer`'s `trace_handle` method on every `Handle` in the tree builder's
-    /// internal state.  This is intended to support garbage-collected DOMs.
+    /// internal state. This is intended to support garbage-collected DOMs.
     pub fn trace_handles(&self, tracer: &dyn Tracer<Handle = Handle>) {
         tracer.trace_handle(&self.doc_handle);
         for e in &*self.open_elems.borrow() {
@@ -400,6 +400,9 @@ where
                     assert!(more_tokens.is_empty());
                     return tokenizer::TokenSinkResult::RawData(k);
                 },
+                ProcessResult::EncodingIndicator(encoding) => {
+                    return tokenizer::TokenSinkResult::EncodingIndicator(encoding)
+                },
             }
         }
     }
@@ -923,6 +926,7 @@ where
             .borrow_mut()
             .pop()
             .expect("no current element");
+
         self.sink.pop(&elem);
         elem
     }
@@ -1183,6 +1187,7 @@ where
         n
     }
 
+    /// Pop element until an element with the given name has been popped.
     fn pop_until_named(&self, name: LocalName) -> usize {
         self.pop_until(|p| *p.ns == ns!(html) && *p.local == name)
     }
@@ -1269,16 +1274,6 @@ where
                 _ => continue,
             };
             match *name {
-                local_name!("select") => {
-                    for ancestor in self.open_elems.borrow()[0..i].iter().rev() {
-                        if self.html_elem_named(ancestor, local_name!("template")) {
-                            return InsertionMode::InSelect;
-                        } else if self.html_elem_named(ancestor, local_name!("table")) {
-                            return InsertionMode::InSelectInTable;
-                        }
-                    }
-                    return InsertionMode::InSelect;
-                },
                 local_name!("td") | local_name!("th") => {
                     if !last {
                         return InsertionMode::InCell;
@@ -1356,7 +1351,7 @@ where
         // FIXME: application cache selection algorithm
     }
 
-    // https://html.spec.whatwg.org/multipage/#create-an-element-for-the-token
+    /// <https://html.spec.whatwg.org/multipage/#create-an-element-for-the-token>
     fn insert_element(
         &self,
         push: PushFlag,