Publish version 0.1.15.

serde_wasm_bindgen was silently dropping many attributes (I suspect it is triggered by serde flatten) so this switches to serializing to JSON for passing values from wasm to js.

.lighthouse/pipeline-rust-test.yaml

@@ -115,7 +115,7 @@ spec:
               [
                 --no-default-features,
                 --features,
-                compare,
+                "compare,wasm_test",
                 --no-fail-fast,
                 --lib,
                 --test,

.lighthouse/pipeline-rustfmt.yaml

@@ -127,7 +127,7 @@ spec:
           - name: command
             value: ["cargo", "fix"]
           - name: args
-            value: ["--allow-dirty"]
+            value: ["--all-targets", "--all-features", "--allow-dirty"]
           - name: docker-image
             value: "$(params.image-name):$(tasks.fetch-repository.results.commit)"
       - name: commit-changes

Cargo.toml

@@ -2,7 +2,7 @@
 
 [package]
 name = "organic"
-version = "0.1.13"
+version = "0.1.15"
 authors = ["Tom Alexander <tom@fizz.buzz>"]
 description = "An org-mode parser."
 edition = "2021"
@@ -45,12 +45,14 @@ path = "src/lib.rs"
   required-features = ["wasm"]
 
 [[bin]]
+  # This bin exists for development purposes only. The real target of this crate is the library.
   name = "wasm_test"
   path = "src/bin_wasm_test.rs"
   required-features = ["wasm_test"]
 
 [dependencies]
 futures = { version = "0.3.28", optional = true }
+gloo-utils = "0.2.0"
 nom = "7.1.1"
 opentelemetry = { version = "0.20.0", optional = true, default-features = false, features = ["trace", "rt-tokio"] }
 opentelemetry-otlp = { version = "0.13.0", optional = true }

Makefile

@@ -7,6 +7,7 @@ MAKEFLAGS += --no-builtin-rules
 TESTJOBS := 4
 OS:=$(shell uname -s)
 RELEASEFLAGS :=
+WASMTARGET := bundler # or web
 
 ifeq ($(OS),Linux)
   TESTJOBS:=$(shell nproc)
@@ -32,11 +33,7 @@ release:
 .PHONY: wasm
 wasm:
 > cargo build --target=wasm32-unknown-unknown --profile wasm --bin wasm --features wasm
-> wasm-bindgen --target web --out-dir target/wasm32-unknown-unknown/js target/wasm32-unknown-unknown/wasm/wasm.wasm
-
-.PHONY: run_wasm
-run_wasm:
-> cat /tmp/test.org | cargo run --profile wasm --bin wasm_test --features wasm_test | jq
+> wasm-bindgen --target $(WASMTARGET) --out-dir target/wasm32-unknown-unknown/js target/wasm32-unknown-unknown/wasm/wasm.wasm
 
 .PHONY: clean
 clean:
@@ -58,11 +55,20 @@ clippy:
 test:
 > cargo test --no-default-features --features compare --no-fail-fast --lib --test test_loader -- --test-threads $(TESTJOBS)
 
+.PHONY: doc
+doc:
+> cargo doc --no-deps --open --lib --release --all-features
+
 .PHONY: dockertest
 dockertest:
 > $(MAKE) -C docker/organic_test
 > docker run --init --rm -i -t --read-only -v "$$(readlink -f ./):/source:ro" --mount type=tmpfs,destination=/tmp --mount source=cargo-cache,target=/usr/local/cargo/registry --mount source=rust-cache,target=/target --env CARGO_TARGET_DIR=/target -w /source organic-test --no-default-features --features compare --no-fail-fast --lib --test test_loader -- --test-threads $(TESTJOBS)
 
+.PHONY: dockerwasmtest
+dockerwasmtest:
+> $(MAKE) -C docker/organic_test
+> docker run --init --rm -i -t --read-only -v "$$(readlink -f ./):/source:ro" --mount type=tmpfs,destination=/tmp --mount source=cargo-cache,target=/usr/local/cargo/registry --mount source=rust-cache,target=/target --env CARGO_TARGET_DIR=/target -w /source organic-test --no-default-features --features compare,wasm_test --no-fail-fast --lib --test test_loader autogen_wasm_ -- --test-threads $(TESTJOBS)
+
 .PHONY: buildtest
 buildtest:
 > cargo build --no-default-features
@@ -71,6 +77,8 @@ buildtest:
 > cargo build --no-default-features --features compare,tracing
 > cargo build --no-default-features --features compare,foreign_document_test
 > cargo build --no-default-features --features compare,tracing,foreign_document_test
+> cargo build --target wasm32-unknown-unknown --profile wasm --bin wasm --no-default-features --features wasm
+> cargo build --bin wasm_test --no-default-features --features wasm_test
 
 .PHONY: foreign_document_test
 foreign_document_test:

README.md

@@ -10,17 +10,16 @@ Currently, Organic parses most documents the same as the official org-mode parse
 
 ### Project Goals
 - We aim to provide perfect parity with the emacs org-mode parser. In that regard, any document that parses differently between Emacs and Organic is considered a bug.
-- The parser should have minimal dependencies. This should reduce effort w.r.t.: security audits, legal compliance, portability.
-- The parser should be usable everywhere. In the interest of getting org-mode used in as many places as possible, this parser should be usable by everyone everywhere. This means:
+- The parser should have minimal dependencies.
+- The parser should be usable everywhere. In the interest of getting org used in as many places as possible, this parser should be usable by everyone everywhere. This means:
   - It must have a permissive license.
-  - We will investigate compiling to WASM. This is an important goal of the project and will definitely happen, but only after the parser has a more stable API.
+  - It compiles to both natively and to wasm.
   - We will investigate compiling to a C library for native linking to other code. This is more of a maybe-goal for the project.
 ### Project Non-Goals
 - This project will not include an elisp engine since that would drastically increase the complexity of the code. Any features requiring an elisp engine will not be implemented (for example, Emacs supports embedded eval expressions in documents but this parser will never support that).
 - This project is exclusively an org-mode **parser**. This limits its scope to roughly the output of `(org-element-parse-buffer)`. It will not render org-mode documents in other formats like HTML or LaTeX.
 ### Project Maybe-Goals
 - table.el support. Currently we support org-mode tables but org-mode also allows table.el tables. So far, their use in org-mode documents seems rather uncommon so this is a low-priority feature.
-- Document editing support. I do not anticipate any advanced editing features to make editing ergonomic, but it should be relatively easy to be able to parse an org-mode document and serialize it back into org-mode. This would enable cool features to be built on top of the library like auto-formatters. To accomplish this feature, We'd have to capture all of the various separators and whitespace that we are currently simply throwing away. This would add many additional fields to the parsed structs and it would add more noise to the parsers themselves, so I do not want to approach this feature until the parser is more complete since it would make modifications and refactoring more difficult.
 ### Supported Versions
 This project targets the version of Emacs and Org-mode that are built into the [organic-test docker image](docker/organic_test/Dockerfile). This is newer than the version of Org-mode that shipped with Emacs 29.1. The parser itself does not depend on Emacs or Org-mode though, so this only matters for development purposes when running the automated tests that compare against upstream Org-mode.
 

docker/organic_clippy/Makefile

@@ -30,7 +30,7 @@ endif
 # NOTE: This target will write to folders underneath the git-root
 .PHONY: run
 run: build
-	docker run --rm --init --read-only --mount type=tmpfs,destination=/tmp -v "$$(readlink -f ../../):/source:ro" --workdir=/source --mount source=cargo-cache,target=/usr/local/cargo/registry --mount source=rust-cache,target=/target --env CARGO_TARGET_DIR=/target $(IMAGE_NAME)
+	docker run --rm --init -t --read-only --mount type=tmpfs,destination=/tmp -v "$$(readlink -f ../../):/source:ro" --workdir=/source --mount source=cargo-cache,target=/usr/local/cargo/registry --mount source=rust-cache,target=/target --env CARGO_TARGET_DIR=/target $(IMAGE_NAME)
 
 .PHONY: shell
 shell: build

scripts/run_docker_wasm_compare.bash

@@ -0,0 +1,111 @@
+#!/usr/bin/env bash
+#
+set -euo pipefail
+IFS=$'\n\t'
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+
+: ${SHELL:="NO"} # or YES to launch a shell instead of running the test
+: ${TRACE:="NO"} # or YES to send traces to jaeger
+: ${BACKTRACE:="NO"} # or YES to print a rust backtrace when panicking
+: ${NO_COLOR:=""} # Set to anything to disable color output
+: ${PROFILE:="debug"}
+
+REALPATH=$(command -v uu-realpath || command -v realpath)
+MAKE=$(command -v gmake || command -v make)
+
+############## Setup #########################
+
+function die {
+    local status_code="$1"
+    shift
+    (>&2 echo "${@}")
+    exit "$status_code"
+}
+
+function log {
+    (>&2 echo "${@}")
+}
+
+############## Program #########################
+
+function main {
+    build_container
+    launch_container "${@}"
+}
+
+function build_container {
+    $MAKE -C "$DIR/../docker/organic_test"
+}
+
+function launch_container {
+    local additional_flags=()
+    local features=(wasm_test)
+
+    if [ "$NO_COLOR" != "" ]; then
+        additional_flags+=(--env "NO_COLOR=$NO_COLOR")
+    fi
+
+    if [ "$TRACE" = "YES" ]; then
+        # We use the host network so it can talk to jaeger hosted at 127.0.0.1
+        additional_flags+=(--network=host --env RUST_LOG=debug)
+        features+=(tracing)
+    fi
+
+    if [ "$SHELL" != "YES" ]; then
+        additional_flags+=(--read-only)
+    else
+        additional_flags+=(-t)
+    fi
+
+    if [ "$BACKTRACE" = "YES" ]; then
+        additional_flags+=(--env RUST_BACKTRACE=full)
+    fi
+
+    if [ "$SHELL" = "YES" ]; then
+        exec docker run "${additional_flags[@]}" --init --rm -i --mount type=tmpfs,destination=/tmp -v "/:/input:ro" -v "$($REALPATH "$DIR/../"):/source:ro" --mount source=cargo-cache,target=/usr/local/cargo/registry --mount source=rust-cache,target=/target --env CARGO_TARGET_DIR=/target -w /source --entrypoint "" organic-test /bin/sh
+    fi
+
+    local features_joined
+    features_joined=$(IFS=","; echo "${features[*]}")
+
+    local build_flags=()
+    if [ "$PROFILE" = "dev" ] || [ "$PROFILE" = "debug" ]; then
+        PROFILE="debug"
+    else
+        build_flags+=(--profile "$PROFILE")
+    fi
+
+
+    if [ $# -gt 0 ]; then
+        # If we passed in args, we need to forward them along
+        for path in "${@}"; do
+            local full_path
+            full_path=$($REALPATH "$path")
+            init_script=$(cat <<EOF
+set -euo pipefail
+IFS=\$'\n\t'
+
+cargo build --bin wasm_test --no-default-features --features "$features_joined" ${build_flags[@]}
+exec /target/${PROFILE}/wasm_test "/input${full_path}"
+EOF
+                       )
+            docker run "${additional_flags[@]}" --init --rm -i --mount type=tmpfs,destination=/tmp -v "/:/input:ro"  -v "$($REALPATH "$DIR/../"):/source:ro" --mount source=cargo-cache,target=/usr/local/cargo/registry --mount source=rust-cache,target=/target --env CARGO_TARGET_DIR=/target -w /source --entrypoint "" organic-test sh -c "$init_script"
+        done
+    else
+        local current_directory init_script
+        current_directory=$(pwd)
+        init_script=$(cat <<EOF
+set -euo pipefail
+IFS=\$'\n\t'
+
+cargo build --bin wasm_test --no-default-features --features "$features_joined" ${build_flags[@]}
+cd /input${current_directory}
+exec /target/${PROFILE}/wasm_test
+EOF
+                       )
+
+        docker run "${additional_flags[@]}" --init --rm -i --mount type=tmpfs,destination=/tmp -v "/:/input:ro" -v "$($REALPATH "$DIR/../"):/source:ro" --mount source=cargo-cache,target=/usr/local/cargo/registry --mount source=rust-cache,target=/target --env CARGO_TARGET_DIR=/target -w /source --entrypoint "" organic-test sh -c "$init_script"
+    fi
+}
+
+main "${@}"

src/bin_wasm.rs

@@ -1,10 +1,8 @@
-use organic::wasm::wasm_parse_org;
 use wasm_bindgen::prelude::wasm_bindgen;
 
 #[wasm_bindgen]
 pub fn parse_org(org_contents: &str) -> wasm_bindgen::JsValue {
-    let rust_parsed = wasm_parse_org(org_contents);
-    serde_wasm_bindgen::to_value(&rust_parsed).unwrap()
+    organic::wasm_cli::parse_org(org_contents)
 }
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {

src/bin_wasm_test.rs

@@ -3,6 +3,7 @@
 use std::io::Read;
 
 use organic::wasm_test::wasm_run_anonymous_compare;
+use organic::wasm_test::wasm_run_compare_on_file;
 
 #[cfg(feature = "tracing")]
 use crate::init_tracing::init_telemetry;
@@ -42,14 +43,13 @@ async fn main_body() -> Result<(), Box<dyn std::error::Error>> {
         }
         Ok(())
     } else {
-        todo!()
-        // for arg in args {
-        //     if run_compare_on_file(arg).await? {
-        //     } else {
-        //         Err("Diff results do not match.")?;
-        //     }
-        // }
-        // Ok(())
+        for arg in args {
+            if wasm_run_compare_on_file(arg).await? {
+            } else {
+                Err("Diff results do not match.")?;
+            }
+        }
+        Ok(())
     }
 }
 

src/compare/compare.rs

@@ -1,15 +1,16 @@
 use std::path::Path;
 
 use crate::compare::diff::compare_document;
-use crate::compare::diff::DiffResult;
-use crate::compare::sexp::sexp;
 use crate::context::GlobalSettings;
 use crate::context::LocalFileAccessInterface;
 use crate::parser::parse_file_with_settings;
 use crate::parser::parse_with_settings;
-use crate::util::emacs_parse_anonymous_org_document;
-use crate::util::emacs_parse_file_org_document;
-use crate::util::print_versions;
+use crate::util::cli::emacs_parse_anonymous_org_document;
+use crate::util::cli::emacs_parse_file_org_document;
+use crate::util::cli::print_versions;
+use crate::util::elisp::sexp;
+use crate::util::terminal::foreground_color;
+use crate::util::terminal::reset_color;
 
 pub async fn run_anonymous_compare<P: AsRef<str>>(
     org_contents: P,
@@ -67,8 +68,8 @@ pub async fn run_anonymous_compare_with_settings<'g, 's, P: AsRef<str>>(
     } else if !silent {
         println!(
             "{color}Entire document passes.{reset}",
-            color = DiffResult::foreground_color(0, 255, 0),
-            reset = DiffResult::reset_color(),
+            color = foreground_color(0, 255, 0),
+            reset = reset_color(),
         );
     }
 
@@ -120,8 +121,8 @@ pub async fn run_compare_on_file_with_settings<'g, 's, P: AsRef<Path>>(
     } else if !silent {
         println!(
             "{color}Entire document passes.{reset}",
-            color = DiffResult::foreground_color(0, 255, 0),
-            reset = DiffResult::reset_color(),
+            color = foreground_color(0, 255, 0),
+            reset = reset_color(),
         );
     }
 

src/compare/compare_field.rs

@@ -9,8 +9,6 @@ use super::diff::artificial_owned_diff_scope;
 use super::diff::compare_ast_node;
 use super::diff::DiffEntry;
 use super::diff::DiffStatus;
-use super::sexp::unquote;
-use super::sexp::Token;
 use super::util::get_property;
 use super::util::get_property_numeric;
 use super::util::get_property_quoted_string;
@@ -20,6 +18,8 @@ use crate::types::CharOffsetInLine;
 use crate::types::LineNumber;
 use crate::types::RetainLabels;
 use crate::types::SwitchNumberLines;
+use crate::util::elisp::unquote;
+use crate::util::elisp::Token;
 
 #[derive(Debug)]
 pub(crate) enum EmacsField<'s> {

src/compare/diff.rs

@@ -16,10 +16,6 @@ use super::compare_field::compare_property_retain_labels;
 use super::compare_field::compare_property_set_of_quoted_string;
 use super::compare_field::compare_property_single_ast_node;
 use super::compare_field::compare_property_unquoted_atom;
-use super::elisp_fact::ElispFact;
-use super::elisp_fact::GetElispFact;
-use super::sexp::unquote;
-use super::sexp::Token;
 use super::util::affiliated_keywords_names;
 use super::util::assert_no_children;
 use super::util::compare_additional_properties;
@@ -109,6 +105,12 @@ use crate::types::Verbatim;
 use crate::types::VerseBlock;
 use crate::types::WarningDelayType;
 use crate::types::Year;
+use crate::util::elisp::unquote;
+use crate::util::elisp::Token;
+use crate::util::elisp_fact::ElispFact;
+use crate::util::elisp_fact::GetElispFact;
+use crate::util::terminal::foreground_color;
+use crate::util::terminal::reset_color;
 
 #[derive(Debug)]
 pub enum DiffEntry<'b, 's> {
@@ -200,21 +202,21 @@ impl<'b, 's> DiffResult<'b, 's> {
                     if self.has_bad_children() {
                         format!(
                             "{color}BADCHILD{reset}",
-                            color = DiffResult::foreground_color(255, 255, 0),
-                            reset = DiffResult::reset_color(),
+                            color = foreground_color(255, 255, 0),
+                            reset = reset_color(),
                         )
                     } else {
                         format!(
                             "{color}GOOD{reset}",
-                            color = DiffResult::foreground_color(0, 255, 0),
-                            reset = DiffResult::reset_color(),
+                            color = foreground_color(0, 255, 0),
+                            reset = reset_color(),
                         )
                     }
                 }
                 DiffStatus::Bad => format!(
                     "{color}BAD{reset}",
-                    color = DiffResult::foreground_color(255, 0, 0),
-                    reset = DiffResult::reset_color(),
+                    color = foreground_color(255, 0, 0),
+                    reset = reset_color(),
                 ),
             }
         };
@@ -239,45 +241,6 @@ impl<'b, 's> DiffResult<'b, 's> {
             .iter()
             .any(|child| child.is_immediately_bad() || child.has_bad_children())
     }
-
-    pub(crate) fn foreground_color(red: u8, green: u8, blue: u8) -> String {
-        if DiffResult::should_use_color() {
-            format!(
-                "\x1b[38;2;{red};{green};{blue}m",
-                red = red,
-                green = green,
-                blue = blue
-            )
-        } else {
-            String::new()
-        }
-    }
-
-    #[allow(dead_code)]
-    pub(crate) fn background_color(red: u8, green: u8, blue: u8) -> String {
-        if DiffResult::should_use_color() {
-            format!(
-                "\x1b[48;2;{red};{green};{blue}m",
-                red = red,
-                green = green,
-                blue = blue
-            )
-        } else {
-            String::new()
-        }
-    }
-
-    pub(crate) fn reset_color() -> &'static str {
-        if DiffResult::should_use_color() {
-            "\x1b[0m"
-        } else {
-            ""
-        }
-    }
-
-    fn should_use_color() -> bool {
-        !std::env::var("NO_COLOR").is_ok_and(|val| !val.is_empty())
-    }
 }
 
 impl<'b, 's> DiffLayer<'b, 's> {
@@ -295,14 +258,14 @@ impl<'b, 's> DiffLayer<'b, 's> {
         let status_text = if self.has_bad_children() {
             format!(
                 "{color}BADCHILD{reset}",
-                color = DiffResult::foreground_color(255, 255, 0),
-                reset = DiffResult::reset_color(),
+                color = foreground_color(255, 255, 0),
+                reset = reset_color(),
             )
         } else {
             format!(
                 "{color}GOOD{reset}",
-                color = DiffResult::foreground_color(0, 255, 0),
-                reset = DiffResult::reset_color(),
+                color = foreground_color(0, 255, 0),
+                reset = reset_color(),
             )
         };
         println!(

src/compare/mod.rs

@@ -2,9 +2,7 @@
 mod compare;
 mod compare_field;
 mod diff;
-mod elisp_fact;
 mod macros;
-mod sexp;
 mod util;
 pub use compare::run_anonymous_compare;
 pub use compare::run_anonymous_compare_with_settings;
@@ -12,5 +10,3 @@ pub use compare::run_compare_on_file;
 pub use compare::run_compare_on_file_with_settings;
 pub use compare::silent_anonymous_compare;
 pub use compare::silent_compare_on_file;
-pub use sexp::sexp;
-pub use sexp::Token;

src/compare/util.rs

@@ -8,14 +8,15 @@ use super::compare_field::compare_property_quoted_string;
 use super::compare_field::ComparePropertiesResult;
 use super::diff::DiffEntry;
 use super::diff::DiffStatus;
-use super::elisp_fact::GetElispFact;
-use super::sexp::Token;
 use crate::compare::diff::compare_ast_node;
-use crate::compare::sexp::unquote;
 use crate::types::AffiliatedKeywordValue;
 use crate::types::AstNode;
 use crate::types::GetAffiliatedKeywords;
 use crate::types::StandardProperties;
+use crate::util::elisp::get_emacs_standard_properties;
+use crate::util::elisp::unquote;
+use crate::util::elisp::Token;
+use crate::util::elisp_fact::GetElispFact;
 
 /// Check if the child string slice is a slice of the parent string slice.
 fn is_slice_of(parent: &str, child: &str) -> bool {
@@ -145,80 +146,6 @@ fn assert_post_blank<'b, 's, S: StandardProperties<'s> + ?Sized>(
     Ok(())
 }
 
-struct EmacsStandardProperties {
-    begin: Option<usize>,
-    #[allow(dead_code)]
-    post_affiliated: Option<usize>,
-    #[allow(dead_code)]
-    contents_begin: Option<usize>,
-    #[allow(dead_code)]
-    contents_end: Option<usize>,
-    end: Option<usize>,
-    #[allow(dead_code)]
-    post_blank: Option<usize>,
-}
-
-fn get_emacs_standard_properties(
-    emacs: &Token<'_>,
-) -> Result<EmacsStandardProperties, Box<dyn std::error::Error>> {
-    let children = emacs.as_list()?;
-    let attributes_child = children.get(1).ok_or("Should have an attributes child.")?;
-    let attributes_map = attributes_child.as_map()?;
-    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 maybe_token_to_usize(
-    token: Option<&Token<'_>>,
-) -> Result<Option<usize>, Box<dyn std::error::Error>> {
-    Ok(token
-        .map(|token| token.as_atom())
-        .map_or(Ok(None), |r| r.map(Some))?
-        .and_then(|val| {
-            if val == "nil" {
-                None
-            } else {
-                Some(val.parse::<usize>())
-            }
-        })
-        .map_or(Ok(None), |r| r.map(Some))?)
-}
-
 /// Get a named property from the emacs token.
 ///
 /// Returns Ok(None) if value is nil or absent.

src/event_count/database.rs

@@ -24,7 +24,7 @@ pub(crate) fn record_event(event_type: EventType, input: OrgSource<'_>) {
     *db.entry(key).or_insert(0) += 1;
 }
 
-pub fn report(original_document: &str) {
+pub(crate) fn report(original_document: &str) {
     let mut db = GLOBAL_DATA.lock().unwrap();
     let db = db.get_or_insert_with(HashMap::new);
     let mut results: Vec<_> = db.iter().collect();

src/event_count/mod.rs

@@ -2,5 +2,5 @@ mod database;
 mod event_type;
 
 pub(crate) use database::record_event;
-pub use database::report;
+pub(crate) use database::report;
 pub(crate) use event_type::EventType;

src/lib.rs

@@ -3,25 +3,29 @@
 #![feature(path_file_prefix)]
 #![feature(is_sorted)]
 #![feature(test)]
+#![feature(iter_intersperse)]
+#![feature(exact_size_is_empty)]
 // TODO: #![warn(missing_docs)]
 #![allow(clippy::bool_assert_comparison)] // Sometimes you want the long form because its easier to see at a glance.
 
 extern crate test;
 
-// TODO: I only include compare to use some shared stuff like sexp and DiffResult. Ideally, this would be moved to a shared module.
-#[cfg(any(feature = "compare", feature = "wasm_test"))]
+#[cfg(feature = "compare")]
 pub mod compare;
-#[cfg(any(feature = "compare", feature = "wasm_test"))]
-pub mod util;
+pub mod parse_cli;
+#[cfg(any(feature = "compare", feature = "wasm", feature = "wasm_test"))]
+mod util;
 #[cfg(any(feature = "wasm", feature = "wasm_test"))]
-pub mod wasm;
+mod wasm;
+#[cfg(any(feature = "wasm", feature = "wasm_test"))]
+pub mod wasm_cli;
 #[cfg(feature = "wasm_test")]
 pub mod wasm_test;
 
 mod context;
 mod error;
 #[cfg(feature = "event_count")]
-pub mod event_count;
+mod event_count;
 mod iter;
 pub mod parser;
 pub mod types;

src/main.rs

@@ -1,12 +1,4 @@
-#![feature(round_char_boundary)]
-#![feature(exact_size_is_empty)]
-use std::io::Read;
-use std::path::Path;
-
-use ::organic::parser::parse;
-use organic::parser::parse_with_settings;
-use organic::settings::GlobalSettings;
-use organic::settings::LocalFileAccessInterface;
+use organic::parse_cli::main_body;
 
 #[cfg(feature = "tracing")]
 use crate::init_tracing::init_telemetry;
@@ -30,55 +22,3 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         main_body_result
     })
 }
-
-#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-fn main_body() -> Result<(), Box<dyn std::error::Error>> {
-    let args = std::env::args().skip(1);
-    if args.is_empty() {
-        let org_contents = read_stdin_to_string()?;
-        run_anonymous_parse(org_contents)
-    } else {
-        for arg in args {
-            run_parse_on_file(arg)?
-        }
-        Ok(())
-    }
-}
-
-fn read_stdin_to_string() -> Result<String, Box<dyn std::error::Error>> {
-    let mut stdin_contents = String::new();
-    std::io::stdin()
-        .lock()
-        .read_to_string(&mut stdin_contents)?;
-    Ok(stdin_contents)
-}
-
-fn run_anonymous_parse<P: AsRef<str>>(org_contents: P) -> Result<(), Box<dyn std::error::Error>> {
-    let org_contents = org_contents.as_ref();
-    let rust_parsed = parse(org_contents)?;
-    println!("{:#?}", rust_parsed);
-    #[cfg(feature = "event_count")]
-    organic::event_count::report(org_contents);
-    Ok(())
-}
-
-fn run_parse_on_file<P: AsRef<Path>>(org_path: P) -> Result<(), Box<dyn std::error::Error>> {
-    let org_path = org_path.as_ref();
-    let parent_directory = org_path
-        .parent()
-        .ok_or("Should be contained inside a directory.")?;
-    let org_contents = std::fs::read_to_string(org_path)?;
-    let org_contents = org_contents.as_str();
-    let file_access_interface = LocalFileAccessInterface {
-        working_directory: Some(parent_directory.to_path_buf()),
-    };
-    let global_settings = GlobalSettings {
-        file_access: &file_access_interface,
-        ..Default::default()
-    };
-    let rust_parsed = parse_with_settings(org_contents, &global_settings)?;
-    println!("{:#?}", rust_parsed);
-    #[cfg(feature = "event_count")]
-    organic::event_count::report(org_contents);
-    Ok(())
-}

src/parse_cli/mod.rs

@@ -0,0 +1,59 @@
+use std::io::Read;
+use std::path::Path;
+
+use crate::parser::parse;
+use crate::parser::parse_with_settings;
+use crate::settings::GlobalSettings;
+use crate::settings::LocalFileAccessInterface;
+
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
+pub fn main_body() -> Result<(), Box<dyn std::error::Error>> {
+    let args = std::env::args().skip(1);
+    if args.is_empty() {
+        let org_contents = read_stdin_to_string()?;
+        run_anonymous_parse(org_contents)
+    } else {
+        for arg in args {
+            run_parse_on_file(arg)?
+        }
+        Ok(())
+    }
+}
+
+fn read_stdin_to_string() -> Result<String, Box<dyn std::error::Error>> {
+    let mut stdin_contents = String::new();
+    std::io::stdin()
+        .lock()
+        .read_to_string(&mut stdin_contents)?;
+    Ok(stdin_contents)
+}
+
+fn run_anonymous_parse<P: AsRef<str>>(org_contents: P) -> Result<(), Box<dyn std::error::Error>> {
+    let org_contents = org_contents.as_ref();
+    let rust_parsed = parse(org_contents)?;
+    println!("{:#?}", rust_parsed);
+    #[cfg(feature = "event_count")]
+    crate::event_count::report(org_contents);
+    Ok(())
+}
+
+fn run_parse_on_file<P: AsRef<Path>>(org_path: P) -> Result<(), Box<dyn std::error::Error>> {
+    let org_path = org_path.as_ref();
+    let parent_directory = org_path
+        .parent()
+        .ok_or("Should be contained inside a directory.")?;
+    let org_contents = std::fs::read_to_string(org_path)?;
+    let org_contents = org_contents.as_str();
+    let file_access_interface = LocalFileAccessInterface {
+        working_directory: Some(parent_directory.to_path_buf()),
+    };
+    let global_settings = GlobalSettings {
+        file_access: &file_access_interface,
+        ..Default::default()
+    };
+    let rust_parsed = parse_with_settings(org_contents, &global_settings)?;
+    println!("{:#?}", rust_parsed);
+    #[cfg(feature = "event_count")]
+    crate::event_count::report(org_contents);
+    Ok(())
+}

src/types/object.rs

@@ -332,19 +332,19 @@ pub type HourInner = u8;
 pub type MinuteInner = u8;
 
 #[derive(Debug, Clone)]
-pub struct Year(YearInner);
+pub struct Year(pub YearInner);
 
 #[derive(Debug, Clone)]
-pub struct Month(MonthInner);
+pub struct Month(pub MonthInner);
 
 #[derive(Debug, Clone)]
-pub struct DayOfMonth(DayOfMonthInner);
+pub struct DayOfMonth(pub DayOfMonthInner);
 
 #[derive(Debug, Clone)]
-pub struct Hour(HourInner);
+pub struct Hour(pub HourInner);
 
 #[derive(Debug, Clone)]
-pub struct Minute(MinuteInner);
+pub struct Minute(pub MinuteInner);
 
 impl Year {
     // TODO: Make a real error type instead of a boxed any error.

src/util/cli.rs

@@ -0,0 +1,191 @@
+use std::path::Path;
+
+use tokio::process::Command;
+
+use crate::settings::GlobalSettings;
+use crate::settings::HeadlineLevelFilter;
+
+pub async fn print_versions() -> Result<(), Box<dyn std::error::Error>> {
+    eprintln!("Using emacs version: {}", get_emacs_version().await?.trim());
+    eprintln!(
+        "Using org-mode version: {}",
+        get_org_mode_version().await?.trim()
+    );
+    Ok(())
+}
+
+pub(crate) async fn get_emacs_version() -> Result<String, Box<dyn std::error::Error>> {
+    let elisp_script = r#"(progn
+     (message "%s" (version))
+)"#;
+    let mut cmd = Command::new("emacs");
+    let cmd = cmd
+        .arg("-q")
+        .arg("--no-site-file")
+        .arg("--no-splash")
+        .arg("--batch")
+        .arg("--eval")
+        .arg(elisp_script);
+
+    let out = cmd.output().await?;
+    out.status.exit_ok()?;
+    Ok(String::from_utf8(out.stderr)?)
+}
+
+pub(crate) async fn get_org_mode_version() -> Result<String, Box<dyn std::error::Error>> {
+    let elisp_script = r#"(progn
+     (org-mode)
+     (message "%s" (org-version nil t nil))
+)"#;
+    let mut cmd = Command::new("emacs");
+    let cmd = cmd
+        .arg("-q")
+        .arg("--no-site-file")
+        .arg("--no-splash")
+        .arg("--batch")
+        .arg("--eval")
+        .arg(elisp_script);
+
+    let out = cmd.output().await?;
+    out.status.exit_ok()?;
+    Ok(String::from_utf8(out.stderr)?)
+}
+
+pub(crate) async fn emacs_parse_anonymous_org_document<'g, 's, C>(
+    file_contents: C,
+    global_settings: &GlobalSettings<'g, 's>,
+) -> Result<String, Box<dyn std::error::Error>>
+where
+    C: AsRef<str>,
+{
+    let escaped_file_contents = escape_elisp_string(file_contents);
+    let elisp_script = format!(
+        r#"(progn
+     (erase-buffer)
+     (require 'org)
+     (defun org-table-align () t)
+     (insert "{escaped_file_contents}")
+     {global_settings}
+     (org-mode)
+     (message "%s" (pp-to-string (org-element-parse-buffer)))
+)"#,
+        escaped_file_contents = escaped_file_contents,
+        global_settings = global_settings_elisp(global_settings)
+    );
+    let mut cmd = Command::new("emacs");
+    let cmd = cmd
+        .arg("-q")
+        .arg("--no-site-file")
+        .arg("--no-splash")
+        .arg("--batch")
+        .arg("--eval")
+        .arg(elisp_script);
+    let out = cmd.output().await?;
+    let status = out.status.exit_ok();
+    if status.is_err() {
+        eprintln!(
+            "Emacs errored out: {}\n{}",
+            String::from_utf8(out.stdout)?,
+            String::from_utf8(out.stderr)?
+        );
+        status?;
+        unreachable!();
+    }
+    let org_sexp = out.stderr;
+    Ok(String::from_utf8(org_sexp)?)
+}
+
+pub(crate) async fn emacs_parse_file_org_document<'g, 's, P>(
+    file_path: P,
+    global_settings: &GlobalSettings<'g, 's>,
+) -> Result<String, Box<dyn std::error::Error>>
+where
+    P: AsRef<Path>,
+{
+    let file_path = file_path.as_ref().canonicalize()?;
+    let containing_directory = file_path.parent().ok_or(format!(
+        "Failed to get containing directory for path {}",
+        file_path.display()
+    ))?;
+    let elisp_script = format!(
+        r#"(progn
+     (require 'org)
+     (defun org-table-align () t)
+     (setq vc-handled-backends nil)
+     {global_settings}
+     (find-file-read-only "{file_path}")
+     (org-mode)
+     (message "%s" (pp-to-string (org-element-parse-buffer)))
+)"#,
+        global_settings = global_settings_elisp(global_settings),
+        file_path = file_path
+            .as_os_str()
+            .to_str()
+            .expect("File name should be valid utf-8.")
+    );
+    let mut cmd = Command::new("emacs");
+    let cmd = cmd
+        .current_dir(containing_directory)
+        .arg("-q")
+        .arg("--no-site-file")
+        .arg("--no-splash")
+        .arg("--batch")
+        .arg("--eval")
+        .arg(elisp_script);
+    let out = cmd.output().await?;
+    let status = out.status.exit_ok();
+    if status.is_err() {
+        eprintln!(
+            "Emacs errored out: {}\n{}",
+            String::from_utf8(out.stdout)?,
+            String::from_utf8(out.stderr)?
+        );
+        status?;
+        unreachable!();
+    }
+    let org_sexp = out.stderr;
+    Ok(String::from_utf8(org_sexp)?)
+}
+
+fn escape_elisp_string<C>(file_contents: C) -> String
+where
+    C: AsRef<str>,
+{
+    let source = file_contents.as_ref();
+    let source_len = source.len();
+    // We allocate a string 10% larger than the source to account for escape characters. Without this, we would have more allocations during processing.
+    let mut output = String::with_capacity(source_len + (source_len / 10));
+    for c in source.chars() {
+        match c {
+            '"' | '\\' => {
+                output.push('\\');
+                output.push(c);
+            }
+            _ => {
+                output.push(c);
+            }
+        }
+    }
+    output
+}
+
+/// Generate elisp to configure org-mode parsing settings
+///
+/// Currently only org-list-allow-alphabetical is supported.
+fn global_settings_elisp(global_settings: &GlobalSettings) -> String {
+    // This string concatenation is wildly inefficient but its only called in tests 🤷.
+    let mut ret = "".to_owned();
+    if global_settings.list_allow_alphabetical {
+        ret += "(setq org-list-allow-alphabetical t)\n"
+    }
+    if global_settings.tab_width != crate::settings::DEFAULT_TAB_WIDTH {
+        ret += format!("(setq-default tab-width {})", global_settings.tab_width).as_str();
+    }
+    if global_settings.odd_levels_only != HeadlineLevelFilter::default() {
+        ret += match global_settings.odd_levels_only {
+            HeadlineLevelFilter::Odd => "(setq org-odd-levels-only t)\n",
+            HeadlineLevelFilter::OddEven => "(setq org-odd-levels-only nil)\n",
+        };
+    }
+    ret
+}

src/util/elisp/mod.rs

@@ -0,0 +1,14 @@
+mod sexp;
+mod util;
+
+pub use sexp::sexp;
+pub(crate) use sexp::unquote;
+#[cfg(feature = "wasm_test")]
+pub(crate) use sexp::TextWithProperties;
+pub use sexp::Token;
+#[cfg(feature = "compare")]
+pub(crate) use util::get_emacs_standard_properties;
+#[cfg(feature = "wasm_test")]
+pub(crate) use util::maybe_token_to_usize;
+#[cfg(feature = "wasm_test")]
+pub(crate) use util::EmacsStandardProperties;

src/util/elisp/sexp.rs

@@ -61,6 +61,7 @@ impl<'s> Token<'s> {
         }?)
     }
 
