literate programming introduced, tangle not yet run

1 files changed, 1599 insertions, 0 deletions

diff --git a/org/ao_emitters_and_interfaces.org b/org/ao_emitters_and_interfaces.org
new file mode 100644
index 0000000..d068b78
--- /dev/null
+++ b/org/ao_emitters_and_interfaces.org
@@ -0,0 +1,1599 @@
+#+TITLE: Emacs config file written in org-mode
+#+AUTHOR: Ralph Amissah
+#+EMAIL: ralph.amissah@gmail.com
+#+STARTUP: indent
+#+LANGUAGE: en
+#+OPTIONS: H:3 num:nil toc:t \n:nil @:t ::t |:t ^:nil -:t f:t *:t <:t
+#+OPTIONS: TeX:t LaTeX:t skip:nil d:nil todo:t pri:nil tags:not-in-toc
+#+OPTIONS: author:nil email:nil creator:nil timestamp:nil
+#+OPTIONS: ^:nil _:nil#+OPTIONS: ^:nil _:nil
+#+EXPORT_SELECT_TAGS: export
+#+EXPORT_EXCLUDE_TAGS: noexport
+#+TAGS: Amissah(A) Class(c) WEB(W) noexport(n)
+
+* emitters & interfaces
+ao_interface.d
+ao_emitter.d
+various emitters and their interfaces (where available)
+** e:   command line interface/instructions
+*** emitter
+#+name: ao_emitter
+#+BEGIN_SRC d                                                  :exports none
+class CLI {
+  string[string] extract_actions(string cmdlnins, string[string] actions)
+  in { }
+  body {
+    switch (cmdlnins) {
+    case "--no-assert":
+      actions["assert"] = "no";
+      break;
+    default:
+      break;
+    }
+    return actions;
+  }
+}
+#+end_src
+** e&i: ocn
+*** emitter
+#+name: ao_emitter
+#+BEGIN_SRC d                                                  :exports none
+class OCNemitter : AssertOCN {
+  int ocn, ocn_;
+  int ocn_emitter(int ocn_status_flag)
+  in { assert(ocn_status_flag <= 2); }
+  body {
+    if (ocn_status_flag == 0) {
+      ocn=++ocn_;
+    } else {
+      ocn=0;
+    }
+    return ocn;
+  }
+  invariant() {
+  }
+}
+#+end_src
+*** interface assert
+#+name: ao_interface
+#+BEGIN_SRC d                                                  :exports none
+interface AssertOCN {
+  int ocn_emitter(int ocn_status_flag)
+    in { assert(ocn_status_flag <= 2); }
+    out(ocn) { assert(ocn >= 0); }
+}
+#+end_src
+** e:   object attributes
+*** emitter
+#+name: ao_emitter
+#+BEGIN_SRC d                                                  :exports none
+class ObjAttributes {
+  string[string] obj_txt;
+  string para_and_blocks(string obj_txt_in)
+  in { }
+  body {
+    auto rgx = new Rgx();
+    obj_txt["munge"]=obj_txt_in;
+    if (match(obj_txt_in, rgx.para_bullet)) {
+      obj_txt["attrib"] =" \"bullet\": \"true\","
+      ~ " \"indent_first\": 0,"
+      ~ " \"indent_rest\": 0,";
+    } else if (auto m = match(obj_txt_in, rgx.para_bullet_indent)) {
+      obj_txt["attrib"] =" \"bullet\": \"true\","
+      ~ " \"indent_first\": " ~ to!string(m.captures[1]) ~ ","
+      ~ " \"indent_rest\": " ~ to!string(m.captures[1]) ~ ",";
+    } else if (auto m = match(obj_txt_in, rgx.para_indent_hang)) {
+      obj_txt["attrib"] =" \"bullet\": \"false\","
+      ~ " \"indent_first\": " ~ to!string(m.captures[1]) ~ ","
+      ~ " \"indent_rest\": " ~  to!string(m.captures[2]) ~ ",";
+    } else if (auto m = match(obj_txt_in, rgx.para_indent)) {
+      obj_txt["attrib"] =" \"bullet\": \"false\","
+      ~ " \"indent_first\": " ~ to!string(m.captures[1]) ~ ","
+      ~ " \"indent_rest\": " ~ to!string(m.captures[1]) ~ ",";
+    } else {
+      obj_txt["attrib"] =" \"bullet\": \"false\","
+      ~ " \"indent_first\": 0,"
+      ~ " \"indent_rest\": 0,";
+    }
+    return obj_txt["attrib"];
+  }
+  string para(string obj_txt_in)
+  in { }
+  body {
+    obj_txt["munge"]=obj_txt_in;
+    obj_txt["attrib"] = " \"use\": \"content\","
+    ~ " \"of\": \"para\","
+    ~ " \"is\": \"para\"";
+    return obj_txt["attrib"];
+  }
+  invariant() {
+  }
+  string heading(string obj_txt_in)
+  in { }
+  body {
+    obj_txt["munge"]=obj_txt_in;
+    obj_txt["attrib"] = " \"use\": \"content\","
+    ~ " \"of\": \"para\","
+    ~ " \"is\": \"heading\"";
+    return obj_txt["attrib"];
+  }
+  invariant() {
+  }
+  string header_make(string obj_txt_in)
+  in { }
+  body {
+    obj_txt["munge"]=obj_txt_in;
+    obj_txt["attrib"] = " \"use\": \"head\","
+    ~ " \"of\": \"header\","
+    ~ " \"is\": \"header_make\"";
+    return obj_txt["attrib"];
+  }
+  invariant() {
+  }
+  string header_metadata(string obj_txt_in)
+  in { }
+  body {
+    obj_txt["munge"]=obj_txt_in;
+    obj_txt["attrib"] = " \"use\": \"head\","
+    ~ " \"of\": \"header\","
+    ~ " \"is\": \"header_metadata\"";
+    return obj_txt["attrib"];
+  }
+  invariant() {
+  }
+  string code(string obj_txt_in)
+  in { }
+  body {
+    obj_txt["munge"]=obj_txt_in;
+    obj_txt["attrib"] = " \"use\": \"content\","
+    ~ " \"of\": \"block\","
+    ~ " \"is\": \"code\"";
+    return obj_txt["attrib"];
+  }
+  invariant() {
+  }
+  string group(string obj_txt_in)
+  in { }
+  body {
+    obj_txt["munge"]=obj_txt_in;
+    obj_txt["attrib"] = " \"use\": \"content\","
+    ~ " \"of\": \"block\","
+    ~ " \"is\": \"group\"";
+    return obj_txt["attrib"];
+  }
+  invariant() {
+  }
+  string block(string obj_txt_in)
+  in { }
+  body {
+    obj_txt["munge"]=obj_txt_in;
+    obj_txt["attrib"] = " \"use\": \"content\","
+    ~ " \"of\": \"block\","
+    ~ " \"is\": \"block\"";
+    return obj_txt["attrib"];
+  }
+  invariant() {
+  }
+  string verse(string obj_txt_in)
+  in { }
+  body {
+    obj_txt["munge"]=obj_txt_in;
+    obj_txt["attrib"] = " \"use\": \"content\","
+    ~ " \"of\": \"block\","
+    ~ " \"is\": \"verse\"";
+    return obj_txt["attrib"];
+  }
+  invariant() {
+  }
+  string quote(string obj_txt_in)
+  in { }
+  body {
+    obj_txt["munge"]=obj_txt_in;
+    obj_txt["attrib"] = " \"use\": \"content\","
+    ~ " \"of\": \"block\","
+    ~ " \"is\": \"quote\"";
+    return obj_txt["attrib"];
+  }
+  invariant() {
+  }
+  string table(string obj_txt_in)
+  in { }
+  body {
+    obj_txt["munge"]=obj_txt_in;
+    obj_txt["attrib"] = " \"use\": \"content\","
+    ~ " \"of\": \"block\","
+    ~ " \"is\": \"table\"";
+    return obj_txt["attrib"];
+  }
+  invariant() {
+  }
+  string comment(string obj_txt_in)
+  in { }
+  body {
+    obj_txt["munge"]=obj_txt_in;
+    obj_txt["attrib"] = " \"use\": \"comment\","
+    ~ " \"of\": \"comment\","
+    ~ " \"is\": \"comment\"";
+    return obj_txt["attrib"];
+  }
+  invariant() {
+  }
+}
+#+end_src
+** e:   object inline markup munge
+*** emitter
+#+name: ao_emitter
+#+BEGIN_SRC d                                                  :exports none
+class ObjInlineMarkupMunge {
+  string[string] obj_txt;
+  int n_foot, n_foot_reg, n_foot_sp_asterisk, n_foot_sp_plus;
+  string obj_txt_out, tail, note;
+  private auto initialize_note_numbers() {
+    n_foot = 0;
+    n_foot_reg = 0;
+    n_foot_sp_asterisk = 0;
+    n_foot_sp_plus = 0;
+  }
+  private auto object_notes_(string obj_txt_in)
+  in { }
+  body {
+    auto rgx = new Rgx();
+    auto mkup = new InternalMarkup();
+    obj_txt_out = "";
+    tail = "";
+    obj_txt_in = replaceAll(
+      obj_txt_in,
+      rgx.inline_notes_curly_sp_asterisk,
+      (mkup.en_a_o ~ "*" ~ " $1" ~ mkup.en_a_c)
+    );
+    obj_txt_in =
+      replaceAll(
+        obj_txt_in,
+        rgx.inline_notes_curly_sp_plus,
+        (mkup.en_a_o ~ "+" ~ " $1" ~ mkup.en_a_c)
+      );
+    obj_txt_in =
+      replaceAll(
+        obj_txt_in,
+        rgx.inline_notes_curly,
+        (mkup.en_a_o ~ " $1" ~ mkup.en_a_c)
+      );
+    if (match(obj_txt_in, rgx.inline_notes_al_gen)) {
+      foreach(m; matchAll(obj_txt_in, rgx.inline_text_and_note_al)) {
+        if (match(obj_txt_in, rgx.inline_al_delimiter_open_asterisk)) {
+          n_foot_sp_asterisk++;
+          n_foot=n_foot_sp_asterisk;
+        } else if (match(obj_txt_in, rgx.inline_al_delimiter_open_plus)) {
+          n_foot_sp_plus++;
+          n_foot=n_foot_sp_plus;
+        } else {
+          n_foot_reg++;
+          n_foot=n_foot_reg;
+        }
+        obj_txt_out ~= replaceFirst(
+          m.hit,
+          rgx.inline_al_delimiter_open_regular,
+          (mkup.en_a_o ~ to!string(n_foot))
+        );
+        tail = m.post;
+      }
+    } else {
+      obj_txt_out = obj_txt_in;
+    }
+    debug(footnotes) {
+      writeln(obj_txt_out, tail);
+    }
+    obj_txt_out = obj_txt_out ~ tail;
+    debug(footnotesdone) {
+      foreach(m; matchAll(obj_txt_out,
+      (mkup.en_a_o ~ `\s*(.+?)` ~ mkup.en_a_c))) {
+        writeln(m.captures[1]);
+        writeln(m.hit);
+      }
+    }
+    return obj_txt_out;
+  }
+  string para(string obj_txt_in)
+  in { }
+  body {
+    auto rgx = new Rgx();
+    obj_txt["munge"]=obj_txt_in;
+    obj_txt["munge"]=replaceFirst(obj_txt["munge"], rgx.para_attribs, "");
+    obj_txt["munge"]=replaceFirst(obj_txt["munge"], rgx.ocn_off_all, "");
+    obj_txt["munge"]=object_notes_(obj_txt["munge"]);
+    debug(munge) {
+      writeln(__LINE__);
+      writeln(obj_txt_in);
+      writeln(__LINE__);
+      writeln(to!string(obj_txt["munge"]));
+    }
+    return obj_txt["munge"];
+  }
+  string heading(string obj_txt_in)
+  in { }
+  body {
+    auto rgx = new Rgx();
+    obj_txt["munge"]=obj_txt_in;
+    obj_txt["munge"]=replaceFirst(obj_txt["munge"], rgx.heading, "");
+    obj_txt["munge"]=replaceFirst(obj_txt["munge"], rgx.ocn_off_all, "");
+    obj_txt["munge"]=object_notes_(obj_txt["munge"]);
+    debug(munge) {
+      writeln(__LINE__);
+      writeln(obj_txt_in);
+      writeln(__LINE__);
+      writeln(to!string(obj_txt["munge"]));
+    }
+    return obj_txt["munge"];
+  }
+  invariant() {
+  }
+  string header_make(string obj_txt_in)
+  in { }
+  body {
+    obj_txt["munge"]=obj_txt_in;
+    return obj_txt["munge"];
+  }
+  invariant() {
+  }
+  string header_metadata(string obj_txt_in)
+  in { }
+  body {
+    obj_txt["munge"]=obj_txt_in;
+    return obj_txt["munge"];
+  }
+  invariant() {
+  }
+  string code(string obj_txt_in)
+  in { }
+  body {
+    obj_txt["munge"]=obj_txt_in;
+    return obj_txt["munge"];
+  }
+  invariant() {
+  }
+  string group(string obj_txt_in)
+  in { }
+  body {
+    obj_txt["munge"]=obj_txt_in;
+    obj_txt["munge"]=object_notes_(obj_txt["munge"]);
+    return obj_txt["munge"];
+  }
+  invariant() {
+  }
+  string block(string obj_txt_in)
+  in { }
+  body {
+    obj_txt["munge"]=obj_txt_in;
+    obj_txt["munge"]=object_notes_(obj_txt["munge"]);
+    return obj_txt["munge"];
+  }
+  invariant() {
+  }
+  string verse(string obj_txt_in)
+  in { }
+  body {
+    obj_txt["munge"]=obj_txt_in;
+    obj_txt["munge"]=object_notes_(obj_txt["munge"]);
+    return obj_txt["munge"];
+  }
+  invariant() {
+  }
+  string quote(string obj_txt_in)
+  in { }
+  body {
+    obj_txt["munge"]=obj_txt_in;
+    return obj_txt["munge"];
+  }
+  invariant() {
+  }
+  string table(string obj_txt_in)
+  in { }
+  body {
+    obj_txt["munge"]=obj_txt_in;
+    return obj_txt["munge"];
+  }
+  invariant() {
+  }
+  string comment(string obj_txt_in)
+  in { }
+  body {
+    obj_txt["munge"]=obj_txt_in;
+    return obj_txt["munge"];
+  }
+  invariant() {
+  }
+}
+#+end_src
+** e&i: object inline markup
+*** emitter
+#+name: ao_emitter
+#+BEGIN_SRC d                                                  :exports none
+class ObjInlineMarkup : AssertObjInlineMarkup {
+  auto munge = new ObjInlineMarkupMunge();
+  string[string] obj_txt;
+  string obj_inline_markup(string obj_is_, string obj_raw)
+  in { }
+  body {
+    obj_txt["munge"]=obj_raw.dup;
+    obj_txt["munge"]=(match(obj_is_, ctRegex!(`verse|code`)))
+      ? obj_txt["munge"]
+      : strip(obj_txt["munge"]);
+    switch (obj_is_) {
+    case "header_make":
+      obj_txt["munge"]=munge.header_make(obj_txt["munge"]);
+      break;
+    case "header_metadata":
+      obj_txt["munge"]=munge.header_metadata(obj_txt["munge"]);
+      break;
+    case "heading":
+      obj_txt["munge"]=munge.heading(obj_txt["munge"]);
+      break;
+    case "para":
+      obj_txt["munge"]=munge.para(obj_txt["munge"]);
+      break;
+    case "code":
+      obj_txt["munge"]=munge.code(obj_txt["munge"]);
+      break;
+    case "group":
+      obj_txt["munge"]=munge.group(obj_txt["munge"]);
+      break;
+    case "block":
+      obj_txt["munge"]=munge.block(obj_txt["munge"]);
+      break;
+    case "verse":
+      obj_txt["munge"]=munge.verse(obj_txt["munge"]);
+      break;
+    case "quote":
+      obj_txt["munge"]=munge.quote(obj_txt["munge"]);
+      break;
+    case "table":
+      obj_txt["munge"]=munge.table(obj_txt["munge"]);
+      break;
+    case "comment":
+      obj_txt["munge"]=munge.comment(obj_txt["munge"]);
+      break;
+    case "doc_end_reset":
+      munge.initialize_note_numbers();
+      break;
+    default:
+      break;
+    }
+    return obj_txt["munge"];
+  }
+  invariant() {
+  }
+}
+#+end_src
+*** interface assert
+#+name: ao_interface
+#+BEGIN_SRC d                                                  :exports none
+interface AssertObjInlineMarkup {
+  string obj_inline_markup(string obj_raw, string obj_type_)
+    in {
+    }
+    out(inline_markup) {
+    }
+}
+#+end_src
+** e&i: object attrib
+*** emitter
+#+name: ao_emitter
+#+BEGIN_SRC d                                                  :exports none
+class ObjAttrib : AssertObjAttrib {
+  auto attrib = new ObjAttributes();
+  string[string] obj_attrib;
+  string obj_attributes(string obj_is_, string obj_raw, string node)
+  in { }
+  body {
+    scope(exit) {
+      destroy(obj_raw);
+      destroy(node);
+    }
+    JSONValue node_j = parseJSON(node);
+    obj_attrib.remove("json");
+    obj_attrib["json"] ="{";
+    switch (obj_is_) {
+    case "header_make":
+      obj_attrib["json"] ~= attrib.header_make(obj_raw);
+      break;
+    case "header_metadata":
+      obj_attrib["json"] ~= attrib.header_metadata(obj_raw);
+      break;
+    case "heading":
+      obj_attrib["json"] ~= attrib.heading(obj_raw); //
+      break;
+    case "para":
+      obj_attrib["json"] ~= attrib.para_and_blocks(obj_raw)
+      ~ attrib.para(obj_raw);
+      break;
+    case "code":
+      obj_attrib["json"] ~= attrib.code(obj_raw);
+      break;
+    case "group":
+      obj_attrib["json"] ~= attrib.para_and_blocks(obj_raw)
+      ~ attrib.group(obj_raw);
+      break;
+    case "block":
+      obj_attrib["json"] ~= attrib.para_and_blocks(obj_raw)
+      ~ attrib.block(obj_raw);
+      break;
+    case "verse":
+      obj_attrib["json"] ~= attrib.verse(obj_raw);
+      break;
+    case "quote":
+      obj_attrib["json"] ~= attrib.quote(obj_raw);
+      break;
+    case "table":
+      obj_attrib["json"] ~= attrib.table(obj_raw);
+      break;
+    case "comment":
+      obj_attrib["json"] ~= attrib.comment(obj_raw);
+      break;
+    default:
+      obj_attrib["json"] ~= attrib.para(obj_raw);
+      break;
+    }
+    obj_attrib["json"] ~=" }";
+    JSONValue oa_j = parseJSON(obj_attrib["json"]);
+    assert(
+      (oa_j.type == JSON_TYPE.OBJECT) &&
+      (node_j.type == JSON_TYPE.OBJECT)
+    );
+    if (obj_is_ == "heading") {
+      oa_j.object["ocn"] = node_j["ocn"];
+      oa_j.object["lvn"] = node_j["lvn"];
+      oa_j.object["lcn"] = node_j["lcn"];
+      oa_j.object["heading_pointer"] =
+        node_j["heading_pointer"]; // check
+      oa_j.object["doc_object_pointer"] =
+        node_j["doc_object_pointer"]; // check
+    }
+    oa_j.object["parent_ocn"] = node_j["parent_ocn"];
+    oa_j.object["parent_lvn"] = node_j["parent_lvn"];
+    obj_attrib["json"] = oa_j.toString();
+    debug(structattrib) {
+      if (oa_j["is"].str() == "heading") {
+        writeln(obj_attrib["json"]);
+        writeln(
+          "is: ", oa_j["is"].str(),
+          "; ocn: ", oa_j["ocn"].integer()
+        );
+      }
+    }
+    return obj_attrib["json"];
+  }
+  invariant() {
+  }
+}
+#+end_src
+*** interface assert
+#+name: ao_interface
+#+BEGIN_SRC d                                                  :exports none
+interface AssertObjAttrib {
+  string obj_attributes(string obj_raw, string node, string obj_type_)
+    in {
+    }
+    out(obj_attrib_json) {
+    }
+}
+#+end_src
+** e:   header document metadata in json
+*** emitter
+#+name: ao_emitter
+#+BEGIN_SRC d                                                  :exports none
+class HeaderDocMetadataMakeJson {
+  auto rgx = new Rgx();
+  string hm, hs;
+  auto header_metadata_and_make_jsonstr(
+    string header,
+    JSONValue[string] dochead_metadata,
+    JSONValue[string] dochead_make
+  )
+  in { }
+  body {
+    scope(exit) {
+      destroy(header);
+      destroy(dochead_metadata);
+      destroy(dochead_make);
+    }
+    if (auto t = match(header, rgx.head_main)) {
+      char[][] obj_spl = split(
+        cast(char[]) header,
+        rgx.line_delimiter_ws_strip
+      );
+      auto hm = to!string(t.captures[1]);
+      if (match(hm, rgx.main_headers)) {
+        foreach (line; obj_spl) {
+          if (auto m = match(line, rgx.head_main)) {
+            if (!empty(m.captures[2])) {
+              if (hm == "creator") {
+                dochead_metadata[hm]["author"].str =
+                  to!string(m.captures[2]);
+              } else if (hm == "title") {
+                dochead_metadata[hm]["main"].str =
+                  to!string(m.captures[2]);
+              } else if (hm == "publisher") {
+                dochead_metadata[hm]["name"].str =
+                  to!string(m.captures[2]);
+              }
+            }
+          } else if (auto s = match(line, rgx.head_sub)) {
+            if (!empty(s.captures[2])) {
+              auto hs = to!string(s.captures[1]);
+              if ((hm == "make" )
+              && (dochead_make[hm].type() == JSON_TYPE.OBJECT)) {
+                switch (hm) {
+                case "make":
+                  if (match(hs, rgx.subhead_make)) {
+                    if (dochead_make[hm][hs].type() == JSON_TYPE.STRING) {
+                      dochead_make[hm][hs].str = to!string(s.captures[2]);
+                    }
+                  } else {
+                    writeln("not a valid header type:", hm, ":", hs);
+                    destroy(hm);
+                    destroy(hs);
+                  }
+                  break;
+                default:
+                  break;
+                }
+              } else if (dochead_metadata[hm].type() == JSON_TYPE.OBJECT) {
+                switch (hm) {
+                case "creator":
+                  if (match(hs, rgx.subhead_creator)) {
+                    if (dochead_metadata[hm][hs].type() == JSON_TYPE.STRING) {
+                      dochead_metadata[hm][hs].str =
+                        to!string(s.captures[2]);
+                    }
+                  } else {
+                    writeln("not a valid header type:", hm, ":", hs);
+                    destroy(hm);
+                    destroy(hs);
+                  }
+                  break;
+                case "title":
+                  if (match(hs, rgx.subhead_title)) {
+                    if ((hs == "subtitle")
+                    && (dochead_metadata[hm]["sub"].type() == JSON_TYPE.STRING)) {
+                      dochead_metadata[hm]["sub"].str =
+                        to!string(s.captures[2]);
+                    } else if (dochead_metadata[hm][hs].type() == JSON_TYPE.STRING) {
+                      dochead_metadata[hm][hs].str =
+                        to!string(s.captures[2]);
+                    }
+                  } else {
+                    writeln("not a valid header type:", hm, ":", hs);
+                    destroy(hm);
+                    destroy(hs);
+                  }
+                  break;
+                case "rights":
+                  if (match(hs, rgx.subhead_rights)) {
+                    if (dochead_metadata[hm][hs].type() == JSON_TYPE.STRING) {
+                      dochead_metadata[hm][hs].str =
+                        to!string(s.captures[2]);
+                    }
+                  } else {
+                    writeln("not a valid header type:", hm, ":", hs);
+                    destroy(hm);
+                    destroy(hs);
+                  }
+                  break;
+                case "date":
+                  if (match(hs, rgx.subhead_date)) {
+                    if (dochead_metadata[hm][hs].type() == JSON_TYPE.STRING) {
+                      dochead_metadata[hm][hs].str =
+                        to!string(s.captures[2]);
+                    }
+                  } else {
+                    writeln("not a valid header type:", hm, ":", hs);
+                    destroy(hm);
+                    destroy(hs);
+                  }
+                  break;
+                case "original":
+                  if (match(hs, rgx.subhead_original)) {
+                    if (dochead_metadata[hm][hs].type() == JSON_TYPE.STRING) {
+                      dochead_metadata[hm][hs].str =
+                        to!string(s.captures[2]);
+                    }
+                  } else {
+                    writeln("not a valid header type:", hm, ":", hs);
+                    destroy(hm);
+                    destroy(hs);
+                  }
+                  break;
+                case "classify":
+                  if (match(hs, rgx.subhead_classify)) {
+                    if (dochead_metadata[hm][hs].type() == JSON_TYPE.STRING) {
+                      dochead_metadata[hm][hs].str =
+                        to!string(s.captures[2]);
+                    }
+                  } else {
+                    writeln("not a valid header type:", hm, ":", hs);
+                    destroy(hm);
+                    destroy(hs);
+                  }
+                  break;
+                case "identifier":
+                  if (match(hs, rgx.subhead_identifier)) {
+                    if (dochead_metadata[hm][hs].type() == JSON_TYPE.STRING) {
+                      dochead_metadata[hm][hs].str =
+                        to!string(s.captures[2]);
+                    }
+                  } else {
+                    writeln("not a valid header type:", hm, ":", hs);
+                    destroy(hm);
+                    destroy(hs);
+                  }
+                  break;
+                case "notes":
+                  if (match(hs, rgx.subhead_notes)) {
+                    if (dochead_metadata[hm][hs].type() == JSON_TYPE.STRING) {
+                      dochead_metadata[hm][hs].str =
+                        to!string(s.captures[2]);
+                    }
+                  } else {
+                    writeln("not a valid header type:", hm, ":", hs);
+                    destroy(hm);
+                    destroy(hs);
+                  }
+                  break;
+                case "publisher":
+                  if (match(hs, rgx.subhead_publisher)) {
+                    if (dochead_metadata[hm][hs].type() == JSON_TYPE.STRING) {
+                      dochead_metadata[hm][hs].str =
+                        to!string(s.captures[2]);
+                    }
+                  } else {
+                    writeln("not a valid header type:", hm, ":", hs);
+                    destroy(hm);
+                    destroy(hs);
+                  }
+                  break;
+                case "links":
+                  destroy(hm);
+                  destroy(hs);
+                  break;
+                default:
+                  break;
+                }
+              }
+            }
+          }
+        }
+      } else {
+        writeln("not a valid header type:", hm);
+      }
+    }
+    auto t = tuple(dochead_metadata, dochead_make);
+    static assert(!isTypeTuple!(t));
+    return t;
+  }
+}
+#+end_src
+** e:   header document metadata as hash
+*** emitter
+#+name: ao_emitter
+#+BEGIN_SRC d                                                  :exports none
+class HeaderMetadataMakeHash {
+  auto rgx = new Rgx();
+  string header_main;
+  string[string] head;
+  string[string] header_topic_hash(string header)
+  in { }
+  body {
+    if (auto t = match(header, rgx.head_main)) {
+      char[][] obj_spl = split(
+        cast(char[]) header,
+        rgx.line_delimiter_ws_strip
+      );
+      auto header_main = to!string(t.captures[1]);
+      head[header_main] = "{";
+      foreach (line; obj_spl) {
+        if (auto m = match(line, rgx.head_main)) {
+          if (!empty(m.captures[2])) {
+            head[header_main] ~=
+              "\"" ~ header_main ~
+              "\": \"" ~
+              to!string(m.captures[2]) ~
+              "\",";
+          }
+        } else if (auto s = match(line, rgx.head_sub)) {
+          head[header_main] ~= "\"" ~ s.captures[1] ~ "\":";
+          if (!empty(s.captures[2])) {
+            head[header_main] ~= "\"" ~ s.captures[2] ~ "\",";
+          }
+        }
+      }
+      head[header_main] = replaceFirst(
+        head[header_main],
+        rgx.tailing_comma,
+        ""
+      );
+      head[header_main] ~= "}";
+      debug(headerjson) {
+        JSONValue j = parseJSON(head[header_main]);
+        assert(
+          (j.type == JSON_TYPE.OBJECT)
+        );
+      }
+    }
+    return head;
+  }
+  invariant() {
+  }
+}
+#+end_src
+** e&i: book index nugget hash
+*** emitter
+#+name: ao_emitter
+#+BEGIN_SRC d                                                  :exports none
+class BookIndexNuggetHash : AssertBookIndexNuggetHash {
+  string main_term, sub_term, sub_term_bits;
+  uint ocn_offset, ocn_endpoint;
+  string[] ocns;
+  string[][string][string] bi;
+  string[][string][string] hash_nugget;
+  string[] bi_main_terms_split_arr;
+  string[][string][string] bookindex_nugget_hash(string bookindex, int ocn)
+  in { }
+  body {
+    auto rgx = new Rgx();
+    if (!bookindex.empty) {
+      auto bi_main_terms_split_arr =
+        split(bookindex, rgx.bi_main_terms_split);
+      foreach (bi_main_terms_content; bi_main_terms_split_arr) {
+        auto bi_main_term_and_rest =
+          split(bi_main_terms_content, rgx.bi_main_term_plus_rest_split);
+        if (auto m = match(
+          bi_main_term_and_rest[0],
+          rgx.bi_term_and_ocns_match)
+        ) {
+          main_term = strip(m.captures[1]);
+          ocn_offset = to!uint(m.captures[2]);
+          ocn_endpoint=(ocn + ocn_offset);
+          ocns ~= (to!string(ocn) ~ "-" ~ to!string(ocn_endpoint));
+        } else {
+          main_term = strip(bi_main_term_and_rest[0]);
+          ocns ~= to!string(ocn);
+        }
+        bi[main_term]["_a"] ~= ocns;
+        ocns=null;
+        if (bi_main_term_and_rest.length > 1) {
+          auto bi_sub_terms_split_arr =
+            split(
+              bi_main_term_and_rest[1],
+              rgx.bi_sub_terms_plus_ocn_offset_split
+            );
+          foreach (sub_terms_bits; bi_sub_terms_split_arr) {
+            if (auto m = match(sub_terms_bits, rgx.bi_term_and_ocns_match)) {
+              sub_term = strip(m.captures[1]);
+              ocn_offset = to!uint(m.captures[2]);
+              ocn_endpoint=(ocn + ocn_offset);
+              ocns ~= (to!string(ocn) ~ " - " ~ to!string(ocn_endpoint));
+            } else {
+              sub_term = strip(sub_terms_bits);
+              ocns ~= to!string(ocn);
+            }
+            if (!empty(sub_term)) {
+              bi[main_term][sub_term] ~= ocns;
+            }
+            ocns=null;
+          }
+        }
+      }
+    }
+    hash_nugget = bi;
+    return hash_nugget;
+  }
+  invariant() {
+  }
+}
+#+end_src
+*** interface assert
+#+name: ao_interface
+#+BEGIN_SRC d                                                  :exports none
+interface AssertBookIndexNuggetHash {
+  string[][string][string] bookindex_nugget_hash(string bookindex, int ocn)
+    in {
+      debug(bookindexraw) {
+        mixin ScreenTxtColors;
+        if (!bookindex.empty) {
+          writeln(
+            scr_txt_color["blue"], "* [bookindex] ", scr_txt_color["off"],
+            "[", to!string(ocn), "] ", bookindex
+          );
+        }
+      }
+    }
+    out(hash_nugget) {
+    }
+}
+#+end_src
+** e&i: book index report
+*** emitter
+#+name: ao_emitter
+#+BEGIN_SRC d                                                  :exports none
+class BookIndexReport {
+  int mkn, skn;
+  auto bookindex_report_sorted(
+    string[][string][string] bookindex_unordered_hashes
+  ) {
+    auto mainkeys=bookindex_unordered_hashes.byKey.array.
+      sort!("toLower(a) < toLower(b)", SwapStrategy.stable).release;
+    foreach (mainkey; mainkeys) {
+      auto subkeys=bookindex_unordered_hashes[mainkey].byKey.array.
+        sort!("toLower(a) < toLower(b)", SwapStrategy.stable).release;
+      foreach (subkey; subkeys) {
+        debug(bookindex) {
+          writeln(
+            mainkey, ": ",
+            subkey, ": ",
+            to!string(bookindex_unordered_hashes[mainkey][subkey])
+          );
+        }
+        skn++;
+      }
+      mkn++;
+    }
+  }
+}
+#+end_src
+*** interface assert
+#+name: ao_interface
+#+BEGIN_SRC d                                                  :exports none
+interface AssertBookIndexReport {
+  string[][string][][string][] bookindex_nugget_hash(string[][string][string] bookindex_unordered_hashes)
+    in {
+    }
+}
+#+end_src
+** e:   book index report indented
+*** emitter
+#+name: ao_emitter
+#+BEGIN_SRC d                                                  :exports none
+class BookIndexReportIndent {
+  int mkn, skn;
+  auto bookindex_report_indented(
+    string[][string][string] bookindex_unordered_hashes
+  ) {
+    auto mainkeys=
+      bookindex_unordered_hashes.byKey.array.sort().release;
+    foreach (mainkey; mainkeys) {
+      debug(bookindex) {
+        writeln(mainkey);
+      }
+      auto subkeys=
+        bookindex_unordered_hashes[mainkey].byKey.array.sort().release;
+      foreach (subkey; subkeys) {
+        debug(bookindex) {
+          writeln("  ", subkey);
+          writeln("    ", to!string(
+            bookindex_unordered_hashes[mainkey][subkey]
+          ));
+        }
+        skn++;
+      }
+      mkn++;
+    }
+  }
+}
+#+end_src
+** e:   book index report section
+*** emitter
+#+name: ao_emitter
+#+BEGIN_SRC d                                                  :exports none
+class BookIndexReportSection {
+  mixin ObjectSetters;
+  int mkn, skn;
+  auto rgx = new Rgx();
+  auto bookindex_write_section(
+    string[][string][string] bookindex_unordered_hashes
+  ) {
+    auto mainkeys=bookindex_unordered_hashes.byKey.array.sort().release;
+    foreach (mainkey; mainkeys) {
+      write("_0_1 !{", mainkey, "}! ");
+      foreach (ref_; bookindex_unordered_hashes[mainkey]["_a"]) {
+        auto go = replaceAll(ref_, rgx.book_index_go, "$1");
+        write(" {", ref_, "}#", go, ", ");
+      }
+      writeln(" \\\\");
+      bookindex_unordered_hashes[mainkey].remove("_a");
+      auto subkeys=
+        bookindex_unordered_hashes[mainkey].byKey.array.sort().release;
+      foreach (subkey; subkeys) {
+        write("  ", subkey, ", ");
+        foreach (ref_; bookindex_unordered_hashes[mainkey][subkey]) {
+          auto go = replaceAll(ref_, rgx.book_index_go, "$1");
+          write(" {", ref_, "}#", go, ", ");
+        }
+        writeln(" \\\\");
+        skn++;
+      }
+      mkn++;
+    }
+  }
+  auto bookindex_build_section(
+    string[][string][string] bookindex_unordered_hashes,
+    int ocn
+  ) {
+    string type;
+    int type_heading;
+    string lev, lvn, lcn;
+    string attrib;
+    string indent_first;
+    string indent_second;
+    auto set_oa = new ObjectAbstractSet();
+    auto mainkeys =
+      bookindex_unordered_hashes.byKey.array.sort().release;
+    string bi_tmp;
+    string[string][1024] bookindex_arbitrary_max_length_set;
+    writeln(mainkeys.length);
+    type_heading=1;
+    bi_tmp = "Book Index";
+    attrib="";
+    lev="B";
+    lvn="1";
+    lcn="1";
+    bookindex_arbitrary_max_length_set[mkn] =
+      set_oa.contents_heading(
+        type_heading,
+        bi_tmp,
+        attrib,
+        ocn,
+        lev,
+        lvn,
+        lcn
+      );
+    ocn++;
+    mkn++;
+    type_heading=1;
+    bi_tmp = "Index";
+    attrib="";
+    lev="1";
+    lvn="4";
+    lcn="2";
+    bookindex_arbitrary_max_length_set[mkn] =
+      set_oa.contents_heading(
+        type_heading,
+        bi_tmp,
+        attrib,
+        ocn,
+        lev,
+        lvn,
+        lcn
+      );
+    ocn++;
+    mkn++;
+    foreach (mainkey; mainkeys) {
+      bi_tmp = "!{" ~ mainkey ~ "}! ";
+      foreach (ref_; bookindex_unordered_hashes[mainkey]["_a"]) {
+        auto go = replaceAll(ref_, rgx.book_index_go, "$1");
+        bi_tmp ~= " {" ~ ref_ ~ "}#" ~ go ~ ", ";
+      }
+      bi_tmp ~= " \\\\\n    ";
+      bookindex_unordered_hashes[mainkey].remove("_a");
+      auto subkeys =
+        bookindex_unordered_hashes[mainkey].byKey.array.sort().release;
+      foreach (subkey; subkeys) {
+        bi_tmp ~= subkey ~ ", ";
+        foreach (ref_; bookindex_unordered_hashes[mainkey][subkey]) {
+          auto go = replaceAll(ref_, rgx.book_index_go, "$1");
+          bi_tmp ~= " {" ~ ref_ ~ "}#" ~ go ~ ", ";
+        }
+        bi_tmp ~= " \\\\\n    ";
+        skn++;
+      }
+      bi_tmp = replaceFirst(bi_tmp, rgx.trailing_linebreak, "");
+      type="para";
+      attrib="";
+      indent_first = "0";
+      indent_second = "1";
+      attrib="";
+      bookindex_arbitrary_max_length_set[mkn] =
+        set_oa.contents_para(
+          type,
+          bi_tmp,
+          attrib,
+          ocn,
+          indent_first,
+          indent_second,
+          false
+        );
+      ocn++;
+      mkn++;
+    }
+    auto bookindex =
+      bookindex_arbitrary_max_length_set[0..mkn].dup;
+    auto t = tuple(bookindex, ocn);
+    return t;
+  }
+  auto bookindex_build_section_(
+    string[][string][string] bookindex_unordered_hashes
+  ) {
+    auto mainkeys =
+      bookindex_unordered_hashes.byKey.array.sort().release;
+    string bi_tmp;
+    string[1024] bookindex_arbitrary_max_length_set;
+    writeln(mainkeys.length);
+    foreach (mainkey; mainkeys) {
+      bi_tmp = "_0_1 !{" ~ mainkey ~ "}! ";
+      foreach (ref_; bookindex_unordered_hashes[mainkey]["_a"]) {
+        auto go = replaceAll(ref_, rgx.book_index_go, "$1");
+        bi_tmp ~= " {" ~ ref_ ~ "}#" ~ go ~ ", ";
+      }
+      bi_tmp ~= " \\\\\n    ";
+      bookindex_unordered_hashes[mainkey].remove("_a");
+      auto subkeys =
+        bookindex_unordered_hashes[mainkey].byKey.array.sort().release;
+      foreach (subkey; subkeys) {
+        bi_tmp ~= subkey ~ ", ";
+        foreach (ref_; bookindex_unordered_hashes[mainkey][subkey]) {
+          auto go = replaceAll(ref_, rgx.book_index_go, "$1");
+          bi_tmp ~= " {" ~ ref_ ~ "}#" ~ go ~ ", ";
+        }
+        bi_tmp ~= " \\\\\n    ";
+        skn++;
+      }
+      bi_tmp = replaceFirst(bi_tmp, rgx.trailing_linebreak, "");
+      bookindex_arbitrary_max_length_set[mkn] = bi_tmp;
+      mkn++;
+    }
+    auto bookindex =
+      bookindex_arbitrary_max_length_set[0..mkn].dup;
+    return bookindex;
+  }
+}
+#+end_src
+** e:   (end)notes section
+*** emitter
+#+name: ao_emitter
+#+BEGIN_SRC d                                                  :exports none
+class NotesSection {
+  mixin ObjectSetters;
+  string object_notes;
+  int previous_count;
+  int mkn;
+  auto rgx = new Rgx();
+  private auto gather_notes_for_endnote_section(
+    string[string][131072] contents_arbitrary_max_length_set,
+    int counter
+  )
+  in {
+    // endnotes/ footnotes for
+    // doc objects other than paragraphs & headings
+    // various forms of grouped text
+    assert((contents_arbitrary_max_length_set[counter]["is"] == "para")
+    || (contents_arbitrary_max_length_set[counter]["is"] == "heading"));
+    assert(counter > previous_count);
+    previous_count=counter;
+    assert(
+      match(contents_arbitrary_max_length_set[counter]["obj"],
+      rgx.inline_notes_delimiter_al_regular_number_note)
+    );
+  }
+  body {
+    foreach(m;
+    matchAll(contents_arbitrary_max_length_set[counter]["obj"],
+    rgx.inline_notes_delimiter_al_regular_number_note)) {
+      debug(endnotes_build) {
+        writeln(
+          "{^{", m.captures[1], ".}^}#noteref_", m.captures[1], " ",
+          m.captures[2]); // sometimes need segment name (segmented html & epub)
+      }
+      object_notes ~=
+        "{^{" ~ m.captures[1] ~ ".}^}#noteref_" ~
+        m.captures[1] ~ " " ~ m.captures[2] ~ "』";
+    }
+    return object_notes;
+  }
+  private auto gathered_notes()
+  in {
+  }
+  body {
+    string[] endnotes_;
+    if (object_notes.length > 1) {
+      endnotes_ = (split(object_notes, rgx.break_string))[0..$-1];
+    }
+    return endnotes_;
+  }
+  private auto endnote_objects(int ocn)
+  in {
+  }
+  body {
+    auto set_oa = new ObjectAbstractSet();
+    string[string][1024] endnotes_arbitrary_max_length_set;
+    auto endnotes_ = gathered_notes();
+    string type;
+    int type_heading;
+    string lev, lvn, lcn;
+    string attrib;
+    string indent_first;
+    string indent_second;
+    type_heading=1;
+    attrib="";
+    lev="B";
+    lvn="1";
+    lcn="1";
+    endnotes_arbitrary_max_length_set[mkn] =
+      set_oa.contents_heading(
+        type_heading,
+        "Endnotes",
+        attrib,
+        ocn,
+        lev,
+        lvn,
+        lcn
+      );
+    ocn++;
+    mkn++;
+    type_heading=1;
+    attrib="";
+    lev="1";
+    lvn="4";
+    lcn="2";
+    endnotes_arbitrary_max_length_set[mkn] =
+      set_oa.contents_heading(
+        type_heading,
+        "Endnotes",
+        attrib,
+        ocn,
+        lev,
+        lvn,
+        lcn
+      );
+    ocn++;
+    mkn++;
+    foreach (endnote; endnotes_) {
+      type="para";
+      attrib="";
+      indent_first = "0";
+      indent_second = "0";
+      attrib="";
+      endnotes_arbitrary_max_length_set[mkn] =
+        set_oa.contents_para(
+          type,
+          endnote,
+          attrib,
+          ocn,
+          indent_first,
+          indent_second,
+          false
+        );
+      ocn++;
+      mkn++;
+    }
+    auto endnotes =
+      endnotes_arbitrary_max_length_set[0..mkn].dup;
+    auto t = tuple(endnotes, ocn);
+    return t;
+  }
+}
+#+end_src
+** e:   bibliography
+*** emitter
+#+name: ao_emitter
+#+BEGIN_SRC d                                                  :exports none
+class Bibliography {
+  public JSONValue[] bibliography(string[] biblio_unsorted_incomplete)
+  in { }
+  body {
+    JSONValue[] biblio_unsorted =
+      biblio_unsorted_complete(biblio_unsorted_incomplete);
+    JSONValue[] biblio_sorted = biblio_sort(biblio_unsorted);
+    biblio_debug(biblio_sorted);
+    return biblio_sorted;
+  }
+  final private JSONValue[] biblio_unsorted_complete(
+    string[] biblio_unordered
+  ) {
+    JSONValue[1024] bib_arr_json;
+    int count_biblio_entry;
+    count_biblio_entry=0;
+    foreach (bibent; biblio_unordered) {
+      // update bib to include deemed_author, needed for:
+      // sort_bibliography_array_by_deemed_author_year_title
+      // either: sort on multiple fields, or; create such sort field
+      JSONValue j = parseJSON(bibent);
+      if (!empty(j["fulltitle"].str)) {
+        if (!empty(j["author_raw"].str)) {
+          j["deemed_author"]=j["author_arr"][0];
+        } else if (!empty(j["editor_raw"].str)) {
+          j["deemed_author"]=j["editor_arr"][0];
+        }
+        j["sortby_deemed_author_year_title"] = (
+          j["deemed_author"].str ~
+           "; " ~
+           j["year"].str ~
+           "; "  ~
+           j["fulltitle"].str
+        );
+      }
+      bib_arr_json[count_biblio_entry] = j;
+      count_biblio_entry++;
+    }
+    JSONValue[] biblio_unsorted_array_of_json_objects =
+      bib_arr_json[0..(count_biblio_entry)].dup;
+    return biblio_unsorted_array_of_json_objects;
+  }
+  final private JSONValue[] biblio_sort(JSONValue[] biblio_unordered) {
+    JSONValue[] biblio_sorted;
+    biblio_sorted =
+      sort!((a, b){
+        return ((a["sortby_deemed_author_year_title"].str) < (b["sortby_deemed_author_year_title"].str));
+      })(biblio_unordered).array;
+    debug(bibliosorted) {
+      foreach (j; biblio_sorted) {
+        if (!empty(j["fulltitle"].str)) {
+          writeln(j["sortby_deemed_author_year_title"]);
+        }
+      }
+    }
+    return biblio_sorted;
+  }
+  auto biblio_debug(JSONValue[] biblio_sorted) {
+    debug(biblio) {
+      foreach (j; biblio_sorted) {
+        if (!empty(j["fulltitle"].str)) {
+          writeln(j["sortby_deemed_author_year_title"]);
+        }
+      }
+    }
+  }
+}
+#+end_src
+** e&i: node structure metadata
+*** emitter
+#+name: ao_emitter
+#+BEGIN_SRC d                                                  :exports none
+class NodeStructureMetadata : AssertNodeJSON {
+  int lv, lv0, lv1, lv2, lv3, lv4, lv5, lv6, lv7;
+  uint ocn;
+  uint[string] p_; // p_ parent_
+  string node;
+  string node_emitter(
+    string lvn,
+    int ocn_,
+    int counter_,
+    int pointer_,
+    string is_
+  )
+  in {
+    auto rgx = new Rgx();
+  }
+  body {
+    assert(is_ != "heading"); // should not be necessary
+    assert(to!int(ocn_) >= 0); // should not be necessary
+    uint ocn=to!uint(ocn_);
+    if (lv7 > 0) {
+      p_["lvn"] = 7; p_["ocn"] = lv7;
+    } else if (lv6 > 0) {
+      p_["lvn"] = 6; p_["ocn"] = lv6;
+    } else if (lv5 > 0) {
+      p_["lvn"] = 5; p_["ocn"] = lv5;
+    } else {
+      p_["lvn"] = 4; p_["ocn"] = lv4;
+    }
+    node=("{ " ~
+      "\"is\": \"" ~ is_ ~ "\"" ~
+      ", \"heading_pointer\": " ~ to!string(pointer_) ~
+      ", \"doc_object_pointer\": " ~ to!string(counter_) ~
+      ", \"ocn\": " ~ to!string(ocn_) ~
+      ", \"parent_ocn\": " ~ to!string(p_["ocn"]) ~
+      ", \"parent_lvn\": " ~ to!string(p_["lvn"]) ~
+      " }"
+    );
+    return node;
+  }
+  invariant() {
+  }
+  string node_emitter_heading(
+    string lvn,
+    string lcn,
+    int ocn_,
+    int counter_,
+    int pointer_,
+    string is_
+  )
+  in {
+    auto rgx = new Rgx();
+  }
+  body {
+    uint ocn=to!uint(ocn_);
+    switch (lvn) { // switch (to!string(lv)) {
+    case "0":
+      lv=0;
+      lv0=ocn; lv1=0; lv2=0; lv3=0; lv4=0; lv5=0; lv6=0; lv7=0;
+      p_["lvn"] = 0; p_["ocn"] = 0;
+      break;
+    case "1":
+      lv=1;
+      lv1=ocn; lv2=0; lv3=0; lv4=0; lv5=0; lv6=0; lv7=0;
+      p_["lvn"] = 0; p_["ocn"] = lv0;
+      break;
+    case "2":
+      lv=2;
+      lv2=ocn; lv3=0; lv4=0; lv5=0; lv6=0; lv7=0;
+      p_["lvn"] = 1; p_["ocn"] = lv1;
+      break;
+    case "3":
+      lv=3;
+      lv3=ocn; lv4=0; lv5=0; lv6=0; lv7=0;
+      p_["lvn"] = 2; p_["ocn"] = lv2;
+      break;
+    case "4":
+      lv=4;
+      lv4=ocn; lv5=0; lv6=0; lv7=0;
+      if (lv3 > 0) {
+        p_["lvn"] = 3; p_["ocn"] = lv3;
+      } else if (lv2 > 0) {
+        p_["lvn"] = 2; p_["ocn"] = lv2;
+      } else if (lv1 > 0) {
+        p_["lvn"] = 1; p_["ocn"] = lv1;
+      } else {
+        p_["lvn"] = 0; p_["ocn"] = lv0;
+      }
+      break;
+    case "5":
+      lv=5;
+      lv5=ocn; lv6=0; lv7=0;
+      p_["lvn"] = 4; p_["ocn"] = lv4;
+      break;
+    case "6":
+      lv=6;
+      lv6=ocn; lv7=0;
+      p_["lvn"] = 5; p_["ocn"] = lv5;
+      break;
+    case "7":
+      lv=7;
+      lv7=ocn;
+      p_["lvn"] = 6; p_["ocn"] = lv6;
+      break;
+    default:
+      break;
+    }
+    node=("{ " ~
+      "\"is\": \"" ~ is_ ~ "\"" ~
+      ", \"heading_pointer\": " ~ to!string(pointer_) ~
+      ", \"doc_object_pointer\": " ~ to!string(counter_) ~
+      ", \"ocn\": " ~ to!string(ocn_) ~
+      ",  \"lvn\": " ~ to!string(lvn) ~
+      ",  \"lcn\": " ~ to!string(lcn) ~
+      ", \"parent_ocn\": " ~ to!string(p_["ocn"]) ~
+      ", \"parent_lvn\": " ~ to!string(p_["lvn"]) ~
+      " }"
+    );
+    return node;
+  }
+  invariant() {
+  }
+}
+#+end_src
+
+*** interface assert
+#+name: ao_interface
+#+BEGIN_SRC d                                                  :exports none
+interface AssertNodeJSON {
+  string node_emitter(
+    string lvn,
+    int ocn_,
+    int counter_,
+    int pointer_,
+    string is_
+  )
+  in {
+    auto rgx = new Rgx();
+    assert(is_ != "heading");
+    assert(to!int(ocn_) >= 0);
+  }
+  out(node) {
+    debug(node) {
+      mixin ScreenTxtColors;
+      if (match(lvn, rgx.levels_numbered_headings)) {
+        writeln(scr_txt_marker["yellow"], to!string(node));
+      } else {
+        writeln(scr_txt_marker["white"], to!string(node));
+      }
+    }
+    JSONValue j = parseJSON(node);
+    assert(j["parent_lvn"].integer >= 4);
+    assert(j["parent_lvn"].integer <= 7);
+    assert(j["parent_ocn"].integer >= 0);
+  }
+  string node_emitter_heading(
+    string lvn,
+    string lcn,
+    int ocn_,
+    int counter_,
+    int pointer_,
+    string is_
+  )
+  in {
+    auto rgx = new Rgx();
+    assert(is_ == "heading");
+    assert(to!uint(ocn_) >= 0);
+    assert(
+      match(lvn, rgx.levels_numbered),
+      ("not a valid heading level: " ~ lvn ~ " at " ~ to!string(ocn_))
+    );
+    if (match(lvn, rgx.levels_numbered)) {
+      if (to!uint(lvn) == 0) {
+        assert(to!uint(ocn_) == 1);
+      }
+    }
+  }
+  out(node) {
+    auto rgx = new Rgx();
+    debug(heading) {
+      mixin ScreenTxtColors;
+      if (match(lvn, rgx.levels_numbered_headings)) {
+        writeln(scr_txt_marker["yellow"], to!string(node));
+      }
+    }
+    debug(node) {
+      mixin ScreenTxtColors;
+      if (match(lvn, rgx.levels_numbered_headings)) {
+        writeln(scr_txt_marker["yellow"], to!string(node));
+      } else {
+        writeln(scr_txt_marker["white"], to!string(node));
+      }
+    }
+    JSONValue j = parseJSON(node);
+    assert(j["parent_lvn"].integer <= 7);
+    assert(j["parent_ocn"].integer >= 0);
+    if (match(lvn, rgx.levels_numbered_headings)) {
+      assert(j["lvn"].integer <= 7);
+      assert(j["ocn"].integer >= 0);
+      if (j["parent_lvn"].integer > 0) {
+        assert(j["parent_lvn"].integer < j["lvn"].integer);
+        if (j["ocn"].integer != 0) {
+          assert(j["parent_ocn"].integer < j["ocn"].integer);
+        }
+      }
+      if (j["lvn"].integer == 0) {
+        assert(j["parent_lvn"].integer == 0);
+      } else if  (j["lvn"].integer == 1) {
+        assert(j["parent_lvn"].integer == 0);
+      } else if  (j["lvn"].integer == 2) {
+        assert(j["parent_lvn"].integer == 1);
+      } else if  (j["lvn"].integer == 3) {
+        assert(j["parent_lvn"].integer == 2);
+      } else if  (j["lvn"].integer == 4) {
+        assert(j["parent_lvn"].integer <= 3);
+      } else if  (j["lvn"].integer == 5) {
+        assert(j["parent_lvn"].integer == 4);
+      } else if  (j["lvn"].integer == 6) {
+        assert(j["parent_lvn"].integer == 5);
+      } else if  (j["lvn"].integer == 7) {
+        assert(j["parent_lvn"].integer == 6);
+      } else if  (j["lvn"].integer == 8) {
+      }
+    }
+  }
+}
+#+end_src
+* tangles
+** code structure:                                                :ao_emitter.d:
+#+name: tangle_ao_emitter
+#+BEGIN_SRC d  :tangle ../lib/sdp/ao_emitter.d  :exports none :noweb yes
+/*
+  emitters
+  ao_emitters.d
+*/
+mixin template Emitters() {
+  mixin InternalMarkup;
+  <<ao_emitter>>
+}
+#+end_src
+** code structure:                                             :ao_interface.d:
+#+name: tangle_ao_interface
+#+BEGIN_SRC d  :tangle ../lib/sdp/ao_interface.d  :exports none :noweb yes
+/*
+  interface
+  ao_interface.d
+*/
+mixin template Interfaces() {
+  <<ao_interface>>
+}
+#+end_src