path: root/org/ao_defaults.org

#+TITLE: sdp defaults
#+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 _: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
#+PROPERTY: header-args :padline no :exports code :noweb yes
#+EXPORT_SELECT_TAGS: export
#+EXPORT_EXCLUDE_TAGS: noexport
#+FILETAGS: :sdp:rel:ao:
#+TAGS: assert(a) class(c) debug(d) mixin(m) sdp(s) tangle(T) template(t) WEB(W) noexport(n)

[[./sdp.org][sdp]]  [[./][org/]]

* default templates                                       :template:defaults:
[[./sdp.org][sdp]] [[./][org/]]
** template: settings metadata associative array indexes                      :settings:

#+name: ao_defaults_templates
#+BEGIN_SRC d
template SiSUregisters() {
  string[string][string] conf_aa() {
    auto conf_ = [
      "webserv": [
         "url_root"         : "",
         "path"             : "~/sdp_www" ,
         "images"           : "" ,
         "cgi"              : "/usr/local/lib/sdp-cgi"
      ],
      "webserv_cgi": [
         "host"             : "localhost",
         "base_path"        : "",
         "port"             : "8081",
         "user"             : "",
         "file_links"       : "www.sisudoc.org"
      ],
      "processing": [
         "path"             : "~",
         "dir"              : "_sisu_processing",
         "concord_max"      : "400000"
      ],
      "flag": [
         "act0"             : "--digest --qrcode --text --html --epub --concordance --pdf --odf --docbook --xhtml --xml-sax --xml-dom --sqlite --manifest --verbose",
         "act1"             : "--digest --text --html --manifest",
         "act2"             : "--digest --text --html --epub --pdf --manifest",
         "act3"             : "--digest --qrcode --text --html --epub --concordance --pdf --manifest",
         "act4"             : "--digest --qrcode --text --html --epub --concordance --pdf --odf --docbook --manifest",
         "act5"             : "--digest --qrcode --text --html --epub --concordance --pdf --odf --docbook --sqlite --manifest",
         "act6"             : "--digest --qrcode --text --html --epub --concordance --pdf --odf --docbook --xhtml --xml-sax --xml-dom --sqlite --manifest",
         "act7"             : "--digest --qrcode --text --html --epub --concordance --pdf --odf --docbook --xhtml --xml-sax --xml-dom --sqlite --source --sisupod --manifest",
         "act8"             : "--digest --qrcode --text --html --epub --concordance --pdf --odf --docbook --xhtml --xml-sax --xml-dom --pg --update --manifest",
         "act9"             : "--digest --qrcode --text --html --epub --concordance --pdf --odf --docbook --xhtml --xml-sax --xml-dom --pg --update --source --sisupod --manifest"
      ],
      "default": [
         "papersize"        : "a4,letter",
         "text_wrap"        : "78",
         "emphasis"         : "bold",
         "language"         : "en",
         "digest"           : "sha256"
      ],
      "permission": [
         "share_source"     : ""
       ],
      "program_select": [
         "editor"           : "vim",
         "epub_viewer"      : "ebook-viewer",
         "html_viewer"      : "xombrero",
         "odf_viewer"       : "lowriter",
         "pdf_viewer"       : "evince",
         "xml_viewer"       : "xml-viewer"
      ],
      "search": [
         "flag"             : "",
         "action"           : "",
         "db"               : "",
         "title"            : ""
      ]
    ];
    return conf_;
  }
  string[string][string] make_aa() {
    auto make_ = [
      "make": [
        "bold"              : "",
        "breaks"            : "",
        "cover_image"       : "",
        "css"               : "",
        "emphasis"          : "",
        "footer"            : "",
        "headings"          : "",
        "home_button_image" : "",
        "home_button_text"  : "",
        "italics"           : "",
        "num_top"           : "",
        "num_depth"         : "",
        "substitute"        : "",
        "texpdf_font"       : ""
      ]
    ];
    return make_;
  }
  string[string][string] meta_aa() {
    auto meta_ = [
      "classify": [
        "dewey"             : "",
        "keywords"          : "",
        "loc"               : "",
        "subject"           : "",
        "topic_register"    : ""
      ],
      "creator": [
        "author"            : "",
        "author_email"      : "",
        "illustrator"       : "",
        "translator"        : ""
      ],
      "date": [
        "added_to_site"     : "",
        "available"         : "",
        "created"           : "",
        "issued"            : "",
        "modified"          : "",
        "published"         : "",
        "valid"             : ""
      ],
      "identifier": [
        "isbn"              : "",
        "oclc"              : "",
        "pg"                : ""
      ],
      "links": [
        "link"              : ""
      ],
      "notes": [
        "abstract"          : "",
        "description"       : ""
      ],
      "original": [
        "language"          : "",
        "source"            : "",
        "title"             : ""
      ],
      "publisher": [
        "name"              : ""
      ],
      "rights": [
        "copyright"         : "",
        "cover"             : "",
        "illustrations"     : "",
        "license"           : ""
      ],
      "title": [
        "edition"           : "",
        "full"              : "",
        "language"          : "",
        "main"              : "",
        "note"              : "",
        "sub"               : "",
        "subtitle"          : ""
      ]
    ];
    return meta_;
  }
#+END_SRC

** template: metadata associative array indexes                      :header:

#+name: ao_defaults_templates
#+BEGIN_SRC d
  auto pointer_head_main =
    [
      "classify",
      "creator",
      "date",
      "identifier",
      "links",
      "make",             /+ make +/
      "original",
      "notes",
      "rights",
      "title"
    ];
  auto pointer_head_sub_classify =
    [
      "dewey",
      "keywords",
      "loc",
      "subject",
      "topic_register"
    ];
  auto pointer_head_sub_creator =
    [
      "author",
      "author_email",
      "cover",
      "illustrator",
      "translator"
    ];
  auto pointer_head_sub_date =
    [
      "added_to_site",
      "available",
      "created",
      "issued",
      "modified",
      "published",
      "valid"
    ];
  auto pointer_head_sub_identifier =
    [
      "isbn",
      "oclc",
      "pg"
    ];
  /+ make +/
  auto pointer_head_sub_make =
    [
      "cover_image",
      "home_button_image",
      "home_button_text",
      "footer", "headings",
      "num_top", "num_depth",
      "breaks",
      "substitute",
      "bold",
      "italics",
      "emphasis",
      "texpdf_font",
      "css"
    ];
  auto pointer_head_sub_notes =
    [
      "abstract",
      "description"
    ];
  auto pointer_head_sub_original =
    [
      "language",
      "source",
      "title"
    ];
  auto pointer_head_sub_publisher =
    [ "name" ];
  auto pointer_head_sub_rights =
    [
      "copyright",
      "cover",
      "illustrations",
      "license"
    ];
  auto pointer_head_sub_title =
    [
      "edition",
      "full",
      "language",
      "main",
      "note",
      "sub"
    ];
  auto config_jsonstr = `{
  }`;
}
#+END_SRC

