use std::borrow::Cow;
use std::collections::HashMap;

use super::diff::WasmDiffResult;
use super::diff::WasmDiffStatus;
use crate::compare::get_emacs_standard_properties;
use crate::compare::maybe_token_to_usize;
use crate::compare::ElispFact;
use crate::compare::EmacsField;
use crate::compare::EmacsStandardProperties;
use crate::compare::Token;
use crate::wasm::WasmAngleLink;
use crate::wasm::WasmAstNode;
use crate::wasm::WasmAstNodeWrapper;
use crate::wasm::WasmBabelCall;
use crate::wasm::WasmBold;
use crate::wasm::WasmCenterBlock;
use crate::wasm::WasmCitation;
use crate::wasm::WasmCitationReference;
use crate::wasm::WasmClock;
use crate::wasm::WasmCode;
use crate::wasm::WasmComment;
use crate::wasm::WasmCommentBlock;
use crate::wasm::WasmDiarySexp;
use crate::wasm::WasmDocument;
use crate::wasm::WasmDrawer;
use crate::wasm::WasmDynamicBlock;
use crate::wasm::WasmEntity;
use crate::wasm::WasmExampleBlock;
use crate::wasm::WasmExportBlock;
use crate::wasm::WasmExportSnippet;
use crate::wasm::WasmFixedWidthArea;
use crate::wasm::WasmFootnoteDefinition;
use crate::wasm::WasmFootnoteReference;
use crate::wasm::WasmHeadline;
use crate::wasm::WasmHorizontalRule;
use crate::wasm::WasmInlineBabelCall;
use crate::wasm::WasmInlineSourceBlock;
use crate::wasm::WasmItalic;
use crate::wasm::WasmKeyword;
use crate::wasm::WasmLatexEnvironment;
use crate::wasm::WasmLatexFragment;
use crate::wasm::WasmLineBreak;
use crate::wasm::WasmNodeProperty;
use crate::wasm::WasmOrgMacro;
use crate::wasm::WasmParagraph;
use crate::wasm::WasmPlainLink;
use crate::wasm::WasmPlainList;
use crate::wasm::WasmPlainListItem;
use crate::wasm::WasmPlainText;
use crate::wasm::WasmPlanning;
use crate::wasm::WasmPropertyDrawer;
use crate::wasm::WasmQuoteBlock;
use crate::wasm::WasmRadioLink;
use crate::wasm::WasmRadioTarget;
use crate::wasm::WasmRegularLink;
use crate::wasm::WasmSection;
use crate::wasm::WasmSpecialBlock;
use crate::wasm::WasmSrcBlock;
use crate::wasm::WasmStatisticsCookie;
use crate::wasm::WasmStrikeThrough;
use crate::wasm::WasmSubscript;
use crate::wasm::WasmSuperscript;
use crate::wasm::WasmTable;
use crate::wasm::WasmTableCell;
use crate::wasm::WasmTableRow;
use crate::wasm::WasmTarget;
use crate::wasm::WasmTimestamp;
use crate::wasm::WasmUnderline;
use crate::wasm::WasmVerbatim;
use crate::wasm::WasmVerseBlock;
use crate::wasm_test::macros::wasm_compare;

pub fn wasm_compare_document<'e, 's, 'w>(
    source: &'s str,
    emacs: &'e Token<'s>,
    wasm: &'w WasmAstNodeWrapper<WasmDocument>,
) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
    let wasm_json = serde_json::to_string(&wasm)?;
    let wasm_json_parsed = serde_json::from_str(&wasm_json)?;
    compare_json_value(source, emacs, &wasm_json_parsed)
}

