path: root/org/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/]]
* 0. ao regex & defaults
** 0. defaults                                                    :defaults:
[[./sdp.org][sdp]] [[./][org/]]

*** 0. defaults:                                                 :defaults:

#+name: tangle_defaults
#+BEGIN_SRC d :tangle ../src/sdp/ao_defaults.d
/++
  default settings
+/
template SiSUregisters() {
  <<ao_defaults_imports>>
  <<ao_defaults_template_registers>>
}
<<ao_defaults_template_init_flags>>
<<ao_defaults_template_node>>
<<ao_defaults_template_biblio>>
<<defaults_template_markup>>
<<defaults_template_language_codes>>
#+END_SRC

*** imports

#+name: ao_defaults_imports
#+BEGIN_SRC d
private import
  std.algorithm,
  std.array,
  std.container,
  std.exception,
  std.file,
  std.getopt,
  std.json,
  std.path,
  std.process,
  std.range,
  std.regex,
  std.stdio,
  std.string,
  std.traits,
  std.typecons,
  std.uni,
  std.utf,
  std.conv : to;
#+END_SRC

*** settings metadata associative array indexes                  :settings:
***** conf associative array

#+name: ao_defaults_template_registers
#+BEGIN_SRC d
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_;
}
#+END_SRC

***** make associative array

#+name: ao_defaults_template_registers
#+BEGIN_SRC d
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_;
}
#+END_SRC

***** meta (metadata) associative array

#+name: ao_defaults_template_registers
#+BEGIN_SRC d
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

*** metadata associative array indexes                             :header:

#+name: ao_defaults_template_registers
#+BEGIN_SRC d
auto ptr_head_main =
  [
    "classify",
    "creator",
    "date",
    "identifier",
    "links",
    "make",             /+ make +/
    "original",
    "notes",
    "rights",
    "title"
  ];
auto ptr_head_sub_classify =
  [
    "dewey",
    "keywords",
    "loc",
    "subject",
    "topic_register"
  ];
auto ptr_head_sub_creator =
  [
    "author",
    "author_email",
    "cover",
    "illustrator",
    "translator"
  ];
auto ptr_head_sub_date =
  [
    "added_to_site",
    "available",
    "created",
    "issued",
    "modified",
    "published",
    "valid"
  ];
auto ptr_head_sub_identifier =
  [
    "isbn",
    "oclc",
    "pg"
  ];
/+ make +/
auto ptr_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 ptr_head_sub_notes =
  [
    "abstract",
    "description"
  ];
auto ptr_head_sub_original =
  [
    "language",
    "source",
    "title"
  ];
auto ptr_head_sub_publisher =
  [ "name" ];
auto ptr_head_sub_rights =
  [
    "copyright",
    "cover",
    "illustrations",
    "license"
  ];
auto ptr_head_sub_title =
  [
    "edition",
    "full",
    "language",
    "main",
    "note",
    "sub"
  ];
auto config_jsonstr = `{
}`;
#+END_SRC

**** notes headers