*** notes headers

#+name: ao_defaults_templates
#+BEGIN_SRC d
/+
/+
  unify internal representation of header info for native & sdlang document headers
  represent either using struct, hashes or possibly json
  sdp internal representation should be identical for native & sdlang variants
+/
header.
  ├── make                         // make instructions
  │   ├── bold
  │   ├── breaks
  │   ├── cover_image
  │   ├── css
  │   ├── emphasis
  │   ├── footer
  │   ├── headings
  │   ├── home_button_image
  │   ├── home_button_text
  │   ├── italics
  │   ├── num_top
  │   ├── substitute
  │   └── texpdf_font
  └── meta                         // metadata
     ├── author                    // move author to creator:author
     ├── classify
     │   ├── dewey
     │   ├── keyword
     │   ├── loc
     │   ├── subject
     │   └── topic_register
     ├── creator
     │   ├── author
     │   │     ├── [ [first_name: x0, last_name: y0], [first_name: x1, last_name: y1] ]
     │   │     └── [ full_name0, full_name1 ]
     │   ├── author_email
     │   ├── illustrator
     │   └── translator
     ├── date
     │   ├── added_to_site
     │   ├── available
     │   ├── created
     │   ├── issued
     │   ├── modified
     │   ├── published
     │   └── valid
     ├── identifier
     │   ├── isbn
     │   ├── oclc
     │   └── pg
     ├── links
     ├── notes
     │   ├── abstract
     │   └── description
     ├── original
     │   ├── language
     │   ├── source
     │   └── title
     ├── publisher
     │   └── name
     ├── rights
     │   ├── copyright
     │   ├── cover
     │   ├── illustrations
     │   └── license
     └── title                    // move title: to title:main
         ├── edition
         ├── [ full (main + sub) ]
         ├── language
         ├── main
         ├── note
         ├── sub
         └── subtitle              // move title:subtitle to title:sub

61 leaves
+/
#+END_SRC

** template: flags regex initialize                             :regex_flags:

#+name: ao_defaults_templates
#+BEGIN_SRC d
/+ regex flags +/
template SiSUrgxInitFlags() {
  int[string] flags_type_init() {
    int[string] flags_type_init = [
      "make_headings"        : 0,
      "header_make"          : 0,
      "header_meta"          : 0,
      "heading"              : 0,
      "biblio_section"       : 0,
      "glossary_section"     : 0,
      "blurb_section"        : 0,
      "para"                 : 0,
      "blocks"               : 0, // 0..2 generic
      "code"                 : 0, // 0..2
      "poem"                 : 0, // 0..2
      "table"                : 0, // 0..2
      "group"                : 0, // 0..2
      "block"                : 0, // 0..2
      "quote"                : 0, // 0..2
      "verse_new"            : 0,
      "curly_code"           : 0,
      "curly_poem"           : 0,
      "curly_table"          : 0,
      "curly_group"          : 0,
      "curly_block"          : 0,
      "curly_quote"          : 0,
      "tic_code"             : 0,
      "tic_poem"             : 0,
      "tic_table"            : 0,
      "tic_group"            : 0,
      "tic_block"            : 0,
      "tic_quote"            : 0,
      "obj_cite_number_status"           : 0, // 0 obj_cite_number; 1 no obj_cite_number; 2 no obj_cite_number & dummy headings
      "obj_cite_number_status_multi_obj" : 0, // 0 obj_cite_number; 1 no obj_cite_number; 2 no obj_cite_number & dummy headings
      "book_index"           : 0,
    ];
    return flags_type_init;
  }
}
#+END_SRC

** template: bibliography                                            :biblio:

#+name: ao_defaults_templates
#+BEGIN_SRC d
template SiSUbiblio() {
  // required: deemed_author (author || editor); year; fulltitle;
  auto biblio_entry_tags_jsonstr =  `{
    "is"                   : "",
    "sortby_deemed_author_year_title"  : "",
    "deemed_author"                    : "",
    "author_raw"                       : "",
    "author"                           : "",
    "author_arr"                       : [ "" ],
    "editor_raw"                       : "",
    "editor"                           : "",
    "editor_arr"                       : [ "" ],
    "title"                            : "",
    "subtitle"                         : "",
    "fulltitle"                        : "",
    "language"                         : "",
    "trans"                            : "",
    "src"                              : "",
    "journal"                          : "",
    "in"                               : "",
    "volume"                           : "",
    "edition"                          : "",
    "year"                             : "",
    "place"                            : "",
    "publisher"                        : "",
    "url"                              : "",
    "pages"                            : "",
    "note"                             : "",
    "short_name"                       : "",
    "id"                               : ""
  }`; // is: book, article, magazine, newspaper, blog, other
}
#+END_SRC

** template: internal markup                                         :markup:

#+name: ao_defaults_templates
#+BEGIN_SRC d
template InternalMarkup() {
  struct InlineMarkup {
    auto en_a_o = "【";      auto en_a_c = "】";   // endnote en_a_o: '~{'; en_a_c: '}~';
    auto en_b_o = "〖";      auto en_b_c = "〗";   // endnote en_b_o: '~['; en_b_c: ']~';
    auto lnk_o = "┥";        auto lnk_c = "┝";
    auto url_o = "┤";        auto url_c = "├";
    auto nbsp = "░";
    auto br_line = "┘";
    auto br_nl = "┙";
    auto br_paragraph = "┚";
    auto br_obj = "break_obj";
    auto br_page_line = "┼";
    auto br_page = "┿";
    auto br_page_new = "╂";
    string indent_by_spaces_provided(int indent) {
      auto _indent_spaces ="░░";   // auto nbsp = "░";
      _indent_spaces = replicate(_indent_spaces, indent);
      return _indent_spaces;
    }
  }
}
#+END_SRC

* regex ctRegex                                                       :regex:
[[./sdp.org][sdp]]  [[./][org/]]
http://dlang.org/phobos/std_regex.html
- Plain string, in which case it's compiled to bytecode before matching.
- Regex!char (wchar/dchar) that contains a pattern in the form of compiled bytecode.
- StaticRegex!char (wchar/dchar) that contains a pattern in the form of compiled native machine code.

** misc                                                                :misc:

#+name: ao_rgx
#+BEGIN_SRC d
/+ misc +/
static true_dollar                                    = ctRegex!(`\$`, "gm");
static flag_action                                    = ctRegex!(`^(--[a-z][a-z0-9-]+)$`);
static flag_action_str                                = ctRegex!(` (--[a-z][a-z0-9-]+)`);
static within_quotes                                  = ctRegex!(`"(.+?)"`);
static make_heading_delimiter                         = ctRegex!(`[;][ ]*`);
static arr_delimiter                                  = ctRegex!(`[ ]*[;][ ]*`);
static name_delimiter                                 = ctRegex!(`^([^,]+)[ ]*,[ ]+(.+?)$`);
static book_index_go                                  = ctRegex!("([0-9]+)(?:-[0-9]+)?");
static trailing_comma                                 = ctRegex!(",[ ]*$");
static trailing_linebreak                             = ctRegex!(",[ ]{1,2}\\\\\\\\\n[ ]{4}$","m");
static newline_eol_delimiter                          = ctRegex!("\n");
static newline_eol_strip_preceeding                   = ctRegex!("[ ]*\n");
static newline_eol_delimiter_only                     = ctRegex!("^\n");
static line_delimiter_ws_strip                        = ctRegex!("[ ]*\n[ ]*");
static para_delimiter                                 = ctRegex!("\n[ ]*\n+");
static levels_markup                                  = ctRegex!(`^[A-D1-4]$`);
static levels_numbered                                = ctRegex!(`^[0-9]$`);
static levels_numbered_headings                       = ctRegex!(`^[0-7]$`);
#+END_SRC