fn compare_json_value<'b, 's>(
    source: &'s str,
    emacs: &'b Token<'s>,
    wasm: &serde_json::Value,
) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
    println!("XXXXXXXXXXXXXX compare_json_value XXXXXXXXXXXXXX");
    println!("{:?}", emacs);
    println!("{:?}", wasm);
    println!("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
    match (wasm, emacs) {
        (serde_json::Value::Object(wasm), Token::List(el)) if wasm.contains_key("ast-node") => {
            // We hit a regular ast node.
            compare_ast_node(source, el, wasm)
        }
        (serde_json::Value::String(w), Token::Atom(e))
            if e.starts_with('"') && e.ends_with('"') =>
        {
            // We hit a string compared against a quoted string from elisp (as opposed to an unquoted literal).
            compare_quoted_string(source, e, w)
        }
        (serde_json::Value::Array(w), Token::List(e)) => {
            wasm_compare_list(source, e.iter(), w.iter())
        }
        (serde_json::Value::Object(wasm), Token::List(e))
            if wasm.contains_key("optval") && wasm.contains_key("val") =>
        {
            compare_optional_pair(source, e, wasm)
        }
        (serde_json::Value::Null, Token::Atom(_)) => todo!(),
        (serde_json::Value::Null, Token::List(_)) => todo!(),
        (serde_json::Value::Null, Token::TextWithProperties(_)) => todo!(),
        (serde_json::Value::Null, Token::Vector(_)) => todo!(),
        (serde_json::Value::Bool(_), Token::Atom(_)) => todo!(),
        (serde_json::Value::Bool(_), Token::List(_)) => todo!(),
        (serde_json::Value::Bool(_), Token::TextWithProperties(_)) => todo!(),
        (serde_json::Value::Bool(_), Token::Vector(_)) => todo!(),
        (serde_json::Value::Number(_), Token::Atom(_)) => todo!(),
        (serde_json::Value::Number(_), Token::List(_)) => todo!(),
        (serde_json::Value::Number(_), Token::TextWithProperties(_)) => todo!(),
        (serde_json::Value::Number(_), Token::Vector(_)) => todo!(),
        (serde_json::Value::String(_), Token::Atom(_)) => todo!(),
        (serde_json::Value::String(_), Token::List(_)) => todo!(),
        (serde_json::Value::String(_), Token::TextWithProperties(_)) => todo!(),
        (serde_json::Value::String(_), Token::Vector(_)) => todo!(),
        (serde_json::Value::Array(_), Token::Atom(_)) => todo!(),
        // (serde_json::Value::Array(_), Token::List(_)) => todo!(),
        (serde_json::Value::Array(_), Token::TextWithProperties(_)) => todo!(),
        (serde_json::Value::Array(_), Token::Vector(_)) => todo!(),
        (serde_json::Value::Object(_), Token::Atom(_)) => todo!(),
        (serde_json::Value::Object(_), Token::List(_)) => todo!(),
        (serde_json::Value::Object(_), Token::TextWithProperties(_)) => todo!(),
        (serde_json::Value::Object(_), Token::Vector(_)) => todo!(),
    }
}