+    #[cfg(feature = "compare")]
     pub(crate) fn as_text<'p>(
         &'p self,
     ) -> Result<&'p TextWithProperties<'s>, Box<dyn std::error::Error>> {

src/util/elisp/util.rs

@@ -0,0 +1,76 @@
+use super::Token;
+
+pub(crate) fn maybe_token_to_usize(
+    token: Option<&Token<'_>>,
+) -> Result<Option<usize>, Box<dyn std::error::Error>> {
+    Ok(token
+        .map(|token| token.as_atom())
+        .map_or(Ok(None), |r| r.map(Some))?
+        .and_then(|val| {
+            if val == "nil" {
+                None
+            } else {
+                Some(val.parse::<usize>())
+            }
+        })
+        .map_or(Ok(None), |r| r.map(Some))?)
+}
+
+pub(crate) struct EmacsStandardProperties {
+    pub(crate) begin: Option<usize>,
+    #[allow(dead_code)]
+    pub(crate) post_affiliated: Option<usize>,
+    #[allow(dead_code)]
+    pub(crate) contents_begin: Option<usize>,
+    #[allow(dead_code)]
+    pub(crate) contents_end: Option<usize>,
+    pub(crate) end: Option<usize>,
+    #[allow(dead_code)]
+    pub(crate) post_blank: Option<usize>,
+}
+
+#[cfg(feature = "compare")]
+pub(crate) fn get_emacs_standard_properties(
+    emacs: &Token<'_>,
+) -> Result<EmacsStandardProperties, Box<dyn std::error::Error>> {
+    let children = emacs.as_list()?;
+    let attributes_child = children.get(1).ok_or("Should have an attributes child.")?;
+    let attributes_map = attributes_child.as_map()?;
+    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,
+        }
+    })
+}

src/util/mod.rs

@@ -1,191 +1,8 @@
-use std::path::Path;
-
-use tokio::process::Command;
-
-use crate::settings::GlobalSettings;
-use crate::settings::HeadlineLevelFilter;
-
-pub async fn print_versions() -> Result<(), Box<dyn std::error::Error>> {
-    eprintln!("Using emacs version: {}", get_emacs_version().await?.trim());
-    eprintln!(
-        "Using org-mode version: {}",
-        get_org_mode_version().await?.trim()
-    );
-    Ok(())
-}
-
-pub(crate) async fn get_emacs_version() -> Result<String, Box<dyn std::error::Error>> {
-    let elisp_script = r#"(progn
-     (message "%s" (version))
-)"#;
-    let mut cmd = Command::new("emacs");
-    let cmd = cmd
-        .arg("-q")
-        .arg("--no-site-file")
-        .arg("--no-splash")
-        .arg("--batch")
-        .arg("--eval")
-        .arg(elisp_script);
-
-    let out = cmd.output().await?;
-    out.status.exit_ok()?;
-    Ok(String::from_utf8(out.stderr)?)
-}
-
-pub(crate) async fn get_org_mode_version() -> Result<String, Box<dyn std::error::Error>> {
-    let elisp_script = r#"(progn
-     (org-mode)
-     (message "%s" (org-version nil t nil))
-)"#;
-    let mut cmd = Command::new("emacs");
-    let cmd = cmd
-        .arg("-q")
-        .arg("--no-site-file")
-        .arg("--no-splash")
-        .arg("--batch")
-        .arg("--eval")
-        .arg(elisp_script);
-
-    let out = cmd.output().await?;
-    out.status.exit_ok()?;
-    Ok(String::from_utf8(out.stderr)?)
-}
-
-pub(crate) async fn emacs_parse_anonymous_org_document<'g, 's, C>(
-    file_contents: C,
-    global_settings: &GlobalSettings<'g, 's>,
-) -> Result<String, Box<dyn std::error::Error>>
-where
-    C: AsRef<str>,
-{
-    let escaped_file_contents = escape_elisp_string(file_contents);
-    let elisp_script = format!(
-        r#"(progn
-     (erase-buffer)
-     (require 'org)
-     (defun org-table-align () t)
-     (insert "{escaped_file_contents}")
-     {global_settings}
-     (org-mode)
-     (message "%s" (pp-to-string (org-element-parse-buffer)))
-)"#,
-        escaped_file_contents = escaped_file_contents,
-        global_settings = global_settings_elisp(global_settings)
-    );
-    let mut cmd = Command::new("emacs");
-    let cmd = cmd
-        .arg("-q")
-        .arg("--no-site-file")
-        .arg("--no-splash")
-        .arg("--batch")
-        .arg("--eval")
-        .arg(elisp_script);
-    let out = cmd.output().await?;
-    let status = out.status.exit_ok();
-    if status.is_err() {
-        eprintln!(
-            "Emacs errored out: {}\n{}",
-            String::from_utf8(out.stdout)?,
-            String::from_utf8(out.stderr)?
-        );
-        status?;
-        unreachable!();
-    }
-    let org_sexp = out.stderr;
-    Ok(String::from_utf8(org_sexp)?)
-}
-
-pub(crate) async fn emacs_parse_file_org_document<'g, 's, P>(
-    file_path: P,
-    global_settings: &GlobalSettings<'g, 's>,
-) -> Result<String, Box<dyn std::error::Error>>
-where
-    P: AsRef<Path>,
-{
-    let file_path = file_path.as_ref().canonicalize()?;
-    let containing_directory = file_path.parent().ok_or(format!(
-        "Failed to get containing directory for path {}",
-        file_path.display()
-    ))?;
-    let elisp_script = format!(
-        r#"(progn
-     (require 'org)
-     (defun org-table-align () t)
-     (setq vc-handled-backends nil)
-     {global_settings}
-     (find-file-read-only "{file_path}")
-     (org-mode)
-     (message "%s" (pp-to-string (org-element-parse-buffer)))
-)"#,
-        global_settings = global_settings_elisp(global_settings),
-        file_path = file_path
-            .as_os_str()
-            .to_str()
-            .expect("File name should be valid utf-8.")
-    );
-    let mut cmd = Command::new("emacs");
-    let cmd = cmd
-        .current_dir(containing_directory)
-        .arg("-q")
-        .arg("--no-site-file")
-        .arg("--no-splash")
-        .arg("--batch")
-        .arg("--eval")
-        .arg(elisp_script);
-    let out = cmd.output().await?;
-    let status = out.status.exit_ok();
-    if status.is_err() {
-        eprintln!(
-            "Emacs errored out: {}\n{}",
-            String::from_utf8(out.stdout)?,
-            String::from_utf8(out.stderr)?
-        );
-        status?;
-        unreachable!();
-    }
-    let org_sexp = out.stderr;
-    Ok(String::from_utf8(org_sexp)?)
-}
-
-fn escape_elisp_string<C>(file_contents: C) -> String
-where
-    C: AsRef<str>,
-{
-    let source = file_contents.as_ref();
-    let source_len = source.len();
-    // We allocate a string 10% larger than the source to account for escape characters. Without this, we would have more allocations during processing.
-    let mut output = String::with_capacity(source_len + (source_len / 10));
-    for c in source.chars() {
-        match c {
-            '"' | '\\' => {
-                output.push('\\');
-                output.push(c);
-            }
-            _ => {
-                output.push(c);
-            }
-        }
-    }
-    output
-}
-
-/// Generate elisp to configure org-mode parsing settings
-///
-/// Currently only org-list-allow-alphabetical is supported.
-fn global_settings_elisp(global_settings: &GlobalSettings) -> String {
-    // This string concatenation is wildly inefficient but its only called in tests 🤷.
-    let mut ret = "".to_owned();
-    if global_settings.list_allow_alphabetical {
-        ret += "(setq org-list-allow-alphabetical t)\n"
-    }
-    if global_settings.tab_width != crate::settings::DEFAULT_TAB_WIDTH {
-        ret += format!("(setq-default tab-width {})", global_settings.tab_width).as_str();
-    }
-    if global_settings.odd_levels_only != HeadlineLevelFilter::default() {
-        ret += match global_settings.odd_levels_only {
-            HeadlineLevelFilter::Odd => "(setq org-odd-levels-only t)\n",
-            HeadlineLevelFilter::OddEven => "(setq org-odd-levels-only nil)\n",
-        };
-    }
-    ret
-}
+#[cfg(any(feature = "compare", feature = "wasm_test"))]
+pub mod cli;
+#[cfg(any(feature = "compare", feature = "wasm_test"))]
+pub mod elisp;
+#[cfg(any(feature = "compare", feature = "wasm", feature = "wasm_test"))]
+pub mod elisp_fact;
+#[cfg(any(feature = "compare", feature = "wasm_test"))]
+pub mod terminal;