** filename (and path) matching (including markup insert file) :insert:file:path:filename:

#+name: ao_rgx
#+BEGIN_SRC d
static src_pth                                        = ctRegex!(`^(?P<path>[a-zA-Z0-9._-]+/)*(?P<filename>[a-zA-Z0-9._-]+[.]ss[tm])$`);
static src_fn                                         =
  ctRegex!(`^([a-zA-Z0-9._-]+/)*(?P<fn_src>(?P<fn_base>[a-zA-Z0-9._-]+)[.](?P<fn_src_suffix>ss[tm]))$`);
static src_fn_master                                  = ctRegex!(`^(?P<path>[a-zA-Z0-9._-]+/)*(?P<filename>[a-zA-Z0-9._-]+[.]ssm)$`);
static src_fn_text                                    = ctRegex!(`^(?P<path>[a-zA-Z0-9._-]+/)*(?P<filename>[a-zA-Z0-9._-]+[.]sst)$`);
static src_fn_insert                                  = ctRegex!(`^(?P<path>[a-zA-Z0-9._-]+/)*(?P<filename>[a-zA-Z0-9._-]+[.]ssi)$`);
static src_fn_find_inserts                            = ctRegex!(`^(?P<path>[a-zA-Z0-9._-]+/)*(?P<filename>[a-zA-Z0-9._-]+[.]ss[im])$`);
static insert_src_fn_ssi_or_sst                       = ctRegex!(`^<<\s*(?P<path>[a-zA-Z0-9._-]+/)*(?P<filename>[a-zA-Z0-9._-]+[.]ss[ti])$`);
#+END_SRC

** comments                                                         :comment:

#+name: ao_rgx
#+BEGIN_SRC d
/+ comments +/
static comment                                        = ctRegex!(`^%+ `);
static comments                                       = ctRegex!(`^%+ |^%+$`);
#+END_SRC

** native header                                              :native:header:

#+name: ao_rgx
#+BEGIN_SRC d
/+ header +/
static main_headers                                   =
  ctRegex!(`^(?:creator|title|rights|date|original|classify|identifier|notes|publisher|make|links)$`, "m");
static native_header                                  = ctRegex!(`^@([a-z_]+):(?:\s|$)`);
static native_header_make                             = ctRegex!(`^@(make):(?:\s|$)`);
static native_header_meta                             =
  ctRegex!(`^@(?:creator|title|rights|date|original|classify|identifier|notes|publisher|links):(?:\s|$)`);
static native_header_main                             = ctRegex!(`^@(?P<header>[a-z_]+):\s*(?P<content>.*)`, "m");
static native_header_sub                              = ctRegex!(`^[ ]*:(?P<subheader>[a-z_]+):\s+(?P<content>.+)`, "m");
static native_header_meta_title                       = ctRegex!(`^@title:\s`, "m");
static variable_doc_title                             = ctRegex!(`@title`);
static variable_doc_author                            = ctRegex!(`@author|@creator`);
static raw_author_munge                               = ctRegex!(`(\S.+?),\s+(.+)`,"i");
#+END_SRC

** subheader                                                :native:subheader:

#+name: ao_rgx
#+BEGIN_SRC d
/+ head +/
static native_subhead_creator                         = ctRegex!(`^(?:author|translator|illustrator)$`, "m");
static native_subhead_title                           = ctRegex!(`^(?:main|sub(?:title)?|full|language|edition|note)$`, "m");
static native_subhead_rights                          = ctRegex!(`^(?:copyright|illustrations|license|cover)$`, "m");
static native_subhead_date                            = ctRegex!(`^(?:published|created|issued|available|valid|modified|added_to_site)$`, "m");
static native_subhead_original                        = ctRegex!(`^(?:title|language|source)$`, "m");
static native_subhead_classify                        = ctRegex!(`^(?:topic_register|subject|keywords|loc|dewey)$`, "m");
static native_subhead_identifier                      = ctRegex!(`^(?:oclc|pg|isbn)$`, "m");
static native_subhead_notes                           = ctRegex!(`^(?:abstract|description)$`, "m");
static native_subhead_publisher                       = ctRegex!(`^(?:name)$`, "m");
static native_subhead_make                            = ctRegex!(`^(?:cover_image|home_button_image|home_button_text|footer|headings|num_top|num_depth|breaks|substitute|bold|italics|emphasis|texpdf_font|css)$`, "m");
#+END_SRC

** heading & paragraph operators                         :paragraph:operator:

#+name: ao_rgx
#+BEGIN_SRC d
/+ heading & paragraph operators +/
static heading_a                                      = ctRegex!(`^:?[A][~] `, "m");
static heading                                        = ctRegex!(`^:?([A-D1-4])[~]([a-z0-9_.-]*[?]?)\s+`,"i");
static heading_seg_and_above                          = ctRegex!(`^:?([A-D1])[~]([a-z0-9_.-]*[?]?)\s+`,"i");
static heading_marker                                 = ctRegex!(`^:?([A-D1-4])[~]`);
static heading_anchor_tag                             = ctRegex!(`^:?[A-D1-4][~]([a-z0-9_.-]+) `,"i");
static heading_identify_anchor_tag                    = ctRegex!(`^:?[A-D1-4][~]\s+(?:(?:(?:chapter|article|section|clause)\s+[0-9.]+)|(?:[0-9]+))`,"i");
                                                        // unless dob.obj =~/^:?[A-D1-4]~\s+(?:|(?:chapter|article|section|clause)\s+)([0-9.]+)/i
static heading_extract_named_anchor_tag               = ctRegex!(`^:?[A-D1-4][~]\s+(chapter|article|section|clause)\s+((?:[0-9]+.)*[0-9]+)(?:[.:;, ]|$)`,"i");
static heading_extract_unnamed_anchor_tag             = ctRegex!(`^:?[A-D1-4][~]\s+((?:[0-9]+.)*[0-9]+)(?:[.:;, ]|$)`);
static heading_marker_missing_tag                     = ctRegex!(`^:?([A-D1-4])[~] `);
static heading_title                                  = ctRegex!(`^:?[A-D1-4][~][a-z0-9_.-]*[?]?\s+(.+?)$`);
static heading_all                                    = ctRegex!(`^:?([A-D1-4])[~]([a-z0-9_.-]*[?]?)\s+(.+?)$`); // test, particularly [2] name/hashtag which may or may not be, does this affect title [3]
static heading_backmatter                             = ctRegex!(`^:?1[~][!](glossary|bibliography|biblio|blurb)\s+`,"i");
static heading_biblio                                 = ctRegex!(`^:?(1)[~][!](biblio(?:graphy)?|references?)`);
static heading_glossary                               = ctRegex!(`^:?(1)[~][!](glossary)`);
static heading_blurb                                  = ctRegex!(`^:?(1)[~][!](blurb)`);
static heading_biblio_glossary                        = ctRegex!(`^:?(?:(1)[~][!](?:(?:biblio(?:graphy)?|references?)|glossary)|[A-D1][~])`);
static heading_biblio_blurb                           = ctRegex!(`^:?(?:(1)[~][!](?:(?:biblio(?:graphy)?|references?)|blurb)|[A-D1][~])`);
static heading_blurb_glossary                         = ctRegex!(`^:?(?:(1)[~][!](?:blurb|glossary)|[A-D1][~])`);
static para_bullet                                    = ctRegex!(`^_[*] `);
static para_bullet_indent                             = ctRegex!(`^_([1-9])[*] `);
static para_indent                                    = ctRegex!(`^_([1-9]) `);
static para_indent_hang                               = ctRegex!(`^_([0-9])_([0-9]) `);
static para_attribs                                   = ctRegex!(`^_(([0-9])(_([0-9]))?|_([1-9])?[*]) `);
#+END_SRC

** blocked markup                                                 :block:tic:

#+name: ao_rgx
#+BEGIN_SRC d
/+ blocked markup +/
static block_open                                     = ctRegex!("^((code([.][a-z][0-9a-z_]+)?|poem|group|block|quote|table)[{].*?$)|^`{3} (code([.][a-z][0-9a-z_]+)?|poem|group|block|quote|table)");
static block_poem_open                                = ctRegex!("^((poem[{].*?$)|`{3} poem)");
#+END_SRC

** blocked markup tics                                            :block:tic:

#+name: ao_rgx
#+BEGIN_SRC d
/+ blocked markup tics +/
static block_tic_open                                 = ctRegex!("^`{3} (code([.][a-z][0-9a-z_]+)?|poem|group|block|quote|table)");
static block_tic_code_open                            = ctRegex!("^`{3} (code)([.][a-z][0-9a-z_]+)?");
static block_tic_poem_open                            = ctRegex!("^`{3} (poem)");
static block_tic_group_open                           = ctRegex!("^`{3} (group)");
static block_tic_block_open                           = ctRegex!("^`{3} (block)");
static block_tic_quote_open                           = ctRegex!("^`{3} (quote)");
static block_tic_table_open                           = ctRegex!("^`{3} (table)");
static block_tic_close                                = ctRegex!("^(`{3})$","m");
#+END_SRC

** blocked markup curly                                         :block:curly:

#+name: ao_rgx
#+BEGIN_SRC d
/+ blocked markup curly +/
static block_curly_open                               = ctRegex!(`^((code([.][a-z][0-9a-z_]+)?|poem|group|block|quote|table)[{].*?$)`);
static block_curly_code_open                          = ctRegex!(`^(code([.][a-z][0-9a-z_]+)?[{].*?$)`);
static block_curly_code_close                         = ctRegex!(`^([}]code)`);
static block_curly_poem_open                          = ctRegex!(`^(poem[{].*?$)`);
static block_curly_poem_close                         = ctRegex!(`^([}]poem)`);
static block_curly_group_open                         = ctRegex!(`^(group[{].*?$)`);
static block_curly_group_close                        = ctRegex!(`^([}]group)`);
static block_curly_block_open                         = ctRegex!(`^(block[{].*?$)`);
static block_curly_block_close                        = ctRegex!(`^([}]block)`);
static block_curly_quote_open                         = ctRegex!(`^(quote[{].*?$)`);
static block_curly_quote_close                        = ctRegex!(`^([}]quote)`);
static block_curly_table_open                         = ctRegex!(`^(table[{].*?$)`);
static block_curly_table_close                        = ctRegex!(`^([}]table)`);
#+END_SRC

** inline markup font face mod                             :inline:font:face:

#+name: ao_rgx
#+BEGIN_SRC d
/+ inline markup font face mod +/
static inline_emphasis                                = ctRegex!(`\*\{(?P<text>.+?)\}\*`);
static inline_bold                                    = ctRegex!(`!\{(?P<text>.+?)\}!`);
static inline_italics                                 = ctRegex!(`/\{(?P<text>.+?)\}/`);
static inline_superscript                             = ctRegex!(`\^\{(?P<text>.+?)\}\^`);
static inline_subscript                               = ctRegex!(`,\{(?P<text>.+?)\},`);
static inline_strike                                  = ctRegex!(`-\{(?P<text>.+?)\}-`);
static inline_insert                                  = ctRegex!(`\+\{(?P<text>.+?)\}\+`);
static inline_mono                                    = ctRegex!(`#\{(?P<text>.+?)\}#`);
#+END_SRC

** inline markup footnotes endnotes                                 :inline:footnote:

#+name: ao_rgx
#+BEGIN_SRC d
/+ inline markup footnotes endnotes +/
static inline_notes_curly_gen                         = ctRegex!(`~\{.+?\}~`, "m");
static inline_notes_curly                             = ctRegex!(`~\{\s*(.+?)\}~`, "mg");
static inline_curly_delimiter_open_and_close_regular  = ctRegex!(`~\{\s*|\s*\}~`, "m");
static inline_notes_delimiter_curly_regular           = ctRegex!(`~\{[ ]*(.+?)\}~`, "m");
static inline_notes_curly_sp                          = ctRegex!(`~\{[*+]+\s+(.+?)\}~`, "m");
static inline_notes_curly_sp_asterisk                 = ctRegex!(`~\{[*]+\s+(.+?)\}~`, "m");
static inline_notes_curly_sp_plus                     = ctRegex!(`~\{[+]+\s+(.+?)\}~`, "m");
static inline_note_curly_delimiters                   = ctRegex!(`(~\{[*+]?\s*)(.+?)(\}~)`, "mg");
static inline_notes_square                            = ctRegex!(`~\[\s*(.+?)\]~`, "mg");
static inline_text_and_note_square_sp                 = ctRegex!(`(.+?)~\[[*+]+\s+(.+?)\]~`, "mg");
static inline_text_and_note_square                    = ctRegex!(`(.+?)~\[\s*(.+?)\]~`, "mg");
static inline_note_square_delimiters                  = ctRegex!(`(~\[\s*)(.+?)(\]~)`, "mg");
static inline_curly_delimiter_open_regular            = ctRegex!(`~\{\s*`, "m");
static inline_curly_delimiter_close_regular           = ctRegex!(`\s*\}~`, "m");
static inline_text_and_note_curly                     = ctRegex!(`(?P<text>.+?)(?:(?:[~])[{][*+ ]*)(?P<note>.+?)(?:[}][~])`, "mg");
static note_ref                                       = ctRegex!(`^\S+?noteref_([0-9]+)`, "mg");     // {^{73.}^}#noteref_73
#+END_SRC

** inline (internal program) markup footnotes endnotes                                 :inline:footnote:

#+name: ao_rgx
#+BEGIN_SRC d
/+ inline markup footnotes endnotes +/
static inline_notes_al                                = ctRegex!(`【(?:[*+]\s+|\s*)(.+?)】`, "mg");
static inline_notes_al_gen                            = ctRegex!(`【.+?】`, "m");
static inline_al_delimiter_open_regular               = ctRegex!(`【\s`, "m");
static inline_al_delimiter_open_symbol_star           = ctRegex!(`【[*]\s`, "m");
static inline_al_delimiter_open_symbol_plus           = ctRegex!(`【[+]\s`, "m");
static inline_al_delimiter_close_regular              = ctRegex!(`】`, "m");
static inline_al_delimiter_open_and_close_regular     = ctRegex!(`【|】`, "m");
static inline_notes_delimiter_al_regular              = ctRegex!(`【(.+?)】`, "mg");
static inline_notes_delimiter_al_regular_number_note  = ctRegex!(`【(\d+)\s+(.+?)】`, "mg");
static inline_al_delimiter_open_asterisk              = ctRegex!(`【\*`, "m");
static inline_al_delimiter_open_plus                  = ctRegex!(`【\+`, "m");
static inline_text_and_note_al                        = ctRegex!(`(?P<text>.+?)【(?:[*+ ]*)(?P<note>.+?)】`, "mg");
static inline_text_and_note_al_                       = ctRegex!(`(.+?(?:【[*+]*\s+.+?】|$))`, "mg");
#+END_SRC

