blitz-pdf 0.1.2 → 0.1.4

package/vendor/blitz-dom/src/font_metrics.rs

@@ -0,0 +1,177 @@
+use std::sync::{Arc, Mutex};
+
+use crate::stylo_to_parley;
+use app_units::Au;
+use parley::{FontContext, FontVariation};
+use skrifa::MetadataProvider as _;
+use skrifa::charmap::Charmap;
+use style::properties::style_structs::Font as FontStyles;
+use style::{
+    device::servo::FontMetricsProvider,
+    font_metrics::FontMetrics,
+    values::computed::{CSSPixelLength, font::QueryFontMetricsFlags},
+};
+
+/// Query fontique for the fonts matching `font_styles` (family list and attributes).
+fn query_for_font_styles<'a>(
+    font_ctx: &'a mut FontContext,
+    font_styles: &'a FontStyles,
+) -> parley::fontique::Query<'a> {
+    use parley::fontique::Attributes;
+
+    let mut query = font_ctx.collection.query(&mut font_ctx.source_cache);
+    let families = font_styles
+        .font_family
+        .families
+        .iter()
+        .map(stylo_to_parley::query_font_family);
+    query.set_families(families);
+    query.set_attributes(Attributes {
+        width: stylo_to_parley::font_width(font_styles.font_width),
+        weight: stylo_to_parley::font_weight(font_styles.font_weight),
+        style: stylo_to_parley::font_style(font_styles.font_style),
+    });
+    query
+}
+
+#[derive(Clone)]
+pub(crate) struct BlitzFontMetricsProvider {
+    pub(crate) font_ctx: Arc<Mutex<FontContext>>,
+}
+
+impl core::fmt::Debug for BlitzFontMetricsProvider {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "BlitzFontMetricsProvider")
+    }
+}
+
+impl FontMetricsProvider for BlitzFontMetricsProvider {
+    fn query_font_metrics(
+        &self,
+        _vertical: bool,
+        font_styles: &FontStyles,
+        font_size: CSSPixelLength,
+        _flags: QueryFontMetricsFlags,
+    ) -> FontMetrics {
+        use parley::fontique::{Query, QueryFont, QueryStatus};
+        use skrifa::instance::{LocationRef, Size};
+        use skrifa::metrics::{GlyphMetrics, Metrics};
+
+        // Lock font_ctx. Explicit reborrow required for borrow checker.
+        let mut font_ctx = self.font_ctx.lock().unwrap();
+        let font_ctx = &mut *font_ctx;
+
+        // Query fontique for the font that matches the font styles
+        let mut query = query_for_font_styles(font_ctx, font_styles);
+        // let fb_script = crate::swash_convert::script_to_fontique(script);
+        // let fb_language = locale.and_then(crate::swash_convert::locale_to_fontique);
+        // query.set_fallbacks(fontique::FallbackKey::new(fb_script, fb_language.as_ref()));
+
+        let variations = stylo_to_parley::font_variations(&font_styles.font_variation_settings);
+        // let features = self.rcx.features(style.font_features).unwrap_or(&[]);
+
+        // fn name_of(font_ref: &skrifa::FontRef) -> String {
+        //     use skrifa::string::StringId;
+        //     font_ref
+        //         .localized_strings(StringId::POSTSCRIPT_NAME)
+        //         .english_or_first()
+        //         .unwrap()
+        //         .chars()
+        //         .collect()
+        // }
+
+        fn find_font_for(query: &mut Query, ch: char) -> Option<QueryFont> {
+            let mut font = None;
+            query.matches_with(|q_font: &QueryFont| {
+                use skrifa::MetadataProvider;
+
+                let Ok(font_ref) = skrifa::FontRef::from_index(q_font.blob.as_ref(), q_font.index)
+                else {
+                    return QueryStatus::Continue;
+                };
+
+                let charmap = font_ref.charmap();
+                if charmap.map(ch).is_some() {
+                    font = Some(q_font.clone());
+                    QueryStatus::Stop
+                } else {
+                    QueryStatus::Continue
+                }
+            });
+            font
+        }
+
+        /// Scales the advance the same way as Parley's shaped glyph advances (font units × size / upem)
+        /// rather than with skrifa's FreeType-compatible fixed-point scale, so that `ch`/`ic`
+        /// lengths exactly match the width of the corresponding laid-out text.
+        fn advance_of(
+            query: &mut Query,
+            ch: char,
+            font_size: f32,
+            variations: &[FontVariation],
+        ) -> Option<f32> {
+            let font = find_font_for(query, ch)?;
+            let font_ref = skrifa::FontRef::from_index(font.blob.as_ref(), font.index).ok()?;
+            let location = font_ref.axes().location(
+                variations
+                    .iter()
+                    .map(|v| (skrifa::Tag::from_be_bytes(v.tag.to_bytes()), v.value)),
+            );
+            let location_ref = LocationRef::from(&location);
+            let upem = Metrics::new(&font_ref, Size::unscaled(), location_ref).units_per_em;
+            if upem == 0 {
+                return None;
+            }
+            let glyph_metrics = GlyphMetrics::new(&font_ref, Size::unscaled(), location_ref);
+            let char_map = Charmap::new(&font_ref);
+            let glyph_id = char_map.map(ch)?;
+            let advance = glyph_metrics.advance_width(glyph_id)?;
+            Some(advance * (font_size / upem as f32))
+        }
+
+        fn metrics_of(
+            query: &mut Query,
+            ch: char,
+            font_size: Size,
+            variations: &[FontVariation],
+        ) -> Option<(f32, Option<f32>, Option<f32>)> {
+            let font = find_font_for(query, ch)?;
+            let font_ref = skrifa::FontRef::from_index(font.blob.as_ref(), font.index).ok()?;
+            let location = font_ref.axes().location(
+                variations
+                    .iter()
+                    .map(|v| (skrifa::Tag::from_be_bytes(v.tag.to_bytes()), v.value)),
+            );
+            let location_ref = LocationRef::from(&location);
+            let metrics = Metrics::new(&font_ref, font_size, location_ref);
+            Some((metrics.ascent, metrics.x_height, metrics.cap_height))
+        }
+
+        let zero_advance = advance_of(&mut query, '0', font_size.px(), &variations);
+        let ic_advance = advance_of(&mut query, '\u{6C34}', font_size.px(), &variations);
+        let (ascent, x_height, cap_height) =
+            metrics_of(&mut query, ' ', Size::new(font_size.px()), &variations)
+                .unwrap_or((0.0, None, None));
+
+        FontMetrics {
+            ascent: CSSPixelLength::new(ascent),
+            x_height: x_height.filter(|xh| *xh != 0.0).map(CSSPixelLength::new),
+            cap_height: cap_height.map(CSSPixelLength::new),
+            zero_advance_measure: zero_advance.map(CSSPixelLength::new),
+            ic_width: ic_advance.map(CSSPixelLength::new),
+            script_percent_scale_down: None,
+            script_script_percent_scale_down: None,
+        }
+    }
+
+    fn base_size_for_generic(
+        &self,
+        generic: style::values::computed::font::GenericFontFamily,
+    ) -> style::values::computed::Length {
+        let size = match generic {
+            style::values::computed::font::GenericFontFamily::Monospace => 13.0,
+            _ => 16.0,
+        };
+        style::values::computed::Length::from(Au::from_f32_px(size))
+    }
+}