fn compare_ast_node<'e, 's, 'w>(
    source: &'s str,
    emacs: &'e Vec<Token<'s>>,
    wasm: &'w serde_json::Map<String, serde_json::Value>,
) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
    let mut result = WasmDiffResult::default();
    let mut emacs_list_iter = emacs.iter();

    {
        // Compare ast node type.
        let emacs_name = emacs_list_iter
            .next()
            .ok_or("Should have a name as the first child.")?
            .as_atom()?;
        let wasm_name = wasm
            .get("ast-node")
            .ok_or("Should have a ast node type.")?
            .as_str()
            .ok_or("Ast node type should be a string.")?;
        result.name = emacs_name.into();
        if emacs_name != wasm_name {
            result.status.push(WasmDiffStatus::Bad(
                format!(
                    "AST node name mismatch. Emacs=({emacs}) Wasm=({wasm}).",
                    emacs = emacs_name,
                    wasm = wasm_name,
                )
                .into(),
            ));
        }
    }

    if result.is_bad() {
        return Ok(result);
    }

    let emacs_attributes_map = emacs_list_iter
        .next()
        .ok_or("Should have an attributes child.")?
        .as_map()?;
    let wasm_attributes_map = wasm
        .get("properties")
        .ok_or(r#"Wasm ast node should have a "properties" attribute."#)?
        .as_object()
        .ok_or(r#"Wasm ast node "properties" attribute should be an object."#)?;

    {
        // Compare attribute names.
        let emacs_keys: std::collections::BTreeSet<String> = emacs_attributes_map
            .keys()
            .map(|s| (*s).to_owned())
            .collect();
        let wasm_keys: std::collections::BTreeSet<String> =
            std::iter::once(":standard-properties".to_owned())
                .chain(wasm_attributes_map.keys().map(wasm_key_to_emacs_key))
                .collect();
        let emacs_only_attributes: Vec<&String> = emacs_keys.difference(&wasm_keys).collect();
        let wasm_only_attributes: Vec<&String> = wasm_keys.difference(&emacs_keys).collect();
        if !emacs_only_attributes.is_empty() {
            result.status.push(WasmDiffStatus::Bad(
                format!(
                    "Wasm node lacked field present in elisp node ({name}).",
                    name = emacs_only_attributes
                        .iter()
                        .map(|s| s.as_str())
                        .intersperse(", ")
                        .collect::<String>(),
                )
                .into(),
            ));
        }
        if !wasm_only_attributes.is_empty() {
            result.status.push(WasmDiffStatus::Bad(
                format!(
                    "Elisp node lacked field present in wasm node ({name}).",
                    name = wasm_only_attributes
                        .iter()
                        .map(|s| s.as_str())
                        .intersperse(", ")
                        .collect::<String>(),
                )
                .into(),
            ));
        }
    }

    if result.is_bad() {
        return Ok(result);
    }

    {
        // Compare attributes.
        for attribute_name in wasm_attributes_map.keys() {
            let mut layer = WasmDiffResult::default();
            layer.name = Cow::Owned(attribute_name.clone());
            let wasm_attribute_value = wasm_attributes_map
                .get(attribute_name)
                .ok_or("Key should exist in both wasm and elisp at this point.")?;
            let emacs_key = wasm_key_to_emacs_key(attribute_name);
            let emacs_attribute_value = *emacs_attributes_map
                .get(emacs_key.as_str())
                .ok_or("Key should exist in both wasm and elisp at this point.")?;
            layer.extend(compare_json_value(
                source,
                emacs_attribute_value,
                wasm_attribute_value,
            )?)?;
            result.children.push(layer);
        }
    }

    {
        // Compare standard-properties.
        let mut layer = WasmDiffResult::default();
        layer.name = "standard-properties".into();
        let emacs_standard_properties = wasm_get_emacs_standard_properties(&emacs_attributes_map)?;
        let wasm_standard_properties = wasm
            .get("standard-properties")
            .ok_or(r#"Wasm AST nodes should have a "standard-properties" attribute."#)?
            .as_object()
            .ok_or(r#"Wasm ast node "standard-properties" attribute should be an object."#)?;
        for (emacs_value, wasm_name) in [
            (emacs_standard_properties.begin, "begin"),
            (emacs_standard_properties.end, "end"),
            (emacs_standard_properties.contents_begin, "contents-begin"),
            (emacs_standard_properties.contents_end, "contents-end"),
            (emacs_standard_properties.post_blank, "post-blank"),
        ] {
            match (emacs_value, wasm_standard_properties.get(wasm_name)) {
                (None, None) => {}
                (None, Some(_)) => {
                    layer.status.push(WasmDiffStatus::Bad(
                        format!(
                            "Elisp node lacked field present in wasm node. Name=({name}).",
                            name = wasm_name,
                        )
                        .into(),
                    ));
                }
                (Some(_), None) => {
                    layer.status.push(WasmDiffStatus::Bad(
                        format!(
                            "Wasm node lacked field present in elisp node. Name=({name}).",
                            name = wasm_name,
                        )
                        .into(),
                    ));
                }
                (Some(e), Some(serde_json::Value::Number(w)))
                    if w.as_u64().map(|w| w as usize) == Some(e) => {}
                (Some(e), Some(w)) => {
                    layer.status.push(WasmDiffStatus::Bad(
                        format!(
                            "Property value mismatch. Emacs=({emacs:?}) Wasm=({wasm:?}).",
                            emacs = e,
                            wasm = w,
                        )
                        .into(),
                    ));
                }
            }
        }
        result.children.push(layer);
    }

    {
        // Compare children.
        let mut layer = WasmDiffResult::default();
        if let Some(wasm_iter) = wasm
            .get("children")
            .map(|children| children.as_array())
            .flatten()
            .map(|children| children.iter())
        {
            layer.extend(wasm_compare_list(source, emacs_list_iter, wasm_iter)?)?;
        } else {
            layer.extend(wasm_compare_list(
                source,
                emacs_list_iter,
                std::iter::empty::<&serde_json::Value>(),
            )?)?;
        }
        result.children.push(layer);
    }

    Ok(result)
}

fn wasm_key_to_emacs_key<WK: std::fmt::Display>(wasm_key: WK) -> String {
    format!(":{key}", key = wasm_key)
}

fn compare_quoted_string<'e, 's, 'w>(
    source: &'s str,
    emacs: &'e str,
    wasm: &'w String,
) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
    let mut result = WasmDiffResult::default();
    // TODO
    Ok(result)
}

pub(crate) fn wasm_get_emacs_standard_properties(
    attributes_map: &HashMap<&str, &Token<'_>>,
) -> Result<EmacsStandardProperties, Box<dyn std::error::Error>> {
    let standard_properties = attributes_map.get(":standard-properties");
    Ok(if standard_properties.is_some() {
        let mut std_props = standard_properties
            .expect("if statement proves its Some")
            .as_vector()?
            .iter();
        let begin = maybe_token_to_usize(std_props.next())?;
        let post_affiliated = maybe_token_to_usize(std_props.next())?;
        let contents_begin = maybe_token_to_usize(std_props.next())?;
        let contents_end = maybe_token_to_usize(std_props.next())?;
        let end = maybe_token_to_usize(std_props.next())?;
        let post_blank = maybe_token_to_usize(std_props.next())?;
        EmacsStandardProperties {
            begin,
            post_affiliated,
            contents_begin,
            contents_end,
            end,
            post_blank,
        }
    } else {
        let begin = maybe_token_to_usize(attributes_map.get(":begin").copied())?;
        let end = maybe_token_to_usize(attributes_map.get(":end").copied())?;
        let contents_begin = maybe_token_to_usize(attributes_map.get(":contents-begin").copied())?;
        let contents_end = maybe_token_to_usize(attributes_map.get(":contents-end").copied())?;
        let post_blank = maybe_token_to_usize(attributes_map.get(":post-blank").copied())?;
        let post_affiliated =
            maybe_token_to_usize(attributes_map.get(":post-affiliated").copied())?;
        EmacsStandardProperties {
            begin,
            post_affiliated,
            contents_begin,
            contents_end,
            end,
            post_blank,
        }
    })
}

fn wasm_compare_list<'e, 's: 'e, 'w, EI, WI>(
    source: &'s str,
    emacs: EI,
    wasm: WI,
) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>>
where
    EI: Iterator<Item = &'e Token<'s>> + ExactSizeIterator,
    WI: Iterator<Item = &'w serde_json::Value> + ExactSizeIterator,
{
    let emacs_length = emacs.len();
    let wasm_length = wasm.len();
    if emacs_length != wasm_length {
        return Ok(WasmDiffResult {
            status: vec![WasmDiffStatus::Bad(
                format!(
                    "Child length mismatch. Emacs=({emacs:?}) Wasm=({wasm:?}).",
                    emacs = emacs_length,
                    wasm = wasm_length
                )
                .into(),
            )],
            children: Vec::new(),
            name: "".into(),
        });
    }

    let mut child_status = Vec::with_capacity(emacs_length);
    for (emacs_child, wasm_child) in emacs.zip(wasm) {
        child_status.push(compare_json_value(source, emacs_child, wasm_child)?);
    }
    Ok(WasmDiffResult {
        status: Vec::new(),
        children: child_status,
        name: "".into(),
    })
}

fn compare_optional_pair<'e, 's, 'w>(
    source: &'s str,
    emacs: &'e Vec<Token<'s>>,
    wasm: &'w serde_json::Map<String, serde_json::Value>,
) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
    let mut result = WasmDiffResult::default();
    let wasm_optval = wasm
        .get("optval")
        .ok_or(r#"Wasm optional pair should have an "optval" attribute."#)?;
    let wasm_val = wasm
        .get("val")
        .ok_or(r#"Wasm optional pair should have an "optval" attribute."#)?;
    if let serde_json::Value::Null = wasm_optval {
        // If the optval is null, then the elisp should have just a single value of a quoted string.
        if emacs.len() != 1 {
            return Ok(WasmDiffResult {
                status: vec![WasmDiffStatus::Bad(
                    format!(
                        "Optional pair with null optval should have 1 element. Emacs=({emacs:?}) Wasm=({wasm:?}).",
                        emacs = emacs,
                        wasm = wasm
                    )
                    .into(),
                )],
                children: Vec::new(),
                name: "".into(),
            });
        }

        let emacs_val = emacs
            .first()
            .expect("If-statement proves this will be Some.");
        result.extend(compare_json_value(source, emacs_val, wasm_val)?)?;
    } else {
        // If the optval is not null, then the elisp should have 3 values, the optval, a dot, and the val.
        if emacs.len() != 3 {
            return Ok(WasmDiffResult {
                status: vec![WasmDiffStatus::Bad(
                    format!(
                        "Optional pair with non-null optval should have 3 elements. Emacs=({emacs:?}) Wasm=({wasm:?}).",
                        emacs = emacs,
                        wasm = wasm
                    )
                    .into(),
                )],
                children: Vec::new(),
                name: "".into(),
            });
        }
        let emacs_optval = emacs
            .first()
            .expect("If-statement proves this will be Some.");
        let emacs_val = emacs
            .get(2)
            .expect("If-statement proves this will be Some.");
        result.extend(compare_json_value(source, emacs_optval, wasm_optval)?)?;
        result.extend(compare_json_value(source, emacs_val, wasm_val)?)?;
    }
    Ok(result)
}

// pub fn old_wasm_compare_document<'b, 's, 'p>(
//     source: &'s str,
//     emacs: &'b Token<'s>,
//     wasm: WasmDocument<'s, 'p>,
// ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//     wasm.compare_ast_node(source, emacs)
// }

// impl<'s, 'p, WAN: WasmElispCompare<'s, 'p>> WasmElispCompare<'s, 'p> for &WAN {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         (*self).compare_ast_node(source, emacs)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmAstNode<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         match self {
//             WasmAstNode::Document(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::Headline(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::Section(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::Paragraph(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::PlainList(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::PlainListItem(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::CenterBlock(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::QuoteBlock(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::SpecialBlock(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::DynamicBlock(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::FootnoteDefinition(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::Comment(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::Drawer(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::PropertyDrawer(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::NodeProperty(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::Table(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::TableRow(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::VerseBlock(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::CommentBlock(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::ExampleBlock(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::ExportBlock(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::SrcBlock(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::Clock(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::DiarySexp(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::Planning(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::FixedWidthArea(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::HorizontalRule(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::Keyword(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::BabelCall(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::LatexEnvironment(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::Bold(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::Italic(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::Underline(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::StrikeThrough(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::Code(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::Verbatim(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::PlainText(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::RegularLink(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::RadioLink(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::RadioTarget(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::PlainLink(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::AngleLink(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::OrgMacro(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::Entity(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::LatexFragment(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::ExportSnippet(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::FootnoteReference(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::Citation(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::CitationReference(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::InlineBabelCall(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::InlineSourceBlock(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::LineBreak(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::Target(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::StatisticsCookie(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::Subscript(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::Superscript(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::TableCell(inner) => inner.compare_ast_node(source, emacs),
//             WasmAstNode::Timestamp(inner) => inner.compare_ast_node(source, emacs),
//         }
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmDocument<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         let result = wasm_compare!(
//             source,
//             emacs,
//             self,
//             (
//                 EmacsField::Required(":path"),
//                 |w| w.path.as_ref().and_then(|p| p.to_str()),
//                 wasm_compare_property_quoted_string
//             ),
//             (
//                 EmacsField::Required(":CATEGORY"),
//                 |w| w.category.as_ref(),
//                 wasm_compare_property_quoted_string
//             )
//         );
//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmHeadline<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmSection<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         let result = wasm_compare!(source, emacs, self,);

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmParagraph<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         let result = wasm_compare!(source, emacs, self,);

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmPlainList<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmPlainListItem<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmCenterBlock<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmQuoteBlock<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmSpecialBlock<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmDynamicBlock<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmFootnoteDefinition<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmComment<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmDrawer<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmPropertyDrawer<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmNodeProperty<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmTable<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmTableRow<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmVerseBlock<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmCommentBlock<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmExampleBlock<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmExportBlock<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmSrcBlock<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmClock<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmDiarySexp<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmPlanning<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmFixedWidthArea<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmHorizontalRule<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmKeyword<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmBabelCall<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmLatexEnvironment<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmBold<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmItalic<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmUnderline<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmStrikeThrough<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmCode<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmVerbatim<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmPlainText<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmRegularLink<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmRadioLink<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmRadioTarget<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmPlainLink<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmAngleLink<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmOrgMacro<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmEntity<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmLatexFragment<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmExportSnippet<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmFootnoteReference<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmCitation<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmCitationReference<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmInlineBabelCall<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmInlineSourceBlock<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmLineBreak<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmTarget<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmStatisticsCookie<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmSubscript<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmSuperscript<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmTableCell<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }

// impl<'s, 'p> WasmElispCompare<'s, 'p> for WasmTimestamp<'s, 'p> {
//     fn compare_ast_node<'b>(
//         &self,
//         source: &'s str,
//         emacs: &'b Token<'s>,
//     ) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
//         // TODO: Implement this.
//         let result = WasmDiffResult::default();
//         // let result = wasm_compare!(
//         //     source,
//         //     emacs,
//         //     self,
//         //     (
//         //         EmacsField::Required(":path"),
//         //         |w| w.path.as_ref().and_then(|p| p.to_str()),
//         //         wasm_compare_property_quoted_string
//         //     ),
//         //     (
//         //         EmacsField::Required(":CATEGORY"),
//         //         |w| w.category.as_ref(),
//         //         wasm_compare_property_quoted_string
//         //     )
//         // );

//         Ok(result)
//     }
// }