src/util/terminal.rs

@@ -0,0 +1,42 @@
+use std::borrow::Cow;
+
+fn should_use_color() -> bool {
+    !std::env::var("NO_COLOR").is_ok_and(|val| !val.is_empty())
+}
+
+pub(crate) fn foreground_color(red: u8, green: u8, blue: u8) -> Cow<'static, str> {
+    if should_use_color() {
+        format!(
+            "\x1b[38;2;{red};{green};{blue}m",
+            red = red,
+            green = green,
+            blue = blue
+        )
+        .into()
+    } else {
+        Cow::from("")
+    }
+}
+
+#[allow(dead_code)]
+pub(crate) fn background_color(red: u8, green: u8, blue: u8) -> Cow<'static, str> {
+    if should_use_color() {
+        format!(
+            "\x1b[48;2;{red};{green};{blue}m",
+            red = red,
+            green = green,
+            blue = blue
+        )
+        .into()
+    } else {
+        Cow::from("")
+    }
+}
+
+pub(crate) fn reset_color() -> &'static str {
+    if should_use_color() {
+        "\x1b[0m"
+    } else {
+        ""
+    }
+}

src/wasm/additional_property.rs

@@ -0,0 +1,95 @@
+use std::collections::HashMap;
+
+use serde::Deserialize;
+use serde::Serialize;
+
+use super::macros::to_wasm;
+use super::to_wasm::ToWasm;
+use super::WasmAstNode;
+use crate::types::AffiliatedKeywordValue;
+use crate::types::AffiliatedKeywords;
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum AdditionalPropertyValue {
+    SingleString(String),
+    ListOfStrings(Vec<String>),
+    OptionalPair {
+        optval: Option<String>,
+        val: String,
+    },
+    ObjectTree {
+        #[serde(rename = "object-tree")]
+        object_tree: Vec<(Option<Vec<WasmAstNode>>, Vec<WasmAstNode>)>,
+    },
+}
+
+#[derive(Debug, Serialize, Deserialize, Default)]
+pub struct AdditionalProperties {
+    #[serde(flatten)]
+    pub(crate) properties: HashMap<String, AdditionalPropertyValue>,
+}
+
+to_wasm!(
+    AdditionalProperties,
+    AffiliatedKeywords<'s>,
+    original,
+    wasm_context,
+    {
+        let mut additional_properties = AdditionalProperties::default();
+        for (name, val) in original.keywords.iter() {
+            let converted_val = match val {
+                AffiliatedKeywordValue::SingleString(val) => {
+                    AdditionalPropertyValue::SingleString((*val).to_owned())
+                }
+                AffiliatedKeywordValue::ListOfStrings(val) => {
+                    AdditionalPropertyValue::ListOfStrings(
+                        val.iter().map(|s| (*s).to_owned()).collect(),
+                    )
+                }
+                AffiliatedKeywordValue::OptionalPair { optval, val } => {
+                    AdditionalPropertyValue::OptionalPair {
+                        optval: optval.map(|s| (*s).to_owned()),
+                        val: (*val).to_owned(),
+                    }
+                }
+                AffiliatedKeywordValue::ObjectTree(val) => {
+                    let mut ret = Vec::with_capacity(val.len());
+
+                    for (optval, value) in val {
+                        let converted_optval = if let Some(optval) = optval {
+                            Some(
+                                optval
+                                    .iter()
+                                    .map(|child| {
+                                        child
+                                            .to_wasm(wasm_context.clone())
+                                            .map(Into::<WasmAstNode>::into)
+                                    })
+                                    .collect::<Result<Vec<_>, _>>()?,
+                            )
+                        } else {
+                            None
+                        };
+                        let converted_value = value
+                            .iter()
+                            .map(|child| {
+                                child
+                                    .to_wasm(wasm_context.clone())
+                                    .map(Into::<WasmAstNode>::into)
+                            })
+                            .collect::<Result<Vec<_>, _>>()?;
+
+                        ret.push((converted_optval, converted_value));
+                    }
+
+                    AdditionalPropertyValue::ObjectTree { object_tree: ret }
+                }
+            };
+            additional_properties
+                .properties
+                .insert(name.clone(), converted_val);
+        }
+        Ok(additional_properties)
+    }
+);

src/wasm/angle_link.rs

@@ -1,34 +1,54 @@
-use std::marker::PhantomData;
+use std::borrow::Cow;
 
-use crate::types::AngleLink;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use crate::types::AngleLink;
+use crate::types::LinkType;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmAngleLink<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(tag = "format")]
+#[serde(rename = "angle")]
+pub struct WasmAngleLink {
+    #[serde(rename = "type")]
+    pub(crate) link_type: String,
+    pub(crate) path: String,
+    #[serde(rename = "raw-link")]
+    pub(crate) raw_link: String,
+    pub(crate) application: Option<String>,
+    #[serde(rename = "search-option")]
+    pub(crate) search_option: Option<String>,
 }
 
 to_wasm!(
-    WasmAngleLink<'s>,
+    WasmAngleLink,
     AngleLink<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::AngleLink(original) },