package/vendor/blitz-dom/src/form.rs

@@ -0,0 +1,463 @@
+use blitz_traits::node_id::NodeId;
+use markup5ever::{LocalName, local_name};
+
+use crate::{
+    BaseDocument, ElementData,
+    traversal::{AncestorTraverser, TreeTraverser},
+};
+use blitz_traits::{
+    navigation::NavigationOptions,
+    net::{Body, Entry, EntryValue, FormData, Method},
+};
+use core::str::FromStr;
+use std::fmt::Display;
+
+/// https://url.spec.whatwg.org/#default-encode-set
+const DEFAULT_ENCODE_SET: percent_encoding::AsciiSet = percent_encoding::CONTROLS
+    // Query Set
+    .add(b' ')
+    .add(b'"')
+    .add(b'#')
+    .add(b'<')
+    .add(b'>')
+    // Path Set
+    .add(b'?')
+    .add(b'`')
+    .add(b'{')
+    .add(b'}');
+
+impl BaseDocument {
+    /// Resets the form owner for a given node by either using an explicit form attribute
+    /// or finding the nearest ancestor form element
+    ///
+    /// # Arguments
+    /// * `node_id` - The ID of the node whose form owner needs to be reset
+    ///
+    /// <https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#reset-the-form-owner>
+    pub fn reset_form_owner(&mut self, node_id: NodeId) {
+        let node = &self.nodes[node_id];
+        let Some(element) = node.element_data() else {
+            return;
+        };
+
+        // First try explicit form attribute
+        let final_owner_id = element
+            .attr(local_name!("form"))
+            .and_then(|owner| self.get_element_by_id(owner))
+            .filter(|owner_id| {
+                self.get_node(*owner_id)
+                    .is_some_and(|node| node.data.is_element_with_tag_name(&local_name!("form")))
+            })
+            .or_else(|| {
+                AncestorTraverser::new(self, node_id).find(|ancestor_id| {
+                    self.nodes[*ancestor_id]
+                        .data
+                        .is_element_with_tag_name(&local_name!("form"))
+                })
+            });
+
+        if let Some(final_owner_id) = final_owner_id {
+            self.controls_to_form.insert(node_id, final_owner_id);
+        }
+    }
+
+    /// Submits a form with the given form node ID and submitter node ID
+    ///
+    /// # Arguments
+    /// * `node_id` - The ID of the form node to submit
+    /// * `submitter_id` - The ID of the node that triggered the submission
+    ///
+    /// <https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#form-submission-algorithm>
+    pub fn submit_form(&self, node_id: NodeId, submitter_id: NodeId) {
+        let node = &self.nodes[node_id];
+        let Some(element) = node.element_data() else {
+            return;
+        };
+
+        let entry = construct_entry_list(self, node_id, submitter_id);
+
+        let method = get_form_attr(
+            self,
+            element,
+            local_name!("method"),
+            submitter_id,
+            local_name!("formmethod"),
+        )
+        .and_then(|method| method.parse::<FormMethod>().ok())
+        .unwrap_or(FormMethod::Get);
+
+        let action = get_form_attr(
+            self,
+            element,
+            local_name!("action"),
+            submitter_id,
+            local_name!("formaction"),
+        )
+        .unwrap_or_default();
+
+        let mut parsed_action = self.resolve_url(action);
+
+        let scheme = parsed_action.scheme();
+
+        let enctype = get_form_attr(
+            self,
+            element,
+            local_name!("enctype"),
+            submitter_id,
+            local_name!("formenctype"),
+        )
+        .and_then(|enctype| enctype.parse::<RequestContentType>().ok())
+        .unwrap_or(RequestContentType::FormUrlEncoded);
+
+        let mut post_resource = Body::Empty;
+
+        match (scheme, method) {
+            ("http" | "https" | "data", FormMethod::Get) => {
+                let pairs = convert_to_list_of_name_value_pairs(entry);
+                let mut query = String::new();
+                url::form_urlencoded::Serializer::new(&mut query).extend_pairs(pairs);
+                parsed_action.set_query(Some(&query));
+            }
+            ("http" | "https", FormMethod::Post) => post_resource = Body::Form(entry),
+            ("mailto", FormMethod::Get) => {
+                let pairs = convert_to_list_of_name_value_pairs(entry);
+                parsed_action.query_pairs_mut().extend_pairs(pairs);
+            }
+            ("mailto", FormMethod::Post) => {
+                let pairs = convert_to_list_of_name_value_pairs(entry);
+                let body = match enctype {
+                    RequestContentType::TextPlain => {
+                        let body = encode_text_plain(&pairs);
+                        percent_encoding::utf8_percent_encode(&body, &DEFAULT_ENCODE_SET)
+                            .to_string()
+                    }
+                    _ => {
+                        let mut body = String::new();
+                        url::form_urlencoded::Serializer::new(&mut body).extend_pairs(pairs);
+                        body
+                    }
+                };
+                let mut query = if let Some(query) = parsed_action.query() {
+                    let mut query = query.to_string();
+                    query.push('&');
+                    query
+                } else {
+                    String::new()
+                };
+                query.push_str("body=");
+                query.push_str(&body);
+                parsed_action.set_query(Some(&query));
+            }
+            _ => {
+                #[cfg(feature = "tracing")]
+                tracing::warn!(
+                    "Scheme {} with method {:?} is not implemented",
+                    scheme,
+                    method
+                );
+                return;
+            }
+        }
+
+        let method = method.try_into().unwrap_or_default();
+
+        let navigation_options =
+            NavigationOptions::new(parsed_action, Some(enctype.to_string()), self.id())
+                .set_document_resource(post_resource)
+                .set_method(method);
+
+        self.navigation_provider.navigate_to(navigation_options)
+    }
+}
+
+/// Constructs a list of form entries from form controls
+///
+/// # Arguments
+/// * `doc` - Reference to the base document
+/// * `form_id` - ID of the form element
+/// * `submitter_id` - ID of the element that triggered form submission
+///
+/// # Returns
+/// Returns an EntryList containing all valid form control entries
+///
+/// https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#constructing-the-form-data-set
+fn construct_entry_list(doc: &BaseDocument, form_id: NodeId, submitter_id: NodeId) -> FormData {
+    let mut entry_list = FormData::new();
+
+    let mut create_entry = |name: &str, value: EntryValue| {
+        entry_list.0.push(Entry {
+            name: name.to_string(),
+            value,
+        });
+    };
+
+    fn datalist_ancestor(doc: &BaseDocument, node_id: NodeId) -> bool {
+        AncestorTraverser::new(doc, node_id).any(|node_id| {
+            doc.nodes[node_id]
+                .data
+                .is_element_with_tag_name(&local_name!("datalist"))
+        })
+    }
+
+    // For each element field in controls, in tree order:
+    for control_id in TreeTraverser::new(doc) {
+        let Some(node) = doc.get_node(control_id) else {
+            continue;
+        };
+        let Some(element) = node.element_data() else {
+            continue;
+        };
+
+        // Check if the form owner is same as form_id
+        if doc
+            .controls_to_form
+            .get(&control_id)
+            .map(|owner_id| *owner_id != form_id)
+            .unwrap_or(true)
+        {
+            continue;
+        }
+
+        let element_type = element.attr(local_name!("type"));
+
+        //  If any of the following are true:
+        //   field has a datalist element ancestor;
+        //   field is disabled;
+        //   field is a button but it is not submitter;
+        //   field is an input element whose type attribute is in the Checkbox state and whose checkedness is false; or
+        //   field is an input element whose type attribute is in the Radio Button state and whose checkedness is false,
+        //  then continue.
+        if datalist_ancestor(doc, node.id)
+            || element.attr(local_name!("disabled")).is_some()
+            || (element.name.local == local_name!("button") && node.id != submitter_id)
+            || element.name.local == local_name!("input")
+                && ((matches!(element_type, Some("checkbox" | "radio"))
+                    && !element.checkbox_input_checked().unwrap_or(false))
+                    || matches!(element_type, Some("submit" | "button")))
+        {
+            continue;
+        }
+
+        // If the field element is an input element whose type attribute is in the Image Button state, then:
+        if element_type == Some("image") {
+            // If the field element is not submitter, then continue.
+            if node.id != submitter_id {
+                continue;
+            }
+            // TODO: If the field element has a name attribute specified and its value is not the empty string, let name be that value followed by U+002E (.). Otherwise, let name be the empty string.
+            //   Let namex be the concatenation of name and U+0078 (x).
+            //   Let namey be the concatenation of name and U+0079 (y).
+            //   Let (x, y) be the selected coordinate.
+            //   Create an entry with namex and x, and append it to entry list.
+            //   Create an entry with namey and y, and append it to entry list.
+            //   Continue.
+            continue;
+        }
+
+        // TODO: If the field is a form-associated custom element,
+        //  then perform the entry construction algorithm given field and entry list,
+        //  then continue.
+
+        // If either the field element does not have a name attribute specified, or its name attribute's value is the empty string, then continue.
+        // Let name be the value of the field element's name attribute.
+        let Some(name) = element
+            .attr(local_name!("name"))
+            .filter(|str| !str.is_empty())
+        else {
+            continue;
+        };
+
+        // TODO: If the field element is a select element,
+        //  then for each option element in the select element's
+        //  list of options whose selectedness is true and that is not disabled,
+        //  create an entry with name and the value of the option element,
+        //  and append it to entry list.
+
+        // Otherwise, if the field element is an input element whose type attribute is in the Checkbox state or the Radio Button state, then:
+        if element.name.local == local_name!("input")
+            && matches!(element_type, Some("checkbox" | "radio"))
+        {
+            // If the field element has a value attribute specified, then let value be the value of that attribute; otherwise, let value be the string "on".
+            let value = element.attr(local_name!("value")).unwrap_or("on");
+            // Create an entry with name and value, and append it to entry list.
+            create_entry(name, value.into());
+            continue;
+        }
+        // Otherwise, if the field element is an input element whose type attribute is in the File Upload state, then:
+        #[cfg(feature = "file-input")]
+        if element.name.local == local_name!("input") && matches!(element_type, Some("file")) {
+            // If there are no selected files, then create an entry with name and a new File object with an empty name, application/octet-stream as type, and an empty body, and append it to entry list.
+            let Some(files) = element.file_data() else {
+                create_entry(name, EntryValue::EmptyFile);
+                continue;
+            };
+            if files.is_empty() {
+                create_entry(name, EntryValue::EmptyFile);
+            }
+            // Otherwise, for each file in selected files, create an entry with name and a File object representing the file, and append it to entry list.
+            else {
+                for path_buf in files.iter() {
+                    create_entry(name, path_buf.clone().into());
+                }
+            }
+            continue;
+        }
+        //Otherwise, if the field element is an input element whose type attribute is in the Hidden state and name is an ASCII case-insensitive match for "_charset_":
+        if element.name.local == local_name!("input")
+            && element_type == Some("hidden")
+            && name.eq_ignore_ascii_case("_charset_")
+        {
+            // Let charset be the name of encoding.
+            let charset = "UTF-8"; // TODO: Support multiple encodings.
+            // Create an entry with name and charset, and append it to entry list.
+            create_entry(name, charset.into());
+        }
+        // Otherwise, create an entry with name and the value of the field element, and append it to entry list.
+        else if let Some(text) = element.text_input_data() {
+            create_entry(name, text.editor.text().to_string().as_str().into());
+        } else if let Some(value) = element.attr(local_name!("value")) {
+            create_entry(name, value.into());
+        }
+    }
+    entry_list
+}
+
+fn get_form_attr<'a>(
+    doc: &'a BaseDocument,
+    form: &'a ElementData,
+    form_local: impl PartialEq<LocalName>,
+    submitter_id: NodeId,
+    submitter_local: impl PartialEq<LocalName>,
+) -> Option<&'a str> {
+    get_submitter_attr(doc, submitter_id, submitter_local).or_else(|| form.attr(form_local))
+}
+
+fn get_submitter_attr(
+    doc: &BaseDocument,
+    submitter_id: NodeId,
+    local_name: impl PartialEq<LocalName>,
+) -> Option<&str> {
+    doc.get_node(submitter_id)
+        .and_then(|node| node.element_data())
+        .and_then(|element_data| {
+            if element_data.name.local == local_name!("button")
+                && element_data.attr(local_name!("type")) == Some("submit")
+            {
+                element_data.attr(local_name)
+            } else {
+                None
+            }
+        })
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+enum FormMethod {
+    Get,
+    Post,
+    Dialog,
+}
+impl FromStr for FormMethod {
+    type Err = ();
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(match s.to_lowercase().as_str() {
+            "get" => FormMethod::Get,
+            "post" => FormMethod::Post,
+            "dialog" => FormMethod::Dialog,
+            _ => return Err(()),
+        })
+    }
+}
+impl TryFrom<FormMethod> for Method {
+    type Error = &'static str;
+    fn try_from(method: FormMethod) -> Result<Self, Self::Error> {
+        Ok(match method {
+            FormMethod::Get => Method::GET,
+            FormMethod::Post => Method::POST,
+            FormMethod::Dialog => return Err("Dialog is not an HTTP method"),
+        })
+    }
+}
+/// Supported content types for HTTP requests
+#[derive(Debug, Clone)]
+pub enum RequestContentType {
+    /// application/x-www-form-urlencoded
+    FormUrlEncoded,
+    /// multipart/form-data
+    MultipartFormData,
+    /// text/plain
+    TextPlain,
+}
+
+impl FromStr for RequestContentType {
+    type Err = ();
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(match s {
+            "application/x-www-form-urlencoded" => RequestContentType::FormUrlEncoded,
+            "multipart/form-data" => RequestContentType::MultipartFormData,
+            "text/plain" => RequestContentType::TextPlain,
+            _ => return Err(()),
+        })
+    }
+}
+
+impl Display for RequestContentType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            RequestContentType::FormUrlEncoded => write!(f, "application/x-www-form-urlencoded"),
+            RequestContentType::MultipartFormData => write!(f, "multipart/form-data"),
+            RequestContentType::TextPlain => write!(f, "text/plain"),
+        }
+    }
+}
+
+/// Converts the entry list to a vector of name-value pairs with normalized line endings
+/// https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#converting-an-entry-list-to-a-list-of-name-value-pairs
+fn convert_to_list_of_name_value_pairs(form_data: FormData) -> Vec<(String, String)> {
+    form_data
+        .iter()
+        .map(|Entry { name, value }| {
+            let name = normalize_line_endings(name.as_ref());
+            let value = normalize_line_endings(value.as_ref());
+            (name, value)
+        })
+        .collect()
+}
+
+/// Normalizes line endings in a string according to HTML spec
+/// Converts single CR or LF to CRLF pairs according to HTML form submission requirements
+fn normalize_line_endings(input: &str) -> String {
+    // Replace every occurrence of U+000D (CR) not followed by U+000A (LF),
+    // and every occurrence of U+000A (LF) not preceded by U+000D (CR),
+    // in value, by a string consisting of U+000D (CR) and U+000A (LF).
+
+    let mut result = String::with_capacity(input.len());
+    let mut chars = input.chars().peekable();
+
+    while let Some(current) = chars.next() {
+        match (current, chars.peek()) {
+            ('\r', Some('\n')) => {
+                result.push_str("\r\n");
+                chars.next();
+            }
+            ('\r' | '\n', _) => {
+                result.push_str("\r\n");
+            }
+            _ => result.push(current),
+        }
+    }
+
+    result
+}
+
+/// Encodes form data as text/plain according to HTML spec given an slice of name-value pairs
+/// https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#text/plain-encoding-algorithm
+fn encode_text_plain<T: AsRef<str>, U: AsRef<str>>(input: &[(T, U)]) -> String {
+    let mut out = String::new();
+    for (name, value) in input {
+        out.push_str(name.as_ref());
+        out.push('=');
+        out.push_str(value.as_ref());
+        out.push_str("\r\n");
+    }
+    out
+}