#+name: ao_defaults_template
#+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_template_init_flags
#+BEGIN_SRC d
template SiSUrgxInitFlags() {
  /+ regex flags +/
  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_group"                : 0,
      "curly_block"                : 0,
      "curly_quote"                : 0,
      "curly_table"                : 0,
      "curly_table_special_markup" : 0,
      "tic_code"                   : 0,
      "tic_poem"                   : 0,
      "tic_group"                  : 0,
      "tic_block"                  : 0,
      "tic_quote"                  : 0,
      "tic_table"                  : 0,
      "ocn_status"                 : 0, // 0 obj_cite_number; 1 no obj_cite_number; 2 no obj_cite_number & dummy headings
      "ocn_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

#+name: ao_defaults_template_node
#+BEGIN_SRC d
template SiSUnode() {
  string[string] node_metadata_heading_str() {
    auto _node = [
        "is"                            : "",
        "ocn"                           : "",
        "marked_up_lev"                 : "",
        "segment_anchor_tag"            : "",
        "attrib"                        : "",
    ];
    return _node;
  }
  int[string] node_metadata_heading_int() {
    auto _node = [
        "ocn"                           : 0,
        "ptr_doc_object"                : 0,
        "ptr_html_segnames"             : 0,
        "ptr_heading"                   : 0,
        "heading_lev_markup"            : 9,
        "heading_lev_collapsed"         : 9,
        "parent_ocn"                    : 0,
        "parent_lev_markup"             : 9,
    ];
    return _node;
  }
  string[string] node_metadata_para_str() {
    auto _node = [
        "is"                            : "",
        "ocn"                           : "",
        "attrib"                        : "",
    ];
    return _node;
  }
  int[string] node_metadata_para_int() {
    auto _node = [
        "ocn"                           : 0,
        "indent_base"                   : 0,
        "indent_hang"                   : 0,
        "bullet"                        : 0, // bool (0|1)
    ];
    return _node;
  }
}
#+END_SRC

*** template: bibliography                                         :biblio:

#+name: ao_defaults_template_biblio
#+BEGIN_SRC d
template SiSUbiblio() {
  // required: deemed_author (author || editor); year; fulltitle;
  struct BibJsnStr {
    auto biblio_entry_tags_jsonstr() {
      string x =  `{
        "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
      return x;
    }
  }
}
#+END_SRC

** 1. 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.

*** 0. rgx code template:                                          :ao_rgx:

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

*** 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!("(?P<link>(?P<ocn>[0-9]+)(?:-[0-9]+)?)");
static book_index_go_scroll                           = ctRegex!("(?P<link>(?P<ocn>[0-9]+)(?:-[0-9]+)?)");
static book_index_go_seg                              = ctRegex!("(?P<link>(?P<ocn>[0-9]+)(?:-[0-9]+)?):(?P<seg>[a-z0-9_-]+)");
static book_index_go_seg_                             = ctRegex!("(?P<link>(?P<ocn>[0-9]+)(?:-[0-9]+)?)(:(?P<seg>[a-z0-9_-]+))?");
static book_index_go_seg_anchorless                   = ctRegex!("(?P<link>(?P<ocn>[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_preceding                    = ctRegex!("[ ]*\n");
static newline_eol_delimiter_only                     = ctRegex!("^\n");
static line_delimiter_ws_strip                        = ctRegex!("[ ]*\n[ ]*");
static para_delimiter                                 = ctRegex!("\n[ ]*\n+");
static table_col_delimiter                            = ctRegex!("[ ]*\n+", "mg");
static table_row_delimiter                            = ctRegex!("\n[ ]*\n+", "mg");
static table_row_delimiter_special                    = ctRegex!("[ ]*\n", "mg"); //
static table_col_delimiter_special                    = ctRegex!("[ ]*[|][ ]*", "mg"); //
static levels_markup                                  = ctRegex!(`^[A-D1-4]$`);
static levels_numbered                                = ctRegex!(`^[0-9]$`);
static levels_numbered_headings                       = ctRegex!(`^[0-7]$`);
static numeric                                        = ctRegex!(`[ 0-9,.-]+`);
static numeric_col                                    = ctRegex!(`^[ 0-9,.$£₤Є€€¥-]+$`);
#+END_SRC

*** comments                                                      :comment:

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

*** native headers
**** 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
**** 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)|^[{]table(~h)?(?P<columns>(?:[ ]+[0-9]+;)+)[}]");
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_]+))?[{]([#]?)\s*$)`);
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)`);
static block_curly_table_special_markup               = ctRegex!(`^[{]table((~h)?(?P<columns>(?:[ ]+[0-9]+;)+))[}]`, "mg"); // sepcial table block markup
#+END_SRC

**** block sub-matches                                       :block:curly:

#+name: ao_rgx
#+BEGIN_SRC d
static table_head_instructions                        = ctRegex!(`(?P<c_heading>h)?(?:[ ]+c(?P<c_num>[0-9]);)?(?P<c_widths>(?:[ ]+[0-9]+[lr]?;)+)`);
static table_col_widths_and_alignment                 = ctRegex!(`(?P<width>[0-9]+)(?P<align>[lr]?)`);
static table_col_widths                               = ctRegex!(`(?P<widths>[0-9]+)`);
static table_col_align                                = ctRegex!(`(?P<align>[lr]?)`);
static table_col_align_match                          = ctRegex!(`(?P<align>[lr])`);
static table_col_separator                            = ctRegex!(`┊`);
static table_col_separator_nl                         = ctRegex!(`[┊]$`, "mg");
#+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_open_symbol_star        = ctRegex!(`~\{[*]\s`, "m"); //
static inline_curly_delimiter_open_symbol_plus        = ctRegex!(`~\{[+]\s`, "m"); //
static inline_curly_delimiter_open_star_or_plus       = ctRegex!(`~\{[+*]`, "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

**** links/ urls                                         :inline:footnote:

#+name: ao_rgx
#+BEGIN_SRC d
static inline_url_generic                              = ctRegex!(`(?:^|[}(\[ ])(?:(?:https?|git):\/\/|¤?\.\.\/|¤?\.\/|¤|#)[a-zA-Z0-9_#]`, "mg");
static inline_url                                      = ctRegex!(`((?:(?:https?|git):\/\/|¤?\.\.\/|¤?\.\/|¤|#)[a-zA-Z0-9_]\S*)`, "mg");
static inline_link_naked_url                           = ctRegex!(`(?P<before>^|[ ])(?P<link>(?:(?:https?|git):\/\/|¤?\.\.\/|¤?\.\/|¤|#)\S+?)(?P<after>[.,;:?!'"]?(?:[ ]|$))`, "mg");
static inline_link_markup_regular                      = ctRegex!(`(?P<before>^|[ ])\{\s*(?P<content>.+?)\s*\}(?P<link>(?:(?:https?|git):\/\/|¤?\.\.\/|¤?\.\/|¤|#)\S+?)(?P<after>[.,;:?!]?(?:[ ]|$))`, "mg");
static inline_link_endnote_url_helper_punctuated       = ctRegex!(`\{~\^\s+(?P<content>.+?)\}(?P<link>(?:(?:https?|git):\/\/|¤?\.\.\/|¤?\.\/|¤|#)\S+?)(?P<after>[.,;:?!]?(?:[ ]|$))`, "mg");
static inline_link_endnote_url_helper                  = ctRegex!(`\{~\^\s+(?P<content>.+?)\}(?P<link>(?:(?:https?|git):\/\/|¤?\.\.\/|¤?\.\/|¤|#)\S+)`, "mg");
#+END_SRC

**** images                                                       :images:

#+name: ao_rgx
#+BEGIN_SRC d
static image                                           = ctRegex!(`([a-zA-Z0-9._-]+?\.(?:png|gif|jpg))`, "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

*** language codes                                         :language:codes:

#+name: ao_rgx
#+BEGIN_SRC d
/+ language codes +/
auto language_codes                                    =
   ctRegex!("(am|bg|bn|br|ca|cs|cy|da|de|el|en|eo|es|et|eu|fi|fr|ga|gl|he|hi|hr|hy|ia|is|it|ja|ko|la|lo|lt|lv|ml|mr|nl|no|nn|oc|pl|pt|pt_BR|ro|ru|sa|se|sk|sl|sq|sr|sv|ta|te|th|tk|tr|uk|ur|vi|zh)");
auto language_code_and_filename                                    =
   ctRegex!("(am|bg|bn|br|ca|cs|cy|da|de|el|en|eo|es|et|eu|fi|fr|ga|gl|he|hi|hr|hy|ia|is|it|ja|ko|la|lo|lt|lv|ml|mr|nl|no|nn|oc|pl|pt|pt_BR|ro|ru|sa|se|sk|sl|sq|sr|sv|ta|te|th|tk|tr|uk|ur|vi|zh)/[A-Za-z0-9._-].+?[.](?:sst|ssm)$");
#+END_SRC

* 1. output regex & defaults
** 0. defaults                                                    :defaults:

*** 0. defaults:                                                 :defaults:

#+name: tangle_defaults
#+BEGIN_SRC d :tangle ../src/sdp/defaults.d
/++
  default settings
+/
<<defaults_template_init_flags>>
<<defaults_template_paths>>
<<defaults_template_markup>>
<<defaults_template_language_codes>>
#+END_SRC

*** imports

#+name: defaults_imports
#+BEGIN_SRC d
private import
  std.algorithm,
  std.array,
  std.container,
  std.exception,
  std.file,
  std.getopt,
  std.json,
  std.path,
  std.process,
  std.range,
  std.regex,
  std.stdio,
  std.string,
  std.traits,
  std.typecons,
  std.uni,
  std.utf,
  std.conv : to;
#+END_SRC


*** TODO template: dir paths                                     :dir:path:

#+name: defaults_template_paths
#+BEGIN_SRC d
template SiSUpaths() {
#+END_SRC

**** base

#+name: defaults_template_paths
#+BEGIN_SRC d
  struct DirPaths {
    string base_filename(string fn_src) {
      return baseName(stripExtension(fn_src));
    }
  }
#+END_SRC

**** sisupod
***** pod

#+name: defaults_template_paths
#+BEGIN_SRC d
  struct SiSUpodPaths {
    string base_filename(string fn_src) {
      return baseName(stripExtension(fn_src));
    }
    string sisupod_filename(string fn_src) {
      return "sisupod".chainPath(base_filename(fn_src) ~ ".zip").array;
    }
    string base(string fn_src) {
      return "sisupod".chainPath(base_filename(fn_src)).array;
    }
  }
#+END_SRC

***** pod zipped

#+name: defaults_template_paths
#+BEGIN_SRC d
  struct SiSUpodPathsZipped {
    auto spod_pths = SiSUpodPaths();
    string base_filename(string fn_src) {
      return spod_pths.base_filename(fn_src);
    }
    string sisupod_filename(string fn_src) {
      return spod_pths.sisupod_filename(fn_src);
    }
    string base(string fn_src) {
      return spod_pths.base(fn_src);
    }
    auto doc_root(string fn_src) {
      return "doc";
    }
    auto doc(string fn_src) {
      return doc_root(fn_src);
    }
    auto doc_lng(string fn_src, string lng) {
      return doc_root(fn_src).chainPath(lng).array;
    }
    auto conf(string fn_src) {
      return doc_root(fn_src).chainPath("_sisu").array;
    }
    auto image(string fn_src) {
      return conf(fn_src).chainPath("image").array;
    }
    auto css(string fn_src) {
      return conf(fn_src).chainPath("css").array;
    }
    auto fn_doc(string fn_src, string lng) {
      return (doc_lng(fn_src, lng)).chainPath(baseName(fn_src)).array;
    }
    auto fn_doc_insert(string fn_src, string fn_insert, string lng) {
      return (doc_lng(fn_src, lng)).chainPath(baseName(fn_insert)).array;
    }
  }
#+END_SRC

***** pod unzipped archive

#+name: defaults_template_paths
#+BEGIN_SRC d
  struct SiSUpodPathsFilesystemArchive {
    auto spod_pths = SiSUpodPaths();
    string base_filename(string fn_src) {
      return spod_pths.base_filename(fn_src);
    }
    string sisupod_filename(string fn_src) {
      return spod_pths.sisupod_filename(fn_src);
    }
    string base(string fn_src) {
      return spod_pths.base(fn_src);
    }
    auto doc_root(string fn_src) {
      return base(fn_src).chainPath("doc").array;
    }
    auto doc(string fn_src) {
      return doc_root(fn_src);
    }
    auto doc_lng(string fn_src, string lng) {
      return doc_root(fn_src).chainPath(lng).array;
    }
    auto conf(string fn_src) {
      return doc_root(fn_src).chainPath("_sisu").array;
    }
    auto image(string fn_src) {
      return conf(fn_src).chainPath("image").array;
    }
    auto css(string fn_src) {
      return conf(fn_src).chainPath("css").array;
    }
    auto fn_doc(string fn_src, string lng) {
      return (doc_lng(fn_src, lng)).chainPath(baseName(fn_src)).array;
    }
    auto fn_doc_insert(string fn_src, string fn_insert, string lng) {
      return (doc_lng(fn_src, lng)).chainPath(baseName(fn_insert)).array;
    }
  }
#+END_SRC

**** html5

#+name: defaults_template_paths
#+BEGIN_SRC d
  struct HtmlPaths {
    string base_filename(string fn_src) {
      return baseName(stripExtension(fn_src));
    }
    string base() {
      return "en".chainPath("html").array;
    }
    string seg(string fn_src) {
      return base.chainPath(base_filename(fn_src)).array;
    }
    string fn_scroll(string fn_src) {
      return base.chainPath(base_filename(fn_src) ~ ".html").array;
    }
    string fn_seg(string fn_src, string seg_filename) {
      return seg(fn_src).chainPath(seg_filename ~ ".html").array;
    }
  }
#+END_SRC

**** epub3

#+name: defaults_template_paths
#+BEGIN_SRC d
  struct Epub3paths {
    string dirtop() {
      return "".chainPath("").array;
    }
    string base_filename(string fn_src) {
      return baseName(stripExtension(fn_src));
    }
    string base() {
      return "en".chainPath("epub3").array;
    }
    string epub_file(string fn_src) {
      return base.chainPath(base_filename(fn_src) ~ ".epub").array;
    }
    string docdir(string fn_src) {
      return base.chainPath(base_filename(fn_src)).array;
    }
    string doc_meta_inf(string fn_src) {
      return dirtop.chainPath("META-INF").array;
    }
    string doc_oebps(string fn_src) {
      return dirtop.chainPath("OEBPS").array;
    }
    string doc_oebps_css(string fn_src) {
      return doc_oebps(fn_src).chainPath("css").array;
    }
    string doc_oebps_image(string fn_src) {
      return doc_oebps(fn_src).chainPath("image").array;
    }
    string fn_mimetypes(string fn_src) {
      return dirtop.chainPath("mimetypes").array;
    }
    string fn_dmi_container_xml(string fn_src) {
      return doc_meta_inf(fn_src).chainPath("container.xml").array;
    }
    string fn_oebps_toc_nav_xhtml(string fn_src) {
      return doc_oebps(fn_src).chainPath("toc_nav.xhtml").array;
    }
    string fn_oebps_toc_ncx(string fn_src) {
      return doc_oebps(fn_src).chainPath("toc.ncx").array;
    }
    string fn_oebps_content_opf(string fn_src) {
      return doc_oebps(fn_src).chainPath("content.opf").array;
    }
    string fn_oebps_content_xhtml(string fn_src, string seg_filename) {
      return doc_oebps(fn_src).chainPath(seg_filename ~ ".xhtml").array;
    }
    debug(epub_output) {
      string dbg_doc_meta_inf(string fn_src) {
        return docdir(fn_src).chainPath("META-INF").array;
      }
      string dbg_doc_oebps(string fn_src) {
        return docdir(fn_src).chainPath("OEBPS").array;
      }
      string dbg_doc_oebps_css(string fn_src) {
        return doc_oebps(fn_src).chainPath("css").array;
      }
      string dbg_doc_oebps_image(string fn_src) {
        return doc_oebps(fn_src).chainPath("image").array;
      }
      string dbg_fn_mimetypes(string fn_src) {
        return docdir(fn_src).chainPath("mimetypes").array;
      }
      string dbg_fn_dmi_container_xml(string fn_src) {
        return doc_meta_inf(fn_src).chainPath("container.xml").array;
      }
      string dbg_fn_oebps_toc_nav_xhtml(string fn_src) {
        return doc_oebps(fn_src).chainPath("toc_nav.xhtml").array;
      }
      string dbg_fn_oebps_toc_ncx(string fn_src) {
        return doc_oebps(fn_src).chainPath("toc.ncx").array;
      }
      string dbg_fn_oebps_content_opf(string fn_src) {
        return doc_oebps(fn_src).chainPath("content.opf").array;
      }
      string dbg_fn_oebps_content_xhtml(string fn_src, string seg_filename) {
        return doc_oebps(fn_src).chainPath(seg_filename ~ ".xhtml").array;
      }
    }
  }
}
#+END_SRC

** 1. 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.

*** 0. code template:                                                 :rgx:

#+name: tangle_ao_rgx
#+BEGIN_SRC d :tangle ../src/sdp/output_rgx.d
/++
  regex: regular expressions used in sisu document parser
+/
template SiSUoutputRgxInit() {
  private import defaults;
  struct Rgx {
    <<prgmkup_rgx>>
    <<sp_ch_xhtml_rgx>>
  }
}
#+END_SRC

*** special characters
**** xhtml special characters

#+name: sp_ch_xhtml_rgx
#+BEGIN_SRC d
static xhtml_ampersand                            = ctRegex!(`[&]`);      // &amp;
static xhtml_less_than                            = ctRegex!(`[<]`);      // &lt;
static xhtml_greater_than                         = ctRegex!(`[>]`);      // &gt;
static xhtml_line_break                           = ctRegex!(` [\\]{2}`); // <br />
#+END_SRC

* 2. defaults shared by ao & output (generic)
** 0. defaults                                                    :defaults:
*** template: internal markup                                      :markup:

#+name: defaults_template_markup
#+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 lnk_o = "⌠";        auto lnk_c = "⌡";     // '⌈' '⌋' '⌠' '⌡' #Mx[:lnk_o= '◁'; Mx[:lnk_c= '▷' #‹ ›
    auto url_o = "┤";        auto url_c = "├";
    auto mark_internal_site_lnk = "¤";
    auto nbsp = "░";
    auto br_line = "┘";                                                    // "╱"; // lB ▌  9612 ┘ ¶
    auto br_nl = "┙";                                                      // "╲"; // lB ▌ 』  ┘
    auto br_paragraph = "┚";                                               // "█"; // FB █  9608 # PP ∥  8741 #▐  #'┘' #'¶' #FB █  9608  lB ▌  9612   RB ▐  9616
    auto br_obj = "break_obj";
    auto br_page_line = "┼";                                              // "▭";
    auto br_page = "┿";                                                   // "┼";
    auto br_page_new = "╂";                                               // "╋";
    auto tc_s = "┊";                                                      // "┴"; //"『"; // "┏" ┓
    auto tc_o = "┏"; //"『"; // "┏" ┓
    auto tc_c = "┚"; // "』"; // "┚"  table row mark #Mx[:tc_c]="』\n"
    auto tc_p = "┆";   // table col/misc mark
    string indent_by_spaces_provided(int indent, string _indent_spaces ="░░") {
      _indent_spaces = replicate(_indent_spaces, indent);
      return _indent_spaces;
    }
    string repeat_character_by_number_provided(C,N)(C _character ="-", N number=10) {
      _character = replicate(_character, number);
      return _character;
    }
  }
}
#+END_SRC

*** template language codes

#+name: defaults_template_language_codes
#+BEGIN_SRC d
template SiSUlanguageCodes() {
  /+ language codes +/
  struct Lang {
    string[string][string] codes() {
      auto _lang_codes = [
        "am":    [ "c": "am",    "n": "Amharic",           "t": "Amharic",                   "xlp": "amharic"      ],
        "bg":    [ "c": "bg",    "n": "Bulgarian",         "t": "Български (Bəlgarski)",     "xlp": "bulgarian"    ],
        "bn":    [ "c": "bn",    "n": "Bengali",           "t": "Bengali",                   "xlp": "bengali"      ],
        "br":    [ "c": "br",    "n": "Breton",            "t": "Breton",                    "xlp": "breton"       ],
        "ca":    [ "c": "ca",    "n": "Catalan",           "t": "catalan",                   "xlp": "catalan"      ],
        "cs":    [ "c": "cs",    "n": "Czech",             "t": "česky",                     "xlp": "czech"        ],
        "cy":    [ "c": "cy",    "n": "Welsh",             "t": "Welsh",                     "xlp": "welsh"        ],
        "da":    [ "c": "da",    "n": "Danish",            "t": "dansk",                     "xlp": "danish"       ],
        "de":    [ "c": "de",    "n": "German",            "t": "Deutsch",                   "xlp": "german"       ],
        "el":    [ "c": "el",    "n": "Greek",             "t": "Ελληνικά (Ellinika)",       "xlp": "greek"        ],
        "en":    [ "c": "en",    "n": "English",           "t": "English",                   "xlp": "english"      ],
        "eo":    [ "c": "eo",    "n": "Esperanto",         "t": "Esperanto",                 "xlp": "esperanto"    ],
        "es":    [ "c": "es",    "n": "Spanish",           "t": "español",                   "xlp": "spanish"      ],
        "et":    [ "c": "et",    "n": "Estonian",          "t": "Estonian",                  "xlp": "estonian"     ],
        "eu":    [ "c": "eu",    "n": "Basque",            "t": "basque",                    "xlp": "basque"       ],
        "fi":    [ "c": "fi",    "n": "Finnish",           "t": "suomi",                     "xlp": "finnish"      ],
        "fr":    [ "c": "fr",    "n": "French",            "t": "français",                  "xlp": "french"       ],
        "ga":    [ "c": "ga",    "n": "Irish",             "t": "Irish",                     "xlp": "irish"        ],
        "gl":    [ "c": "gl",    "n": "Galician",          "t": "Galician",                  "xlp": "galician"     ],
        "he":    [ "c": "he",    "n": "Hebrew",            "t": "Hebrew",                    "xlp": "hebrew"       ],
        "hi":    [ "c": "hi",    "n": "Hindi",             "t": "Hindi",                     "xlp": "hindi"        ],
        "hr":    [ "c": "hr",    "n": "Croatian",          "t": "Croatian",                  "xlp": "croatian"     ],
        "hy":    [ "c": "hy",    "n": "Armenian",          "t": "Armenian",                  "xlp": "armenian"     ],
        "ia":    [ "c": "ia",    "n": "Interlingua",       "t": "Interlingua",               "xlp": "interlingua"  ],
        "is":    [ "c": "is",    "n": "Icelandic",         "t": "Icelandic",                 "xlp": "icelandic"    ],
        "it":    [ "c": "it",    "n": "Italian",           "t": "Italiano",                  "xlp": "italian"      ],
        "ja":    [ "c": "ja",    "n": "Japanese",          "t": "日本語 (Nihongo)",         "xlp": "japanese"      ],
        "ko":    [ "c": "ko",    "n": "Korean",            "t": "Korean",                    "xlp": "korean"       ],
        "la":    [ "c": "la",    "n": "Latin",             "t": "Latin",                     "xlp": "latin"        ],
        "lo":    [ "c": "lo",    "n": "Lao",               "t": "Lao",                       "xlp": "lao"          ],
        "lt":    [ "c": "lt",    "n": "Lithuanian",        "t": "Lithuanian",                "xlp": "lithuanian"   ],
        "lv":    [ "c": "lv",    "n": "Latvian",           "t": "Latvian",                   "xlp": "latvian"      ],
        "ml":    [ "c": "ml",    "n": "Malayalam",         "t": "Malayalam",                 "xlp": "malayalam"    ],
        "mr":    [ "c": "mr",    "n": "Marathi",           "t": "Marathi",                   "xlp": "marathi"      ],
        "nl":    [ "c": "nl",    "n": "Dutch",             "t": "Nederlands",                "xlp": "dutch"        ],
        "no":    [ "c": "no",    "n": "Norwegian",         "t": "norsk",                     "xlp": "norsk"        ],
        "nn":    [ "c": "nn",    "n": "Norwegian Nynorsk", "t": "nynorsk",                   "xlp": "nynorsk"      ],
        "oc":    [ "c": "oc",    "n": "Occitan",           "t": "Occitan",                   "xlp": "occitan"      ],
        "pl":    [ "c": "pl",    "n": "Polish",            "t": "polski",                    "xlp": "polish"       ],
        "pt":    [ "c": "pt",    "n": "Portuguese",        "t": "Português",                 "xlp": "portuges"     ],
        "pt_BR": [ "c": "pt_BR", "n": "Portuguese Brazil", "t": "Brazilian Português",       "xlp": "brazilian"    ],
        "ro":    [ "c": "ro",    "n": "Romanian",          "t": "română",                    "xlp": "romanian"     ],
        "ru":    [ "c": "ru",    "n": "Russian",           "t": "Русский (Russkij)",         "xlp": "russian"      ],
        "sa":    [ "c": "sa",    "n": "Sanskrit",          "t": "Sanskrit",                  "xlp": "sanskrit"     ],
        "se":    [ "c": "se",    "n": "Sami",              "t": "Samin",                     "xlp": "samin"        ],
        "sk":    [ "c": "sk",    "n": "Slovak",            "t": "slovensky",                 "xlp": "slovak"       ],
        "sl":    [ "c": "sl",    "n": "Slovenian",         "t": "Slovenian",                 "xlp": "slovenian"    ],
        "sq":    [ "c": "sq",    "n": "Albanian",          "t": "Albanian",                  "xlp": "albanian"     ],
        "sr":    [ "c": "sr",    "n": "Serbian",           "t": "Serbian",                   "xlp": "serbian"      ],
        "sv":    [ "c": "sv",    "n": "Swedish",           "t": "svenska",                   "xlp": "swedish"      ],
        "ta":    [ "c": "ta",    "n": "Tamil",             "t": "Tamil",                     "xlp": "tamil"        ],
        "te":    [ "c": "te",    "n": "Telugu",            "t": "Telugu",                    "xlp": "telugu"       ],
        "th":    [ "c": "th",    "n": "Thai",              "t": "Thai",                      "xlp": "thai"         ],
        "tk":    [ "c": "tk",    "n": "Turkmen",           "t": "Turkmen",                   "xlp": "turkmen"      ],
        "tr":    [ "c": "tr",    "n": "Turkish",           "t": "Türkçe",                    "xlp": "turkish"      ],
        "uk":    [ "c": "uk",    "n": "Ukranian",          "t": "українська (ukrajins\"ka)", "xlp": "ukrainian"    ],
        "ur":    [ "c": "ur",    "n": "Urdu",              "t": "Urdu",                      "xlp": "urdu"         ],
        "us":    [ "c": "en",    "n": "English (American)","t": "English",                   "xlp": "english"      ],
        "vi":    [ "c": "vi",    "n": "Vietnamese",        "t": "Vietnamese",                "xlp": "vietnamese"   ],
        "zh":    [ "c": "zh",    "n": "Chinese",           "t": "中文",                     "xlp": "chinese"       ],
        "en":    [ "c": "en",    "n": "English",           "t": "English",                   "xlp": "english"      ],
        "xx":    [ "c": "xx",    "n": "Default",           "t": "English",                   "xlp": "english"      ],
      ];
      return _lang_codes;
    }
    string[] code_arr_ptr() {
      auto _lang_codes = ["am", "bg", "bn", "br", "ca", "cs", "cy", "da", "de", "el", "en", "eo", "es", "et", "eu", "fi", "fr", "ga", "gl", "he", "hi", "hr", "hy", "ia", "is", "it", "ja", "ko", "la", "lo", "lt", "lv", "ml", "mr", "nl", "no", "nn", "oc", "pl", "pt", "pt_BR", "ro", "ru", "sa", "se", "sk", "sl", "sq", "sr", "sv", "ta", "te", "th", "tk", "tr", "uk", "ur", "us", "vi", "zh", "en", "xx",];
      return _lang_codes;
    }
    string[] code_arr() {
      auto _lang_codes = ["am", "bg", "bn", "br", "ca", "cs", "cy", "da", "de", "el", "en", "eo", "es", "et", "eu", "fi", "fr", "ga", "gl", "he", "hi", "hr", "hy", "ia", "is", "it", "ja", "ko", "la", "lo", "lt", "lv", "ml", "mr", "nl", "no", "nn", "oc", "pl", "pt", "pt_BR", "ro", "ru", "sa", "se", "sk", "sl", "sq", "sr", "sv", "ta", "te", "th", "tk", "tr", "uk", "ur", "vi", "zh"];
      return _lang_codes;
    }
    auto codes_() {
      return "(" ~ join(code_arr,"|") ~ ")";
    }
    auto codes_regex() {
      return regex(codes_);
    }
  }
}
#+END_SRC

** 1. ctRegex                                                        :regex:

*** misc generic

#+name: prgmkup_rgx
#+BEGIN_SRC d
static newline                                        = ctRegex!("\n", "mg");
static strip_br                                       = ctRegex!("^<br>\n|<br>\n*$");
static space                                          = ctRegex!(`[ ]`, "mg");
static spaces_line_start                              = ctRegex!(`^(?P<opening_spaces>[ ]+)`, "mg");
static spaces_multiple                                = ctRegex!(`(?P<multiple_spaces>[ ]{2,})`, "mg"); // could be issues for endnotes
static two_spaces                                     = ctRegex!(`[ ]{2}`, "mg");
static nbsp_char                                      = ctRegex!(`░`, "mg");
static nbsp_chars_line_start                          = ctRegex!(`^░+`, "mg");
static nbsp_and_space                                 = ctRegex!(`&nbsp;[ ]`, "mg");
static nbsp_char_and_space                            = ctRegex!(`░[ ]`, "mg");
#+END_SRC

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

#+name: prgmkup_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

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

#+name: prgmkup_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

**** inline links

#+name: prgmkup_rgx
#+BEGIN_SRC d
/+ inline markup footnotes endnotes +/
static inline_link                                    = ctRegex!(`┥(.+?)┝┤(.+?)├`, "mg");
static inline_a_url                                   = ctRegex!(`(┤)(\S+?)(├)`, "mg");
static fn_suffix                                      = ctRegex!(`\.fnSuffix`, "mg");
static inline_link_fn_suffix                          = ctRegex!(`¤(.+?)(\.fnSuffix)`, "mg");
static inline_seg_link                                = ctRegex!(`(¤)(?:.+?)\.fnSuffix`, "mg");
static mark_internal_site_lnk                         = ctRegex!(`¤`, "mg");
#+END_SRC

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

#+name: prgmkup_rgx
#+BEGIN_SRC d
/+ inline markup font face mod +/
static inline_faces                                   = ctRegex!(`(?P<markup>(?P<mod>[*!_^,+#-])\{(?P<text>.+?)\}[*!_^,+#-])`, "mg");
static inline_emphasis                                = ctRegex!(`\*\{(?P<text>.+?)\}\*`, "mg");
static inline_bold                                    = ctRegex!(`!\{(?P<text>.+?)\}!`, "mg");
static inline_underscore                              = ctRegex!(`_\{(?P<text>.+?)\}_`, "mg");
static inline_italics                                 = ctRegex!(`/\{(?P<text>.+?)\}/`, "mg");
static inline_superscript                             = ctRegex!(`\^\{(?P<text>.+?)\}\^`, "mg");
static inline_subscript                               = ctRegex!(`,\{(?P<text>.+?)\},`, "mg");
static inline_strike                                  = ctRegex!(`-\{(?P<text>.+?)\}-`, "mg");
static inline_insert                                  = ctRegex!(`\+\{(?P<text>.+?)\}\+`, "mg");
static inline_mono                                    = ctRegex!(`#\{(?P<text>.+?)\}#`, "mg");
static inline_cite                                    = ctRegex!(`"\{(?P<text>.+?)\}"`, "mg");
static inline_faces_line                              = ctRegex!(`^[*!/_]_ (?P<text>.+?)((?: [\\]{2}|[~]#){0,2}$)`);
static inline_emphasis_line                           = ctRegex!(`^\*_ (?P<text>.+?)((?: [\\]{2}|[~]#){0,2}$)`);
static inline_bold_line                               = ctRegex!(`^!_ (?P<text>.+?)((?: [\\]{2}|[~]#){0,2}$)`);
static inline_italics_line                            = ctRegex!(`^/_ (?P<text>.+?)((?: [\\]{2}|[~]#){0,2}$)`);
static inline_underscore_line                         = ctRegex!(`^__ (?P<text>.+?)((?: [\\]{2}|[~]#){0,2}$)`);
#+END_SRC

**** table related

#+name: prgmkup_rgx
#+BEGIN_SRC d
/+ table delimiters +/
static table_delimiter_col                           = ctRegex!("[ ]*[┊][ ]*", "mg"); //
static table_delimiter_row                           = ctRegex!("[ ]*\n", "mg"); //
#+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