use std::borrow::Cow;

use super::diff::WasmDiffResult;
use super::diff::WasmDiffStatus;
use crate::compare::ElispFact;
use crate::compare::EmacsField;
use crate::compare::Token;
use crate::wasm::WasmAngleLink;
use crate::wasm::WasmAstNode;
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 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(&wasm_json_parsed, source, emacs)
}

fn compare_json_value<'b, 's>(
    value: &serde_json::Value,
    source: &'s str,
    emacs: &'b Token<'s>,
) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
    match (value, 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::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<'b, 's, 'p>(
    source: &'s str,
    emacs: &'b Vec<Token<'s>>,
    wasm: &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()?;

    {
        // 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> = wasm
            .keys()
            .filter(|k| !k.starts_with("__"))
            .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
            .keys()
            .filter(|k| !k.starts_with("__") && k.as_str() != "standard-properties")
        {
            let mut layer = WasmDiffResult::default();
            layer.name = Cow::Owned(attribute_name.clone());
            let wasm_attribute_value = wasm
                .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(
                wasm_attribute_value,
                source,
                emacs_attribute_value,
            )?)?;
            result.children.push(layer);
        }
    }

    // TODO: compare standard-properties.
    // TODO: compare children

    Ok(result)
}

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

// 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)
//     }
// }