html-to-markdown 2.24.6 → 2.25.0

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

@@ -1,216 +0,0 @@
-// Copyright 2014-2017 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::tree_builder::NamespaceMap;
-use crate::QualName;
-pub use markup5ever::serialize::{AttrRef, Serialize, Serializer, TraversalScope};
-use std::io::{self, Write};
-
-#[derive(Clone)]
-/// Struct for setting serializer options.
-pub struct SerializeOpts {
-    /// Serialize the root node? Default: ChildrenOnly
-    pub traversal_scope: TraversalScope,
-}
-
-impl Default for SerializeOpts {
-    fn default() -> SerializeOpts {
-        SerializeOpts {
-            traversal_scope: TraversalScope::ChildrenOnly(None),
-        }
-    }
-}
-
-/// Method for serializing generic node to a given writer.
-pub fn serialize<Wr, T>(writer: Wr, node: &T, opts: SerializeOpts) -> io::Result<()>
-where
-    Wr: Write,
-    T: Serialize,
-{
-    let mut ser = XmlSerializer::new(writer);
-    node.serialize(&mut ser, opts.traversal_scope)
-}
-
-/// Struct used for serializing nodes into a text that other XML
-/// parses can read.
-///
-/// Serializer contains a set of functions (start_elem, end_elem...)
-/// that make parsing nodes easier.
-pub struct XmlSerializer<Wr> {
-    writer: Wr,
-    namespace_stack: NamespaceMapStack,
-}
-
-#[derive(Debug)]
-struct NamespaceMapStack(Vec<NamespaceMap>);
-
-impl NamespaceMapStack {
-    fn new() -> NamespaceMapStack {
-        NamespaceMapStack(vec![])
-    }
-
-    fn push(&mut self, namespace: NamespaceMap) {
-        self.0.push(namespace);
-    }
-
-    fn pop(&mut self) {
-        self.0.pop();
-    }
-}
-
-/// Writes given text into the Serializer, escaping it,
-/// depending on where the text is written inside the tag or attribute value.
-///
-/// For example
-///```text
-///    <tag>'&-quotes'</tag>   becomes      <tag>'&amp;-quotes'</tag>
-///    <tag = "'&-quotes'">    becomes      <tag = "&apos;&amp;-quotes&apos;"
-///```
-fn write_to_buf_escaped<W: Write>(writer: &mut W, text: &str, attr_mode: bool) -> io::Result<()> {
-    for c in text.chars() {
-        match c {
-            '&' => writer.write_all(b"&amp;"),
-            '\'' if attr_mode => writer.write_all(b"&apos;"),
-            '"' if attr_mode => writer.write_all(b"&quot;"),
-            '<' if !attr_mode => writer.write_all(b"&lt;"),
-            '>' if !attr_mode => writer.write_all(b"&gt;"),
-            c => writer.write_fmt(format_args!("{c}")),
-        }?;
-    }
-    Ok(())
-}
-
-#[inline]
-fn write_qual_name<W: Write>(writer: &mut W, name: &QualName) -> io::Result<()> {
-    if let Some(ref prefix) = name.prefix {
-        writer.write_all(prefix.as_bytes())?;
-        writer.write_all(b":")?;
-    }
-
-    writer.write_all(name.local.as_bytes())?;
-    Ok(())
-}
-
-impl<Wr: Write> XmlSerializer<Wr> {
-    /// Creates a new Serializier from a writer and given serialization options.
-    pub fn new(writer: Wr) -> Self {
-        XmlSerializer {
-            writer,
-            namespace_stack: NamespaceMapStack::new(),
-        }
-    }
-
-    #[inline(always)]
-    fn qual_name(&mut self, name: &QualName) -> io::Result<()> {
-        self.find_or_insert_ns(name);
-        write_qual_name(&mut self.writer, name)
-    }
-
-    #[inline(always)]
-    fn qual_attr_name(&mut self, name: &QualName) -> io::Result<()> {
-        self.find_or_insert_ns(name);
-        write_qual_name(&mut self.writer, name)
-    }
-
-    fn find_uri(&self, name: &QualName) -> bool {
-        let mut found = false;
-        for stack in self.namespace_stack.0.iter().rev() {
-            if let Some(Some(el)) = stack.get(&name.prefix) {
-                found = *el == name.ns;
-                break;
-            }
-        }
-        found
-    }
-
-    fn find_or_insert_ns(&mut self, name: &QualName) {
-        if (name.prefix.is_some() || !name.ns.is_empty()) && !self.find_uri(name) {
-            if let Some(last_ns) = self.namespace_stack.0.last_mut() {
-                last_ns.insert(name);
-            }
-        }
-    }
-}
-
-impl<Wr: Write> Serializer for XmlSerializer<Wr> {
-    /// Serializes given start element into text. Start element contains
-    /// qualified name and an attributes iterator.
-    fn start_elem<'a, AttrIter>(&mut self, name: QualName, attrs: AttrIter) -> io::Result<()>
-    where
-        AttrIter: Iterator<Item = AttrRef<'a>>,
-    {
-        self.namespace_stack.push(NamespaceMap::empty());
-
-        self.writer.write_all(b"<")?;
-        self.qual_name(&name)?;
-        if let Some(current_namespace) = self.namespace_stack.0.last() {
-            for (prefix, url_opt) in current_namespace.get_scope_iter() {
-                self.writer.write_all(b" xmlns")?;
-                if let Some(ref prefix) = *prefix {
-                    self.writer.write_all(b":")?;
-                    self.writer.write_all(prefix.as_bytes())?;
-                }
-
-                self.writer.write_all(b"=\"")?;
-                let url = if let Some(ref a) = *url_opt {
-                    a.as_bytes()
-                } else {
-                    b""
-                };
-                self.writer.write_all(url)?;
-                self.writer.write_all(b"\"")?;
-            }
-        }
-        for (name, value) in attrs {
-            self.writer.write_all(b" ")?;
-            self.qual_attr_name(name)?;
-            self.writer.write_all(b"=\"")?;
-            write_to_buf_escaped(&mut self.writer, value, true)?;
-            self.writer.write_all(b"\"")?;
-        }
-        self.writer.write_all(b">")?;
-        Ok(())
-    }
-
-    /// Serializes given end element into text.
-    fn end_elem(&mut self, name: QualName) -> io::Result<()> {
-        self.namespace_stack.pop();
-        self.writer.write_all(b"</")?;
-        self.qual_name(&name)?;
-        self.writer.write_all(b">")
-    }
-
-    /// Serializes comment into text.
-    fn write_comment(&mut self, text: &str) -> io::Result<()> {
-        self.writer.write_all(b"<!--")?;
-        self.writer.write_all(text.as_bytes())?;
-        self.writer.write_all(b"-->")
-    }
-
-    /// Serializes given doctype
-    fn write_doctype(&mut self, name: &str) -> io::Result<()> {
-        self.writer.write_all(b"<!DOCTYPE ")?;
-        self.writer.write_all(name.as_bytes())?;
-        self.writer.write_all(b">")
-    }
-
-    /// Serializes text for a node or an attributes.
-    fn write_text(&mut self, text: &str) -> io::Result<()> {
-        write_to_buf_escaped(&mut self.writer, text, false)
-    }
-
-    /// Serializes given processing instruction.
-    fn write_processing_instruction(&mut self, target: &str, data: &str) -> io::Result<()> {
-        self.writer.write_all(b"<?")?;
-        self.writer.write_all(target.as_bytes())?;
-        self.writer.write_all(b" ")?;
-        self.writer.write_all(data.as_bytes())?;
-        self.writer.write_all(b"?>")
-    }
-}