** links/ urls                                             :inline:footnote:

#+name: ao_rgx
#+BEGIN_SRC d
static inline_url                                      = ctRegex!(`((?:(?:https?|git):\/\/|\.\.\/|\.\/|#)\S+)`, "mg");
static inline_link_naked_url                           = ctRegex!(`(^|[ ])((?:(?:https?|git):\/\/|\.\.\/|\.\/|#)\S+?)([.,;:?!]?(?:[ ]|$))`, "mg");
static inline_link_markup_regular                      = ctRegex!(`(^|[ ])\{\s*(.+?)\s*\}((?:(?:https?|git):\/\/|\.\.\/|\.\/|#)\S+?)([.,;:?!]?(?:[ ]|$))`, "mg");
static inline_link_endnote_url_helper_punctuated       = ctRegex!(`\{~\^\s+(.+?)\}((?:(?:https?|git):\/\/|\.\.\/|\.\/|#)\S+?)([.,;:?!]?(?:[ ]|$))`, "mg");
static inline_link_endnote_url_helper                  = ctRegex!(`\{~\^\s+(.+?)\}((?:(?:https?|git):\/\/|\.\.\/|\.\/|#)\S+)`, "mg");
static inline_a_url                                    = ctRegex!(`(┤)(\S+?)(├)`, "mg");
#+END_SRC

** inline markup book index                                :inline:bookindex:

#+name: ao_rgx
#+BEGIN_SRC d
/+ inline markup book index +/
static book_index                                     = ctRegex!(`^=\{\s*(.+?)\}$`, "m");
static book_index_open                                = ctRegex!(`^=\{\s*([^}]+?)$`);
static book_index_close                               = ctRegex!(`^(.*?)\}$`, "m"); // strip
#+END_SRC

** no obj_cite_number object                                 :ocn:off:object:

#+name: ao_rgx
#+BEGIN_SRC d
/+ no obj_cite_number object +/
static obj_cite_number_off                            = ctRegex!(`~#$`, "m");
static obj_cite_number_off_dh                         = ctRegex!(`-#$`, "m");
static obj_cite_number_off_all                        = ctRegex!(`[~-]#$`, "m");
#+END_SRC

** no obj_cite_number block                                   :ocn:off:block:

#+name: ao_rgx
#+BEGIN_SRC d
/+ no obj_cite_number block +/
static obj_cite_number_off_block                      = ctRegex!(`^--~#$`);
static obj_cite_number_off_block_dh                   = ctRegex!(`^---#$`);
static obj_cite_number_off_block_close                = ctRegex!(`^--\+#$`);
static obj_cite_number_block_marks                    = ctRegex!(`^--[+~-]#$`);
#+END_SRC

** ignore outside code blocks                                    :block:code:

#+name: ao_rgx
#+BEGIN_SRC d
/+ ignore outside code blocks +/
static skip_from_regular_parse    = ctRegex!(`^(--[+~-]#|-[\\]{2}-|=[.\\]{2}=)$`); // not structural info
#+END_SRC

** line & page breaks                                                 :break:

#+name: ao_rgx
#+BEGIN_SRC d
/+ line & page breaks +/
static break_line_within_object                       = ctRegex!(`[\\]{2}( |$)`);
static break_page                                     = ctRegex!(`^-[\\]{2}-$`);
static break_page_new                                 = ctRegex!(`^=[\\]{2}=$`);
static break_page_line_across                         = ctRegex!(`^=[.]{2}=$`);
static break_string                                   = ctRegex!(`』`);
static parent                                         = ctRegex!(`([0-7]):([0-9]+)`);
#+END_SRC

** json                                                                :json:

#+name: ao_rgx
#+BEGIN_SRC d
/+ json +/
static tailing_comma                                  = ctRegex!(`,$`, "m");
#+END_SRC

** biblio tags                                                  :biblio:tags:

#+name: ao_rgx
#+BEGIN_SRC d
/+ biblio tags +/
static biblio_tags                                    = ctRegex!(`^(is|au|author_raw|author|author_arr|editor_raw|ed|editor_arr|ti|title|subtitle|fulltitle|lng|language|trans|src|jo|journal|in|vol|volume|edn|edition|yr|year|pl|place|pb|pub|publisher|url|pg|pages|note|short_name|id):\s+(.+)`);
static biblio_abbreviations                           = ctRegex!(`^(au|ed|ti|lng|jo|vol|edn|yr|pl|pb|pub|pg|pgs|sn)$`);
#+END_SRC