package/vendor/blitz-dom/src/html.rs

@@ -0,0 +1,38 @@
+use crate::{BaseDocument, Document, DocumentConfig, DocumentMutator, PlainDocument};
+use blitz_traits::node_id::NodeId;
+
+pub trait HtmlParserProvider {
+    fn parse_inner_html<'m, 'doc>(
+        &self,
+        mutr: &'m mut DocumentMutator<'doc>,
+        element_id: NodeId,
+        html: &str,
+    );
+
+    /// Parse a full HTML document (e.g. the contents of an `<iframe>`).
+    ///
+    /// The default implementation ignores the HTML and returns an empty document.
+    fn parse_document(&self, html: &str, config: DocumentConfig) -> Box<dyn Document> {
+        let _ = html;
+        Box::new(PlainDocument(BaseDocument::new(config)))
+    }
+}
+
+pub struct DummyHtmlParserProvider;
+impl HtmlParserProvider for DummyHtmlParserProvider {
+    fn parse_inner_html<'m, 'doc>(
+        &self,
+        mutr: &'m mut DocumentMutator<'doc>,
+        element_id: NodeId,
+        html: &str,
+    ) {
+        let _ = mutr;
+        let _ = element_id;
+        let _ = html;
+        // Do nothing for now
+        //
+        // TODO: do something:
+        // - Print warning?
+        // - Parse HTML as plain text?
+    }
+}