data/rust-vendor/xml5ever/src/tokenizer/char_ref/mod.rs

@@ -1,456 +0,0 @@
-// Copyright 2014-2017 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 super::{TokenSink, XmlTokenizer};
-use crate::data;
-use crate::tendril::StrTendril;
-use log::debug;
-use markup5ever::buffer_queue::BufferQueue;
-use std::borrow::Cow::{self, Borrowed};
-use std::char::from_u32;
-
-use self::State::*;
-pub use self::Status::*;
-
-//§ tokenizing-character-references
-pub struct CharRef {
-    /// The resulting character(s)
-    pub chars: [char; 2],
-
-    /// How many slots in `chars` are valid?
-    pub num_chars: u8,
-}
-
-pub enum Status {
-    Stuck,
-    Progress,
-    Done,
-}
-
-#[derive(Debug)]
-enum State {
-    Begin,
-    Octothorpe,
-    Numeric(u32), // base
-    NumericSemicolon,
-    Named,
-    BogusName,
-}
-
-pub struct CharRefTokenizer {
-    state: State,
-    addnl_allowed: Option<char>,
-    result: Option<CharRef>,
-
-    num: u32,
-    num_too_big: bool,
-    seen_digit: bool,
-    hex_marker: Option<char>,
-
-    name_buf_opt: Option<StrTendril>,
-    name_match: Option<(u32, u32)>,
-    name_len: usize,
-}
-
-impl CharRefTokenizer {
-    // NB: We assume that we have an additional allowed character iff we're
-    // tokenizing in an attribute value.
-    pub fn new(addnl_allowed: Option<char>) -> CharRefTokenizer {
-        CharRefTokenizer {
-            state: Begin,
-            addnl_allowed,
-            result: None,
-            num: 0,
-            num_too_big: false,
-            seen_digit: false,
-            hex_marker: None,
-            name_buf_opt: None,
-            name_match: None,
-            name_len: 0,
-        }
-    }
-
-    // A CharRefTokenizer can only tokenize one character reference,
-    // so this method consumes the tokenizer.
-    pub fn get_result(self) -> CharRef {
-        self.result.expect("get_result called before done")
-    }
-
-    fn name_buf(&self) -> &StrTendril {
-        self.name_buf_opt
-            .as_ref()
-            .expect("name_buf missing in named character reference")
-    }
-
-    fn name_buf_mut(&mut self) -> &mut StrTendril {
-        self.name_buf_opt
-            .as_mut()
-            .expect("name_buf missing in named character reference")
-    }
-
-    fn finish_none(&mut self) -> Status {
-        self.result = Some(CharRef {
-            chars: ['\0', '\0'],
-            num_chars: 0,
-        });
-        Done
-    }
-
-    fn finish_one(&mut self, c: char) -> Status {
-        self.result = Some(CharRef {
-            chars: [c, '\0'],
-            num_chars: 1,
-        });
-        Done
-    }
-}
-
-impl CharRefTokenizer {
-    pub fn step<Sink: TokenSink>(
-        &mut self,
-        tokenizer: &XmlTokenizer<Sink>,
-        input: &BufferQueue,
-    ) -> Status {
-        if self.result.is_some() {
-            return Done;
-        }
-
-        debug!("char ref tokenizer stepping in state {:?}", self.state);
-        match self.state {
-            Begin => self.do_begin(tokenizer, input),
-            Octothorpe => self.do_octothorpe(tokenizer, input),
-            Numeric(base) => self.do_numeric(tokenizer, base, input),
-            NumericSemicolon => self.do_numeric_semicolon(tokenizer, input),
-            Named => self.do_named(tokenizer, input),
-            BogusName => self.do_bogus_name(tokenizer, input),
-        }
-    }
-
-    fn do_begin<Sink: TokenSink>(
-        &mut self,
-        tokenizer: &XmlTokenizer<Sink>,
-        input: &BufferQueue,
-    ) -> Status {
-        match tokenizer.peek(input) {
-            Some('\t' | '\n' | '\x0C' | ' ' | '<' | '&') => self.finish_none(),
-            Some(c) if Some(c) == self.addnl_allowed => self.finish_none(),
-            Some('#') => {
-                tokenizer.discard_char(input);
-                self.state = Octothorpe;
-                Progress
-            },
-            Some(_) => {
-                self.state = Named;
-                self.name_buf_opt = Some(StrTendril::new());
-                Progress
-            },
-            None => Stuck,
-        }
-    }
-
-    fn do_octothorpe<Sink: TokenSink>(
-        &mut self,
-        tokenizer: &XmlTokenizer<Sink>,
-        input: &BufferQueue,
-    ) -> Status {
-        match tokenizer.peek(input) {
-            Some(c @ ('x' | 'X')) => {
-                tokenizer.discard_char(input);
-                self.hex_marker = Some(c);
-                self.state = Numeric(16);
-            },
-            Some(_) => {
-                self.hex_marker = None;
-                self.state = Numeric(10);
-            },
-            None => return Stuck,
-        }
-        Progress
-    }
-
-    fn do_numeric<Sink: TokenSink>(
-        &mut self,
-        tokenizer: &XmlTokenizer<Sink>,
-        base: u32,
-        input: &BufferQueue,
-    ) -> Status {
-        let Some(c) = tokenizer.peek(input) else {
-            return Stuck;
-        };
-        match c.to_digit(base) {
-            Some(n) => {
-                tokenizer.discard_char(input);
-                self.num = self.num.wrapping_mul(base);
-                if self.num > 0x10FFFF {
-                    // We might overflow, and the character is definitely invalid.
-                    // We still parse digits and semicolon, but don't use the result.
-                    self.num_too_big = true;
-                }
-                self.num = self.num.wrapping_add(n);
-                self.seen_digit = true;
-                Progress
-            },
-
-            None if !self.seen_digit => self.unconsume_numeric(tokenizer, input),
-
-            None => {
-                self.state = NumericSemicolon;
-                Progress
-            },
-        }
-    }
-
-    fn do_numeric_semicolon<Sink: TokenSink>(
-        &mut self,
-        tokenizer: &XmlTokenizer<Sink>,
-        input: &BufferQueue,
-    ) -> Status {
-        match tokenizer.peek(input) {
-            Some(';') => tokenizer.discard_char(input),
-            Some(_) => tokenizer.emit_error(Borrowed(
-                "Semicolon missing after numeric character reference",
-            )),
-            None => return Stuck,
-        };
-        self.finish_numeric(tokenizer)
-    }
-
-    fn unconsume_numeric<Sink: TokenSink>(
-        &mut self,
-        tokenizer: &XmlTokenizer<Sink>,
-        input: &BufferQueue,
-    ) -> Status {
-        let mut unconsume = StrTendril::from_char('#');
-        if let Some(c) = self.hex_marker {
-            unconsume.push_char(c);
-        }
-
-        tokenizer.unconsume(input, unconsume);
-        tokenizer.emit_error(Borrowed("Numeric character reference without digits"));
-        self.finish_none()
-    }
-
-    fn finish_numeric<Sink: TokenSink>(&mut self, tokenizer: &XmlTokenizer<Sink>) -> Status {
-        fn conv(n: u32) -> char {
-            from_u32(n).expect("invalid char missed by error handling cases")
-        }
-
-        let (c, error) = match self.num {
-            n if (n > 0x10FFFF) || self.num_too_big => ('\u{fffd}', true),
-            0x00 | 0xD800..=0xDFFF => ('\u{fffd}', true),
-
-            0x80..=0x9F => match data::C1_REPLACEMENTS[(self.num - 0x80) as usize] {
-                Some(c) => (c, true),
-                None => (conv(self.num), true),
-            },
-
-            0x01..=0x08 | 0x0B | 0x0D..=0x1F | 0x7F | 0xFDD0..=0xFDEF => (conv(self.num), true),
-
-            n if (n & 0xFFFE) == 0xFFFE => (conv(n), true),
-
-            n => (conv(n), false),
-        };
-
-        if error {
-            let msg = if tokenizer.opts.exact_errors {
-                Cow::from(format!(
-                    "Invalid numeric character reference value 0x{:06X}",
-                    self.num
-                ))
-            } else {
-                Cow::from("Invalid numeric character reference")
-            };
-            tokenizer.emit_error(msg);
-        }
-
-        self.finish_one(c)
-    }
-
-    fn do_named<Sink: TokenSink>(
-        &mut self,
-        tokenizer: &XmlTokenizer<Sink>,
-        input: &BufferQueue,
-    ) -> Status {
-        let Some(c) = tokenizer.get_char(input) else {
-            return Stuck;
-        };
-        self.name_buf_mut().push_char(c);
-        match data::NAMED_ENTITIES.get(&self.name_buf()[..]) {
-            // We have either a full match or a prefix of one.
-            Some(&m) => {
-                if m.0 != 0 {
-                    // We have a full match, but there might be a longer one to come.
-                    self.name_match = Some(m);
-                    self.name_len = self.name_buf().len();
-                }
-                // Otherwise we just have a prefix match.
-                Progress
-            },
-
-            // Can't continue the match.
-            None => self.finish_named(tokenizer, Some(c), input),
-        }
-    }
-
-    fn emit_name_error<Sink: TokenSink>(&mut self, tokenizer: &XmlTokenizer<Sink>) {
-        let msg = if tokenizer.opts.exact_errors {
-            Cow::from(format!("Invalid character reference &{}", self.name_buf()))
-        } else {
-            Cow::from("Invalid character reference")
-        };
-        tokenizer.emit_error(msg);
-    }
-
-    fn unconsume_name<Sink: TokenSink>(
-        &mut self,
-        tokenizer: &XmlTokenizer<Sink>,
-        input: &BufferQueue,
-    ) {
-        tokenizer.unconsume(input, self.name_buf_opt.take().unwrap());
-    }
-
-    fn finish_named<Sink: TokenSink>(
-        &mut self,
-        tokenizer: &XmlTokenizer<Sink>,
-        end_char: Option<char>,
-        input: &BufferQueue,
-    ) -> Status {
-        match self.name_match {
-            None => {
-                match end_char {
-                    Some(c) if c.is_ascii_alphanumeric() => {
-                        // Keep looking for a semicolon, to determine whether
-                        // we emit a parse error.
-                        self.state = BogusName;
-                        return Progress;
-                    },
-
-                    // Check length because &; is not a parse error.
-                    Some(';') if self.name_buf().len() > 1 => self.emit_name_error(tokenizer),
-
-                    _ => (),
-                }
-                self.unconsume_name(tokenizer, input);
-                self.finish_none()
-            },
-
-            Some((c1, c2)) => {
-                // We have a complete match, but we may have consumed
-                // additional characters into self.name_buf.  Usually
-                // at least one, but several in cases like
-                //
-                //     &not    => match for U+00AC
-                //     &noti   => valid prefix for &notin
-                //     &notit  => can't continue match
-
-                let name_len = self.name_len;
-                assert!(name_len > 0);
-                let last_matched = self.name_buf()[name_len - 1..].chars().next().unwrap();
-
-                // There might not be a next character after the match, if
-                // we had a full match and then hit EOF.
-                let next_after = if name_len == self.name_buf().len() {
-                    None
-                } else {
-                    Some(self.name_buf()[name_len..].chars().next().unwrap())
-                };
-
-                // "If the character reference is being consumed as part of an
-                // attribute, and the last character matched is not a U+003B
-                // SEMICOLON character (;), and the next character is either a
-                // U+003D EQUALS SIGN character (=) or an alphanumeric ASCII
-                // character, then, for historical reasons, all the characters
-                // that were matched after the U+0026 AMPERSAND character (&)
-                // must be unconsumed, and nothing is returned. However, if
-                // this next character is in fact a U+003D EQUALS SIGN
-                // character (=), then this is a parse error"
-
-                let unconsume_all = match (self.addnl_allowed, last_matched, next_after) {
-                    (_, ';', _) => false,
-                    (Some(_), _, Some('=')) => {
-                        tokenizer.emit_error(Borrowed(
-                            "Equals sign after character reference in attribute",
-                        ));
-                        true
-                    },
-                    (Some(_), _, Some(c)) if c.is_ascii_alphanumeric() => true,
-                    _ => {
-                        tokenizer.emit_error(Borrowed(
-                            "Character reference does not end with semicolon",
-                        ));
-                        false
-                    },
-                };
-
-                if unconsume_all {
-                    self.unconsume_name(tokenizer, input);
-                    self.finish_none()
-                } else {
-                    tokenizer
-                        .unconsume(input, StrTendril::from_slice(&self.name_buf()[name_len..]));
-                    self.result = Some(CharRef {
-                        chars: [from_u32(c1).unwrap(), from_u32(c2).unwrap()],
-                        num_chars: if c2 == 0 { 1 } else { 2 },
-                    });
-                    Done
-                }
-            },
-        }
-    }
-
-    fn do_bogus_name<Sink: TokenSink>(
-        &mut self,
-        tokenizer: &XmlTokenizer<Sink>,
-        input: &BufferQueue,
-    ) -> Status {
-        let Some(c) = tokenizer.get_char(input) else {
-            return Stuck;
-        };
-        self.name_buf_mut().push_char(c);
-        match c {
-            _ if c.is_ascii_alphanumeric() => return Progress,
-            ';' => self.emit_name_error(tokenizer),
-            _ => (),
-        }
-        self.unconsume_name(tokenizer, input);
-        self.finish_none()
-    }
-
-    pub fn end_of_file<Sink: TokenSink>(
-        &mut self,
-        tokenizer: &XmlTokenizer<Sink>,
-        input: &BufferQueue,
-    ) {
-        while self.result.is_none() {
-            match self.state {
-                Begin => drop(self.finish_none()),
-
-                Numeric(_) if !self.seen_digit => drop(self.unconsume_numeric(tokenizer, input)),
-
-                Numeric(_) | NumericSemicolon => {
-                    tokenizer.emit_error(Borrowed("EOF in numeric character reference"));
-                    self.finish_numeric(tokenizer);
-                },
-
-                Named => drop(self.finish_named(tokenizer, None, input)),
-
-                BogusName => {
-                    self.unconsume_name(tokenizer, input);
-                    self.finish_none();
-                },
-
-                Octothorpe => {
-                    tokenizer.unconsume(input, StrTendril::from_slice("#"));
-                    tokenizer.emit_error(Borrowed("EOF after '#' in character reference"));
-                    self.finish_none();
-                },
-            }
-        }
-    }
-}