x  ="x"
// interactions between !=> and &~ mean that I need to rethink the chartage
// indentation styling...
// literal blocks [[need to ignore bracing]] double-colon style?
// definition -- by prior line indentation, like headings in the original structured text
// tables
// dropcap
// output formats: latex, contex, ps, pdf, html, man, txt, rfc

// escapification
// comment
// math
// image
// figures

// FIXME: these have to go at the top so they have their dropAll bit set before PreSequence.build...
ws      !  = w**
w       !  =  [\r\n\ ]
nw         = ~[\r\n\ ]

//////////////////////////////////////////////////////////////////////////////

s                   = Doc => top

Doc                 = {Header} Body                   /ws => doc
Header              = "header" { kv */ ws }           /ws => header
Body                = Section*/ws                         => body
Section             = { SectionHeader Paragraph* /ws => section }
SectionHeader       = "==" SectionHeaderBody "=="
SectionHeaderBody   =  "=" SectionHeaderBody "="
                    >      ws text ws

sp    !  = " "**
blank    = sp "\n" sp "\n" ws

kv           = word "=" text /ws => kv1
wp !  = w++
num !  = [0-9]++
Paragraph    = { "\"\"" ws  text }  => "blockquote"
             > { "---" "-"*      }  => "hr"
             > { text }             => "p"

onums     !  = nums (". "|") ")
any       !  = ~[]*

uli          = "* "         (ws text &~ any (oli|uli)) => "li"
oli          = ("# "|onums) (ws text &~ any (oli|uli)) => "li"

text         = Item => text
Itemx        = ws Item
             | ()
Item         = blockquote
             > { uli+/ws => "ul" }       Itemx  => []
             | { oli+/ws => "ol" }       Itemx  => []
             > pre                       Itemx  => []
             > structured                Itemx  => []
             > structuredx               Itemx  => []
             > styled                    Itemx  => []
             > qtext                     Itemx  => []
             > (alphanum++ => stringify) Itemx  => []
             > symbol                    Itemx  => []
             > (sym++ => stringify)      Itemx  => []
             > Paragraph                 Itemx  => []

blockquote   = "\"\"" text "\"\""        => "blockquote"
             | "\"\"" block              => "blockquote"
             
qtext        = "\"" text "\""            => "quoted"
pre          = "[verbatim]" { ~[]+ } /ws => "verbatim"   // FIXME doesn't work

styled       = "__" text "__"      => underline
             | "((" text "))"      => footnote
             | ( "[[" text "]]"    => tt
               >  "[" word "]"     => citation
               )
             | "!!" text "!!"      => strikethrough
             | "^^" (word|block)   => superscript
             | ",," (word|block)   => subscript
             | "\\sc" block        => smallcap
             | "**" text "**"      => bold
             | "!" (word|block)    => keyword
             >  "*" text "*"       => it

block   = { text }
structured   = { text } "->" (url|email) => link
              //> alphanum++ "->" (url|email) => link
structuredx   = glyph
              > email
              > url

glyph        = "(r)" | "(c)" | "(tm)" | "--"  // euro symbol?
             | "\\today" -> ~[a-z] => today


// URLs //////////////////////////////////////////////////////////////////////////////

// interesting opportunity to show off boolean grammars here: define other
// subtypes of url (ftp, etc) as conjunctions, but the "master pattern"
// only gets parsed once

urlpath      = urlchar*
username     = [a-zA-Z0-9;/?:&=$\-_.+]++ => stringify
password     = [a-zA-Z0-9;/?:&=$\-_.+]++ => stringify
urlchar      = [a-zA-Z0-9;/?:&=$\-_.+@]
             | "%" [0-9] [0-9]       => "%"
url          = "mailto" ":"   email
             > method "://" url_login? host (":" nums)? ("/" urlpath)?     => "url"
url_login    = username (":" password) "@"                                 => "login"
method       = [+\-.a-z0-9]+ => stringify
domain       = (part +/ ".") -> ~"." => domain
part         = [a-zA-Z0-9\-]++  => stringify
// interesting use of boolean grammars
//            &~ ([\-0-9] ~[]* | ~[]* [\-0-9])

email        = username "@" host -> ~[.] => emailaddr
nums         = [0-9]++ => stringify
host         = nums "." nums "." nums "." nums => "ip"
             | domain



// Tokens ///////////////////////////////////////////////////////////////////

word       = alphanum++ => stringify
           | quoted

quoted     = "\"" ((~[\"\\] | escaped)+) "\""
           | "\"\"" => ""
escaped    = "\\n" => "\n"
           | "\\r" => "\r"
           | "\\" ~[nr]


// Chars ///////////////////////////////////////////////////////////////

alpha      = [a-zA-Z]
//num        = [0-9]
alphanum   = [a-zA-Z0-9]
sym        = ~[a-zA-Z0-9\ \r\n=\">]