+    { "link".into() },
     {
-        Ok(WasmAngleLink {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        Ok((
+            Vec::new(),
+            WasmAngleLink {
+                link_type: match &original.link_type {
+                    LinkType::File => "file".to_owned(),
+                    LinkType::Protocol(protocol) => protocol.clone().into_owned(),
+                    LinkType::Id => "id".to_owned(),
+                    LinkType::CustomId => "custom-id".to_owned(),
+                    LinkType::CodeRef => "coderef".to_owned(),
+                    LinkType::Fuzzy => "fuzzy".to_owned(),
+                },
+                path: original.get_path().into_owned(),
+                raw_link: original.raw_link.to_owned(),
+                application: original.application.map(|c| c.to_owned()),
+                search_option: original.get_search_option().map(Cow::into_owned),
+            },
+        ))
     }
 );

src/wasm/ast_node.rs

@@ -1,3 +1,4 @@
+use serde::Deserialize;
 use serde::Serialize;
 
 use super::angle_link::WasmAngleLink;
@@ -58,71 +59,84 @@ use super::timestamp::WasmTimestamp;
 use super::underline::WasmUnderline;
 use super::verbatim::WasmVerbatim;
 use super::verse_block::WasmVerseBlock;
+use super::WasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(untagged)]
-pub enum WasmAstNode<'s> {
-    // Document Nodes
-    Document(WasmDocument<'s>),
-    Headline(WasmHeadline<'s>),
-    Section(WasmSection<'s>),
-    // Elements
-    Paragraph(WasmParagraph<'s>),
-    PlainList(WasmPlainList<'s>),
-    PlainListItem(WasmPlainListItem<'s>),
-    CenterBlock(WasmCenterBlock<'s>),
-    QuoteBlock(WasmQuoteBlock<'s>),
-    SpecialBlock(WasmSpecialBlock<'s>),
-    DynamicBlock(WasmDynamicBlock<'s>),
-    FootnoteDefinition(WasmFootnoteDefinition<'s>),
-    Comment(WasmComment<'s>),
-    Drawer(WasmDrawer<'s>),
-    PropertyDrawer(WasmPropertyDrawer<'s>),
-    NodeProperty(WasmNodeProperty<'s>),
-    Table(WasmTable<'s>),
-    TableRow(WasmTableRow<'s>),
-    VerseBlock(WasmVerseBlock<'s>),
-    CommentBlock(WasmCommentBlock<'s>),
-    ExampleBlock(WasmExampleBlock<'s>),
-    ExportBlock(WasmExportBlock<'s>),
-    SrcBlock(WasmSrcBlock<'s>),
-    Clock(WasmClock<'s>),
-    DiarySexp(WasmDiarySexp<'s>),
-    Planning(WasmPlanning<'s>),
-    FixedWidthArea(WasmFixedWidthArea<'s>),
-    HorizontalRule(WasmHorizontalRule<'s>),
-    Keyword(WasmKeyword<'s>),
-    BabelCall(WasmBabelCall<'s>),
-    LatexEnvironment(WasmLatexEnvironment<'s>),
-    // Objects
-    Bold(WasmBold<'s>),
-    Italic(WasmItalic<'s>),
-    Underline(WasmUnderline<'s>),
-    StrikeThrough(WasmStrikeThrough<'s>),
-    Code(WasmCode<'s>),
-    Verbatim(WasmVerbatim<'s>),
-    PlainText(WasmPlainText<'s>),
-    RegularLink(WasmRegularLink<'s>),
-    RadioLink(WasmRadioLink<'s>),
-    RadioTarget(WasmRadioTarget<'s>),
-    PlainLink(WasmPlainLink<'s>),
-    AngleLink(WasmAngleLink<'s>),
-    OrgMacro(WasmOrgMacro<'s>),
-    Entity(WasmEntity<'s>),
-    LatexFragment(WasmLatexFragment<'s>),
-    ExportSnippet(WasmExportSnippet<'s>),
-    FootnoteReference(WasmFootnoteReference<'s>),
-    Citation(WasmCitation<'s>),
-    CitationReference(WasmCitationReference<'s>),
-    InlineBabelCall(WasmInlineBabelCall<'s>),
-    InlineSourceBlock(WasmInlineSourceBlock<'s>),
-    LineBreak(WasmLineBreak<'s>),
-    Target(WasmTarget<'s>),
-    StatisticsCookie(WasmStatisticsCookie<'s>),
-    Subscript(WasmSubscript<'s>),
-    Superscript(WasmSuperscript<'s>),
-    TableCell(WasmTableCell<'s>),
-    Timestamp(WasmTimestamp<'s>),
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmAstNodeWrapper<I> {
+    #[serde(rename = "ast-node")]
+    pub(crate) ast_node: String,
+    #[serde(rename = "standard-properties")]
+    pub(crate) standard_properties: WasmStandardProperties,
+    #[serde(rename = "children")]
+    pub(crate) children: Vec<WasmAstNode>,
+    #[serde(rename = "properties")]
+    pub(crate) properties: I,
 }
 
-impl<'s> WasmAstNode<'s> {}
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum WasmAstNode {
+    // Document Nodes
+    Document(WasmAstNodeWrapper<WasmDocument>),
+    Headline(WasmAstNodeWrapper<WasmHeadline>),
+    Section(WasmAstNodeWrapper<WasmSection>),
+    // Elements
+    Paragraph(WasmAstNodeWrapper<WasmParagraph>),
+    PlainList(WasmAstNodeWrapper<WasmPlainList>),
+    PlainListItem(WasmAstNodeWrapper<WasmPlainListItem>),
+    CenterBlock(WasmAstNodeWrapper<WasmCenterBlock>),
+    QuoteBlock(WasmAstNodeWrapper<WasmQuoteBlock>),
+    SpecialBlock(WasmAstNodeWrapper<WasmSpecialBlock>),
+    DynamicBlock(WasmAstNodeWrapper<WasmDynamicBlock>),
+    FootnoteDefinition(WasmAstNodeWrapper<WasmFootnoteDefinition>),
+    Comment(WasmAstNodeWrapper<WasmComment>),
+    Drawer(WasmAstNodeWrapper<WasmDrawer>),
+    PropertyDrawer(WasmAstNodeWrapper<WasmPropertyDrawer>),
+    NodeProperty(WasmAstNodeWrapper<WasmNodeProperty>),
+    Table(WasmAstNodeWrapper<WasmTable>),
+    TableRow(WasmAstNodeWrapper<WasmTableRow>),
+    VerseBlock(WasmAstNodeWrapper<WasmVerseBlock>),
+    CommentBlock(WasmAstNodeWrapper<WasmCommentBlock>),
+    ExampleBlock(WasmAstNodeWrapper<WasmExampleBlock>),
+    ExportBlock(WasmAstNodeWrapper<WasmExportBlock>),
+    SrcBlock(WasmAstNodeWrapper<WasmSrcBlock>),
+    Clock(WasmAstNodeWrapper<WasmClock>),
+    DiarySexp(WasmAstNodeWrapper<WasmDiarySexp>),
+    Planning(WasmAstNodeWrapper<WasmPlanning>),
+    FixedWidthArea(WasmAstNodeWrapper<WasmFixedWidthArea>),
+    HorizontalRule(WasmAstNodeWrapper<WasmHorizontalRule>),
+    Keyword(WasmAstNodeWrapper<WasmKeyword>),
+    BabelCall(WasmAstNodeWrapper<WasmBabelCall>),
+    LatexEnvironment(WasmAstNodeWrapper<WasmLatexEnvironment>),
+    // Objects
+    Bold(WasmAstNodeWrapper<WasmBold>),
+    Italic(WasmAstNodeWrapper<WasmItalic>),
+    Underline(WasmAstNodeWrapper<WasmUnderline>),
+    StrikeThrough(WasmAstNodeWrapper<WasmStrikeThrough>),
+    Code(WasmAstNodeWrapper<WasmCode>),
+    Verbatim(WasmAstNodeWrapper<WasmVerbatim>),
+    PlainText(WasmAstNodeWrapper<WasmPlainText>),
+    RegularLink(WasmAstNodeWrapper<WasmRegularLink>),
+    RadioLink(WasmAstNodeWrapper<WasmRadioLink>),
+    RadioTarget(WasmAstNodeWrapper<WasmRadioTarget>),
+    PlainLink(WasmAstNodeWrapper<WasmPlainLink>),
+    AngleLink(WasmAstNodeWrapper<WasmAngleLink>),
+    OrgMacro(WasmAstNodeWrapper<WasmOrgMacro>),
+    Entity(WasmAstNodeWrapper<WasmEntity>),
+    LatexFragment(WasmAstNodeWrapper<WasmLatexFragment>),
+    ExportSnippet(WasmAstNodeWrapper<WasmExportSnippet>),
+    FootnoteReference(WasmAstNodeWrapper<WasmFootnoteReference>),
+    Citation(WasmAstNodeWrapper<WasmCitation>),
+    CitationReference(WasmAstNodeWrapper<WasmCitationReference>),
+    InlineBabelCall(WasmAstNodeWrapper<WasmInlineBabelCall>),
+    InlineSourceBlock(WasmAstNodeWrapper<WasmInlineSourceBlock>),
+    LineBreak(WasmAstNodeWrapper<WasmLineBreak>),
+    Target(WasmAstNodeWrapper<WasmTarget>),
+    StatisticsCookie(WasmAstNodeWrapper<WasmStatisticsCookie>),
+    Subscript(WasmAstNodeWrapper<WasmSubscript>),
+    Superscript(WasmAstNodeWrapper<WasmSuperscript>),
+    TableCell(WasmAstNodeWrapper<WasmTableCell>),
+    Timestamp(WasmAstNodeWrapper<WasmTimestamp>),
+}
+
+impl WasmAstNode {}

src/wasm/babel_call.rs

@@ -1,34 +1,50 @@
-use std::marker::PhantomData;
-
-use crate::types::BabelCall;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use super::AdditionalProperties;
+use crate::types::BabelCall;
+use crate::types::GetAffiliatedKeywords;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmBabelCall<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmBabelCall {
+    #[serde(flatten)]
+    pub(crate) additional_properties: AdditionalProperties,
+    pub(crate) call: Option<String>,
+    #[serde(rename = "inside-header")]
+    pub(crate) inside_header: Option<String>,
+    pub(crate) arguments: Option<String>,
+    #[serde(rename = "end-header")]
+    pub(crate) end_header: Option<String>,
+    pub(crate) value: String,
 }
 
 to_wasm!(
-    WasmBabelCall<'s>,
+    WasmBabelCall,
     BabelCall<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::BabelCall(original) },
+    { "babel-call".into() },
     {
-        Ok(WasmBabelCall {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        let additional_properties = original
+            .get_affiliated_keywords()
+            .to_wasm(wasm_context.clone())?;
+
+        Ok((
+            Vec::new(),
+            WasmBabelCall {
+                additional_properties,
+                call: original.call.map(|s| s.to_owned()),
+                inside_header: original.inside_header.map(|s| s.to_owned()),
+                arguments: original.arguments.map(|s| s.to_owned()),
+                end_header: original.end_header.map(|s| s.to_owned()),
+                value: original.value.to_owned(),
+            },
+        ))
     }
 );

src/wasm/bold.rs

@@ -1,34 +1,34 @@
-use std::marker::PhantomData;
-
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
 use crate::types::Bold;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmBold<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
-}
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmBold {}
 
 to_wasm!(
-    WasmBold<'s>,
+    WasmBold,
     Bold<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::Bold(original) },
+    { "bold".into() },
     {
-        Ok(WasmBold {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        let children = original
+            .children
+            .iter()
+            .map(|child| {
+                child
+                    .to_wasm(wasm_context.clone())
+                    .map(Into::<WasmAstNode>::into)
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        Ok((children, WasmBold {}))
     }
 );

src/wasm/center_block.rs

@@ -1,34 +1,48 @@
-use std::marker::PhantomData;
-
-use crate::types::CenterBlock;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use super::AdditionalProperties;
+use crate::types::CenterBlock;
+use crate::types::GetAffiliatedKeywords;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmCenterBlock<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmCenterBlock {
+    #[serde(flatten)]
+    pub(crate) additional_properties: AdditionalProperties,
 }
 
 to_wasm!(
-    WasmCenterBlock<'s>,
+    WasmCenterBlock,
     CenterBlock<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::CenterBlock(original) },
+    { "center-block".into() },
     {
-        Ok(WasmCenterBlock {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        let additional_properties = original
+            .get_affiliated_keywords()
+            .to_wasm(wasm_context.clone())?;
+
+        let children = original
+            .children
+            .iter()
+            .map(|child| {
+                child
+                    .to_wasm(wasm_context.clone())
+                    .map(Into::<WasmAstNode>::into)
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        Ok((
+            children,
+            WasmCenterBlock {
+                additional_properties,
+            },
+        ))
     }
 );

src/wasm/citation.rs

@@ -1,34 +1,71 @@
-use std::marker::PhantomData;
-
-use crate::types::Citation;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use crate::types::Citation;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmCitation<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmCitation {
+    pub(crate) style: Option<String>,
+    pub(crate) prefix: Option<Vec<WasmAstNode>>,
+    pub(crate) suffix: Option<Vec<WasmAstNode>>,
 }
 
 to_wasm!(
-    WasmCitation<'s>,
+    WasmCitation,
     Citation<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::Citation(original) },
+    { "citation".into() },
     {
-        Ok(WasmCitation {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        let children = original
+            .children
+            .iter()
+            .map(|child| {
+                child
+                    .to_wasm(wasm_context.clone())
+                    .map(Into::<WasmAstNode>::into)
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+        let prefix = original
+            .prefix
+            .iter()
+            .map(|child| {
+                child
+                    .to_wasm(wasm_context.clone())
+                    .map(Into::<WasmAstNode>::into)
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+        let suffix = original
+            .suffix
+            .iter()
+            .map(|child| {
+                child
+                    .to_wasm(wasm_context.clone())
+                    .map(Into::<WasmAstNode>::into)
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        Ok((
+            children,
+            WasmCitation {
+                style: original.style.map(|s| s.to_owned()),
+                prefix: if prefix.is_empty() {
+                    None
+                } else {
+                    Some(prefix)
+                },
+                suffix: if suffix.is_empty() {
+                    None
+                } else {
+                    Some(suffix)
+                },
+            },
+        ))
     }
 );

src/wasm/citation_reference.rs

@@ -1,34 +1,62 @@
-use std::marker::PhantomData;
-
-use crate::types::CitationReference;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use crate::types::CitationReference;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmCitationReference<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmCitationReference {
+    pub(crate) key: String,
+    pub(crate) prefix: Option<Vec<WasmAstNode>>,
+    pub(crate) suffix: Option<Vec<WasmAstNode>>,
 }
 
 to_wasm!(
-    WasmCitationReference<'s>,
+    WasmCitationReference,
     CitationReference<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::CitationReference(original) },
+    { "citation-reference".into() },
     {
-        Ok(WasmCitationReference {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        let prefix = original
+            .prefix
+            .iter()
+            .map(|child| {
+                child
+                    .to_wasm(wasm_context.clone())
+                    .map(Into::<WasmAstNode>::into)
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+        let suffix = original
+            .suffix
+            .iter()
+            .map(|child| {
+                child
+                    .to_wasm(wasm_context.clone())
+                    .map(Into::<WasmAstNode>::into)
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        Ok((
+            Vec::new(),
+            WasmCitationReference {
+                key: original.key.to_owned(),
+                prefix: if prefix.is_empty() {
+                    None
+                } else {
+                    Some(prefix)
+                },
+                suffix: if suffix.is_empty() {
+                    None
+                } else {
+                    Some(suffix)
+                },
+            },
+        ))
     }
 );

src/wasm/clock.rs

@@ -1,34 +1,43 @@
-use std::marker::PhantomData;
-
-use crate::types::Clock;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use crate::types::Clock;
+use crate::types::ClockStatus;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmClock<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmClock {
+    #[serde(rename = "value")]
+    pub(crate) timestamp: Box<WasmAstNode>,
+    pub(crate) duration: Option<String>,
+    pub(crate) status: String,
 }
 
 to_wasm!(
-    WasmClock<'s>,
+    WasmClock,
     Clock<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::Clock(original) },
+    { "clock".into() },
     {
-        Ok(WasmClock {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        Ok((
+            Vec::new(),
+            WasmClock {
+                timestamp: Box::new(Into::<WasmAstNode>::into(
+                    original.timestamp.to_wasm(wasm_context.clone())?,
+                )),
+                duration: original.duration.map(|s| s.to_owned()),
+                status: match original.status {
+                    ClockStatus::Running => "running",
+                    ClockStatus::Closed => "closed",
+                }
+                .to_owned(),
+            },
+        ))
     }
 );

src/wasm/code.rs

@@ -1,34 +1,31 @@
-use std::marker::PhantomData;
-
-use crate::types::Code;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use crate::types::Code;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmCode<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmCode {
+    pub(crate) value: String,
 }
 
 to_wasm!(
-    WasmCode<'s>,
+    WasmCode,
     Code<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::Code(original) },
+    { "code".into() },
     {
-        Ok(WasmCode {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        Ok((
+            Vec::new(),
+            WasmCode {
+                value: original.contents.to_owned(),
+            },
+        ))
     }
 );

src/wasm/comment.rs

@@ -1,34 +1,31 @@
-use std::marker::PhantomData;
-
-use crate::types::Comment;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use crate::types::Comment;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmComment<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmComment {
+    pub(crate) value: String,
 }
 
 to_wasm!(
-    WasmComment<'s>,
+    WasmComment,
     Comment<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::Comment(original) },
+    { "comment".into() },
     {
-        Ok(WasmComment {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        Ok((
+            Vec::new(),
+            WasmComment {
+                value: original.get_value(),
+            },
+        ))
     }
 );

src/wasm/comment_block.rs

@@ -1,34 +1,40 @@
-use std::marker::PhantomData;
-
-use crate::types::CommentBlock;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use super::AdditionalProperties;
+use crate::types::CommentBlock;
+use crate::types::GetAffiliatedKeywords;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmCommentBlock<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmCommentBlock {
+    #[serde(flatten)]
+    pub(crate) additional_properties: AdditionalProperties,
+    pub(crate) value: String,
 }
 
 to_wasm!(
-    WasmCommentBlock<'s>,
+    WasmCommentBlock,
     CommentBlock<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::CommentBlock(original) },
+    { "comment-block".into() },
     {
-        Ok(WasmCommentBlock {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        let additional_properties = original
+            .get_affiliated_keywords()
+            .to_wasm(wasm_context.clone())?;
+
+        Ok((
+            Vec::new(),
+            WasmCommentBlock {
+                additional_properties,
+                value: original.contents.to_owned(),
+            },
+        ))
     }
 );

src/wasm/diary_sexp.rs

@@ -1,34 +1,40 @@
-use std::marker::PhantomData;
-
-use crate::types::DiarySexp;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use super::AdditionalProperties;
+use crate::types::DiarySexp;
+use crate::types::GetAffiliatedKeywords;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmDiarySexp<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmDiarySexp {
+    #[serde(flatten)]
+    pub(crate) additional_properties: AdditionalProperties,
+    pub(crate) value: String,
 }
 
 to_wasm!(
-    WasmDiarySexp<'s>,
+    WasmDiarySexp,
     DiarySexp<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::DiarySexp(original) },
+    { "diary-sexp".into() },
     {
-        Ok(WasmDiarySexp {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        let additional_properties = original
+            .get_affiliated_keywords()
+            .to_wasm(wasm_context.clone())?;
+
+        Ok((
+            Vec::new(),
+            WasmDiarySexp {
+                additional_properties,
+                value: original.value.to_owned(),
+            },
+        ))
     }
 );

src/wasm/document.rs

@@ -1,37 +1,46 @@
+use std::path::PathBuf;
+
+use serde::Deserialize;
 use serde::Serialize;
 
+use super::additional_property::AdditionalProperties;
+use super::additional_property::AdditionalPropertyValue;
 use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
 use crate::types::Document;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub struct WasmDocument<'s> {
-    standard_properties: WasmStandardProperties,
-    additional_properties: Vec<(String, &'s str)>,
-    children: Vec<WasmAstNode<'s>>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmDocument {
+    #[serde(flatten)]
+    pub(crate) additional_properties: AdditionalProperties,
+    #[serde(rename = "CATEGORY")]
+    pub(crate) category: Option<String>,
+    pub(crate) path: Option<PathBuf>,
 }
 
 to_wasm!(
-    WasmDocument<'s>,
+    WasmDocument,
     Document<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::Document(original) },
+    { "org-data".into() },
     {
-        let additional_properties: Vec<(String, &str)> = original
-            .get_additional_properties()
-            .map(|node_property| {
-                (
-                    format!(":{}", node_property.property_name.to_uppercase()),
-                    node_property.value.unwrap_or(""),
-                )
-            })
-            .collect();
+        let category = original.category.as_deref();
+        let path = original.path.clone();
+
+        let mut additional_properties = AdditionalProperties::default();
+        for (name, val) in original.get_additional_properties().map(|node_property| {
+            (
+                node_property.property_name.to_uppercase(),
+                AdditionalPropertyValue::SingleString(node_property.value.unwrap_or("").to_owned()),
+            )
+        }) {
+            additional_properties.properties.insert(name, val);
+        }
 
         let children = original
             .zeroth_section
@@ -39,34 +48,22 @@ to_wasm!(
             .map(|child| {
                 child
                     .to_wasm(wasm_context.clone())
-                    .map(Into::<WasmAstNode<'_>>::into)
+                    .map(Into::<WasmAstNode>::into)
             })
             .chain(original.children.iter().map(|child| {
                 child
                     .to_wasm(wasm_context.clone())
-                    .map(Into::<WasmAstNode<'_>>::into)
+                    .map(Into::<WasmAstNode>::into)
             }))
             .collect::<Result<Vec<_>, _>>()?;
-        // let children = original
-        //     .children
-        //     .iter()
-        //     .map(|child| {
-        //         child
-        //             .to_wasm(wasm_context.clone())
-        //             .map(Into::<WasmAstNode<'_>>::into)
-        //     })
-        //     .collect::<Result<Vec<_>, _>>()?;
 
-        Ok(WasmDocument {
-            standard_properties,
-            additional_properties,
+        Ok((
             children,
-        })
+            WasmDocument {
+                additional_properties,
+                category: category.map(str::to_owned),
+                path,
+            },
+        ))
     }
 );
-
-impl<'s> Into<WasmAstNode<'s>> for WasmDocument<'s> {
-    fn into(self) -> WasmAstNode<'s> {
-        WasmAstNode::Document(self)
-    }
-}

src/wasm/drawer.rs

@@ -1,34 +1,51 @@
-use std::marker::PhantomData;
-
-use crate::types::Drawer;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use super::AdditionalProperties;
+use crate::types::Drawer;
+use crate::types::GetAffiliatedKeywords;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmDrawer<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmDrawer {
+    #[serde(flatten)]
+    pub(crate) additional_properties: AdditionalProperties,
+    #[serde(rename = "drawer-name")]
+    pub(crate) drawer_name: String,
 }
 
 to_wasm!(
-    WasmDrawer<'s>,
+    WasmDrawer,
     Drawer<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::Drawer(original) },
+    { "drawer".into() },
     {
-        Ok(WasmDrawer {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        let additional_properties = original
+            .get_affiliated_keywords()
+            .to_wasm(wasm_context.clone())?;
+
+        let children = original
+            .children
+            .iter()
+            .map(|child| {
+                child
+                    .to_wasm(wasm_context.clone())
+                    .map(Into::<WasmAstNode>::into)
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        Ok((
+            children,
+            WasmDrawer {
+                additional_properties,
+                drawer_name: original.drawer_name.to_owned(),
+            },
+        ))
     }
 );

src/wasm/dynamic_block.rs

@@ -1,34 +1,53 @@
-use std::marker::PhantomData;
-
-use crate::types::DynamicBlock;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use super::AdditionalProperties;
+use crate::types::DynamicBlock;
+use crate::types::GetAffiliatedKeywords;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmDynamicBlock<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmDynamicBlock {
+    #[serde(flatten)]
+    pub(crate) additional_properties: AdditionalProperties,
+    #[serde(rename = "block-name")]
+    pub(crate) block_name: String,
+    pub(crate) arguments: Option<String>,
 }
 
 to_wasm!(
-    WasmDynamicBlock<'s>,
+    WasmDynamicBlock,
     DynamicBlock<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::DynamicBlock(original) },
+    { "dynamic-block".into() },
     {
-        Ok(WasmDynamicBlock {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        let additional_properties = original
+            .get_affiliated_keywords()
+            .to_wasm(wasm_context.clone())?;
+
+        let children = original
+            .children
+            .iter()
+            .map(|child| {
+                child
+                    .to_wasm(wasm_context.clone())
+                    .map(Into::<WasmAstNode>::into)
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        Ok((
+            children,
+            WasmDynamicBlock {
+                additional_properties,
+                block_name: original.block_name.to_owned(),
+                arguments: original.parameters.map(|s| s.to_owned()),
+            },
+        ))
     }
 );

src/wasm/entity.rs

@@ -1,34 +1,49 @@
-use std::marker::PhantomData;
-
-use crate::types::Entity;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
+use super::headline::Noop;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use crate::types::Entity;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmEntity<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmEntity {
+    pub(crate) name: String,
+    pub(crate) latex: String,
+    #[serde(rename = "latex-math-p")]
+    pub(crate) latex_math_mode: bool,
+    pub(crate) html: String,
+    pub(crate) ascii: String,
+    pub(crate) latin1: Noop,
+    #[serde(rename = "utf-8")]
+    pub(crate) utf8: String,
+    #[serde(rename = "use-brackets-p")]
+    pub(crate) use_brackets: bool,
 }
 
 to_wasm!(
-    WasmEntity<'s>,
+    WasmEntity,
     Entity<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::Entity(original) },
+    { "entity".into() },
     {
-        Ok(WasmEntity {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        Ok((
+            Vec::new(),
+            WasmEntity {
+                name: original.name.to_owned(),
+                latex: original.latex.to_owned(),
+                latex_math_mode: original.latex_math_mode,
+                html: original.html.to_owned(),
+                ascii: original.ascii.to_owned(),
+                latin1: Noop {},
+                utf8: original.utf8.to_owned(),
+                use_brackets: original.use_brackets,
+            },
+        ))
     }
 );

src/wasm/example_block.rs

@@ -1,34 +1,75 @@
-use std::marker::PhantomData;
-
-use crate::types::ExampleBlock;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
+use super::src_block::WasmNumberLines;
+use super::src_block::WasmNumberLinesWrapper;
+use super::src_block::WasmRetainLabels;
 use super::to_wasm::ToWasm;
+use super::AdditionalProperties;
+use crate::types::CharOffsetInLine;
+use crate::types::ExampleBlock;
+use crate::types::GetAffiliatedKeywords;
+use crate::types::RetainLabels;
+use crate::types::SwitchNumberLines;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmExampleBlock<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmExampleBlock {
+    #[serde(flatten)]
+    pub(crate) additional_properties: AdditionalProperties,
+    pub(crate) value: String,
+    pub(crate) switches: Option<String>,
+    #[serde(rename = "number-lines")]
+    pub(crate) number_lines: Option<WasmNumberLinesWrapper>,
+    #[serde(rename = "preserve-indent")]
+    pub(crate) preserve_indent: Option<CharOffsetInLine>,
+    #[serde(rename = "retain-labels")]
+    pub(crate) retain_labels: WasmRetainLabels,
+    #[serde(rename = "use-labels")]
+    pub(crate) use_labels: bool,
+    #[serde(rename = "label-fmt")]
+    pub(crate) label_format: Option<String>,
 }
 
 to_wasm!(
-    WasmExampleBlock<'s>,
+    WasmExampleBlock,
     ExampleBlock<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::ExampleBlock(original) },
+    { "example-block".into() },
     {
-        Ok(WasmExampleBlock {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        let additional_properties = original
+            .get_affiliated_keywords()
+            .to_wasm(wasm_context.clone())?;
+
+        Ok((
+            Vec::new(),
+            WasmExampleBlock {
+                additional_properties,
+                value: original.get_value().into_owned(),
+                switches: original.switches.map(|s| s.to_owned()),
+                number_lines: match original.number_lines {
+                    None => None,
+                    Some(SwitchNumberLines::New(n)) => Some(WasmNumberLinesWrapper {
+                        inner: WasmNumberLines::New(n),
+                    }),
+                    Some(SwitchNumberLines::Continued(n)) => Some(WasmNumberLinesWrapper {
+                        inner: WasmNumberLines::Continued(n),
+                    }),
+                },
+                preserve_indent: original.preserve_indent,
+                retain_labels: match original.retain_labels {
+                    RetainLabels::No => WasmRetainLabels::YesNo(false),
+                    RetainLabels::Yes => WasmRetainLabels::YesNo(true),
+                    RetainLabels::Keep(n) => WasmRetainLabels::Keep(n),
+                },
+                use_labels: original.use_labels,
+                label_format: original.label_format.map(|s| s.to_owned()),
+            },
+        ))
     }
 );

src/wasm/export_block.rs

@@ -1,34 +1,43 @@
-use std::marker::PhantomData;
-
-use crate::types::ExportBlock;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use super::AdditionalProperties;
+use crate::types::ExportBlock;
+use crate::types::GetAffiliatedKeywords;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmExportBlock<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmExportBlock {
+    #[serde(flatten)]
+    pub(crate) additional_properties: AdditionalProperties,
+    #[serde(rename = "type")]
+    pub(crate) export_type: Option<String>,
+    pub(crate) value: String,
 }
 
 to_wasm!(
-    WasmExportBlock<'s>,
+    WasmExportBlock,
     ExportBlock<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::ExportBlock(original) },
+    { "export-block".into() },
     {
-        Ok(WasmExportBlock {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        let additional_properties = original
+            .get_affiliated_keywords()
+            .to_wasm(wasm_context.clone())?;
+
+        Ok((
+            Vec::new(),
+            WasmExportBlock {
+                additional_properties,
+                export_type: original.get_export_type(),
+                value: original.get_value().into_owned(),
+            },
+        ))
     }
 );

src/wasm/export_snippet.rs

@@ -1,34 +1,34 @@
-use std::marker::PhantomData;
-
-use crate::types::ExportSnippet;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use crate::types::ExportSnippet;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmExportSnippet<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmExportSnippet {
+    #[serde(rename = "back-end")]
+    pub(crate) backend: String,
+    pub(crate) value: Option<String>,
 }
 
 to_wasm!(
-    WasmExportSnippet<'s>,
+    WasmExportSnippet,
     ExportSnippet<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::ExportSnippet(original) },
+    { "export-snippet".into() },
     {
-        Ok(WasmExportSnippet {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        Ok((
+            Vec::new(),
+            WasmExportSnippet {
+                backend: original.backend.to_owned(),
+                value: original.contents.map(|s| s.to_owned()),
+            },
+        ))
     }
 );

src/wasm/fixed_width_area.rs

@@ -1,34 +1,42 @@
-use std::marker::PhantomData;
-
-use crate::types::FixedWidthArea;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use super::AdditionalProperties;
+use crate::types::FixedWidthArea;
+use crate::types::GetAffiliatedKeywords;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmFixedWidthArea<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmFixedWidthArea {
+    #[serde(flatten)]
+    pub(crate) additional_properties: AdditionalProperties,
+    pub(crate) value: String,
 }
 
 to_wasm!(
-    WasmFixedWidthArea<'s>,
+    WasmFixedWidthArea,
     FixedWidthArea<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::FixedWidthArea(original) },
+    { "fixed-width".into() },
     {
-        Ok(WasmFixedWidthArea {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        let additional_properties = original
+            .get_affiliated_keywords()
+            .to_wasm(wasm_context.clone())?;
+
+        let value = original.get_value();
+
+        Ok((
+            Vec::new(),
+            WasmFixedWidthArea {
+                additional_properties,
+                value,
+            },
+        ))
     }
 );

src/wasm/footnote_definition.rs

@@ -1,34 +1,54 @@
-use std::marker::PhantomData;
-
-use crate::types::FootnoteDefinition;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
+use super::headline::Noop;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use super::AdditionalProperties;
+use crate::types::FootnoteDefinition;
+use crate::types::GetAffiliatedKeywords;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmFootnoteDefinition<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmFootnoteDefinition {
+    #[serde(flatten)]
+    pub(crate) additional_properties: AdditionalProperties,
+    pub(crate) label: String,
+    #[serde(rename = "pre-blank")]
+    pub(crate) pre_blank: Noop,
 }
 
 to_wasm!(
-    WasmFootnoteDefinition<'s>,
+    WasmFootnoteDefinition,
     FootnoteDefinition<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::FootnoteDefinition(original) },
+    { "footnote-definition".into() },
     {
-        Ok(WasmFootnoteDefinition {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        let additional_properties = original
+            .get_affiliated_keywords()
+            .to_wasm(wasm_context.clone())?;
+
+        let children = original
+            .children
+            .iter()
+            .map(|child| {
+                child
+                    .to_wasm(wasm_context.clone())
+                    .map(Into::<WasmAstNode>::into)
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        Ok((
+            children,
+            WasmFootnoteDefinition {
+                additional_properties,
+                label: original.label.to_owned(),
+                pre_blank: Noop {},
+            },
+        ))
     }
 );

src/wasm/footnote_reference.rs

@@ -1,34 +1,49 @@
-use std::marker::PhantomData;
-
-use crate::types::FootnoteReference;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use crate::types::FootnoteReference;
+use crate::types::FootnoteReferenceType;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmFootnoteReference<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmFootnoteReference {
+    pub(crate) label: Option<String>,
+    #[serde(rename = "type")]
+    pub(crate) footnote_reference_type: String,
 }
 
 to_wasm!(
-    WasmFootnoteReference<'s>,
+    WasmFootnoteReference,
     FootnoteReference<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::FootnoteReference(original) },
+    { "footnote-reference".into() },
     {
-        Ok(WasmFootnoteReference {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        let children = original
+            .definition
+            .iter()
+            .map(|child| {
+                child
+                    .to_wasm(wasm_context.clone())
+                    .map(Into::<WasmAstNode>::into)
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        Ok((
+            children,
+            WasmFootnoteReference {
+                label: original.label.map(|s| s.to_owned()),
+                footnote_reference_type: match original.get_type() {
+                    FootnoteReferenceType::Standard => "standard",
+                    FootnoteReferenceType::Inline => "inline",
+                }
+                .to_owned(),
+            },
+        ))
     }
 );

src/wasm/headline.rs

@@ -1,40 +1,140 @@
-use std::marker::PhantomData;
-
-use crate::types::Heading;
+use serde::Deserialize;
 use serde::Serialize;
 
 use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use super::AdditionalProperties;
+use super::AdditionalPropertyValue;
+use crate::types::Heading;
+use crate::types::HeadlineLevel;
+use crate::types::PriorityCookie;
+use crate::types::TodoKeywordType;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "headline")]
-pub(crate) struct WasmHeadline<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmHeadline {
+    #[serde(flatten)]
+    pub(crate) additional_properties: AdditionalProperties,
+    pub(crate) level: HeadlineLevel,
+    pub(crate) tags: Vec<String>,
+    #[serde(rename = "todo-keyword")]
+    pub(crate) todo_keyword: Option<String>,
+    #[serde(rename = "todo-type")]
+    pub(crate) todo_type: Option<String>,
+    pub(crate) title: Vec<WasmAstNode>,
+    pub(crate) priority: Option<PriorityCookie>,
+    #[serde(rename = "archivedp")]
+    pub(crate) is_archived: bool,
+    #[serde(rename = "commentedp")]
+    pub(crate) is_comment: bool,
+    #[serde(rename = "raw-value")]
+    pub(crate) raw_value: String,
+    #[serde(rename = "footnote-section-p")]
+    pub(crate) is_footnote_section: bool,
+    pub(crate) scheduled: Option<Box<WasmAstNode>>,
+    pub(crate) deadline: Option<Box<WasmAstNode>>,
+    pub(crate) closed: Option<Box<WasmAstNode>>,
+    #[serde(rename = "pre-blank")]
+    pub(crate) pre_blank: Noop,
 }
 
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(tag = "noop")]
+pub struct Noop {}
+
 to_wasm!(
-    WasmHeadline<'s>,
+    WasmHeadline,
     Heading<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::Headline(original) },
+    { "headline".into() },
     {
-        Ok(WasmHeadline {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        let mut additional_properties = AdditionalProperties::default();
+        for (name, val) in original.get_additional_properties().map(|node_property| {
+            (
+                node_property.property_name.to_uppercase(),
+                AdditionalPropertyValue::SingleString(node_property.value.unwrap_or("").to_owned()),
+            )
+        }) {
+            additional_properties.properties.insert(name, val);
+        }
+
+        let children = original
+            .children
+            .iter()
+            .map(|child| {
+                child
+                    .to_wasm(wasm_context.clone())
+                    .map(Into::<WasmAstNode>::into)
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        Ok((
+            children,
+            WasmHeadline {
+                additional_properties,
+                level: original.level,
+                tags: original.tags.iter().map(|tag| (*tag).to_owned()).collect(),
+                todo_keyword: original
+                    .todo_keyword
+                    .as_ref()
+                    .map(|(_, keyword)| (*keyword).to_owned()),
+                todo_type: original
+                    .todo_keyword
+                    .as_ref()
+                    .map(|(keyword, _)| match keyword {
+                        TodoKeywordType::Done => "done".to_owned(),
+                        TodoKeywordType::Todo => "todo".to_owned(),
+                    }),
+                title: original
+                    .title
+                    .iter()
+                    .map(|child| {
+                        child
+                            .to_wasm(wasm_context.clone())
+                            .map(Into::<WasmAstNode>::into)
+                    })
+                    .collect::<Result<Vec<_>, _>>()?,
+                priority: original.priority_cookie,
+                is_archived: original.is_archived,
+                is_comment: original.is_comment,
+                raw_value: original.get_raw_value(),
+                is_footnote_section: original.is_footnote_section,
+                scheduled: original
+                    .scheduled
+                    .as_ref()
+                    .map(|child| {
+                        child
+                            .to_wasm(wasm_context.clone())
+                            .map(Into::<WasmAstNode>::into)
+                    })
+                    .map_or(Ok(None), |r| r.map(Some))?
+                    .map(Box::new),
+                deadline: original
+                    .deadline
+                    .as_ref()
+                    .map(|child| {
+                        child
+                            .to_wasm(wasm_context.clone())
+                            .map(Into::<WasmAstNode>::into)
+                    })
+                    .map_or(Ok(None), |r| r.map(Some))?
+                    .map(Box::new),
+                closed: original
+                    .closed
+                    .as_ref()
+                    .map(|child| {
+                        child
+                            .to_wasm(wasm_context.clone())
+                            .map(Into::<WasmAstNode>::into)
+                    })
+                    .map_or(Ok(None), |r| r.map(Some))?
+                    .map(Box::new),
+                pre_blank: Noop {},
+            },
+        ))
     }
 );
-
-impl<'s> Into<WasmAstNode<'s>> for WasmHeadline<'s> {
-    fn into(self) -> WasmAstNode<'s> {
-        WasmAstNode::Headline(self)
-    }
-}

src/wasm/horizontal_rule.rs

@@ -1,34 +1,38 @@
-use std::marker::PhantomData;
-
-use crate::types::HorizontalRule;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use super::AdditionalProperties;
+use crate::types::GetAffiliatedKeywords;
+use crate::types::HorizontalRule;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmHorizontalRule<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmHorizontalRule {
+    #[serde(flatten)]
+    pub(crate) additional_properties: AdditionalProperties,
 }
 
 to_wasm!(
-    WasmHorizontalRule<'s>,
+    WasmHorizontalRule,
     HorizontalRule<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::HorizontalRule(original) },
+    { "horizontal-rule".into() },
     {
-        Ok(WasmHorizontalRule {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        let additional_properties = original
+            .get_affiliated_keywords()
+            .to_wasm(wasm_context.clone())?;
+
+        Ok((
+            Vec::new(),
+            WasmHorizontalRule {
+                additional_properties,
+            },
+        ))
     }
 );

src/wasm/inline_babel_call.rs

@@ -1,34 +1,41 @@
-use std::marker::PhantomData;
-
-use crate::types::InlineBabelCall;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use crate::types::InlineBabelCall;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmInlineBabelCall<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmInlineBabelCall {
+    pub(crate) call: String,
+    #[serde(rename = "inside-header")]
+    pub(crate) inside_header: Option<String>,
+    pub(crate) arguments: Option<String>,
+    #[serde(rename = "end-header")]
+    pub(crate) end_header: Option<String>,
+    pub(crate) value: String,
 }
 
 to_wasm!(
-    WasmInlineBabelCall<'s>,
+    WasmInlineBabelCall,
     InlineBabelCall<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::InlineBabelCall(original) },
+    { "inline-babel-call".into() },
     {
-        Ok(WasmInlineBabelCall {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        Ok((
+            Vec::new(),
+            WasmInlineBabelCall {
+                call: original.call.to_owned(),
+                inside_header: original.inside_header.map(|s| s.to_owned()),
+                arguments: original.arguments.map(|s| s.to_owned()),
+                end_header: original.end_header.map(|s| s.to_owned()),
+                value: original.value.to_owned(),
+            },
+        ))
     }
 );

src/wasm/inline_source_block.rs

@@ -1,34 +1,35 @@
-use std::marker::PhantomData;
-
-use crate::types::InlineSourceBlock;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use crate::types::InlineSourceBlock;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmInlineSourceBlock<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmInlineSourceBlock {
+    pub(crate) language: String,
+    pub(crate) value: String,
+    pub(crate) parameters: Option<String>,
 }
 
 to_wasm!(
-    WasmInlineSourceBlock<'s>,
+    WasmInlineSourceBlock,
     InlineSourceBlock<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::InlineSourceBlock(original) },
+    { "inline-src-block".into() },
     {
-        Ok(WasmInlineSourceBlock {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        Ok((
+            Vec::new(),
+            WasmInlineSourceBlock {
+                language: original.language.to_owned(),
+                value: original.value.to_owned(),
+                parameters: original.parameters.map(str::to_owned),
+            },
+        ))
     }
 );

src/wasm/italic.rs

@@ -1,34 +1,34 @@
-use std::marker::PhantomData;
-
-use crate::types::Italic;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use crate::types::Italic;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmItalic<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
-}
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmItalic {}
 
 to_wasm!(
-    WasmItalic<'s>,
+    WasmItalic,
     Italic<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::Italic(original) },
+    { "italic".into() },
     {
-        Ok(WasmItalic {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        let children = original
+            .children
+            .iter()
+            .map(|child| {
+                child
+                    .to_wasm(wasm_context.clone())
+                    .map(Into::<WasmAstNode>::into)
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        Ok((children, WasmItalic {}))
     }
 );

src/wasm/keyword.rs

@@ -1,34 +1,42 @@
-use std::marker::PhantomData;
-
-use crate::types::Keyword;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use super::AdditionalProperties;
+use crate::types::GetAffiliatedKeywords;
+use crate::types::Keyword;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmKeyword<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmKeyword {
+    #[serde(flatten)]
+    pub(crate) additional_properties: AdditionalProperties,
+    pub(crate) key: String,
+    pub(crate) value: String,
 }
 
 to_wasm!(
-    WasmKeyword<'s>,
+    WasmKeyword,
     Keyword<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::Keyword(original) },
+    { "keyword".into() },
     {
-        Ok(WasmKeyword {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        let additional_properties = original
+            .get_affiliated_keywords()
+            .to_wasm(wasm_context.clone())?;
+
+        Ok((
+            Vec::new(),
+            WasmKeyword {
+                additional_properties,
+                key: original.key.to_uppercase(),
+                value: original.value.to_owned(),
+            },
+        ))
     }
 );

src/wasm/latex_environment.rs

@@ -1,34 +1,40 @@
-use std::marker::PhantomData;
-
-use crate::types::LatexEnvironment;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use super::AdditionalProperties;
+use crate::types::GetAffiliatedKeywords;
+use crate::types::LatexEnvironment;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmLatexEnvironment<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmLatexEnvironment {
+    #[serde(flatten)]
+    pub(crate) additional_properties: AdditionalProperties,
+    pub(crate) value: String,
 }
 
 to_wasm!(
-    WasmLatexEnvironment<'s>,
+    WasmLatexEnvironment,
     LatexEnvironment<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::LatexEnvironment(original) },
+    { "latex-environment".into() },
     {
-        Ok(WasmLatexEnvironment {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        let additional_properties = original
+            .get_affiliated_keywords()
+            .to_wasm(wasm_context.clone())?;
+
+        Ok((
+            Vec::new(),
+            WasmLatexEnvironment {
+                additional_properties,
+                value: original.value.to_owned(),
+            },
+        ))
     }
 );

src/wasm/latex_fragment.rs

@@ -1,34 +1,31 @@
-use std::marker::PhantomData;
-
-use crate::types::LatexFragment;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use crate::types::LatexFragment;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmLatexFragment<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmLatexFragment {
+    pub(crate) value: String,
 }
 
 to_wasm!(
-    WasmLatexFragment<'s>,
+    WasmLatexFragment,
     LatexFragment<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::LatexFragment(original) },
+    { "latex-fragment".into() },
     {
-        Ok(WasmLatexFragment {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        Ok((
+            Vec::new(),
+            WasmLatexFragment {
+                value: original.value.to_owned(),
+            },
+        ))
     }
 );

src/wasm/line_break.rs

@@ -1,34 +1,22 @@
-use std::marker::PhantomData;
-
-use crate::types::LineBreak;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use crate::types::LineBreak;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmLineBreak<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
-}
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmLineBreak {}
 
 to_wasm!(
-    WasmLineBreak<'s>,
+    WasmLineBreak,
     LineBreak<'s>,
     original,
     wasm_context,
-    standard_properties,
-    {
-        Ok(WasmLineBreak {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
-    }
+    { WasmAstNode::LineBreak(original) },
+    { "line-break".into() },
+    { Ok((Vec::new(), WasmLineBreak {},)) }
 );

src/wasm/macros.rs

@@ -2,7 +2,7 @@
 ///
 /// This exists to make changing the type signature easier.
 macro_rules! to_wasm {
-    ($ostruct:ty, $istruct:ty, $original:ident, $wasm_context:ident, $standard_properties:ident, $fnbody:tt) => {
+    ($ostruct:ty, $istruct:ty, $original:ident, $wasm_context:ident, $fnbody:tt) => {
         impl<'s> ToWasm for $istruct {
             type Output = $ostruct;
 
@@ -11,12 +11,49 @@ macro_rules! to_wasm {
                 $wasm_context: crate::wasm::to_wasm::ToWasmContext<'_>,
             ) -> Result<Self::Output, crate::error::CustomError> {
                 let $original = self;
-                let $standard_properties =
-                    self.to_wasm_standard_properties($wasm_context.clone())?;
+                #[allow(unused_braces)]
                 $fnbody
             }
         }
     };
+    ($ostruct:ty, $istruct:ty, $original:ident, $wasm_context:ident, $toastnodebody:tt, $elispnamebody:tt, $fnbody:tt) => {
+        impl<'s> ToWasm for $istruct {
+            type Output = crate::wasm::ast_node::WasmAstNodeWrapper<$ostruct>;
+
+            fn to_wasm(
+                &self,
+                $wasm_context: crate::wasm::to_wasm::ToWasmContext<'_>,
+            ) -> Result<Self::Output, crate::error::CustomError> {
+                #[allow(unused_variables)]
+                let $original = self;
+                let standard_properties =
+                    self.to_wasm_standard_properties($wasm_context.clone())?;
+
+                $fnbody.map(
+                    |(children, inner)| crate::wasm::ast_node::WasmAstNodeWrapper {
+                        ast_node: inner.get_elisp_name().into_owned(),
+                        standard_properties,
+                        children,
+                        properties: inner,
+                    },
+                )
+            }
+        }
+
+        impl From<crate::wasm::ast_node::WasmAstNodeWrapper<$ostruct>> for WasmAstNode {
+            fn from($original: crate::wasm::ast_node::WasmAstNodeWrapper<$ostruct>) -> Self {
+                let ret = $toastnodebody;
+                ret
+            }
+        }
+
+        impl<'s> crate::util::elisp_fact::ElispFact<'s> for $ostruct {
+            fn get_elisp_name<'b>(&'b self) -> std::borrow::Cow<'s, str> {
+                let ret = $elispnamebody;
+                ret
+            }
+        }
+    };
 }
 
 pub(crate) use to_wasm;

src/wasm/mod.rs

@@ -1,3 +1,4 @@
+mod additional_property;
 mod angle_link;
 mod ast_node;
 mod babel_call;
@@ -62,8 +63,14 @@ mod underline;
 mod verbatim;
 mod verse_block;
 
+pub use additional_property::AdditionalProperties;
+pub use additional_property::AdditionalPropertyValue;
+pub use ast_node::WasmAstNode;
+#[cfg(feature = "wasm_test")]
+pub use ast_node::WasmAstNodeWrapper;
+#[cfg(feature = "wasm_test")]
 pub use document::WasmDocument;
-pub use parse_result::wasm_parse_org;
 pub use parse_result::ParseResult;
-pub(crate) use to_wasm::ToWasm;
-pub(crate) use to_wasm::ToWasmContext;
+pub(crate) use standard_properties::WasmStandardProperties;
+pub use to_wasm::ToWasm;
+pub use to_wasm::ToWasmContext;

src/wasm/node_property.rs

@@ -1,34 +1,33 @@
-use std::marker::PhantomData;
-
-use crate::types::NodeProperty;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use crate::types::NodeProperty;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmNodeProperty<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmNodeProperty {
+    pub(crate) key: String,
+    pub(crate) value: Option<String>,
 }
 
 to_wasm!(
-    WasmNodeProperty<'s>,
+    WasmNodeProperty,
     NodeProperty<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::NodeProperty(original) },
+    { "node-property".into() },
     {
-        Ok(WasmNodeProperty {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        Ok((
+            Vec::new(),
+            WasmNodeProperty {
+                key: original.property_name.to_owned(),
+                value: original.value.map(|s| s.to_owned()),
+            },
+        ))
     }
 );

src/wasm/org_macro.rs

@@ -1,34 +1,35 @@
-use std::marker::PhantomData;
-
-use crate::types::OrgMacro;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use crate::types::OrgMacro;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmOrgMacro<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmOrgMacro {
+    pub(crate) key: String,
+    pub(crate) value: String,
+    pub(crate) args: Vec<String>,
 }
 
 to_wasm!(
-    WasmOrgMacro<'s>,
+    WasmOrgMacro,
     OrgMacro<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::OrgMacro(original) },
+    { "macro".into() },
     {
-        Ok(WasmOrgMacro {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        Ok((
+            Vec::new(),
+            WasmOrgMacro {
+                key: original.key.to_lowercase(),
+                value: original.value.to_owned(),
+                args: original.get_args().map(|s| s.into_owned()).collect(),
+            },
+        ))
     }
 );

src/wasm/paragraph.rs

@@ -1,34 +1,48 @@
-use std::marker::PhantomData;
-
-use crate::types::Paragraph;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use super::AdditionalProperties;
+use crate::types::GetAffiliatedKeywords;
+use crate::types::Paragraph;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmParagraph<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmParagraph {
+    #[serde(flatten)]
+    pub(crate) additional_properties: AdditionalProperties,
 }
 
 to_wasm!(
-    WasmParagraph<'s>,
+    WasmParagraph,
     Paragraph<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::Paragraph(original) },
+    { "paragraph".into() },
     {
-        Ok(WasmParagraph {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        let additional_properties = original
+            .get_affiliated_keywords()
+            .to_wasm(wasm_context.clone())?;
+
+        let children = original
+            .children
+            .iter()
+            .map(|child| {
+                child
+                    .to_wasm(wasm_context.clone())
+                    .map(Into::<WasmAstNode>::into)
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        Ok((
+            children,
+            WasmParagraph {
+                additional_properties,
+            },
+        ))
     }
 );

src/wasm/parse_result.rs

@@ -1,32 +1,15 @@
+use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNodeWrapper;
 use super::document::WasmDocument;
-use super::ToWasm;
-use super::ToWasmContext;
-use crate::parser::parse_with_settings;
-use crate::settings::GlobalSettings;
 
-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(tag = "status", content = "content")]
-pub enum ParseResult<'s> {
+pub enum ParseResult {
     #[serde(rename = "success")]
-    Success(WasmDocument<'s>),
+    Success(WasmAstNodeWrapper<WasmDocument>),
 
     #[serde(rename = "error")]
     Error(String),
 }
-
-pub fn wasm_parse_org(org_contents: &str) -> ParseResult<'_> {
-    let global_settings = GlobalSettings::default();
-    let to_wasm_context = ToWasmContext::new(org_contents);
-    let rust_parsed = match parse_with_settings(org_contents, &global_settings)
-        .map(|document| document.to_wasm(to_wasm_context))
-        .map(|wasm_document| match wasm_document {
-            Ok(wasm_document) => ParseResult::Success(wasm_document),
-            Err(err) => ParseResult::Error(format!("{:?}", err)),
-        }) {
-        Ok(wasm_document) => wasm_document,
-        Err(err) => ParseResult::Error(format!("{:?}", err)),
-    };
-    rust_parsed
-}

src/wasm/plain_link.rs

@@ -1,34 +1,52 @@
-use std::marker::PhantomData;
-
-use crate::types::PlainLink;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use crate::types::LinkType;
+use crate::types::PlainLink;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmPlainLink<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(tag = "format")]
+#[serde(rename = "plain")]
+pub struct WasmPlainLink {
+    #[serde(rename = "type")]
+    pub(crate) link_type: String,
+    pub(crate) path: String,
+    #[serde(rename = "raw-link")]
+    pub(crate) raw_link: String,
+    pub(crate) application: Option<String>,
+    #[serde(rename = "search-option")]
+    pub(crate) search_option: Option<String>,
 }
 
 to_wasm!(
-    WasmPlainLink<'s>,
+    WasmPlainLink,
     PlainLink<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::PlainLink(original) },
+    { "link".into() },
     {
-        Ok(WasmPlainLink {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        Ok((
+            Vec::new(),
+            WasmPlainLink {
+                link_type: match &original.link_type {
+                    LinkType::File => "file".to_owned(),
+                    LinkType::Protocol(protocol) => protocol.clone().into_owned(),
+                    LinkType::Id => "id".to_owned(),
+                    LinkType::CustomId => "custom-id".to_owned(),
+                    LinkType::CodeRef => "coderef".to_owned(),
+                    LinkType::Fuzzy => "fuzzy".to_owned(),
+                },
+                path: original.path.to_owned(),
+                raw_link: original.raw_link.to_owned(),
+                application: original.application.map(str::to_owned),
+                search_option: original.search_option.map(str::to_owned),
+            },
+        ))
     }
 );

src/wasm/plain_list.rs

@@ -1,34 +1,57 @@
-use std::marker::PhantomData;
-
-use crate::types::PlainList;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use super::AdditionalProperties;
+use crate::types::GetAffiliatedKeywords;
+use crate::types::PlainList;
+use crate::types::PlainListType;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmPlainList<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmPlainList {
+    #[serde(flatten)]
+    pub(crate) additional_properties: AdditionalProperties,
+    #[serde(rename = "type")]
+    pub(crate) list_type: String,
 }
 
 to_wasm!(
-    WasmPlainList<'s>,
+    WasmPlainList,
     PlainList<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::PlainList(original) },
+    { "plain-list".into() },
     {
-        Ok(WasmPlainList {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        let additional_properties = original
+            .get_affiliated_keywords()
+            .to_wasm(wasm_context.clone())?;
+
+        let children = original
+            .children
+            .iter()
+            .map(|child| {
+                child
+                    .to_wasm(wasm_context.clone())
+                    .map(Into::<WasmAstNode>::into)
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        Ok((
+            children,
+            WasmPlainList {
+                additional_properties,
+                list_type: match original.list_type {
+                    PlainListType::Unordered => "unordered",
+                    PlainListType::Ordered => "ordered",
+                    PlainListType::Descriptive => "descriptive",
+                }
+                .to_owned(),
+            },
+        ))
     }
 );

src/wasm/plain_list_item.rs

@@ -1,34 +1,68 @@
-use std::marker::PhantomData;
-
-use crate::types::PlainListItem;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use crate::types::CheckboxType;
+use crate::types::PlainListItem;
+use crate::types::PlainListItemCounter;
+use crate::types::PlainListItemPreBlank;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmPlainListItem<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmPlainListItem {
+    pub(crate) tag: Vec<WasmAstNode>,
+    pub(crate) bullet: String,
+    pub(crate) counter: Option<PlainListItemCounter>,
+    pub(crate) checkbox: Option<String>,
+    #[serde(rename = "pre-blank")]
+    pub(crate) pre_blank: PlainListItemPreBlank,
 }
 
 to_wasm!(
-    WasmPlainListItem<'s>,
+    WasmPlainListItem,
     PlainListItem<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::PlainListItem(original) },
+    { "item".into() },
     {
-        Ok(WasmPlainListItem {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        let children = original
+            .children
+            .iter()
+            .map(|child| {
+                child
+                    .to_wasm(wasm_context.clone())
+                    .map(Into::<WasmAstNode>::into)
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        Ok((
+            children,
+            WasmPlainListItem {
+                tag: original
+                    .tag
+                    .iter()
+                    .map(|child| {
+                        child
+                            .to_wasm(wasm_context.clone())
+                            .map(Into::<WasmAstNode>::into)
+                    })
+                    .collect::<Result<Vec<_>, _>>()?,
+                bullet: original.bullet.to_owned(),
+                counter: original.counter,
+                checkbox: original.checkbox.as_ref().map(|(checkbox_type, _)| {
+                    match checkbox_type {
+                        CheckboxType::On => "on",
+                        CheckboxType::Trans => "trans",
+                        CheckboxType::Off => "off",
+                    }
+                    .to_owned()
+                }),
+                pre_blank: original.pre_blank,
+            },
+        ))
     }
 );

src/wasm/plain_text.rs

@@ -1,34 +1,22 @@
-use std::marker::PhantomData;
-
-use crate::types::PlainText;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use crate::types::PlainText;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmPlainText<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
-}
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmPlainText {}
 
 to_wasm!(
-    WasmPlainText<'s>,
+    WasmPlainText,
     PlainText<'s>,
     original,
     wasm_context,
-    standard_properties,
-    {
-        Ok(WasmPlainText {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
-    }
+    { WasmAstNode::PlainText(original) },
+    { "plain-text".into() },
+    { Ok((Vec::new(), WasmPlainText {},)) }
 );

src/wasm/planning.rs

@@ -1,34 +1,62 @@
-use std::marker::PhantomData;
-
-use crate::types::Planning;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use crate::types::Planning;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmPlanning<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmPlanning {
+    pub(crate) scheduled: Option<Box<WasmAstNode>>,
+    pub(crate) deadline: Option<Box<WasmAstNode>>,
+    pub(crate) closed: Option<Box<WasmAstNode>>,
 }
 
 to_wasm!(
-    WasmPlanning<'s>,
+    WasmPlanning,
     Planning<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::Planning(original) },
+    { "planning".into() },
     {
-        Ok(WasmPlanning {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        Ok((
+            Vec::new(),
+            WasmPlanning {
+                scheduled: original
+                    .scheduled
+                    .as_ref()
+                    .map(|child| {
+                        child
+                            .to_wasm(wasm_context.clone())
+                            .map(Into::<WasmAstNode>::into)
+                    })
+                    .map_or(Ok(None), |r| r.map(Some))?
+                    .map(Box::new),
+                deadline: original
+                    .deadline
+                    .as_ref()
+                    .map(|child| {
+                        child
+                            .to_wasm(wasm_context.clone())
+                            .map(Into::<WasmAstNode>::into)
+                    })
+                    .map_or(Ok(None), |r| r.map(Some))?
+                    .map(Box::new),
+                closed: original
+                    .closed
+                    .as_ref()
+                    .map(|child| {
+                        child
+                            .to_wasm(wasm_context.clone())
+                            .map(Into::<WasmAstNode>::into)
+                    })
+                    .map_or(Ok(None), |r| r.map(Some))?
+                    .map(Box::new),
+            },
+        ))
     }
 );

src/wasm/property_drawer.rs

@@ -1,34 +1,34 @@
-use std::marker::PhantomData;
-
-use crate::types::PropertyDrawer;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use crate::types::PropertyDrawer;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmPropertyDrawer<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
-}
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmPropertyDrawer {}
 
 to_wasm!(
-    WasmPropertyDrawer<'s>,
+    WasmPropertyDrawer,
     PropertyDrawer<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::PropertyDrawer(original) },
+    { "property-drawer".into() },
     {
-        Ok(WasmPropertyDrawer {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        let children = original
+            .children
+            .iter()
+            .map(|child| {
+                child
+                    .to_wasm(wasm_context.clone())
+                    .map(Into::<WasmAstNode>::into)
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        Ok((children, WasmPropertyDrawer {}))
     }
 );

src/wasm/quote_block.rs

@@ -1,34 +1,48 @@
-use std::marker::PhantomData;
-
-use crate::types::QuoteBlock;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use super::AdditionalProperties;
+use crate::types::GetAffiliatedKeywords;
+use crate::types::QuoteBlock;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmQuoteBlock<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmQuoteBlock {
+    #[serde(flatten)]
+    pub(crate) additional_properties: AdditionalProperties,
 }
 
 to_wasm!(
-    WasmQuoteBlock<'s>,
+    WasmQuoteBlock,
     QuoteBlock<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::QuoteBlock(original) },
+    { "quote-block".into() },
     {
-        Ok(WasmQuoteBlock {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        let additional_properties = original
+            .get_affiliated_keywords()
+            .to_wasm(wasm_context.clone())?;
+
+        let children = original
+            .children
+            .iter()
+            .map(|child| {
+                child
+                    .to_wasm(wasm_context.clone())
+                    .map(Into::<WasmAstNode>::into)
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        Ok((
+            children,
+            WasmQuoteBlock {
+                additional_properties,
+            },
+        ))
     }
 );

src/wasm/radio_link.rs

@@ -1,34 +1,54 @@
-use std::marker::PhantomData;
-
-use crate::types::RadioLink;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use crate::types::RadioLink;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmRadioLink<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(tag = "format")]
+#[serde(rename = "plain")]
+pub struct WasmRadioLink {
+    #[serde(rename = "type")]
+    pub(crate) link_type: String,
+    pub(crate) path: String,
+    #[serde(rename = "raw-link")]
+    pub(crate) raw_link: String,
+    pub(crate) application: Option<String>, // Always None
+    #[serde(rename = "search-option")]
+    pub(crate) search_option: Option<String>, // Always None
 }
 
 to_wasm!(
-    WasmRadioLink<'s>,
+    WasmRadioLink,
     RadioLink<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::RadioLink(original) },
+    { "link".into() },
     {
-        Ok(WasmRadioLink {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        let children = original
+            .children
+            .iter()
+            .map(|child| {
+                child
+                    .to_wasm(wasm_context.clone())
+                    .map(Into::<WasmAstNode>::into)
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        Ok((
+            children,
+            WasmRadioLink {
+                link_type: "radio".to_owned(),
+                path: original.path.to_owned(),
+                raw_link: original.get_raw_link().to_owned(),
+                application: None,
+                search_option: None,
+            },
+        ))
     }
 );

src/wasm/radio_target.rs

@@ -1,34 +1,41 @@
-use std::marker::PhantomData;
-
-use crate::types::RadioTarget;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use crate::types::RadioTarget;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmRadioTarget<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmRadioTarget {
+    pub(crate) value: String,
 }
 
 to_wasm!(
-    WasmRadioTarget<'s>,
+    WasmRadioTarget,
     RadioTarget<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::RadioTarget(original) },
+    { "radio-target".into() },
     {
-        Ok(WasmRadioTarget {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        let children = original
+            .children
+            .iter()
+            .map(|child| {
+                child
+                    .to_wasm(wasm_context.clone())
+                    .map(Into::<WasmAstNode>::into)
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        Ok((
+            children,
+            WasmRadioTarget {
+                value: original.value.to_owned(),
+            },
+        ))
     }
 );

src/wasm/regular_link.rs

@@ -1,34 +1,67 @@
-use std::marker::PhantomData;
+use std::borrow::Cow;
 
-use crate::types::RegularLink;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use crate::types::LinkType;
+use crate::types::RegularLink;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmRegularLink<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(tag = "format")]
+#[serde(rename = "bracket")]
+pub struct WasmRegularLink {
+    #[serde(rename = "type")]
+    pub(crate) link_type: String,
+    pub(crate) path: String,
+    #[serde(rename = "raw-link")]
+    pub(crate) raw_link: String,
+    pub(crate) application: Option<String>,
+    #[serde(rename = "search-option")]
+    pub(crate) search_option: Option<String>,
 }
 
 to_wasm!(
-    WasmRegularLink<'s>,
+    WasmRegularLink,
     RegularLink<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::RegularLink(original) },
+    { "link".into() },
     {
-        Ok(WasmRegularLink {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        let children = original
+            .children
+            .iter()
+            .map(|child| {
+                child
+                    .to_wasm(wasm_context.clone())
+                    .map(Into::<WasmAstNode>::into)
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        Ok((
+            children,
+            WasmRegularLink {
+                link_type: match &original.link_type {
+                    LinkType::File => "file".to_owned(),
+                    LinkType::Protocol(protocol) => protocol.clone().into_owned(),
+                    LinkType::Id => "id".to_owned(),
+                    LinkType::CustomId => "custom-id".to_owned(),
+                    LinkType::CodeRef => "coderef".to_owned(),
+                    LinkType::Fuzzy => "fuzzy".to_owned(),
+                },
+                path: original.get_path().into_owned(),
+                raw_link: original.get_raw_link().into_owned(),
+                application: original
+                    .application
+                    .as_ref()
+                    .map(|c| c.clone().into_owned()),
+                search_option: original.get_search_option().map(Cow::into_owned),
+            },
+        ))
     }
 );

src/wasm/section.rs

@@ -1,40 +1,34 @@
-use std::marker::PhantomData;
-
-use crate::types::Section;
+use serde::Deserialize;
 use serde::Serialize;
 
 use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use crate::types::Section;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "section")]
-pub(crate) struct WasmSection<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
-}
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmSection {}
 
 to_wasm!(
-    WasmSection<'s>,
+    WasmSection,
     Section<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::Section(original) },
+    { "section".into() },
     {
-        Ok(WasmSection {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        let children = original
+            .children
+            .iter()
+            .map(|child| {
+                child
+                    .to_wasm(wasm_context.clone())
+                    .map(Into::<WasmAstNode>::into)
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        Ok((children, WasmSection {}))
     }
 );
-
-impl<'s> Into<WasmAstNode<'s>> for WasmSection<'s> {
-    fn into(self) -> WasmAstNode<'s> {
-        WasmAstNode::Section(self)
-    }
-}

src/wasm/special_block.rs

@@ -1,34 +1,56 @@
-use std::marker::PhantomData;
-
-use crate::types::SpecialBlock;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
+use super::headline::Noop;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use super::AdditionalProperties;
+use crate::types::GetAffiliatedKeywords;
+use crate::types::SpecialBlock;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmSpecialBlock<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmSpecialBlock {
+    #[serde(flatten)]
+    pub(crate) additional_properties: AdditionalProperties,
+    #[serde(rename = "type")]
+    pub(crate) block_type: String,
+    pub(crate) parameters: Option<String>,
+    pub(crate) results: Noop,
 }
 
 to_wasm!(
-    WasmSpecialBlock<'s>,
+    WasmSpecialBlock,
     SpecialBlock<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::SpecialBlock(original) },
+    { "special-block".into() },
     {
-        Ok(WasmSpecialBlock {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        let additional_properties = original
+            .get_affiliated_keywords()
+            .to_wasm(wasm_context.clone())?;
+
+        let children = original
+            .children
+            .iter()
+            .map(|child| {
+                child
+                    .to_wasm(wasm_context.clone())
+                    .map(Into::<WasmAstNode>::into)
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        Ok((
+            children,
+            WasmSpecialBlock {
+                additional_properties,
+                block_type: original.block_type.to_owned(),
+                parameters: original.parameters.map(|s| s.to_owned()),
+                results: Noop {},
+            },
+        ))
     }
 );

src/wasm/src_block.rs

@@ -1,34 +1,100 @@
-use std::marker::PhantomData;
-
-use crate::types::SrcBlock;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use super::AdditionalProperties;
+use crate::types::CharOffsetInLine;
+use crate::types::GetAffiliatedKeywords;
+use crate::types::LineNumber;
+use crate::types::RetainLabels;
+use crate::types::SrcBlock;
+use crate::types::SwitchNumberLines;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmSrcBlock<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmSrcBlock {
+    #[serde(flatten)]
+    pub(crate) additional_properties: AdditionalProperties,
+    pub(crate) language: Option<String>,
+    pub(crate) value: String,
+    pub(crate) switches: Option<String>,
+    pub(crate) parameters: Option<String>,
+    #[serde(rename = "number-lines")]
+    pub(crate) number_lines: Option<WasmNumberLinesWrapper>,
+    #[serde(rename = "preserve-indent")]
+    pub(crate) preserve_indent: Option<CharOffsetInLine>,
+    #[serde(rename = "retain-labels")]
+    pub(crate) retain_labels: WasmRetainLabels,
+    #[serde(rename = "use-labels")]
+    pub(crate) use_labels: bool,
+    #[serde(rename = "label-fmt")]
+    pub(crate) label_format: Option<String>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(untagged)]
+pub(crate) enum WasmRetainLabels {
+    YesNo(bool),
+    Keep(CharOffsetInLine),
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub(crate) enum WasmNumberLines {
+    #[serde(rename = "new")]
+    New(LineNumber),
+    #[serde(rename = "continued")]
+    Continued(LineNumber),
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename = "number-lines")]
+#[serde(tag = "number-lines")]
+pub(crate) struct WasmNumberLinesWrapper {
+    #[serde(flatten)]
+    pub(crate) inner: WasmNumberLines,
 }
 
 to_wasm!(
-    WasmSrcBlock<'s>,
+    WasmSrcBlock,
     SrcBlock<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::SrcBlock(original) },
+    { "src-block".into() },
     {
-        Ok(WasmSrcBlock {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        let additional_properties = original
+            .get_affiliated_keywords()
+            .to_wasm(wasm_context.clone())?;
+
+        Ok((
+            Vec::new(),
+            WasmSrcBlock {
+                additional_properties,
+                language: original.language.map(|s| s.to_owned()),
+                value: original.get_value().into_owned(),
+                switches: original.switches.map(|s| s.to_owned()),
+                parameters: original.parameters.map(|s| s.to_owned()),
+                number_lines: match original.number_lines {
+                    None => None,
+                    Some(SwitchNumberLines::New(n)) => Some(WasmNumberLinesWrapper {
+                        inner: WasmNumberLines::New(n),
+                    }),
+                    Some(SwitchNumberLines::Continued(n)) => Some(WasmNumberLinesWrapper {
+                        inner: WasmNumberLines::Continued(n),
+                    }),
+                },
+                preserve_indent: original.preserve_indent,
+                retain_labels: match original.retain_labels {
+                    RetainLabels::No => WasmRetainLabels::YesNo(false),
+                    RetainLabels::Yes => WasmRetainLabels::YesNo(true),
+                    RetainLabels::Keep(n) => WasmRetainLabels::Keep(n),
+                },
+                use_labels: original.use_labels,
+                label_format: original.label_format.map(|s| s.to_owned()),
+            },
+        ))
     }
 );

src/wasm/standard_properties.rs

@@ -1,18 +1,21 @@
-use crate::types::PostBlank;
-use crate::types::StandardProperties;
 use serde::Deserialize;
 use serde::Serialize;
 
 use super::to_wasm::ToWasmContext;
 use super::to_wasm::ToWasmStandardProperties;
+use crate::types::PostBlank;
+use crate::types::StandardProperties;
 
-#[derive(Debug, Serialize)]
+#[derive(Debug, Serialize, Deserialize)]
 pub(crate) struct WasmStandardProperties {
-    begin: usize,
-    end: usize,
-    contents_begin: Option<usize>,
-    contents_end: Option<usize>,
-    post_blank: PostBlank,
+    pub(crate) begin: usize,
+    pub(crate) end: usize,
+    #[serde(rename = "contents-begin")]
+    pub(crate) contents_begin: Option<usize>,
+    #[serde(rename = "contents-end")]
+    pub(crate) contents_end: Option<usize>,
+    #[serde(rename = "post-blank")]
+    pub(crate) post_blank: PostBlank,
 }
 
 impl<'s, SP: StandardProperties<'s>> ToWasmStandardProperties for SP {

src/wasm/statistics_cookie.rs

@@ -1,34 +1,31 @@
-use std::marker::PhantomData;
-
-use crate::types::StatisticsCookie;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use crate::types::StatisticsCookie;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmStatisticsCookie<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmStatisticsCookie {
+    pub(crate) value: String,
 }
 
 to_wasm!(
-    WasmStatisticsCookie<'s>,
+    WasmStatisticsCookie,
     StatisticsCookie<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::StatisticsCookie(original) },
+    { "statistics-cookie".into() },
     {
-        Ok(WasmStatisticsCookie {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        Ok((
+            Vec::new(),
+            WasmStatisticsCookie {
+                value: original.value.to_owned(),
+            },
+        ))
     }
 );

src/wasm/strike_through.rs

@@ -1,34 +1,34 @@
-use std::marker::PhantomData;
-
-use crate::types::StrikeThrough;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use crate::types::StrikeThrough;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmStrikeThrough<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
-}
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmStrikeThrough {}
 
 to_wasm!(
-    WasmStrikeThrough<'s>,
+    WasmStrikeThrough,
     StrikeThrough<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::StrikeThrough(original) },
+    { "strike-through".into() },
     {
-        Ok(WasmStrikeThrough {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        let children = original
+            .children
+            .iter()
+            .map(|child| {
+                child
+                    .to_wasm(wasm_context.clone())
+                    .map(Into::<WasmAstNode>::into)
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        Ok((children, WasmStrikeThrough {}))
     }
 );

src/wasm/subscript.rs

@@ -1,34 +1,42 @@
-use std::marker::PhantomData;
-
-use crate::types::Subscript;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use crate::types::Subscript;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmSubscript<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmSubscript {
+    #[serde(rename = "use-brackets-p")]
+    pub(crate) use_brackets: bool,
 }
 
 to_wasm!(
-    WasmSubscript<'s>,
+    WasmSubscript,
     Subscript<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::Subscript(original) },
+    { "subscript".into() },
     {
-        Ok(WasmSubscript {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        let children = original
+            .children
+            .iter()
+            .map(|child| {
+                child
+                    .to_wasm(wasm_context.clone())
+                    .map(Into::<WasmAstNode>::into)
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        Ok((
+            children,
+            WasmSubscript {
+                use_brackets: original.use_brackets,
+            },
+        ))
     }
 );

src/wasm/superscript.rs

@@ -1,34 +1,42 @@
-use std::marker::PhantomData;
-
-use crate::types::Superscript;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use crate::types::Superscript;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmSuperscript<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmSuperscript {
+    #[serde(rename = "use-brackets-p")]
+    pub(crate) use_brackets: bool,
 }
 
 to_wasm!(
-    WasmSuperscript<'s>,
+    WasmSuperscript,
     Superscript<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::Superscript(original) },
+    { "superscript".into() },
     {
-        Ok(WasmSuperscript {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        let children = original
+            .children
+            .iter()
+            .map(|child| {
+                child
+                    .to_wasm(wasm_context.clone())
+                    .map(Into::<WasmAstNode>::into)
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        Ok((
+            children,
+            WasmSuperscript {
+                use_brackets: original.use_brackets,
+            },
+        ))
     }
 );

src/wasm/table.rs

@@ -1,34 +1,75 @@
-use std::marker::PhantomData;
+use std::collections::BTreeSet;
 
-use crate::types::Table;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use super::AdditionalProperties;
+use crate::types::GetAffiliatedKeywords;
+use crate::types::Table;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmTable<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmTable {
+    #[serde(flatten)]
+    pub(crate) additional_properties: AdditionalProperties,
+    #[serde(rename = "tblfm")]
+    pub(crate) formulas: Option<WasmStringSet>,
+    #[serde(rename = "type")]
+    pub(crate) table_type: String,
+    pub(crate) value: Option<String>, // Always None
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(tag = "string-set")]
+#[serde(rename = "string-set")]
+pub(crate) struct WasmStringSet {
+    value: BTreeSet<String>,
 }
 
 to_wasm!(
-    WasmTable<'s>,
+    WasmTable,
     Table<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::Table(original) },
+    { "table".into() },
     {
-        Ok(WasmTable {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        let additional_properties = original
+            .get_affiliated_keywords()
+            .to_wasm(wasm_context.clone())?;
+
+        let children = original
+            .children
+            .iter()
+            .map(|child| {
+                child
+                    .to_wasm(wasm_context.clone())
+                    .map(Into::<WasmAstNode>::into)
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        Ok((
+            children,
+            WasmTable {
+                additional_properties,
+                formulas: if original.formulas.is_empty() {
+                    None
+                } else {
+                    Some(WasmStringSet {
+                        value: original
+                            .formulas
+                            .iter()
+                            .map(|kw| kw.value.to_owned())
+                            .collect(),
+                    })
+                },
+                table_type: "org".to_owned(),
+                value: None,
+            },
+        ))
     }
 );

src/wasm/table_cell.rs

@@ -1,34 +1,34 @@
-use std::marker::PhantomData;
-
-use crate::types::TableCell;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use crate::types::TableCell;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmTableCell<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
-}
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmTableCell {}
 
 to_wasm!(
-    WasmTableCell<'s>,
+    WasmTableCell,
     TableCell<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::TableCell(original) },
+    { "table-cell".into() },
     {
-        Ok(WasmTableCell {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        let children = original
+            .children
+            .iter()
+            .map(|child| {
+                child
+                    .to_wasm(wasm_context.clone())
+                    .map(Into::<WasmAstNode>::into)
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        Ok((children, WasmTableCell {}))
     }
 );

src/wasm/table_row.rs

@@ -1,34 +1,47 @@
-use std::marker::PhantomData;
-
-use crate::types::TableRow;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use crate::types::TableRow;
+use crate::types::TableRowType;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmTableRow<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmTableRow {
+    #[serde(rename = "type")]
+    pub(crate) row_type: String,
 }
 
 to_wasm!(
-    WasmTableRow<'s>,
+    WasmTableRow,
     TableRow<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::TableRow(original) },
+    { "table-row".into() },
     {
-        Ok(WasmTableRow {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        let children = original
+            .children
+            .iter()
+            .map(|child| {
+                child
+                    .to_wasm(wasm_context.clone())
+                    .map(Into::<WasmAstNode>::into)
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        Ok((
+            children,
+            WasmTableRow {
+                row_type: match original.get_type() {
+                    TableRowType::Standard => "standard",
+                    TableRowType::Rule => "rule",
+                }
+                .to_owned(),
+            },
+        ))
     }
 );

src/wasm/target.rs

@@ -1,34 +1,31 @@
-use std::marker::PhantomData;
-
-use crate::types::Target;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use crate::types::Target;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmTarget<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmTarget {
+    pub(crate) value: String,
 }
 
 to_wasm!(
-    WasmTarget<'s>,
+    WasmTarget,
     Target<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::Target(original) },
+    { "target".into() },
     {
-        Ok(WasmTarget {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        Ok((
+            Vec::new(),
+            WasmTarget {
+                value: original.value.to_owned(),
+            },
+        ))
     }
 );

src/wasm/timestamp.rs

@@ -1,34 +1,146 @@
-use std::marker::PhantomData;
-
-use crate::types::Timestamp;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use crate::types::DayOfMonthInner;
+use crate::types::HourInner;
+use crate::types::MinuteInner;
+use crate::types::MonthInner;
+use crate::types::RepeaterType;
+use crate::types::RepeaterWarningDelayValueType;
+use crate::types::TimeUnit;
+use crate::types::Timestamp;
+use crate::types::TimestampRangeType;
+use crate::types::TimestampType;
+use crate::types::WarningDelayType;
+use crate::types::YearInner;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmTimestamp<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmTimestamp {
+    #[serde(rename = "type")]
+    pub(crate) timestamp_type: String,
+    #[serde(rename = "range-type")]
+    pub(crate) range_type: Option<String>,
+    #[serde(rename = "raw-value")]
+    pub(crate) raw_value: String,
+    #[serde(rename = "year-start")]
+    pub(crate) year_start: Option<YearInner>,
+    #[serde(rename = "month-start")]
+    pub(crate) month_start: Option<MonthInner>,
+    #[serde(rename = "day-start")]
+    pub(crate) day_of_month_start: Option<DayOfMonthInner>,
+    #[serde(rename = "hour-start")]
+    pub(crate) hour_start: Option<HourInner>,
+    #[serde(rename = "minute-start")]
+    pub(crate) minute_start: Option<MinuteInner>,
+    #[serde(rename = "year-end")]
+    pub(crate) year_end: Option<YearInner>,
+    #[serde(rename = "month-end")]
+    pub(crate) month_end: Option<MonthInner>,
+    #[serde(rename = "day-end")]
+    pub(crate) day_of_month_end: Option<DayOfMonthInner>,
+    #[serde(rename = "hour-end")]
+    pub(crate) hour_end: Option<HourInner>,
+    #[serde(rename = "minute-end")]
+    pub(crate) minute_end: Option<MinuteInner>,
+    #[serde(rename = "repeater-type")]
+    pub(crate) repeater_type: Option<String>,
+    #[serde(rename = "repeater-unit")]
+    pub(crate) repeater_unit: Option<String>,
+    #[serde(rename = "repeater-value")]
+    pub(crate) repeater_value: Option<RepeaterWarningDelayValueType>,
+    #[serde(rename = "warning-type")]
+    pub(crate) warning_type: Option<String>,
+    #[serde(rename = "warning-unit")]
+    pub(crate) warning_unit: Option<String>,
+    #[serde(rename = "warning-value")]
+    pub(crate) warning_value: Option<RepeaterWarningDelayValueType>,
 }
 
 to_wasm!(
-    WasmTimestamp<'s>,
+    WasmTimestamp,
     Timestamp<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::Timestamp(original) },
+    { "timestamp".into() },
     {
-        Ok(WasmTimestamp {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        Ok((
+            Vec::new(),
+            WasmTimestamp {
+                timestamp_type: match original.timestamp_type {
+                    TimestampType::Diary => "diary",
+                    TimestampType::Active => "active",
+                    TimestampType::Inactive => "inactive",
+                    TimestampType::ActiveRange => "active-range",
+                    TimestampType::InactiveRange => "inactive-range",
+                }
+                .to_owned(),
+                range_type: match original.range_type {
+                    TimestampRangeType::DateRange => Some("daterange".to_owned()),
+                    TimestampRangeType::TimeRange => Some("timerange".to_owned()),
+                    TimestampRangeType::None => None,
+                },
+                raw_value: original.get_raw_value().to_owned(),
+                year_start: original.start.as_ref().map(|date| date.get_year().0),
+                month_start: original.start.as_ref().map(|date| date.get_month().0),
+                day_of_month_start: original
+                    .start
+                    .as_ref()
+                    .map(|date| date.get_day_of_month().0),
+                hour_start: original.start_time.as_ref().map(|time| time.get_hour().0),
+                minute_start: original.start_time.as_ref().map(|time| time.get_minute().0),
+                year_end: original.end.as_ref().map(|date| date.get_year().0),
+                month_end: original.end.as_ref().map(|date| date.get_month().0),
+                day_of_month_end: original.end.as_ref().map(|date| date.get_day_of_month().0),
+                hour_end: original.end_time.as_ref().map(|time| time.get_hour().0),
+                minute_end: original.end_time.as_ref().map(|time| time.get_minute().0),
+                repeater_type: original
+                    .repeater
+                    .as_ref()
+                    .map(|repeater| match repeater.repeater_type {
+                        RepeaterType::Cumulative => "cumulate",
+                        RepeaterType::CatchUp => "catch-up",
+                        RepeaterType::Restart => "restart",
+                    })
+                    .map(|text| text.to_owned()),
+                repeater_unit: original
+                    .repeater
+                    .as_ref()
+                    .map(|repeater| match repeater.unit {
+                        TimeUnit::Hour => "hour",
+                        TimeUnit::Day => "day",
+                        TimeUnit::Week => "week",
+                        TimeUnit::Month => "month",
+                        TimeUnit::Year => "year",
+                    })
+                    .map(|text| text.to_owned()),
+                repeater_value: original.repeater.as_ref().map(|repeater| repeater.value),
+                warning_type: original
+                    .warning_delay
+                    .as_ref()
+                    .map(|warning| match warning.warning_delay_type {
+                        WarningDelayType::All => "all",
+                        WarningDelayType::First => "first",
+                    })
+                    .map(|text| text.to_owned()),
+                warning_unit: original
+                    .warning_delay
+                    .as_ref()
+                    .map(|warning| match warning.unit {
+                        TimeUnit::Hour => "hour",
+                        TimeUnit::Day => "day",
+                        TimeUnit::Week => "week",
+                        TimeUnit::Month => "month",
+                        TimeUnit::Year => "year",
+                    })
+                    .map(|text| text.to_owned()),
+                warning_value: original.warning_delay.as_ref().map(|warning| warning.value),
+            },
+        ))
     }
 );

src/wasm/to_wasm.rs

@@ -1,6 +1,11 @@
+use super::macros::to_wasm;
+use super::WasmAstNode;
 use crate::error::CustomError;
+use crate::types::DocumentElement;
+use crate::types::Element;
+use crate::types::Object;
 
-pub(crate) trait ToWasm {
+pub trait ToWasm {
     type Output;
 
     fn to_wasm(&self, full_document: ToWasmContext<'_>) -> Result<Self::Output, CustomError>;
@@ -16,12 +21,104 @@ pub(crate) trait ToWasmStandardProperties {
 }
 
 #[derive(Debug, Clone)]
-pub(crate) struct ToWasmContext<'s> {
+pub struct ToWasmContext<'s> {
     pub(crate) full_document: &'s str,
 }
 
 impl<'s> ToWasmContext<'s> {
-    pub(crate) fn new(full_document: &'s str) -> ToWasmContext<'s> {
+    pub fn new(full_document: &'s str) -> ToWasmContext<'s> {
         ToWasmContext { full_document }
     }
 }
+
+to_wasm!(WasmAstNode, DocumentElement<'s>, original, wasm_context, {
+    match original {
+        DocumentElement::Heading(inner) => {
+            inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
+        }
+        DocumentElement::Section(inner) => {
+            inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
+        }
+    }
+});
+
+to_wasm!(WasmAstNode, Element<'s>, original, wasm_context, {
+    match original {
+        Element::Paragraph(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+        Element::PlainList(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+        Element::CenterBlock(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+        Element::QuoteBlock(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+        Element::SpecialBlock(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+        Element::DynamicBlock(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+        Element::FootnoteDefinition(inner) => {
+            inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
+        }
+        Element::Comment(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+        Element::Drawer(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+        Element::PropertyDrawer(inner) => {
+            inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
+        }
+        Element::Table(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+        Element::VerseBlock(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+        Element::CommentBlock(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+        Element::ExampleBlock(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+        Element::ExportBlock(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+        Element::SrcBlock(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+        Element::Clock(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+        Element::DiarySexp(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+        Element::Planning(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+        Element::FixedWidthArea(inner) => {
+            inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
+        }
+        Element::HorizontalRule(inner) => {
+            inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
+        }
+        Element::Keyword(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+        Element::BabelCall(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+        Element::LatexEnvironment(inner) => {
+            inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
+        }
+    }
+});
+
+to_wasm!(WasmAstNode, Object<'s>, original, wasm_context, {
+    match original {
+        Object::Bold(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+        Object::Italic(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+        Object::Underline(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+        Object::StrikeThrough(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+        Object::Code(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+        Object::Verbatim(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+        Object::PlainText(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+        Object::RegularLink(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+        Object::RadioLink(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+        Object::RadioTarget(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+        Object::PlainLink(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+        Object::AngleLink(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+        Object::OrgMacro(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+        Object::Entity(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+        Object::LatexFragment(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+        Object::ExportSnippet(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+        Object::FootnoteReference(inner) => {
+            inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
+        }
+        Object::Citation(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+        Object::CitationReference(inner) => {
+            inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
+        }
+        Object::InlineBabelCall(inner) => {
+            inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
+        }
+        Object::InlineSourceBlock(inner) => {
+            inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
+        }
+        Object::LineBreak(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+        Object::Target(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+        Object::StatisticsCookie(inner) => {
+            inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into)
+        }
+        Object::Subscript(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+        Object::Superscript(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+        Object::Timestamp(inner) => inner.to_wasm(wasm_context).map(Into::<WasmAstNode>::into),
+    }
+});

src/wasm/underline.rs

@@ -1,34 +1,34 @@
-use std::marker::PhantomData;
-
-use crate::types::Underline;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use crate::types::Underline;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmUnderline<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
-}
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmUnderline {}
 
 to_wasm!(
-    WasmUnderline<'s>,
+    WasmUnderline,
     Underline<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::Underline(original) },
+    { "underline".into() },
     {
-        Ok(WasmUnderline {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        let children = original
+            .children
+            .iter()
+            .map(|child| {
+                child
+                    .to_wasm(wasm_context.clone())
+                    .map(Into::<WasmAstNode>::into)
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        Ok((children, WasmUnderline {}))
     }
 );

src/wasm/verbatim.rs

@@ -1,34 +1,31 @@
-use std::marker::PhantomData;
-
-use crate::types::Verbatim;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use crate::types::Verbatim;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmVerbatim<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmVerbatim {
+    pub(crate) value: String,
 }
 
 to_wasm!(
-    WasmVerbatim<'s>,
+    WasmVerbatim,
     Verbatim<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::Verbatim(original) },
+    { "verbatim".into() },
     {
-        Ok(WasmVerbatim {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        Ok((
+            Vec::new(),
+            WasmVerbatim {
+                value: original.contents.to_owned(),
+            },
+        ))
     }
 );

src/wasm/verse_block.rs

@@ -1,34 +1,48 @@
-use std::marker::PhantomData;
-
-use crate::types::VerseBlock;
 use serde::Deserialize;
 use serde::Serialize;
 
+use super::ast_node::WasmAstNode;
 use super::macros::to_wasm;
-use super::standard_properties::WasmStandardProperties;
 use super::to_wasm::ToWasm;
+use super::AdditionalProperties;
+use crate::types::GetAffiliatedKeywords;
+use crate::types::VerseBlock;
+use crate::util::elisp_fact::ElispFact;
 use crate::wasm::to_wasm::ToWasmStandardProperties;
 
-#[derive(Debug, Serialize)]
-#[serde(tag = "ast_node")]
-#[serde(rename = "org-data")]
-pub(crate) struct WasmVerseBlock<'s> {
-    standard_properties: WasmStandardProperties,
-    children: Vec<()>,
-    phantom: PhantomData<&'s ()>,
+#[derive(Debug, Serialize, Deserialize)]
+pub struct WasmVerseBlock {
+    #[serde(flatten)]
+    pub(crate) additional_properties: AdditionalProperties,
 }
 
 to_wasm!(
-    WasmVerseBlock<'s>,
+    WasmVerseBlock,
     VerseBlock<'s>,
     original,
     wasm_context,
-    standard_properties,
+    { WasmAstNode::VerseBlock(original) },
+    { "verse-block".into() },
     {
-        Ok(WasmVerseBlock {
-            standard_properties,
-            children: Vec::new(),
-            phantom: PhantomData,
-        })
+        let additional_properties = original
+            .get_affiliated_keywords()
+            .to_wasm(wasm_context.clone())?;
+
+        let children = original
+            .children
+            .iter()
+            .map(|child| {
+                child
+                    .to_wasm(wasm_context.clone())
+                    .map(Into::<WasmAstNode>::into)
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        Ok((
+            children,
+            WasmVerseBlock {
+                additional_properties,
+            },
+        ))
     }
 );

src/wasm_cli/mod.rs

@@ -0,0 +1,25 @@
+use gloo_utils::format::JsValueSerdeExt;
+use wasm_bindgen::JsValue;
+
+use crate::parser::parse_with_settings;
+use crate::settings::GlobalSettings;
+use crate::wasm::ParseResult;
+use crate::wasm::ToWasm;
+use crate::wasm::ToWasmContext;
+
+pub fn parse_org(org_contents: &str) -> wasm_bindgen::JsValue {
+    let rust_parsed = match parse_with_settings(org_contents, &GlobalSettings::default()) {
+        Ok(document) => document,
+        Err(err) => {
+            return JsValue::from_serde(&ParseResult::Error(format!("{:?}", err))).unwrap();
+        }
+    };
+    let to_wasm_context = ToWasmContext::new(org_contents);
+    let wasm_document = match rust_parsed.to_wasm(to_wasm_context) {
+        Ok(document) => document,
+        Err(err) => {
+            return JsValue::from_serde(&ParseResult::Error(format!("{:?}", err))).unwrap();
+        }
+    };
+    JsValue::from_serde(&ParseResult::Success(wasm_document)).unwrap()
+}

src/wasm_test/compare.rs

@@ -1,9 +1,912 @@
-use crate::compare::Token;
+use std::borrow::Borrow;
+use std::borrow::Cow;
+use std::collections::BTreeSet;
+use std::collections::HashMap;
+
+use super::diff::WasmDiffResult;
+use super::diff::WasmDiffStatus;
+use crate::util::elisp::maybe_token_to_usize;
+use crate::util::elisp::unquote;
+use crate::util::elisp::EmacsStandardProperties;
+use crate::util::elisp::TextWithProperties;
+use crate::util::elisp::Token;
+use crate::wasm::WasmAstNodeWrapper;
 use crate::wasm::WasmDocument;
 
-pub fn wasm_compare_document<'b, 's>(
-    emacs: &'b Token<'s>,
-    wasm: &'b WasmDocument<'s>,
-) -> Result<(), Box<dyn std::error::Error>> {
-    todo!()
+pub fn wasm_compare_document<'s>(
+    source: &'s str,
+    emacs: &Token<'s>,
+    wasm: &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<'s>(
+    source: &'s str,
+    emacs: &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)) => {
+            // TODO: This is creating children with no names.
+            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::Object(wasm), Token::List(el)) if wasm.contains_key("object-tree") => {
+            // We hit an object tree additional property.
+            compare_object_tree(source, el, wasm)
+        }
+        (serde_json::Value::Object(wasm), Token::List(el)) if wasm.contains_key("number-lines") => {
+            // We hit an object tree additional property.
+            compare_number_lines(source, el, wasm)
+        }
+        (serde_json::Value::Object(wasm), Token::List(el)) if wasm.contains_key("string-set") => {
+            // We hit an object tree additional property.
+            compare_string_set(source, el, wasm)
+        }
+        (serde_json::Value::Object(w), Token::TextWithProperties(e)) if is_plain_text(w) => {
+            compare_plain_text(source, e, w)
+        }
+        (serde_json::Value::Null, Token::Atom("nil")) => Ok(WasmDiffResult::default()),
+        (serde_json::Value::Bool(false), Token::Atom("nil")) => Ok(WasmDiffResult::default()),
+        (serde_json::Value::Bool(true), Token::Atom(e)) if (*e) != "nil" => {
+            Ok(WasmDiffResult::default())
+        }
+        (serde_json::Value::Bool(w), Token::Atom(e)) => {
+            let mut result = WasmDiffResult::default();
+            result.status.push(WasmDiffStatus::Bad(
+                format!(
+                    "Value mismatch. Emacs=({emacs:?}) Wasm=({wasm:?}).",
+                    emacs = e,
+                    wasm = w,
+                )
+                .into(),
+            ));
+            Ok(result)
+        }
+        (serde_json::Value::Number(w), Token::Atom(e)) if w.to_string().as_str() == (*e) => {
+            Ok(WasmDiffResult::default())
+        }
+        (serde_json::Value::Number(w), Token::Atom(e)) => {
+            let mut result = WasmDiffResult::default();
+            result.status.push(WasmDiffStatus::Bad(
+                format!(
+                    "Value mismatch. Emacs=({emacs:?}) Wasm=({wasm:?}).",
+                    emacs = e,
+                    wasm = w,
+                )
+                .into(),
+            ));
+            Ok(result)
+        }
+        (serde_json::Value::Array(w), Token::Atom("nil")) if w.is_empty() => {
+            Ok(WasmDiffResult::default())
+        }
+        (serde_json::Value::String(w), Token::Atom(e)) if w.as_str() == *e => {
+            Ok(WasmDiffResult::default())
+        }
+        (serde_json::Value::Object(w), _) if w.contains_key("noop") => {
+            Ok(WasmDiffResult::default())
+        }
+        (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(w), Token::Atom(e)) => {
+            let mut result = WasmDiffResult::default();
+            result.status.push(WasmDiffStatus::Bad(
+                format!(
+                    "Value mismatch. Emacs=({emacs:?}) Wasm=({wasm:?}).",
+                    emacs = e,
+                    wasm = w,
+                )
+                .into(),
+            ));
+            Ok(result)
+        }
+        (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_optional_json_value<'s>(
+    source: &'s str,
+    emacs: Option<&Token<'s>>,
+    wasm: Option<&serde_json::Value>,
+) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
+    match (emacs, wasm) {
+        (None, None) | (None, Some(serde_json::Value::Null)) | (Some(Token::Atom("nil")), None) => {
+            Ok(WasmDiffResult::default())
+        }
+        (None, Some(serde_json::Value::Object(w))) if w.contains_key("noop") => {
+            Ok(WasmDiffResult::default())
+        }
+        (Some(e), Some(w)) => compare_json_value(source, e, w),
+        _ => Ok(WasmDiffResult {
+            status: vec![WasmDiffStatus::Bad(
+                format!(
+                    "Nullness mismatch. Emacs=({emacs:?}) Wasm=({wasm:?}).",
+                    emacs = emacs,
+                    wasm = wasm
+                )
+                .into(),
+            )],
+            children: Vec::new(),
+            name: "".into(),
+        }),
+    }
+}
+
+fn compare_ast_node<'s>(
+    source: &'s str,
+    emacs: &[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()?;
+    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();
+        // wasm_attributes_map.iter().filter_map(|(k,v)| if matches!(v, serde_json::Value::Null) {None} else {Some(k)}).map(wasm_key_to_emacs_key)
+        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)
+            .filter(|attribute| {
+                emacs_attributes_map
+                    .get(attribute.as_str())
+                    .map(|token| !matches!(token, Token::Atom("nil")))
+                    .unwrap_or(false)
+            })
+            .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::<'_> {
+                name: Cow::Owned(attribute_name.clone()),
+                ..Default::default()
+            };
+            let wasm_attribute_value = wasm_attributes_map.get(attribute_name);
+            let emacs_key = wasm_key_to_emacs_key(attribute_name);
+            let emacs_attribute_value = emacs_attributes_map.get(emacs_key.as_str()).copied();
+            let inner_layer =
+                compare_optional_json_value(source, emacs_attribute_value, wasm_attribute_value)?;
+            if !inner_layer.name.is_empty() {
+                layer.children.push(inner_layer);
+            } else {
+                layer.extend(inner_layer)?;
+            }
+            result.children.push(layer);
+        }
+    }
+
+    {
+        // Compare standard-properties.
+        let mut layer = WasmDiffResult::<'_> {
+            name: "standard-properties".into(),
+            ..Default::default()
+        };
+        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(serde_json::Value::Null)) => {}
+                (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::<'_> {
+            name: "children".into(),
+            ..Default::default()
+        };
+        if let Some(wasm_iter) = wasm
+            .get("children")
+            .and_then(|children| children.as_array())
+            .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<'s>(
+    _source: &'s str,
+    emacs: &str,
+    wasm: &String,
+) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
+    let mut result = WasmDiffResult::default();
+    let emacs_text = unquote(emacs)?;
+    if wasm.as_str() != emacs_text {
+        result.status.push(WasmDiffStatus::Bad(
+            format!(
+                "Text mismatch. Emacs=({emacs:?}) Wasm=({wasm:?}).",
+                emacs = emacs_text,
+                wasm = wasm,
+            )
+            .into(),
+        ));
+    }
+    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,
+    mut 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 == 1 && wasm_length == 0 && emacs.all(|t| matches!(t.as_atom(), Ok(r#""""#))) {
+        return Ok(WasmDiffResult::default());
+    }
+    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<'s>(
+    source: &'s str,
+    emacs: &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 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
+            .get(2)
+            .expect("If-statement proves this will be Some.");
+        let emacs_val = emacs
+            .first()
+            .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)
+}
+
+fn compare_object_tree<'s>(
+    source: &'s str,
+    emacs: &[Token<'s>],
+    wasm: &serde_json::Map<String, serde_json::Value>,
+) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
+    let mut result = WasmDiffResult::default();
+    let wasm_attributes = wasm
+        .get("object-tree")
+        .ok_or(r#"Wasm object tree should have an "object-tree" attribute."#)?
+        .as_array()
+        .ok_or(r#"Wasm "object-tree" attribute should be a list."#)?;
+    let emacs_outer_length = emacs.len();
+    let wasm_outer_length = wasm_attributes.len();
+    if emacs_outer_length != wasm_outer_length {
+        result.status.push(WasmDiffStatus::Bad(
+            format!(
+                "Child length mismatch. Emacs=({emacs:?}) Wasm=({wasm:?}).",
+                emacs = emacs_outer_length,
+                wasm = wasm_outer_length
+            )
+            .into(),
+        ));
+        return Ok(result);
+    }
+
+    for (emacs_attribute, wasm_attribute) in emacs.iter().zip(wasm_attributes.iter()) {
+        let wasm_attribute = wasm_attribute
+            .as_array()
+            .ok_or("Wasm middle layer in object tree should be a list.")?;
+        if wasm_attribute.len() != 2 {
+            result.status.push(WasmDiffStatus::Bad(
+                format!(
+                    "Wasm middle layer in object tree should have a length of 2. Wasm=({wasm:?}).",
+                    wasm = wasm_attribute.len()
+                )
+                .into(),
+            ));
+            return Ok(result);
+        }
+        if let Ok("nil") = emacs_attribute.as_atom() {
+            if let Some(serde_json::Value::Null) = wasm_attribute.first() {
+                if let Some(serde_json::Value::Array(w)) = wasm_attribute.get(1) {
+                    if w.is_empty() {
+                        continue;
+                    }
+                }
+            }
+        }
+        let emacs_attribute = emacs_attribute.as_list()?;
+        if let Some(serde_json::Value::Null) = wasm_attribute.first() {
+            // If optval is null then the emacs array should only contain 1 value.
+            if emacs_attribute.len() != 1 {
+                result.status.push(WasmDiffStatus::Bad(
+                    format!(
+                        "Emacs middle layer in object tree should have a length of 1. Emacs=({emacs:?}) Wasm=({wasm:?}).",
+                        emacs = emacs_attribute,
+                    wasm = wasm_attribute
+                )
+                    .into(),
+                ));
+                return Ok(result);
+            }
+
+            let emacs_val = emacs_attribute
+                .first()
+                .expect("If-statement proves this will be Some.");
+            let wasm_val = wasm_attribute
+                .get(1)
+                .expect("If-statement proves this will be Some.");
+            result.extend(compare_json_value(source, emacs_val, wasm_val)?)?;
+        } else {
+            // If optval is not null, then the emacs array should contain a list, the first child of which is a list for optval, and all other entries to the outer list are the val.
+            if emacs_attribute.len() < 2 {
+                result.status.push(WasmDiffStatus::Bad(
+                    format!(
+                        "Emacs middle layer in object tree should have a length of at least 2. Emacs=({emacs:?}) Wasm=({wasm:?}).",
+                        emacs = emacs_attribute,
+                    wasm = wasm_attribute
+                )
+                    .into(),
+                ));
+                return Ok(result);
+            }
+            let emacs_optval = emacs_attribute.iter().skip(1);
+            let wasm_optval = wasm_attribute
+                .first()
+                .expect("If-statement proves this will be Some.")
+                .as_array()
+                .ok_or("first value in wasm object tree should be a list.")?;
+            let emacs_val = emacs_attribute
+                .first()
+                .ok_or("If-statement proves this will be Some.")?;
+            let wasm_val = wasm_attribute
+                .get(1)
+                .expect("If-statement proves this will be Some.")
+                .as_array()
+                .ok_or("2nd value in wasm object tree should be a list.")?;
+            result.extend(wasm_compare_list(source, emacs_optval, wasm_optval.iter())?)?;
+            if let Ok("nil") = emacs_val.as_atom() {
+                result.extend(wasm_compare_list(
+                    source,
+                    std::iter::empty(),
+                    wasm_val.iter(),
+                )?)?;
+            } else {
+                result.extend(wasm_compare_list(
+                    source,
+                    emacs_val.as_list()?.iter(),
+                    wasm_val.iter(),
+                )?)?;
+            }
+        }
+    }
+
+    Ok(result)
+}
+
+fn compare_number_lines<'s>(
+    _source: &'s str,
+    emacs: &[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_iter = emacs.iter();
+    let emacs_directive = emacs_iter
+        .next()
+        .ok_or("Emacs number lines should have 3 children.")?
+        .as_atom()?;
+    let emacs_number: i64 = emacs_iter
+        .nth(1)
+        .ok_or("Emacs number lines should have 3 children.")?
+        .as_atom()?
+        .parse()?;
+    if wasm.contains_key("new") {
+        let wasm_number = wasm
+            .get("new")
+            .ok_or(r#"Wasm number lines should have a "new" attribute."#)?
+            .as_i64()
+            .ok_or(r#"Wasm number lines "new" attribute should be a number."#)?;
+        if emacs_directive != "new" {
+            result.status.push(WasmDiffStatus::Bad(
+                format!(
+                    "Number lines directive mismatch. Emacs=({emacs:?}) Wasm=({wasm:?}).",
+                    emacs = emacs_directive,
+                    wasm = "new"
+                )
+                .into(),
+            ));
+            return Ok(result);
+        }
+        if emacs_number != wasm_number {
+            result.status.push(WasmDiffStatus::Bad(
+                format!(
+                    "Number lines number mismatch. Emacs=({emacs:?}) Wasm=({wasm:?}).",
+                    emacs = emacs_number,
+                    wasm = wasm_number
+                )
+                .into(),
+            ));
+            return Ok(result);
+        }
+    } else if wasm.contains_key("continued") {
+        let wasm_number = wasm
+            .get("continued")
+            .ok_or(r#"Wasm number lines should have a "continued" attribute."#)?
+            .as_i64()
+            .ok_or(r#"Wasm number lines "continued" attribute should be a number."#)?;
+        if emacs_directive != "continued" {
+            result.status.push(WasmDiffStatus::Bad(
+                format!(
+                    "Number lines directive mismatch. Emacs=({emacs:?}) Wasm=({wasm:?}).",
+                    emacs = emacs_directive,
+                    wasm = "continued"
+                )
+                .into(),
+            ));
+            return Ok(result);
+        }
+        if emacs_number != wasm_number {
+            result.status.push(WasmDiffStatus::Bad(
+                format!(
+                    "Number lines number mismatch. Emacs=({emacs:?}) Wasm=({wasm:?}).",
+                    emacs = emacs_number,
+                    wasm = wasm_number
+                )
+                .into(),
+            ));
+            return Ok(result);
+        }
+    } else {
+        result.status.push(WasmDiffStatus::Bad(
+            format!(
+                "Unrecognized number lines directive. Wasm=({wasm:?}).",
+                wasm = wasm
+            )
+            .into(),
+        ));
+        return Ok(result);
+    }
+
+    Ok(result)
+}
+
+fn compare_string_set<'s>(
+    _source: &'s str,
+    emacs: &[Token<'s>],
+    wasm: &serde_json::Map<String, serde_json::Value>,
+) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
+    let mut result = WasmDiffResult::default();
+    let wasm_list = wasm
+        .get("value")
+        .ok_or(r#"Wasm string set should have a "value" attribute."#)?
+        .as_array()
+        .ok_or(r#"Wasm string set "value" attribute should be a list."#)?;
+    let wasm_strings = wasm_list
+        .iter()
+        .map(|v| v.as_str().ok_or("Non-string in wasm string set."))
+        .collect::<Result<BTreeSet<_>, &'static str>>()?;
+    let emacs_strings = emacs
+        .iter()
+        .map(|v| v.as_atom())
+        .collect::<Result<Vec<_>, Box<dyn std::error::Error>>>()?
+        .into_iter()
+        .map(unquote)
+        .collect::<Result<Vec<_>, Box<dyn std::error::Error>>>()?;
+    let emacs_strings = emacs_strings
+        .iter()
+        .map(|s| s.borrow())
+        .collect::<BTreeSet<&str>>();
+
+    let mismatched: Vec<_> = emacs_strings
+        .symmetric_difference(&wasm_strings)
+        .copied()
+        .collect();
+    if !mismatched.is_empty() {
+        result.status.push(WasmDiffStatus::Bad(
+            format!(
+                "String set mismatch. MismatchedValues=({values:?}).",
+                values = mismatched.join(", ")
+            )
+            .into(),
+        ));
+    }
+
+    Ok(result)
+}
+
+fn is_plain_text(wasm: &serde_json::Map<String, serde_json::Value>) -> bool {
+    if let Some(serde_json::Value::String(node_type)) = wasm.get("ast-node") {
+        node_type == "plain-text"
+    } else {
+        false
+    }
+}
+
+fn compare_plain_text<'s>(
+    source: &'s str,
+    emacs: &TextWithProperties<'s>,
+    wasm: &serde_json::Map<String, serde_json::Value>,
+) -> Result<WasmDiffResult<'s>, Box<dyn std::error::Error>> {
+    let mut result = WasmDiffResult::<'_> {
+        name: "plain-text".into(),
+        ..Default::default()
+    };
+    if !is_plain_text(wasm) {
+        result.status.push(WasmDiffStatus::Bad(
+            format!(
+                "AST node type mismatch. Emacs=({emacs:?}) Wasm=({wasm:?}).",
+                emacs = emacs,
+                wasm = wasm,
+            )
+            .into(),
+        ));
+        return Ok(result);
+    }
+
+    let emacs_text = unquote(emacs.text)?;
+    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."#)?;
+    let wasm_begin = {
+        if let Some(serde_json::Value::Number(begin)) = wasm_standard_properties.get("begin") {
+            begin
+                .as_u64()
+                .map(|w| w as usize)
+                .ok_or("Begin should be a number.")?
+        } else {
+            result.status.push(WasmDiffStatus::Bad(
+                format!(
+                    "AST node type mismatch. Emacs=({emacs:?}) Wasm=({wasm:?}).",
+                    emacs = emacs,
+                    wasm = wasm,
+                )
+                .into(),
+            ));
+            return Ok(result);
+        }
+    };
+    let wasm_end = {
+        if let Some(serde_json::Value::Number(end)) = wasm_standard_properties.get("end") {
+            end.as_u64()
+                .map(|w| w as usize)
+                .ok_or("End should be a number.")?
+        } else {
+            result.status.push(WasmDiffStatus::Bad(
+                format!(
+                    "AST node type mismatch. Emacs=({emacs:?}) Wasm=({wasm:?}).",
+                    emacs = emacs,
+                    wasm = wasm,
+                )
+                .into(),
+            ));
+            return Ok(result);
+        }
+    };
+    let wasm_text: String = source
+        .chars()
+        .skip(wasm_begin - 1)
+        .take(wasm_end - wasm_begin)
+        .collect();
+    if wasm_text != emacs_text {
+        result.status.push(WasmDiffStatus::Bad(
+            format!(
+                "Text mismatch. Emacs=({emacs:?}) Wasm=({wasm:?}).",
+                emacs = emacs_text,
+                wasm = wasm_text,
+            )
+            .into(),
+        ));
+        return Ok(result);
+    }
+
+    let emacs_start = emacs
+        .properties
+        .first()
+        .map(|t| t.as_atom())
+        .map_or(Ok(None), |r| r.map(Some))?;
+    if emacs_start != Some("0") {
+        result.status.push(WasmDiffStatus::Bad(
+            format!(
+                "Text should start at offset 0. Emacs=({emacs:?}) Wasm=({wasm:?}).",
+                emacs = emacs,
+                wasm = wasm,
+            )
+            .into(),
+        ));
+    }
+    let emacs_end = emacs
+        .properties
+        .get(1)
+        .map(|t| t.as_atom())
+        .map_or(Ok(None), |r| r.map(Some))?;
+    if emacs_end != Some((wasm_end - wasm_begin).to_string().as_str()) {
+        result.status.push(WasmDiffStatus::Bad(
+            format!(
+                "Text end mismatch. Emacs=({emacs:?}) Wasm=({wasm:?}).",
+                emacs = emacs_end,
+                wasm = wasm_end - wasm_begin,
+            )
+            .into(),
+        ));
+    }
+
+    Ok(result)
 }

src/wasm_test/diff.rs

@@ -0,0 +1,109 @@
+use std::borrow::Cow;
+
+use crate::util::terminal::foreground_color;
+use crate::util::terminal::reset_color;
+
+#[derive(Debug)]
+pub struct WasmDiffResult<'s> {
+    pub(crate) status: Vec<WasmDiffStatus>,
+    pub(crate) name: Cow<'s, str>,
+    pub(crate) children: Vec<WasmDiffResult<'s>>,
+}
+
+#[derive(Debug)]
+pub(crate) enum WasmDiffStatus {
+    #[allow(dead_code)]
+    Good,
+    Bad(Cow<'static, str>),
+}
+
+impl<'s> WasmDiffResult<'s> {
+    pub(crate) fn extend(
+        &mut self,
+        other: WasmDiffResult<'s>,
+    ) -> Result<&mut WasmDiffResult<'s>, Box<dyn std::error::Error>> {
+        if self.name.is_empty() {
+            self.name = other.name;
+        }
+        self.status.extend(other.status);
+        self.children.extend(other.children);
+        Ok(self)
+    }
+
+    pub fn is_bad(&self) -> bool {
+        self.is_self_bad() || self.has_bad_children()
+    }
+
+    pub fn is_self_bad(&self) -> bool {
+        self.status
+            .iter()
+            .any(|status| matches!(status, WasmDiffStatus::Bad(_)))
+    }
+
+    pub fn has_bad_children(&self) -> bool {
+        self.children.iter().any(WasmDiffResult::is_bad)
+    }
+
+    pub fn print(&self, original_document: &str) -> Result<(), Box<dyn std::error::Error>> {
+        self.print_indented(0, original_document)
+    }
+
+    fn print_indented(
+        &self,
+        indentation: usize,
+        _original_document: &str,
+    ) -> Result<(), Box<dyn std::error::Error>> {
+        let status_text = {
+            if self.is_self_bad() {
+                format!(
+                    "{color}BAD{reset}",
+                    color = foreground_color(255, 0, 0),
+                    reset = reset_color(),
+                )
+            } else if self.has_bad_children() {
+                format!(
+                    "{color}BADCHILD{reset}",
+                    color = foreground_color(255, 255, 0),
+                    reset = reset_color(),
+                )
+            } else {
+                format!(
+                    "{color}GOOD{reset}",
+                    color = foreground_color(0, 255, 0),
+                    reset = reset_color(),
+                )
+            }
+        };
+        let message = self
+            .status
+            .iter()
+            .filter_map(|status| match status {
+                WasmDiffStatus::Good => None,
+                WasmDiffStatus::Bad(message) => Some(message),
+            })
+            .next();
+        println!(
+            "{indentation}{status_text} {name} {message}",
+            indentation = "  ".repeat(indentation),
+            status_text = status_text,
+            name = self.name,
+            message = message.unwrap_or(&Cow::Borrowed(""))
+        );
+
+        for child in self.children.iter() {
+            child.print_indented(indentation + 1, _original_document)?;
+        }
+
+        Ok(())
+    }
+}
+
+impl<'s> Default for WasmDiffResult<'s> {
+    fn default() -> Self {
+        WasmDiffResult {
+            status: Vec::new(),
+            name: "".into(),
+            children: Vec::new(),
+        }
+    }
+}

src/wasm_test/mod.rs

@@ -1,5 +1,8 @@
 mod compare;
+mod diff;
 mod runner;
 
 pub use runner::wasm_run_anonymous_compare;
 pub use runner::wasm_run_anonymous_compare_with_settings;
+pub use runner::wasm_run_compare_on_file;
+pub use runner::wasm_run_compare_on_file_with_settings;

src/wasm_test/runner.rs

@@ -1,9 +1,16 @@
+use std::path::Path;
+
 use super::compare::wasm_compare_document;
-use crate::compare::sexp;
 use crate::context::GlobalSettings;
+use crate::parser::parse_file_with_settings;
 use crate::parser::parse_with_settings;
-use crate::util::emacs_parse_anonymous_org_document;
-use crate::util::print_versions;
+use crate::settings::LocalFileAccessInterface;
+use crate::util::cli::emacs_parse_anonymous_org_document;
+use crate::util::cli::emacs_parse_file_org_document;
+use crate::util::cli::print_versions;
+use crate::util::elisp::sexp;
+use crate::util::terminal::foreground_color;
+use crate::util::terminal::reset_color;
 use crate::wasm::ToWasm;
 use crate::wasm::ToWasmContext;
 
@@ -40,20 +47,85 @@ pub async fn wasm_run_anonymous_compare_with_settings<'g, 's, P: AsRef<str>>(
     }
 
     // We do the diffing after printing out both parsed forms in case the diffing panics
-    let diff_result = wasm_compare_document(&parsed_sexp, &wasm_parsed)?;
-    // if !silent {
-    //     diff_result.print(org_contents)?;
-    // }
+    let diff_result = wasm_compare_document(org_contents, &parsed_sexp, &wasm_parsed)?;
+    if !silent {
+        diff_result.print(org_contents)?;
+    }
 
-    // if diff_result.is_bad() {
-    //     return Ok(false);
-    // } else if !silent {
-    //     println!(
-    //         "{color}Entire document passes.{reset}",
-    //         color = DiffResult::foreground_color(0, 255, 0),
-    //         reset = DiffResult::reset_color(),
-    //     );
-    // }
+    if diff_result.is_bad() {
+        return Ok(false);
+    } else if !silent {
+        println!(
+            "{color}Entire document passes.{reset}",
+            color = foreground_color(0, 255, 0),
+            reset = reset_color(),
+        );
+    }
+
+    Ok(true)
+}
+
+//wasm_run_compare_on_file
+pub async fn wasm_run_compare_on_file<P: AsRef<Path>>(
+    org_path: P,
+) -> Result<bool, Box<dyn std::error::Error>> {
+    wasm_run_compare_on_file_with_settings(org_path, &GlobalSettings::default(), false).await
+}
+
+pub async fn wasm_run_compare_on_file_with_settings<'g, 's, P: AsRef<Path>>(
+    org_path: P,
+    global_settings: &GlobalSettings<'g, 's>,
+    silent: bool,
+) -> Result<bool, Box<dyn std::error::Error>> {
+    let org_path = org_path.as_ref();
+    if !silent {
+        print_versions().await?;
+    }
+    let parent_directory = org_path
+        .parent()
+        .ok_or("Should be contained inside a directory.")?;
+    let org_contents = std::fs::read_to_string(org_path)?;
+    // TODO: This is a work-around to pretend that dos line endings do not exist. It would be better to handle the difference in line endings.
+    let org_contents = org_contents.replace("\r\n", "\n");
+    let org_contents = org_contents.as_str();
+    let file_access_interface = LocalFileAccessInterface {
+        working_directory: Some(parent_directory.to_path_buf()),
+    };
+    let global_settings = {
+        let mut global_settings = global_settings.clone();
+        global_settings.file_access = &file_access_interface;
+        global_settings
+    };
+    let rust_parsed = parse_file_with_settings(org_contents, &global_settings, Some(org_path))?;
+    let to_wasm_context = ToWasmContext::new(org_contents);
+    let wasm_parsed = rust_parsed
+        .to_wasm(to_wasm_context)
+        .map_err(|_e| "Failed to convert to wasm.")?;
+    let org_sexp = emacs_parse_file_org_document(org_path, &global_settings).await?;
+    let (_remaining, parsed_sexp) = sexp(org_sexp.as_str()).map_err(|e| e.to_string())?;
+
+    if !silent {
+        println!("{}\n\n\n", org_contents);
+        println!("{}", org_sexp);
+        println!("{:#?}", rust_parsed);
+        println!("{}", serde_json::to_string(&wasm_parsed)?);
+    }
+
+    // We do the diffing after printing out both parsed forms in case the diffing panics
+    let diff_result = wasm_compare_document(org_contents, &parsed_sexp, &wasm_parsed)?;
+    if !silent {
+        diff_result.print(org_contents)?;
+    }
+
+    if diff_result.is_bad() {
+        return Ok(false);
+    } else if !silent {
+        println!(
+            "{color}Entire document passes.{reset}",
+            color = foreground_color(0, 255, 0),
+            reset = reset_color(),
+        );
+    }
 
     Ok(true)
 }

tests/test_template

@@ -60,3 +60,13 @@ async fn autogen_odd_{name}() -> Result<(), Box<dyn std::error::Error>> {{
     assert!(organic::compare::run_anonymous_compare_with_settings(org_contents.as_str(), &global_settings, false).await?);
     Ok(())
 }}
+
+#[cfg(feature = "wasm_test")]
+{expect_fail}
+#[tokio::test]
+async fn autogen_wasm_{name}() -> Result<(), Box<dyn std::error::Error>> {{
+    let org_path = "{path}";
+    let org_contents = std::fs::read_to_string(org_path).expect("Read org file.");
+    assert!(organic::wasm_test::wasm_run_anonymous_compare(org_contents.as_str()).await?);
+    Ok(())
+}}