** bookindex split                                          :bookindex:split:

#+name: ao_rgx
#+BEGIN_SRC d
/+ bookindex split +/
static bi_main_terms_split                            = ctRegex!(`\s*;\s*`);
static bi_main_term_plus_rest_split                   = ctRegex!(`\s*:\s*`);
static bi_sub_terms_plus_obj_cite_number_offset_split = ctRegex!(`\s*\|\s*`);
static bi_term_and_obj_cite_numbers_match             = ctRegex!(`^(.+?)\+(\d+)`);
#+END_SRC

* +set colors for terminal+ (unused)                                  :colors:terminal:

#+name: ao_ansi_colors
#+BEGIN_SRC d
string[string] scr_txt_color = [
  "off"           : "\033[0m",
  "white"         : "\033[37m",
  "white_bold"    : "\033[1m",
  "marker"        : "\033[42m",
  "bold"          : "\033[1m",
  "underline"     : "\033[4m",
  "invert"        : "\033[7m",
  "darkgrey_hi"   : "\033[100m",
  "grey_hi"       : "\033[47m",
  "pink_hi"       : "\033[105m",
  "fuchsia_hi"    : "\033[45m",
  "red_hi"        : "\033[41m",
  "orange_hi"     : "\033[101m",
  "yellow_hi"     : "\033[103m",
  "brown_hi"      : "\033[43m",
  "lightgreen_hi" : "\033[102m",
  "green_hi"      : "\033[42m",
  "cyan_hi"       : "\033[106m",
  "blue_hi"       : "\033[104m",
  "navy_hi"       : "\033[44m",
  "grey"          : "\033[90m",
  "pink"          : "\033[95m",
  "fuchsia"       : "\033[35m",
  "ruby"          : "\033[31m",
  "red"           : "\033[91m",
  "orange"        : "\033[91m",
  "yellow"        : "\033[93m",
  "brown"         : "\033[33m",
  "green"         : "\033[92m",
  "darkgreen"     : "\033[32m",
  "cyan"          : "\033[36m",
  "blue"          : "\033[94m",
  "navy"          : "\033[34m",
  "black"         : "\033[30m"
];
string[string] scr_txt_marker = [
  "white"         : "\033[37m*\033[0m ",
  "bold"          : "\033[1m*\033[0m ",
  "invert"        : "\033[7m*\033[0m ",
  "darkgrey_hi"   : "\033[100m*\033[0m ",
  "grey_hi"       : "\033[47m*\033[0m ",
  "pink_hi"       : "\033[105m*\033[0m ",
  "fuchsia_hi"    : "\033[45m*\033[0m ",
  "red_hi"        : "\033[41m*\033[0m ",
  "orange_hi"     : "\033[101m*\033[0m ",
  "yellow_hi"     : "\033[103m*\033[0m ",
  "brown_hi"      : "\033[43m*\033[0m ",
  "lightgreen_hi" : "\033[102m*\033[0m ",
  "green_hi"      : "\033[42m*\033[0m ",
  "cyan_hi"       : "\033[106m*\033[0m ",
  "blue_hi"       : "\033[104m*\033[0m ",
  "navy_hi"       : "\033[44m*\033[0m ",
  "grey"          : "\033[90m*\033[0m ",
  "pink"          : "\033[95m*\033[0m ",
  "fuchsia"       : "\033[35m*\033[0m ",
  "ruby"          : "\033[31m*\033[0m ",
  "red"           : "\033[91m*\033[0m ",
  "orange"        : "\033[91m*\033[0m ",
  "yellow"        : "\033[93m*\033[0m ",
  "brown"         : "\033[33m*\033[0m ",
  "green"         : "\033[92m*\033[0m ",
  "darkgreen"     : "\033[32m*\033[0m ",
  "cyan"          : "\033[36m*\033[0m ",
  "blue"          : "\033[94m*\033[0m ",
  "navy"          : "\033[34m*\033[0m ",
  "black"         : "\033[30m*\033[0m "
];
#+END_SRC

* tangles (code structure)                                           :tangle:
** defaults:                                              :ao_defaults.d:

#+name: tangle_ao_defaults
#+BEGIN_SRC d :tangle ../src/sdp/ao_defaults.d
/++
  default settings
+/
<<ao_defaults_templates>>
#+END_SRC

** rgx:                                                        :ao_rgx.d:

#+name: tangle_ao_rgx
#+BEGIN_SRC d :tangle ../src/sdp/ao_rgx.d
/++
  regex: regular expressions used in sisu document parser
+/
template RgxInit() {
  struct Rgx {
    <<ao_rgx>>
  }
}
#+END_SRC