From 9b92dd173f5e6fb58d58417faa2015500b1b037b Mon Sep 17 00:00:00 2001
From: Caleb Maclennan <caleb@alerque.com>
Date: Tue, 3 Oct 2023 02:59:04 +0300
Subject: [PATCH] feat(core): Add vendored lunamark fork removed from SILE
 upstream

---
 lua-libraries/LICENSE-lunamark             |   20 +
 lua-libraries/lunamark.lua                 |   94 ++
 lua-libraries/lunamark/entities.lua        |  282 +++++
 lua-libraries/lunamark/reader.lua          |   20 +
 lua-libraries/lunamark/reader/markdown.lua | 1172 ++++++++++++++++++++
 lua-libraries/lunamark/util.lua            |  228 ++++
 lua-libraries/lunamark/writer.lua          |   20 +
 lua-libraries/lunamark/writer/ast.lua      |   73 ++
 lua-libraries/lunamark/writer/context.lua  |  194 ++++
 lua-libraries/lunamark/writer/docbook.lua  |  152 +++
 lua-libraries/lunamark/writer/dzslides.lua |  368 ++++++
 lua-libraries/lunamark/writer/generic.lua  |  294 +++++
 lua-libraries/lunamark/writer/groff.lua    |   81 ++
 lua-libraries/lunamark/writer/html.lua     |  191 ++++
 lua-libraries/lunamark/writer/html5.lua    |   37 +
 lua-libraries/lunamark/writer/latex.lua    |  260 +++++
 lua-libraries/lunamark/writer/man.lua      |  130 +++
 lua-libraries/lunamark/writer/tex.lua      |   89 ++
 lua-libraries/lunamark/writer/xml.lua      |   60 +
 19 files changed, 3765 insertions(+)
 create mode 100644 lua-libraries/LICENSE-lunamark
 create mode 100644 lua-libraries/lunamark.lua
 create mode 100644 lua-libraries/lunamark/entities.lua
 create mode 100644 lua-libraries/lunamark/reader.lua
 create mode 100644 lua-libraries/lunamark/reader/markdown.lua
 create mode 100644 lua-libraries/lunamark/util.lua
 create mode 100644 lua-libraries/lunamark/writer.lua
 create mode 100644 lua-libraries/lunamark/writer/ast.lua
 create mode 100644 lua-libraries/lunamark/writer/context.lua
 create mode 100644 lua-libraries/lunamark/writer/docbook.lua
 create mode 100644 lua-libraries/lunamark/writer/dzslides.lua
 create mode 100644 lua-libraries/lunamark/writer/generic.lua
 create mode 100644 lua-libraries/lunamark/writer/groff.lua
 create mode 100644 lua-libraries/lunamark/writer/html.lua
 create mode 100644 lua-libraries/lunamark/writer/html5.lua
 create mode 100644 lua-libraries/lunamark/writer/latex.lua
 create mode 100644 lua-libraries/lunamark/writer/man.lua
 create mode 100644 lua-libraries/lunamark/writer/tex.lua
 create mode 100644 lua-libraries/lunamark/writer/xml.lua

diff --git a/lua-libraries/LICENSE-lunamark b/lua-libraries/LICENSE-lunamark
new file mode 100644
index 00000000..48d92db4
--- /dev/null
+++ b/lua-libraries/LICENSE-lunamark
@@ -0,0 +1,20 @@
+Copyright (C) 2009-2016 John MacFarlane
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
\ No newline at end of file
diff --git a/lua-libraries/lunamark.lua b/lua-libraries/lunamark.lua
new file mode 100644
index 00000000..cf8344ec
--- /dev/null
+++ b/lua-libraries/lunamark.lua
@@ -0,0 +1,94 @@
+-- (c) 2009-2011 John MacFarlane.  Released under MIT license.
+-- See the file LICENSE in the source for details.
+
+--- Copyright &copy; 2009-2011 John MacFarlane.
+--
+-- Released under the MIT license (see LICENSE in the source for details).
+--
+-- ## Description
+--
+-- Lunamark is a lua library for conversion of markdown to
+-- other textual formats. Currently HTML, Docbook, ConTeXt,
+-- LaTeX, and Groff man are the supported output formats,
+-- but lunamark's modular architecture makes it easy to add
+-- writers and modify the markdown parser (written with a PEG
+-- grammar).
+--
+-- Lunamark's markdown parser currently supports the following
+-- extensions (which can be turned on or off individually):
+--
+--   - Smart typography (fancy quotes, dashes, ellipses)
+--   - Significant start numbers in ordered lists
+--   - Footnotes
+--   - Definition lists
+--
+-- More extensions will be supported in later versions.
+--
+-- The library is as portable as lua and has very good performance.
+-- It is about as fast as the author's own C library
+-- [peg-markdown](http://github.com/jgm/peg-markdown).
+--
+-- ## Simple usage example
+--
+--     local lunamark = require("lunamark")
+--     local writer = lunamark.writer.html.new()
+--     local parse = lunamark.reader.markdown.new(writer, { smart = true })
+--     local result, metadata = parse("Here's 'my *text*'...")
+--     print(result)
+--     assert(result == 'Here’s ‘my <em>text</em>’…')
+--
+-- ## Customizing the writer
+--
+-- Render emphasized text using `<u>` tags rather than `<em>`.
+--
+--     local unicode = require("unicode")
+--     function writer.emphasis(s)
+--       return {"<u>",s,"</u>"}
+--     end
+--     local parse = lunamark.reader.markdown.new(writer, { smart = true })
+--     local result, metadata = parse("*Beiß* nicht in die Hand, die dich *füttert*.")
+--     print(result)
+--     assert(result == '<u>Beiß</u> nicht in die Hand, die dich <u>füttert</u>.')
+--
+-- Eliminate hyperlinks:
+--
+--     function writer.link(lab,url,tit)
+--       return lab
+--     end
+--     local parse = lunamark.reader.markdown.new(writer, { smart = true })
+--     local result, metadata = parse("[hi](/url) there")
+--     print(result)
+--     assert(result == 'hi there')
+--
+-- ## Customizing the parser
+--
+-- Parse CamelCase words as wikilinks:
+--
+--     lpeg = require("lpeg")
+--     local writer = lunamark.writer.html.new()
+--     function add_wikilinks(syntax)
+--       local capword = lpeg.R("AZ")^1 * lpeg.R("az")^1
+--       local parse_wikilink = lpeg.C(capword^2)
+--                            / function(wikipage)
+--                                return writer.link(writer.string(wikipage),
+--                                                   "/" .. wikipage,
+--                                                   "Go to " .. wikipage)
+--                              end
+--       syntax.Inline = parse_wikilink + syntax.Inline
+--       return syntax
+--     end
+--     local parse = lunamark.reader.markdown.new(writer, { alter_syntax = add_wikilinks })
+--     local result, metadata = parse("My text with WikiLinks.\n")
+--     print(result)
+--     assert(result == 'My text with <a href="/WikiLinks" title="Go to WikiLinks">WikiLinks</a>.')
+--
+
+local G = {}
+
+setmetatable(G,{ __index = function(t,name)
+                             local mod = require("lunamark." .. name)
+                             rawset(t,name,mod)
+                             return t[name]
+                            end })
+
+return G
diff --git a/lua-libraries/lunamark/entities.lua b/lua-libraries/lunamark/entities.lua
new file mode 100644
index 00000000..420d8b0c
--- /dev/null
+++ b/lua-libraries/lunamark/entities.lua
@@ -0,0 +1,282 @@
+-- (c) 2009-2011 John MacFarlane.  Released under MIT license.
+-- See the file LICENSE in the source for details.
+
+--- Functions for dealing with HTML/XML entities.
+
+local M = {}
+
+local luautf8=require("lua-utf8")
+utf8_char = luautf8.char
+
+local character_entities = {
+  ["quot"] = 0x0022,
+  ["amp"] = 0x0026,
+  ["apos"] = 0x0027,
+  ["lt"] = 0x003C,
+  ["gt"] = 0x003E,
+  ["nbsp"] = 160,
+  ["iexcl"] = 0x00A1,
+  ["cent"] = 0x00A2,
+  ["pound"] = 0x00A3,
+  ["curren"] = 0x00A4,
+  ["yen"] = 0x00A5,
+  ["brvbar"] = 0x00A6,
+  ["sect"] = 0x00A7,
+  ["uml"] = 0x00A8,
+  ["copy"] = 0x00A9,
+  ["ordf"] = 0x00AA,
+  ["laquo"] = 0x00AB,
+  ["not"] = 0x00AC,
+  ["shy"] = 173,
+  ["reg"] = 0x00AE,
+  ["macr"] = 0x00AF,
+  ["deg"] = 0x00B0,
+  ["plusmn"] = 0x00B1,
+  ["sup2"] = 0x00B2,
+  ["sup3"] = 0x00B3,
+  ["acute"] = 0x00B4,
+  ["micro"] = 0x00B5,
+  ["para"] = 0x00B6,
+  ["middot"] = 0x00B7,
+  ["cedil"] = 0x00B8,
+  ["sup1"] = 0x00B9,
+  ["ordm"] = 0x00BA,
+  ["raquo"] = 0x00BB,
+  ["frac14"] = 0x00BC,
+  ["frac12"] = 0x00BD,
+  ["frac34"] = 0x00BE,
+  ["iquest"] = 0x00BF,
+  ["Agrave"] = 0x00C0,
+  ["Aacute"] = 0x00C1,
+  ["Acirc"] = 0x00C2,
+  ["Atilde"] = 0x00C3,
+  ["Auml"] = 0x00C4,
+  ["Aring"] = 0x00C5,
+  ["AElig"] = 0x00C6,
+  ["Ccedil"] = 0x00C7,
+  ["Egrave"] = 0x00C8,
+  ["Eacute"] = 0x00C9,
+  ["Ecirc"] = 0x00CA,
+  ["Euml"] = 0x00CB,
+  ["Igrave"] = 0x00CC,
+  ["Iacute"] = 0x00CD,
+  ["Icirc"] = 0x00CE,
+  ["Iuml"] = 0x00CF,
+  ["ETH"] = 0x00D0,
+  ["Ntilde"] = 0x00D1,
+  ["Ograve"] = 0x00D2,
+  ["Oacute"] = 0x00D3,
+  ["Ocirc"] = 0x00D4,
+  ["Otilde"] = 0x00D5,
+  ["Ouml"] = 0x00D6,
+  ["times"] = 0x00D7,
+  ["Oslash"] = 0x00D8,
+  ["Ugrave"] = 0x00D9,
+  ["Uacute"] = 0x00DA,
+  ["Ucirc"] = 0x00DB,
+  ["Uuml"] = 0x00DC,
+  ["Yacute"] = 0x00DD,
+  ["THORN"] = 0x00DE,
+  ["szlig"] = 0x00DF,
+  ["agrave"] = 0x00E0,
+  ["aacute"] = 0x00E1,
+  ["acirc"] = 0x00E2,
+  ["atilde"] = 0x00E3,
+  ["auml"] = 0x00E4,
+  ["aring"] = 0x00E5,
+  ["aelig"] = 0x00E6,
+  ["ccedil"] = 0x00E7,
+  ["egrave"] = 0x00E8,
+  ["eacute"] = 0x00E9,
+  ["ecirc"] = 0x00EA,
+  ["euml"] = 0x00EB,
+  ["igrave"] = 0x00EC,
+  ["iacute"] = 0x00ED,
+  ["icirc"] = 0x00EE,
+  ["iuml"] = 0x00EF,
+  ["eth"] = 0x00F0,
+  ["ntilde"] = 0x00F1,
+  ["ograve"] = 0x00F2,
+  ["oacute"] = 0x00F3,
+  ["ocirc"] = 0x00F4,
+  ["otilde"] = 0x00F5,
+  ["ouml"] = 0x00F6,
+  ["divide"] = 0x00F7,
+  ["oslash"] = 0x00F8,
+  ["ugrave"] = 0x00F9,
+  ["uacute"] = 0x00FA,
+  ["ucirc"] = 0x00FB,
+  ["uuml"] = 0x00FC,
+  ["yacute"] = 0x00FD,
+  ["thorn"] = 0x00FE,
+  ["yuml"] = 0x00FF,
+  ["OElig"] = 0x0152,
+  ["oelig"] = 0x0153,
+  ["Scaron"] = 0x0160,
+  ["scaron"] = 0x0161,
+  ["Yuml"] = 0x0178,
+  ["fnof"] = 0x0192,
+  ["circ"] = 0x02C6,
+  ["tilde"] = 0x02DC,
+  ["Alpha"] = 0x0391,
+  ["Beta"] = 0x0392,
+  ["Gamma"] = 0x0393,
+  ["Delta"] = 0x0394,
+  ["Epsilon"] = 0x0395,
+  ["Zeta"] = 0x0396,
+  ["Eta"] = 0x0397,
+  ["Theta"] = 0x0398,
+  ["Iota"] = 0x0399,
+  ["Kappa"] = 0x039A,
+  ["Lambda"] = 0x039B,
+  ["Mu"] = 0x039C,
+  ["Nu"] = 0x039D,
+  ["Xi"] = 0x039E,
+  ["Omicron"] = 0x039F,
+  ["Pi"] = 0x03A0,
+  ["Rho"] = 0x03A1,
+  ["Sigma"] = 0x03A3,
+  ["Tau"] = 0x03A4,
+  ["Upsilon"] = 0x03A5,
+  ["Phi"] = 0x03A6,
+  ["Chi"] = 0x03A7,
+  ["Psi"] = 0x03A8,
+  ["Omega"] = 0x03A9,
+  ["alpha"] = 0x03B1,
+  ["beta"] = 0x03B2,
+  ["gamma"] = 0x03B3,
+  ["delta"] = 0x03B4,
+  ["epsilon"] = 0x03B5,
+  ["zeta"] = 0x03B6,
+  ["eta"] = 0x03B7,
+  ["theta"] = 0x03B8,
+  ["iota"] = 0x03B9,
+  ["kappa"] = 0x03BA,
+  ["lambda"] = 0x03BB,
+  ["mu"] = 0x03BC,
+  ["nu"] = 0x03BD,
+  ["xi"] = 0x03BE,
+  ["omicron"] = 0x03BF,
+  ["pi"] = 0x03C0,
+  ["rho"] = 0x03C1,
+  ["sigmaf"] = 0x03C2,
+  ["sigma"] = 0x03C3,
+  ["tau"] = 0x03C4,
+  ["upsilon"] = 0x03C5,
+  ["phi"] = 0x03C6,
+  ["chi"] = 0x03C7,
+  ["psi"] = 0x03C8,
+  ["omega"] = 0x03C9,
+  ["thetasym"] = 0x03D1,
+  ["upsih"] = 0x03D2,
+  ["piv"] = 0x03D6,
+  ["ensp"] = 0x2002,
+  ["emsp"] = 0x2003,
+  ["thinsp"] = 0x2009,
+  ["ndash"] = 0x2013,
+  ["mdash"] = 0x2014,
+  ["lsquo"] = 0x2018,
+  ["rsquo"] = 0x2019,
+  ["sbquo"] = 0x201A,
+  ["ldquo"] = 0x201C,
+  ["rdquo"] = 0x201D,
+  ["bdquo"] = 0x201E,
+  ["dagger"] = 0x2020,
+  ["Dagger"] = 0x2021,
+  ["bull"] = 0x2022,
+  ["hellip"] = 0x2026,
+  ["permil"] = 0x2030,
+  ["prime"] = 0x2032,
+  ["Prime"] = 0x2033,
+  ["lsaquo"] = 0x2039,
+  ["rsaquo"] = 0x203A,
+  ["oline"] = 0x203E,
+  ["frasl"] = 0x2044,
+  ["euro"] = 0x20AC,
+  ["image"] = 0x2111,
+  ["weierp"] = 0x2118,
+  ["real"] = 0x211C,
+  ["trade"] = 0x2122,
+  ["alefsym"] = 0x2135,
+  ["larr"] = 0x2190,
+  ["uarr"] = 0x2191,
+  ["rarr"] = 0x2192,
+  ["darr"] = 0x2193,
+  ["harr"] = 0x2194,
+  ["crarr"] = 0x21B5,
+  ["lArr"] = 0x21D0,
+  ["uArr"] = 0x21D1,
+  ["rArr"] = 0x21D2,
+  ["dArr"] = 0x21D3,
+  ["hArr"] = 0x21D4,
+  ["forall"] = 0x2200,
+  ["part"] = 0x2202,
+  ["exist"] = 0x2203,
+  ["empty"] = 0x2205,
+  ["nabla"] = 0x2207,
+  ["isin"] = 0x2208,
+  ["notin"] = 0x2209,
+  ["ni"] = 0x220B,
+  ["prod"] = 0x220F,
+  ["sum"] = 0x2211,
+  ["minus"] = 0x2212,
+  ["lowast"] = 0x2217,
+  ["radic"] = 0x221A,
+  ["prop"] = 0x221D,
+  ["infin"] = 0x221E,
+  ["ang"] = 0x2220,
+  ["and"] = 0x2227,
+  ["or"] = 0x2228,
+  ["cap"] = 0x2229,
+  ["cup"] = 0x222A,
+  ["int"] = 0x222B,
+  ["there4"] = 0x2234,
+  ["sim"] = 0x223C,
+  ["cong"] = 0x2245,
+  ["asymp"] = 0x2248,
+  ["ne"] = 0x2260,
+  ["equiv"] = 0x2261,
+  ["le"] = 0x2264,
+  ["ge"] = 0x2265,
+  ["sub"] = 0x2282,
+  ["sup"] = 0x2283,
+  ["nsub"] = 0x2284,
+  ["sube"] = 0x2286,
+  ["supe"] = 0x2287,
+  ["oplus"] = 0x2295,
+  ["otimes"] = 0x2297,
+  ["perp"] = 0x22A5,
+  ["sdot"] = 0x22C5,
+  ["lceil"] = 0x2308,
+  ["rceil"] = 0x2309,
+  ["lfloor"] = 0x230A,
+  ["rfloor"] = 0x230B,
+  ["lang"] = 0x27E8,
+  ["rang"] = 0x27E9,
+  ["loz"] = 0x25CA,
+  ["spades"] = 0x2660,
+  ["clubs"] = 0x2663,
+  ["hearts"] = 0x2665,
+  ["diams"] = 0x2666,
+}
+
+--- Given a string of decimal digits, returns a UTF-8 encoded
+-- string encoding a unicode character.
+function M.dec_entity(s)
+  return utf8_char(tonumber(s))
+end
+
+--- Given a string of hexadecimal digits, returns a UTF-8 encoded
+-- string encoding a unicode character.
+function M.hex_entity(s)
+  return utf8_char(tonumber("0x"..s))
+end
+
+--- Given a character entity name (like `ouml`), returns a UTF-8 encoded
+-- string encoding a unicode character.
+function M.char_entity(s)
+  local n = character_entities[s]
+  return utf8_char(n)
+end
+
+return M
diff --git a/lua-libraries/lunamark/reader.lua b/lua-libraries/lunamark/reader.lua
new file mode 100644
index 00000000..2ee5d0c0
--- /dev/null
+++ b/lua-libraries/lunamark/reader.lua
@@ -0,0 +1,20 @@
+-- (c) 2009-2011 John MacFarlane.  Released under MIT license.
+-- See the file LICENSE in the source for details.
+
+--- Provides access to all lunamark readers without preloading
+-- them.  Reader modules are loaded only when needed.
+--
+--     local readers = require("lunamark.reader")
+--     local htmlreader = readers.html       -- html reader loaded now
+--     local myformat = 'markdown'
+--     local myreader = readers[myformat]    -- markdown reader loaded now
+
+local G = {}
+
+setmetatable(G,{ __index = function(t,name)
+                             local mod = require("lunamark.reader." .. name)
+                             rawset(t,name,mod)
+                             return t[name]
+                            end })
+
+return G
diff --git a/lua-libraries/lunamark/reader/markdown.lua b/lua-libraries/lunamark/reader/markdown.lua
new file mode 100644
index 00000000..d829b591
--- /dev/null
+++ b/lua-libraries/lunamark/reader/markdown.lua
@@ -0,0 +1,1172 @@
+-- (c) 2009-2011 John MacFarlane, Hans Hagen.  Released under MIT license.
+-- See the file LICENSE in the source for details.
+
+local util = require("lunamark.util")
+local lpeg = require("lpeg")
+local entities = require("lunamark.entities")
+local lower, upper, gsub, format, length =
+  string.lower, string.upper, string.gsub, string.format, string.len
+local P, R, S, V, C, Cg, Cb, Cmt, Cc, Ct, B, Cs =
+  lpeg.P, lpeg.R, lpeg.S, lpeg.V, lpeg.C, lpeg.Cg, lpeg.Cb,
+  lpeg.Cmt, lpeg.Cc, lpeg.Ct, lpeg.B, lpeg.Cs
+local lpegmatch = lpeg.match
+local expand_tabs_in_line = util.expand_tabs_in_line
+local luautf8 = require("lua-utf8")
+
+local M = {}
+
+local rope_to_string = util.rope_to_string
+
+-- Normalize a markdown reference tag.  (Make lowercase, and collapse
+-- adjacent whitespace characters.)
+local function normalize_tag(tag)
+  return luautf8.lower(gsub(rope_to_string(tag), "[ \n\r\t]+", " "))
+end
+
+------------------------------------------------------------------------------
+-- Character parsers
+------------------------------------------------------------------------------
+
+local percent                = P("%")
+local at                     = P("@")
+local comma                  = P(",")
+local asterisk               = P("*")
+local dash                   = P("-")
+local plus                   = P("+")
+local underscore             = P("_")
+local period                 = P(".")
+local hash                   = P("#")
+local ampersand              = P("&")
+local backtick               = P("`")
+local less                   = P("<")
+local more                   = P(">")
+local space                  = P(" ")
+local squote                 = P("'")
+local dquote                 = P('"')
+local lparent                = P("(")
+local rparent                = P(")")
+local lbracket               = P("[")
+local rbracket               = P("]")
+local circumflex             = P("^")
+local slash                  = P("/")
+local equal                  = P("=")
+local colon                  = P(":")
+local semicolon              = P(";")
+local exclamation            = P("!")
+local tilde                  = P("~")
+local tab                    = P("\t")
+local newline                = P("\n")
+local tightblocksep          = P("\001")
+
+--- Create a new markdown parser.
+--
+-- *   `writer` is a writer table (see [lunamark.writer.generic]).
+--
+-- *   `options` is a table with parsing options.
+--     The following fields are significant:
+--
+--     `alter_syntax`
+--     :   Function from syntax table to syntax table,
+--         allowing the user to change or extend the markdown syntax.
+--         For an example, see the documentation for `lunamark`.
+--
+--     `references`
+--     :   A table of references to be used in resolving links
+--         in the document.  The keys should be all lowercase, with
+--         spaces and newlines collapsed into single spaces.
+--         Example:
+--
+--             { foo: { url = "/url", title = "my title" },
+--               bar: { url = "http://fsf.org" } }
+--
+--     `preserve_tabs`
+--     :   Preserve tabs instead of converting to spaces.
+--
+--     `smart`
+--     :   Parse quotation marks, dashes, ellipses intelligently.
+--
+--     `startnum`
+--     :   Make the opening number in an ordered list significant.
+--
+--     `notes`
+--     :   Enable footnotes as in pandoc.
+--
+--     `definition_lists`
+--     :   Enable definition lists as in pandoc.
+--
+--     `citations`
+--     :   Enable citations as in pandoc.
+--
+--     `fenced_code_blocks`
+--     :   Enable fenced code blocks.
+--
+--     `pandoc_title_blocks`
+--     :   Parse pandoc-style title block at the beginning of document:
+--
+--             % Title
+--             % Author1; Author2
+--             % Date
+--
+--     `lua_metadata`
+--     :   Enable lua metadata.  This is an HTML comment block
+--         that starts with `<!--@` and contains lua code.
+--         The lua code is interpreted in a sandbox, and
+--         any variables defined are added to the metadata.
+--         The function `markdown` (also `m`) is defined and can
+--         be used to ensure that string fields are parsed
+--         as markdown; otherwise, they will be read literally.
+--
+--     `require_blank_before_blockquote`
+--     :   Require a blank line between a paragraph and a following
+--         block quote.
+--
+--     `require_blank_before_header`
+--     :   Require a blank line between a paragraph and a following
+--         header.
+--
+--     `require_blank_before_fenced_code_block`
+--     :   Require a blank line between a paragraph and a following
+--         fenced code block.
+--
+--     `hash_enumerators`
+--     :   Allow `#` instead of a digit for an ordered list enumerator
+--         (equivalent to `1`).
+--
+-- *   Returns a converter function that converts a markdown string
+--     using `writer`, returning the parsed document as first result,
+--     and a table containing any extracted metadata as the second
+--     result. The converter assumes that the input has unix
+--     line endings (newline).  If the input might have DOS
+--     line endings, a simple `gsub("\r","")` should take care of them.
+function M.new(writer, options)
+  options = options or {}
+
+  local function expandtabs(s)
+    if s:find("\t") then
+      return s:gsub("[^\n]*",expand_tabs_in_line)
+    else
+      return s
+    end
+  end
+
+  if options.preserve_tabs then
+    expandtabs = function(s) return s end
+  end
+
+  ------------------------------------------------------------------------------
+
+  local syntax
+  local blocks
+  local inlines
+  local inlines_no_link
+  local inlines_nbsp
+
+  local function create_parser(name, grammar)
+    return function(str)
+      local res = lpeg.match(grammar(), str)
+      if res == nil then
+        error(format("%s failed on:\n%s", name, str:sub(1,20)))
+      else
+        return res
+      end
+    end
+  end
+
+  local parse_blocks = create_parser("parse_blocks",
+    function() return blocks end)
+  local parse_inlines = create_parser("parse_inlines",
+    function() return inlines end)
+  local parse_inlines_no_link = create_parser("parse_inlines_no_link",
+    function() return inlines_no_link end)
+  local parse_inlines_nbsp = create_parser("parse_inlines_nbsp",
+    function() return inlines_nbsp end)
+
+  local parse_markdown
+
+  ------------------------------------------------------------------------------
+  -- Generic parsers
+  ------------------------------------------------------------------------------
+
+  local digit                  = R("09")
+  local hexdigit               = R("09","af","AF")
+  local letter                 = R("AZ","az")
+  local alphanumeric           = R("AZ","az","09")
+  local keyword                = letter * alphanumeric^0
+  local internal_punctuation   = S(":;,.#$%&-+?<>~/")
+
+  local doubleasterisks        = P("**")
+  local doubleunderscores      = P("__")
+  local fourspaces             = P("    ")
+
+  local any                    = P(1)
+  local fail                   = any - 1
+
+  local escapable              = S("\\`*_{}[]()+_.!<>#-~:^@;")
+  local anyescaped             = P("\\") / "" * escapable
+                               + any
+
+  local spacechar              = S("\t ")
+  local spacing                = S(" \n\r\t")
+  local nonspacechar           = any - spacing
+
+  local specialchar
+  if options.smart then
+    specialchar                = S("*_`&[]<!\\'\"-.@")
+  else
+    specialchar                = S("*_`&[]<!\\-@")
+  end
+
+  local normalchar             = any -
+                                 (specialchar + spacing + tightblocksep)
+  local optionalspace          = spacechar^0
+  local eof                    = - any
+  local nonindentspace         = space^-3 * - spacechar
+  local indent                 = space^-3 * tab
+                               + fourspaces / ""
+  local linechar               = P(1 - newline)
+
+  local blankline              = optionalspace * newline / "\n"
+  local blanklines             = blankline^0
+  local skipblanklines         = (optionalspace * newline)^0
+  local indentedline           = indent    /"" * C(linechar^1 * newline^-1)
+  local optionallyindentedline = indent^-1 /"" * C(linechar^1 * newline^-1)
+  local sp                     = spacing^0
+  local spnl                   = optionalspace * (newline * optionalspace)^-1
+  local line                   = linechar^0 * newline
+                               + linechar^1 * eof
+  local nonemptyline           = line - blankline
+
+  local chunk = line * (optionallyindentedline - blankline)^0
+
+  -- block followed by 0 or more optionally
+  -- indented blocks with first line indented.
+  local function indented_blocks(bl)
+    return Cs( bl
+             * (blankline^1 * indent * -blankline * bl)^0
+             * blankline^1 )
+  end
+
+  -----------------------------------------------------------------------------
+  -- Parsers used for markdown lists
+  -----------------------------------------------------------------------------
+
+  local bulletchar = C(plus + asterisk + dash)
+
+  local bullet     = ( bulletchar * #spacing * (tab + space^-3)
+                     + space * bulletchar * #spacing * (tab + space^-2)
+                     + space * space * bulletchar * #spacing * (tab + space^-1)
+                     + space * space * space * bulletchar * #spacing
+                     )
+
+  local dig
+  if options.hash_enumerators then
+    dig = digit + hash
+  else
+    dig = digit
+  end
+
+  local enumerator = C(dig^3 * period) * #spacing
+                   + C(dig^2 * period) * #spacing * (tab + space^1)
+                   + C(dig * period) * #spacing * (tab + space^-2)
+                   + space * C(dig^2 * period) * #spacing
+                   + space * C(dig * period) * #spacing * (tab + space^-1)
+                   + space * space * C(dig^1 * period) * #spacing
+
+  -----------------------------------------------------------------------------
+  -- Parsers used for markdown code spans
+  -----------------------------------------------------------------------------
+
+  local openticks   = Cg(backtick^1, "ticks")
+
+  local function captures_equal_length(s,i,a,b)
+    return #a == #b and i
+  end
+
+  local closeticks  = space^-1 *
+                      Cmt(C(backtick^1) * Cb("ticks"), captures_equal_length)*1
+
+  local intickschar = (any - S(" \n\r`"))
+                    + (newline * -blankline)
+                    + (space - closeticks)
+                    + (backtick^1 - closeticks)
+
+  local inticks     = openticks * space^-1 * C(intickschar^1) * closeticks
+
+  -----------------------------------------------------------------------------
+  -- Parsers used for fenced code blocks
+  -----------------------------------------------------------------------------
+
+  local function captures_geq_length(s,i,a,b)
+    return #a >= #b and i
+  end
+
+  local infostring     = (linechar - (backtick + space^1 * newline))^0
+
+  local fenceindent
+  local function fencehead(char)
+    return               C(nonindentspace) / function(s) fenceindent = #s end
+                       * Cg(char^3, "fencelength")
+                       * optionalspace * C(infostring) * optionalspace
+                       * newline + eof
+  end
+
+  local function fencetail(char)
+    return               nonindentspace
+                       * Cmt(C(char^3) * Cb("fencelength"),
+                             captures_geq_length)
+                       * optionalspace * (newline + eof)
+  end
+
+  local function fencedline(char)
+    return               C(line - fencetail(char))
+                       / function(s)
+                           return s:gsub("^" .. string.rep(" ?",
+                             fenceindent), "")
+                         end
+  end
+
+  -----------------------------------------------------------------------------
+  -- Parsers used for markdown tags and links
+  -----------------------------------------------------------------------------
+
+  local leader        = space^-3
+
+  -- in balanced brackets, parentheses, quotes:
+  local bracketed     = P{ lbracket
+                         * ((anyescaped - (lbracket + rbracket + blankline^2)) + V(1))^0
+                         * rbracket }
+
+  local inparens      = P{ lparent
+                         * ((anyescaped - (lparent + rparent + blankline^2)) + V(1))^0
+                         * rparent }
+
+  local squoted       = P{ squote * alphanumeric
+                         * ((anyescaped - (squote + blankline^2)) + V(1))^0
+                         * squote }
+
+  local dquoted       = P{ dquote * alphanumeric
+                         * ((anyescaped - (dquote + blankline^2)) + V(1))^0
+                         * dquote }
+
+  -- bracketed 'tag' for markdown links, allowing nested brackets:
+  local tag           = lbracket
+                      * Cs((alphanumeric^1
+                           + bracketed
+                           + inticks
+                           + (anyescaped - (rbracket + blankline^2)))^0)
+                      * rbracket
+
+  -- url for markdown links, allowing balanced parentheses:
+  local url           = less * Cs((anyescaped-more)^0) * more
+                      + Cs((inparens + (anyescaped-spacing-rparent))^1)
+
+  -- quoted text possibly with nested quotes:
+  local title_s       = squote  * Cs(((anyescaped-squote) + squoted)^0) * squote
+
+  local title_d       = dquote  * Cs(((anyescaped-dquote) + dquoted)^0) * dquote
+
+  local title_p       = lparent
+                      * Cs((inparens + (anyescaped-rparent))^0)
+                      * rparent
+
+  local title         = title_d + title_s + title_p
+
+  local optionaltitle = spnl * title * spacechar^0
+                      + Cc("")
+
+  ------------------------------------------------------------------------------
+  -- Citations
+  ------------------------------------------------------------------------------
+
+  local citation_name = Cs(dash^-1) * at
+                      * Cs(alphanumeric
+                          * (alphanumeric + internal_punctuation
+                              - comma - semicolon)^0)
+
+  local citation_body_prenote
+                      = Cs((alphanumeric^1
+                           + bracketed
+                           + inticks
+                           + (anyescaped
+                               - (rbracket + blankline^2))
+                           - (spnl * dash^-1 * at))^0)
+
+  local citation_body_postnote
+                      = Cs((alphanumeric^1
+                           + bracketed
+                           + inticks
+                           + (anyescaped
+                               - (rbracket + semicolon + blankline^2))
+                           - (spnl * rbracket))^0)
+
+  local citation_body_chunk
+                      = citation_body_prenote
+                      * spnl * citation_name
+                      * (comma * spnl)^-1
+                      * citation_body_postnote
+
+  local citation_body = citation_body_chunk
+                      * (semicolon * spnl * citation_body_chunk)^0
+
+  local citation_headless_body
+                      = Cs((alphanumeric^1
+                           + bracketed
+                           + inticks
+                           + (anyescaped
+                               - (rbracket + at + semicolon + blankline^2))
+                           - (spnl * rbracket))^0)
+                      * (sp * semicolon * spnl * citation_body_chunk)^0
+
+  local function citations(text_cites, raw_cites)
+      local function normalize(str)
+          if str == "" then
+              str = nil
+          else
+              str = (options.citation_nbsps and parse_inlines_nbsp or
+                parse_inlines)(str)
+          end
+          return str
+      end
+
+      local cites = {}
+      for i = 1,#raw_cites,4 do
+          cites[#cites+1] = {
+              prenote = normalize(raw_cites[i]),
+              suppress_author = raw_cites[i+1] == "-",
+              name = writer.string(raw_cites[i+2]),
+              postnote = normalize(raw_cites[i+3]),
+          }
+      end
+      return writer.citations(text_cites, cites)
+  end
+
+  ------------------------------------------------------------------------------
+  -- Footnotes
+  ------------------------------------------------------------------------------
+
+  local rawnotes = {}
+
+  local function strip_first_char(s)
+    return s:sub(2)
+  end
+
+  -- like indirect_link
+  local function lookup_note(ref)
+    return function()
+      local found = rawnotes[normalize_tag(ref)]
+      if found then
+        return writer.note(parse_blocks(found))
+      else
+        return {"[", parse_inlines("^" .. ref), "]"}
+      end
+    end
+  end
+
+  local function register_note(ref,rawnote)
+    rawnotes[normalize_tag(ref)] = rawnote
+    return ""
+  end
+
+  local RawNoteRef = #(lbracket * circumflex) * tag / strip_first_char
+
+  local NoteRef    = RawNoteRef / lookup_note
+
+  local NoteBlock
+
+  if options.notes then
+    NoteBlock = leader * RawNoteRef * colon * spnl * indented_blocks(chunk)
+              / register_note
+  else
+    NoteBlock = fail
+  end
+
+  ------------------------------------------------------------------------------
+  -- Helpers for links and references
+  ------------------------------------------------------------------------------
+
+  -- List of references defined in the document
+  local references
+
+  -- add a reference to the list
+  local function register_link(tag,url,title)
+      references[normalize_tag(tag)] = { url = url, title = title }
+      return ""
+  end
+
+  -- parse a reference definition:  [foo]: /bar "title"
+  local define_reference_parser =
+    leader * tag * colon * spacechar^0 * url * optionaltitle * blankline^1
+
+  -- lookup link reference and return either
+  -- the link or nil and fallback text.
+  local function lookup_reference(label,sps,tag)
+      local tagpart
+      if not tag then
+          tag = label
+          tagpart = ""
+      elseif tag == "" then
+          tag = label
+          tagpart = "[]"
+      else
+          tagpart = {"[", parse_inlines(tag), "]"}
+      end
+      if sps then
+        tagpart = {sps, tagpart}
+      end
+      local r = references[normalize_tag(tag)]
+      if r then
+        return r
+      else
+        return nil, {"[", parse_inlines(label), "]", tagpart}
+      end
+  end
+
+  -- lookup link reference and return a link, if the reference is found,
+  -- or a bracketed label otherwise.
+  local function indirect_link(label,sps,tag)
+    return function()
+      local r,fallback = lookup_reference(label,sps,tag)
+      if r then
+        return writer.link(parse_inlines_no_link(label), r.url, r.title)
+      else
+        return fallback
+      end
+    end
+  end
+
+  -- lookup image reference and return an image, if the reference is found,
+  -- or a bracketed label otherwise.
+  local function indirect_image(label,sps,tag)
+    return function()
+      local r,fallback = lookup_reference(label,sps,tag)
+      if r then
+        return writer.image(writer.string(label), r.url, r.title)
+      else
+        return {"!", fallback}
+      end
+    end
+  end
+
+  ------------------------------------------------------------------------------
+  -- HTML
+  ------------------------------------------------------------------------------
+
+  -- case-insensitive match (we assume s is lowercase). must be single byte encoding
+  local function keyword_exact(s)
+    local parser = P(0)
+    for i=1,#s do
+      local c = s:sub(i,i)
+      local m = c .. upper(c)
+      parser = parser * S(m)
+    end
+    return parser
+  end
+
+  local block_keyword =
+      keyword_exact("address") + keyword_exact("blockquote") +
+      keyword_exact("center") + keyword_exact("del") +
+      keyword_exact("dir") + keyword_exact("div") +
+      keyword_exact("p") + keyword_exact("pre") + keyword_exact("li") +
+      keyword_exact("ol") + keyword_exact("ul") + keyword_exact("dl") +
+      keyword_exact("dd") + keyword_exact("form") + keyword_exact("fieldset") +
+      keyword_exact("isindex") + keyword_exact("ins") +
+      keyword_exact("menu") + keyword_exact("noframes") +
+      keyword_exact("frameset") + keyword_exact("h1") + keyword_exact("h2") +
+      keyword_exact("h3") + keyword_exact("h4") + keyword_exact("h5") +
+      keyword_exact("h6") + keyword_exact("hr") + keyword_exact("script") +
+      keyword_exact("noscript") + keyword_exact("table") +
+      keyword_exact("tbody") + keyword_exact("tfoot") +
+      keyword_exact("thead") + keyword_exact("th") +
+      keyword_exact("td") + keyword_exact("tr")
+
+  -- There is no reason to support bad html, so we expect quoted attributes
+  local htmlattributevalue  = squote * (any - (blankline + squote))^0 * squote
+                            + dquote * (any - (blankline + dquote))^0 * dquote
+
+  local htmlattribute       = spacing^1 * (alphanumeric + S("_-"))^1 * sp * equal
+                            * sp * htmlattributevalue
+
+  local htmlcomment         = P("<!--") * (any - P("-->"))^0 * P("-->")
+
+  local htmlinstruction     = P("<?")   * (any - P("?>" ))^0 * P("?>" )
+
+  local openelt_any = less * keyword * htmlattribute^0 * sp * more
+
+  local function openelt_exact(s)
+    return (less * sp * keyword_exact(s) * htmlattribute^0 * sp * more)
+  end
+
+  local openelt_block = sp * block_keyword * htmlattribute^0 * sp * more
+
+  local closeelt_any = less * sp * slash * keyword * sp * more
+
+  local function closeelt_exact(s)
+    return (less * sp * slash * keyword_exact(s) * sp * more)
+  end
+
+  local emptyelt_any = less * sp * keyword * htmlattribute^0 * sp * slash * more
+
+  local emptyelt_block = less * sp * block_keyword * htmlattribute^0 * sp * slash * more
+
+  local displaytext         = (any - less)^1
+
+  -- return content between two matched HTML tags
+  local function in_matched(s)
+    return { openelt_exact(s)
+           * (V(1) + displaytext + (less - closeelt_exact(s)))^0
+           * closeelt_exact(s) }
+  end
+
+  local function parse_matched_tags(s,pos)
+    local t = lower(lpegmatch(C(keyword),s,pos))
+    return lpegmatch(in_matched(t),s,pos-1)
+  end
+
+  local in_matched_block_tags = less * Cmt(#openelt_block, parse_matched_tags)
+
+  local displayhtml = htmlcomment
+                    + emptyelt_block
+                    + openelt_exact("hr")
+                    + in_matched_block_tags
+                    + htmlinstruction
+
+  local inlinehtml  = emptyelt_any
+                    + htmlcomment
+                    + htmlinstruction
+                    + openelt_any
+                    + closeelt_any
+
+  ------------------------------------------------------------------------------
+  -- Entities
+  ------------------------------------------------------------------------------
+
+  local hexentity = ampersand * hash * S("Xx") * C(hexdigit    ^1) * semicolon
+  local decentity = ampersand * hash           * C(digit       ^1) * semicolon
+  local tagentity = ampersand *                  C(alphanumeric^1) * semicolon
+
+  ------------------------------------------------------------------------------
+  -- Inline elements
+  ------------------------------------------------------------------------------
+
+  local Inline    = V("Inline")
+
+  local Str       = normalchar^1 / writer.string
+
+  local Ellipsis  = P("...") / writer.ellipsis
+
+  local Dash      = P("---") * -dash / writer.mdash
+                  + P("--") * -dash / writer.ndash
+                  + P("-") * #digit * B(digit*1, 2) / writer.ndash
+
+  local DoubleQuoted = dquote * Ct((Inline - dquote)^1) * dquote
+                     / writer.doublequoted
+
+  local squote_start = squote * -spacing
+
+  local squote_end = squote * B(nonspacechar*1, 2)
+
+  local SingleQuoted = squote_start * Ct((Inline - squote_end)^1) * squote_end
+                     / writer.singlequoted
+
+  local Apostrophe = squote * B(nonspacechar*1, 2) / "’"
+
+  local Smart      = Ellipsis + Dash + SingleQuoted + DoubleQuoted + Apostrophe
+
+  local Symbol    = (specialchar - tightblocksep) / writer.string
+
+  local Code      = inticks / writer.code
+
+  local bqstart      = more
+  local headerstart  = hash
+                     + (line * (equal^1 + dash^1) * optionalspace * newline)
+  local fencestart   = fencehead(backtick) + fencehead(tilde)
+
+  if options.require_blank_before_blockquote then
+    bqstart = fail
+  end
+
+  if options.require_blank_before_header then
+    headerstart = fail
+  end
+
+  if not options.fenced_code_blocks or
+    options.blank_before_fenced_code_blocks then
+    fencestart = fail
+  end
+
+  local Endline   = newline * -( -- newline, but not before...
+                        blankline -- paragraph break
+                      + tightblocksep  -- nested list
+                      + eof       -- end of document
+                      + bqstart
+                      + headerstart
+                      + fencestart
+                    ) * spacechar^0 / writer.space
+
+  local Space     = spacechar^2 * Endline / writer.linebreak
+                  + spacechar^1 * Endline^-1 * eof / ""
+                  + spacechar^1 * Endline^-1 * optionalspace / writer.space
+
+  local NonbreakingEndline
+                  = newline * -( -- newline, but not before...
+                        blankline -- paragraph break
+                      + tightblocksep  -- nested list
+                      + eof       -- end of document
+                      + bqstart
+                      + headerstart
+                      + fencestart
+                    ) * spacechar^0 / writer.nbsp
+
+  local NonbreakingSpace
+                  = spacechar^2 * Endline / writer.linebreak
+                  + spacechar^1 * Endline^-1 * eof / ""
+                  + spacechar^1 * Endline^-1 * optionalspace / writer.nbsp
+
+  -- parse many p between starter and ender
+  local function between(p, starter, ender)
+      local ender2 = B(nonspacechar) * ender
+      return (starter * #nonspacechar * Ct(p * (p - ender2)^0) * ender2)
+  end
+
+  local Strong = ( between(Inline, doubleasterisks, doubleasterisks)
+                 + between(Inline, doubleunderscores, doubleunderscores)
+                 ) / writer.strong
+
+  local Emph   = ( between(Inline, asterisk, asterisk)
+                 + between(Inline, underscore, underscore)
+                 ) / writer.emphasis
+
+  local urlchar = anyescaped - newline - more
+
+  local AutoLinkUrl   = less
+                      * C(alphanumeric^1 * P("://") * urlchar^1)
+                      * more
+                      / function(url) return writer.link(writer.string(url),url) end
+
+  local AutoLinkEmail = less
+                      * C((alphanumeric + S("-._+"))^1 * P("@") * urlchar^1)
+                      * more
+                      / function(email) return writer.link(writer.string(email),"mailto:"..email) end
+
+  local DirectLink    = (tag / parse_inlines_no_link)  -- no links inside links
+                      * spnl
+                      * lparent
+                      * (url + Cc(""))  -- link can be empty [foo]()
+                      * optionaltitle
+                      * rparent
+                      / writer.link
+
+  local IndirectLink = tag * (C(spnl) * tag)^-1 / indirect_link
+
+  -- parse a link or image (direct or indirect)
+  local Link          = DirectLink + IndirectLink
+
+  local DirectImage   = exclamation
+                      * (tag / parse_inlines)
+                      * spnl
+                      * lparent
+                      * (url + Cc(""))  -- link can be empty [foo]()
+                      * optionaltitle
+                      * rparent
+                      / writer.image
+
+  local IndirectImage  = exclamation * tag * (C(spnl) * tag)^-1 / indirect_image
+
+  local Image         = DirectImage + IndirectImage
+
+  local TextCitations = Ct(Cc("")
+                      * citation_name
+                      * ((spnl
+                           * lbracket
+                           * citation_headless_body
+                           * rbracket) + Cc(""))) /
+                        function(raw_cites)
+                            return citations(true, raw_cites)
+                        end
+
+  local ParenthesizedCitations
+                      = Ct(lbracket
+                      * citation_body
+                      * rbracket) /
+                        function(raw_cites)
+                            return citations(false, raw_cites)
+                        end
+
+  local Citations     = TextCitations + ParenthesizedCitations
+
+  -- avoid parsing long strings of * or _ as emph/strong
+  local UlOrStarLine  = asterisk^4 + underscore^4 / writer.string
+
+  local EscapedChar   = S("\\") * C(escapable) / writer.string
+
+  local InlineHtml    = C(inlinehtml) / writer.inline_html
+
+  local HtmlEntity    = hexentity / entities.hex_entity  / writer.string
+                      + decentity / entities.dec_entity  / writer.string
+                      + tagentity / entities.char_entity / writer.string
+
+  ------------------------------------------------------------------------------
+  -- Block elements
+  ------------------------------------------------------------------------------
+
+  local Block          = V("Block")
+
+  local DisplayHtml    = C(displayhtml) / expandtabs / writer.display_html
+
+  local Verbatim       = Cs( (blanklines
+                           * ((indentedline - blankline))^1)^1
+                           ) / expandtabs / writer.verbatim
+
+  local TildeFencedCodeBlock
+                       = fencehead(tilde)
+                       * Cs(fencedline(tilde)^0)
+                       * fencetail(tilde)
+
+  local BacktickFencedCodeBlock
+                       = fencehead(backtick)
+                       * Cs(fencedline(backtick)^0)
+                       * fencetail(backtick)
+
+  local FencedCodeBlock
+                       = (TildeFencedCodeBlock + BacktickFencedCodeBlock)
+                       / function(infostring, code)
+                             return writer.fenced_code(
+                                 expandtabs(code),
+                                 writer.string(infostring))
+                         end
+
+  -- strip off leading > and indents, and run through blocks
+  local Blockquote     = Cs((
+            ((leader * more * space^-1)/"" * linechar^0 * newline)^1
+          * (-blankline * linechar^1 * newline)^0
+          * blankline^0
+          )^1) / parse_blocks / writer.blockquote
+
+  local function lineof(c)
+      return (leader * (P(c) * optionalspace)^3 * newline * blankline^1)
+  end
+
+  local HorizontalRule = ( lineof(asterisk)
+                         + lineof(dash)
+                         + lineof(underscore)
+                         ) / writer.hrule
+
+  local Reference      = define_reference_parser / register_link
+
+  local Paragraph      = nonindentspace * Ct(Inline^1) * newline
+                       * ( blankline^1
+                         + #hash
+                         + #(leader * more * space^-1)
+                         )
+                       / writer.paragraph
+
+  local Plain          = nonindentspace * Ct(Inline^1) / writer.plain
+
+  ------------------------------------------------------------------------------
+  -- Lists
+  ------------------------------------------------------------------------------
+
+  local starter = bullet + enumerator
+
+  -- we use \001 as a separator between a tight list item and a
+  -- nested list under it.
+  local NestedList            = Cs((optionallyindentedline - starter)^1)
+                              / function(a) return "\001"..a end
+
+  local ListBlockLine         = optionallyindentedline
+                                - blankline - (indent^-1 * starter)
+
+  local ListBlock             = line * ListBlockLine^0
+
+  local ListContinuationBlock = blanklines * (indent / "") * ListBlock
+
+  local function TightListItem(starter)
+      return -HorizontalRule
+             * (Cs(starter / "" * ListBlock * NestedList^-1) / parse_blocks)
+             * -(blanklines * indent)
+  end
+
+  local function LooseListItem(starter)
+      return -HorizontalRule
+             * Cs( starter / "" * ListBlock * Cc("\n")
+               * (NestedList + ListContinuationBlock^0)
+               * (blanklines / "\n\n")
+               ) / parse_blocks
+  end
+
+  local BulletList = ( Ct(TightListItem(bullet)^1)
+                       * Cc(true) * skipblanklines * -bullet
+                     + Ct(LooseListItem(bullet)^1)
+                       * Cc(false) * skipblanklines ) / writer.bulletlist
+
+  local function ordered_list(s,tight,startnum)
+    if options.startnum then
+      startnum = tonumber(startnum) or 1  -- fallback for '#'
+    else
+      startnum = nil
+    end
+    return writer.orderedlist(s,tight,startnum)
+  end
+
+  local OrderedList = Cg(enumerator, "listtype") *
+                      ( Ct(TightListItem(Cb("listtype")) * TightListItem(enumerator)^0)
+                        * Cc(true) * skipblanklines * -enumerator
+                      + Ct(LooseListItem(Cb("listtype")) * LooseListItem(enumerator)^0)
+                        * Cc(false) * skipblanklines
+                      ) * Cb("listtype") / ordered_list
+
+  local defstartchar = S("~:")
+  local defstart     = ( defstartchar * #spacing * (tab + space^-3)
+                     + space * defstartchar * #spacing * (tab + space^-2)
+                     + space * space * defstartchar * #spacing * (tab + space^-1)
+                     + space * space * space * defstartchar * #spacing
+                     )
+
+  local dlchunk = Cs(line * (indentedline - blankline)^0)
+
+  local function definition_list_item(term, defs, tight)
+    return { term = parse_inlines(term), definitions = defs }
+  end
+
+  local DefinitionListItemLoose = C(line) * skipblanklines
+                           * Ct((defstart * indented_blocks(dlchunk) / parse_blocks)^1)
+                           * Cc(false)
+                           / definition_list_item
+
+  local DefinitionListItemTight = C(line)
+                           * Ct((defstart * dlchunk / parse_blocks)^1)
+                           * Cc(true)
+                           / definition_list_item
+
+  local DefinitionList =  ( Ct(DefinitionListItemLoose^1) * Cc(false)
+                          +  Ct(DefinitionListItemTight^1)
+                             * (skipblanklines * -DefinitionListItemLoose * Cc(true))
+                          ) / writer.definitionlist
+
+  ------------------------------------------------------------------------------
+  -- Lua metadata
+  ------------------------------------------------------------------------------
+
+  local function lua_metadata(s)  -- run lua code in comment in sandbox
+    local env = { m = parse_markdown, markdown = parse_blocks }
+    local scode = s:match("^<!%-%-@%s*(.*)%-%->")
+    local untrusted_table, message = load(scode, nil, "t", env)
+    if not untrusted_table then
+      util.err(message, 37)
+    end
+    local ok, msg = pcall(untrusted_table)
+    if not ok then
+      util.err(msg)
+    end
+    for k,v in pairs(env) do
+      writer.set_metadata(k,v)
+    end
+    return ""
+  end
+
+  local LuaMeta = fail
+  if options.lua_metadata then
+    LuaMeta = #P("<!--@") * htmlcomment / lua_metadata
+  end
+
+  ------------------------------------------------------------------------------
+  -- Pandoc title block parser
+  ------------------------------------------------------------------------------
+
+  local pandoc_title =
+      percent * optionalspace
+    * C(line * (spacechar * nonemptyline)^0) / parse_inlines
+  local pandoc_author =
+      spacechar * optionalspace
+    * C((anyescaped - newline - semicolon)^0)
+    * (semicolon + newline)
+  local pandoc_authors =
+    percent * Ct((pandoc_author / parse_inlines)^0) * newline^-1
+  local pandoc_date =
+    percent * optionalspace * C(line) / parse_inlines
+  local pandoc_title_block =
+      (pandoc_title + Cc(""))
+    * (pandoc_authors + Cc({}))
+    * (pandoc_date + Cc(""))
+    * C(P(1)^0)
+
+  ------------------------------------------------------------------------------
+  -- Blank
+  ------------------------------------------------------------------------------
+
+  local Blank          = blankline / ""
+                       + LuaMeta
+                       + NoteBlock
+                       + Reference
+                       + (tightblocksep / "\n")
+
+  ------------------------------------------------------------------------------
+  -- Headers
+  ------------------------------------------------------------------------------
+
+  -- parse Atx heading start and return level
+  local HeadingStart = #hash * C(hash^-6) * -hash / length
+
+  -- parse setext header ending and return level
+  local HeadingLevel = equal^1 * Cc(1) + dash^1 * Cc(2)
+
+  local function strip_atx_end(s)
+    return s:gsub("[#%s]*\n$","")
+  end
+
+  -- parse atx header
+  local AtxHeader = Cg(HeadingStart,"level")
+                     * optionalspace
+                     * (C(line) / strip_atx_end / parse_inlines)
+                     * Cb("level")
+                     / writer.header
+
+  -- parse setext header
+  local SetextHeader = #(line * S("=-"))
+                     * Ct(line / parse_inlines)
+                     * HeadingLevel
+                     * optionalspace * newline
+                     / writer.header
+
+  ------------------------------------------------------------------------------
+  -- Syntax specification
+  ------------------------------------------------------------------------------
+
+  syntax =
+    { "Blocks",
+
+      Blocks                = Blank^0 *
+                              Block^-1 *
+                              (Blank^0 / function() return writer.interblocksep end * Block)^0 *
+                              Blank^0 *
+                              eof,
+
+      Blank                 = Blank,
+
+      Block                 = V("Blockquote")
+                            + V("Verbatim")
+                            + V("FencedCodeBlock")
+                            + V("HorizontalRule")
+                            + V("BulletList")
+                            + V("OrderedList")
+                            + V("Header")
+                            + V("DefinitionList")
+                            + V("DisplayHtml")
+                            + V("Paragraph")
+                            + V("Plain"),
+
+      Blockquote            = Blockquote,
+      Verbatim              = Verbatim,
+      FencedCodeBlock       = FencedCodeBlock,
+      HorizontalRule        = HorizontalRule,
+      BulletList            = BulletList,
+      OrderedList           = OrderedList,
+      Header                = AtxHeader + SetextHeader,
+      DefinitionList        = DefinitionList,
+      DisplayHtml           = DisplayHtml,
+      Paragraph             = Paragraph,
+      Plain                 = Plain,
+
+      Inline                = V("Str")
+                            + V("Space")
+                            + V("Endline")
+                            + V("UlOrStarLine")
+                            + V("Strong")
+                            + V("Emph")
+                            + V("NoteRef")
+                            + V("Citations")
+                            + V("Link")
+                            + V("Image")
+                            + V("Code")
+                            + V("AutoLinkUrl")
+                            + V("AutoLinkEmail")
+                            + V("InlineHtml")
+                            + V("HtmlEntity")
+                            + V("EscapedChar")
+                            + V("Smart")
+                            + V("Symbol"),
+
+      Str                   = Str,
+      Space                 = Space,
+      Endline               = Endline,
+      UlOrStarLine          = UlOrStarLine,
+      Strong                = Strong,
+      Emph                  = Emph,
+      NoteRef               = NoteRef,
+      Citations             = Citations,
+      Link                  = Link,
+      Image                 = Image,
+      Code                  = Code,
+      AutoLinkUrl           = AutoLinkUrl,
+      AutoLinkEmail         = AutoLinkEmail,
+      InlineHtml            = InlineHtml,
+      HtmlEntity            = HtmlEntity,
+      EscapedChar           = EscapedChar,
+      Smart                 = Smart,
+      Symbol                = Symbol,
+    }
+
+  if not options.definition_lists then
+    syntax.DefinitionList = fail
+  end
+
+  if not options.fenced_code_blocks then
+    syntax.FencedCodeBlock = fail
+  end
+
+  if not options.citations then
+    syntax.Citations = fail
+  end
+
+  if not options.notes then
+    syntax.NoteRef = fail
+  end
+
+  if not options.smart then
+    syntax.Smart = fail
+  end
+
+  if options.alter_syntax and type(options.alter_syntax) == "function" then
+    syntax = options.alter_syntax(syntax)
+  end
+
+  blocks = Ct(syntax)
+
+  local inlines_t = util.table_copy(syntax)
+  inlines_t[1] = "Inlines"
+  inlines_t.Inlines = Inline^0 * (spacing^0 * eof / "")
+  inlines = Ct(inlines_t)
+
+  local inlines_no_link_t = util.table_copy(inlines_t)
+  inlines_no_link_t.Link = fail
+  inlines_no_link = Ct(inlines_no_link_t)
+
+  local inlines_nbsp_t = util.table_copy(inlines_t)
+  inlines_nbsp_t.Endline = NonbreakingEndline
+  inlines_nbsp_t.Space = NonbreakingSpace
+  inlines_nbsp = Ct(inlines_nbsp_t)
+
+  ------------------------------------------------------------------------------
+  -- Exported conversion function
+  ------------------------------------------------------------------------------
+
+  -- inp is a string; line endings are assumed to be LF (unix-style)
+  -- and tabs are assumed to be expanded.
+  parse_markdown =
+    function(inp)
+      references = options.references or {}
+      if options.pandoc_title_blocks then
+        local title, authors, date, rest = lpegmatch(pandoc_title_block, inp)
+        writer.set_metadata("title",title)
+        writer.set_metadata("author",authors)
+        writer.set_metadata("date",date)
+        inp = rest
+      end
+      local result = { writer.start_document(), parse_blocks(inp), writer.stop_document() }
+      return writer.merge(result), writer.get_metadata()
+  end
+
+  return parse_markdown
+end
+
+return M
diff --git a/lua-libraries/lunamark/util.lua b/lua-libraries/lunamark/util.lua
new file mode 100644
index 00000000..9955a8a1
--- /dev/null
+++ b/lua-libraries/lunamark/util.lua
@@ -0,0 +1,228 @@
+-- (c) 2009-2011 John MacFarlane.  Released under MIT license.
+-- See the file LICENSE in the source for details.
+
+--- Utility functions for lunamark.
+
+local M = {}
+local cosmo = require("cosmo")
+local rep  = string.rep
+local lpeg = require("lpeg")
+local Cs, P, S, lpegmatch = lpeg.Cs, lpeg.P, lpeg.S, lpeg.match
+local any = lpeg.P(1)
+
+--- Find a template and return its contents (or `false` if
+-- not found). The template is sought first in the
+-- working directory, then in `templates`, then in
+-- `$HOME/.lunamark/templates`, then in the Windows
+-- `APPDATA` directory.
+function M.find_template(name)
+  local base, ext = name:match("([^%.]*)(.*)")
+  local fname = base .. ext
+  local file = io.open(fname, "read")
+  if not file then
+    file = io.open("templates/" .. fname, "read")
+  end
+  if not file then
+    local home = os.getenv("HOME")
+    if home then
+      file = io.open(home .. "/.lunamark/templates/" .. fname, "read")
+    end
+  end
+  if not file then
+    local appdata = os.getenv("APPDATA")
+    if appdata then
+      file = io.open(appdata .. "/lunamark/templates/" .. fname, "read")
+    end
+  end
+  if file then
+    local data = file:read("*all")
+    file:close()
+    return data
+  else
+    return false, "Could not find template '" .. fname .. "'"
+  end
+end
+
+--- Implements a `sepby` directive for cosmo templates.
+-- `$sepby{ myarray }[[$it]][[, ]]` will render the elements
+-- of `myarray` separated by commas. If `myarray` is a string,
+-- it will be treated as an array with one element.  If it is
+-- `nil`, it will be treated as an empty array.
+function M.sepby(arg)
+  local a = arg[1]
+  if not a then
+    a = {}
+  elseif type(a) ~= "table" then
+    a = {a}
+  end
+  for i in ipairs(a) do
+     if i > 1 then cosmo.yield{_template=2} end
+     cosmo.yield{it = a[i], _template=1}
+  end
+end
+
+--[[
+-- extend(t) returns a table that falls back to t for non-found values
+function M.extend(prototype)
+  local newt = {}
+  local metat = { __index = function(t,key)
+                              return prototype[key]
+                            end }
+  setmetatable(newt, metat)
+  return newt
+end
+--]]
+
+--- Print error message and exit.
+function M.err(msg, exit_code)
+  io.stderr:write("lunamark: " .. msg .. "\n")
+  os.exit(exit_code or 1)
+end
+
+--- Shallow table copy including metatables.
+function M.table_copy(t)
+  local u = { }
+  for k, v in pairs(t) do u[k] = v end
+  return setmetatable(u, getmetatable(t))
+end
+
+--- Expand tabs in a line of text.
+-- `s` is assumed to be a single line of text.
+-- From *Programming Lua*.
+function M.expand_tabs_in_line(s, tabstop)
+  local tab = tabstop or 4
+  local corr = 0
+  return (s:gsub("()\t", function(p)
+          local sp = tab - (p - 1 + corr)%tab
+          corr = corr - 1 + sp
+          return rep(" ",sp)
+        end))
+end
+
+--- Walk a rope `t`, applying a function `f` to each leaf element in order.
+-- A rope is an array whose elements may be ropes, strings, numbers,
+-- or functions. If a leaf element is a function, call it and get the return value
+-- before proceeding.
+local function walk(t, f)
+    local typ = type(t)
+    if typ == "string" then
+      f(t)
+    elseif typ == "table" then
+      local i = 1
+      local n
+      n = t[i]
+      while n do
+        walk(n, f)
+        i = i + 1
+        n = t[i]
+      end
+    elseif typ == "function" then
+      local ok, val = pcall(t)
+      if ok then
+        walk(val,f)
+      end
+    else
+      f(tostring(t))
+    end
+end
+
+M.walk = walk
+
+--- Flatten an array `ary`.
+local function flatten(ary)
+  local new = {}
+  for _,v in ipairs(ary) do
+    if type(v) == "table" then
+      for _,w in ipairs(flatten(v)) do
+        new[#new + 1] = w
+      end
+    else
+      new[#new + 1] = v
+    end
+  end
+  return new
+end
+
+M.flatten = flatten
+
+--- Convert a rope to a string.
+local function rope_to_string(rope)
+  local buffer = {}
+  walk(rope, function(x) buffer[#buffer + 1] = x end)
+  return table.concat(buffer)
+end
+
+M.rope_to_string = rope_to_string
+
+-- assert(rope_to_string{"one","two"} == "onetwo")
+-- assert(rope_to_string{"one",{"1","2"},"three"} == "one12three")
+
+--- Return the last item in a rope.
+local function rope_last(rope)
+  if #rope == 0 then
+    return nil
+  else
+    local l = rope[#rope]
+    if type(l) == "table" then
+      return rope_last(l)
+    else
+      return l
+    end
+  end
+end
+
+-- assert(rope_last{"one","two"} == "two")
+-- assert(rope_last{} == nil)
+-- assert(rope_last{"one",{"2",{"3","4"}}} == "4")
+
+M.rope_last = rope_last
+
+--- Given an array `ary`, return a new array with `x`
+-- interspersed between elements of `ary`.
+function M.intersperse(ary, x)
+  local new = {}
+  local l = #ary
+  for i,v in ipairs(ary) do
+    local n = #new
+    new[n + 1] = v
+    if i ~= l then
+      new[n + 2] = x
+    end
+  end
+  return new
+end
+
+--- Given an array `ary`, return a new array with each
+-- element `x` of `ary` replaced by `f(x)`.
+function M.map(ary, f)
+  local new = {}
+  for i,v in ipairs(ary) do
+    new[i] = f(v)
+  end
+  return new
+end
+
+--- Given a table `char_escapes` mapping escapable characters onto
+-- their escaped versions and optionally `string_escapes` mapping
+-- escapable strings (or multibyte UTF-8 characters) onto their
+-- escaped versions, returns a function that escapes a string.
+-- This function uses lpeg and is faster than gsub.
+function M.escaper(char_escapes, string_escapes)
+  local char_escapes_list = ""
+  for i,_ in pairs(char_escapes) do
+    char_escapes_list = char_escapes_list .. i
+  end
+  local escapable = S(char_escapes_list) / char_escapes
+  if string_escapes then
+    for k,v in pairs(string_escapes) do
+      escapable = P(k) / v + escapable
+    end
+  end
+  local escape_string = Cs((escapable + any)^0)
+  return function(s)
+    return lpegmatch(escape_string, s)
+  end
+end
+
+
+return M
diff --git a/lua-libraries/lunamark/writer.lua b/lua-libraries/lunamark/writer.lua
new file mode 100644
index 00000000..73ccf262
--- /dev/null
+++ b/lua-libraries/lunamark/writer.lua
@@ -0,0 +1,20 @@
+-- (c) 2009-2011 John MacFarlane.  Released under MIT license.
+-- See the file LICENSE in the source for details.
+
+--- Provides access to all lunamark writers without preloading
+-- them.  Writer modules are loaded only when needed.
+--
+--     local writers = require("lunamark.writer")
+--     local htmlwriter = writers.html       -- html writer loaded now
+--     local myformat = 'latex'
+--     local mywriter = writers[myformat]    -- latex writer loaded now
+
+local G = {}
+
+setmetatable(G,{ __index = function(t,name)
+                             local mod = require("lunamark.writer." .. name)
+                             rawset(t,name,mod)
+                             return t[name]
+                            end })
+
+return G
diff --git a/lua-libraries/lunamark/writer/ast.lua b/lua-libraries/lunamark/writer/ast.lua
new file mode 100644
index 00000000..ebb036d3
--- /dev/null
+++ b/lua-libraries/lunamark/writer/ast.lua
@@ -0,0 +1,73 @@
+-- Return an abstract syntax tree
+
+local M = {}
+
+local format = string.format
+local util = require("lunamark.util")
+local generic = require("lunamark.writer.generic")
+local entities = require("lunamark.entities")
+
+function M.new(options)
+  local options = options or {}
+  local AST = generic.new(options)
+
+  function AST.merge(result)
+    local function walk(t)
+      local out = {}
+      for i = 1,#t do
+        local typ = type(t[i])
+        if typ == "string" and #t[i] > 0 then
+          if type(out[#out]) == "string" then
+            out[#out] = out[#out] .. t[i]
+          else
+            out[#out+1] = t[i]
+          end
+        elseif typ == "table" then
+          out[#out+1] = walk(t[i])
+          out[#out].tag = t[i].tag
+          -- Copy attributes
+          for key,value in pairs(t[i]) do
+            if type(key)=="string" then out[#out][key] = value end
+          end
+        elseif typ == "function" then
+          out[#out+1] = t[i]()
+        end
+      end
+      return out
+    end
+    return walk(result)
+    -- return result
+  end
+
+  AST.genericCommand = function(name) return function(s)
+      local node = { tag = name }
+      node[1] = s
+      return node
+    end
+  end
+
+  AST.strong = AST.genericCommand("strong")
+  AST.paragraph = AST.genericCommand("paragraph")
+  AST.code = AST.genericCommand("code")
+  AST.emphasis = AST.genericCommand("emphasis")
+  AST.blockquote = AST.genericCommand("blockquote")
+  AST.verbatim = AST.genericCommand("verbatim")
+  AST.header = function (s,level)
+    return (AST.genericCommand("sect"..level))(s)
+  end
+  AST.listitem = AST.genericCommand("listitem")
+  AST.bulletlist = function (items)
+    local node = {tag = "bulletlist"}
+    for i=1,#items do node[i] = AST.listitem(items[i]) end
+    return node
+  end
+  AST.link = function(lab, src, tit)
+    return { [1] = lab, tag = "link", href = src }
+  end
+  AST.image = function(lab, src, tit)
+    return { tag = "image", src=src, [1]=lab }
+  end
+  return AST
+end
+
+return M
diff --git a/lua-libraries/lunamark/writer/context.lua b/lua-libraries/lunamark/writer/context.lua
new file mode 100644
index 00000000..2c1c4e10
--- /dev/null
+++ b/lua-libraries/lunamark/writer/context.lua
@@ -0,0 +1,194 @@
+-- (c) 2009-2011 John MacFarlane, Khaled Hosny, Hans Hagen.
+-- Released under MIT license. See the file LICENSE in the source for details.
+
+--- ConTeXt writer for lunamark.
+-- Extends [lunamark.writer.tex].
+
+local M = {}
+
+local tex = require("lunamark.writer.tex")
+local util = require("lunamark.util")
+
+--- Returns a new ConTeXt writer
+-- For a list of all the fields, see [lunamark.writer.generic].
+function M.new(options)
+  options = options or {}
+  local ConTeXt = tex.new(options)
+
+  -- we don't try to escape utf-8 characters in context
+  local escape = util.escaper(ConTeXt.escaped)
+  ConTeXt.string = escape
+
+  function ConTeXt.singlequoted(s)
+    return {"\\quote{",s,"}"}
+  end
+
+  function ConTeXt.doublequoted(s)
+    return {"\\quotation{",s,"}"}
+  end
+
+  function ConTeXt.code(s)
+    return {"\\type{",ConTeXt.string(s),"}"}
+  end
+
+  function ConTeXt.link(lab,src,tit)
+    return {"\\goto{",lab,"}[url(",ConTeXt.string(src),"]"}
+  end
+
+  function ConTeXt.image(lab,src,tit)
+    return {"\\externalfigure[",ConTeXt.string(src),"]"}
+  end
+
+  local function listitem(s)
+    return {"\\item ",s,"\n"}
+  end
+
+  function ConTeXt.bulletlist(items,tight)
+    local opt = ""
+    if tight then opt = "[packed]" end
+    local buffer = {}
+    for _,item in ipairs(items) do
+      buffer[#buffer + 1] = listitem(item)
+    end
+    local contents = util.intersperse(buffer)
+    return {"\\startitemize",opt,"\n",contents,"\\stopitemize"}
+  end
+
+  function ConTeXt.orderedlist(items,tight,startnum)
+    local tightstr = ""
+    if tight then tightstr = ",packed" end
+    local opt = string.format("[%d%s]", startnum or 1, tightstr)
+    local buffer = {}
+    for _,item in ipairs(items) do
+      buffer[#buffer + 1] = listitem(item)
+    end
+    local contents = util.intersperse(buffer)
+    return {"\\startitemize",opt,"\n",contents,"\\stopitemize"}
+  end
+
+  function ConTeXt.emphasis(s)
+    return {"{\\em ",s,"}"}
+  end
+
+  function ConTeXt.strong(s)
+    return {"{\\bf ",s,"}"}
+  end
+
+  function ConTeXt.blockquote(s)
+    return {"\\startblockquote\n",s,"\\stopblockquote"}
+  end
+
+  function ConTeXt.verbatim(s)
+    return {"\\starttyping\n",s,"\\stoptyping"}
+  end
+
+  function ConTeXt.fenced_code(s,i)
+    if i ~= "" then
+      return {"\\starttyping[option=",i:match("[^ ]*"),
+        "]\n",s,"\\stoptyping"}
+    else
+      return ConTeXt.verbatim(s)
+    end
+  end
+
+  function ConTeXt.header(s,level)
+    local cmd
+    if level == 1 then
+      cmd = "\\section"
+    elseif level == 2 then
+      cmd = "\\subsection"
+    elseif level == 3 then
+      cmd = "\\subsubsection"
+    elseif level == 4 then
+      cmd = "\\paragraph"
+    elseif level == 5 then
+      cmd = "\\subparagraph"
+    else
+      cmd = ""
+    end
+    return {cmd,"{",s,"}"}
+  end
+
+  ConTeXt.hrule = "\\hairline"
+
+  function ConTeXt.note(contents)
+    return {"\\footnote{",contents,"}"}
+  end
+
+  function ConTeXt.definitionlist(items)
+    local buffer = {}
+    for _,item in ipairs(items) do
+      buffer[#buffer + 1] = {"\\startdescription{",item.term,"}\n",
+         util.intersperse(item.definitions,ConTeXt.interblocksep),"\n\\stopdescription"}
+    end
+    local contents = util.intersperse(buffer, ConTeXt.containersep)
+    return contents
+  end
+
+  ConTeXt.template = [===[
+\startmode[*mkii]
+  \enableregime[utf-8]
+  \setupcolors[state=start]
+\stopmode
+
+% Enable hyperlinks
+\setupinteraction[state=start, color=middleblue]
+
+\setuppapersize [letter][letter]
+\setuplayout    [width=middle,  backspace=1.5in, cutspace=1.5in,
+                 height=middle, topspace=0.75in, bottomspace=0.75in]
+
+\setuppagenumbering[location={footer,center}]
+
+\setupbodyfont[11pt]
+
+\setupwhitespace[medium]
+
+\setuphead[section]      [style=\tfc]
+\setuphead[subsection]   [style=\tfb]
+\setuphead[subsubsection][style=\bf]
+
+\definedescription
+  [description]
+  [headstyle=bold, style=normal, location=hanging, width=broad, margin=1cm]
+
+\setupitemize[autointro]    % prevent orphan list intro
+\setupitemize[indentnext=no]
+
+\setupthinrules[width=15em] % width of horizontal rules
+
+\setupdelimitedtext
+  [blockquote]
+  [before={\blank[medium]},
+   after={\blank[medium]},
+   indentnext=no,
+  ]
+
+\starttext
+$if{ title }[=[
+\startalignment[center]
+\blank[2*big]
+{\tfd $title}
+$if{ author }[[
+\blank[3*medium]
+{\tfa $sepby{author}[==[$it]==][==[\crlf ]==]}
+]]
+$if{ date }[[
+\blank[2*medium]
+{\tfa $date}
+]]
+\blank[3*medium]
+\stopalignment
+
+]=]
+$if{ toc }[[{\placecontent}
+]]
+$body
+
+\stoptext
+]===]
+
+  return ConTeXt
+end
+
+return M
diff --git a/lua-libraries/lunamark/writer/docbook.lua b/lua-libraries/lunamark/writer/docbook.lua
new file mode 100644
index 00000000..4bb675c3
--- /dev/null
+++ b/lua-libraries/lunamark/writer/docbook.lua
@@ -0,0 +1,152 @@
+-- (c) 2009-2011 John MacFarlane. Released under MIT license.
+-- See the file LICENSE in the source for details.
+
+--- DocBook writer for lunamark.
+-- Extends [lunamark.writer.xml].
+
+local M = {}
+
+local xml = require("lunamark.writer.xml")
+local util = require("lunamark.util")
+
+--- Returns a new DocBook writer.
+-- For a list of all the fields, see [lunamark.writer.generic].
+function M.new(options)
+  options = options or {}
+  local Docbook = xml.new(options)
+
+  Docbook.linebreak = "<literallayout>&#xA;</literallayout>"
+
+  Docbook.nbsp = "&nbsp;"
+
+  function Docbook.code(s)
+    return {"<literal>",Docbook.string(s),"</literal>"}
+  end
+
+  function Docbook.link(lab,src,tit)
+    local titattr
+    -- if tit and string.len(tit) > 0
+    --   then titattr = format(" xlink:title=\"%s\"", Docbook.string(tit))
+    --   else titattr = ""
+    --   end
+    return {"<ulink url=\"",Docbook.string(src),"\">",lab,"</ulink>"}
+  end
+
+  function Docbook.image(lab,src,tit)
+    local titattr
+    if tit and string.len(tit) > 0
+       then titattr = string.format("<objectinfo><title>%s%</title></objectinfo>",
+                        Docbook.string(tit))
+       else titattr = ""
+       end
+    return {"<inlinemediaobject><imageobject>",titattr,"<imagedata fileref=\"",Docbook.string(src),"\" /></imageobject></inlinemediaobject>"}
+  end
+
+  function Docbook.paragraph(s)
+    return {"<para>",s,"</para>"}
+  end
+
+  Docbook.plain = Docbook.paragraph
+
+  local function listitem(s)
+    return {"<listitem>",s,"</listitem>"}
+  end
+
+  function Docbook.bulletlist(items)
+    local buffer = {}
+    for _,item in ipairs(items) do
+      buffer[#buffer + 1] = listitem(item)
+      buffer[#buffer + 1]= Docbook.containersep
+    end
+    return {"<itemizedlist>", Docbook.containersep, buffer, "</itemizedlist>"}
+  end
+
+  function Docbook.orderedlist(items)
+    local buffer = {}
+    for _,item in ipairs(items) do
+      buffer[#buffer + 1] = listitem(item)
+      buffer[#buffer + 1]= Docbook.containersep
+    end
+    return {"<orderedlist>",Docbook.containersep,buffer,"</orderedlist>"}
+  end
+
+  function Docbook.inline_html(s)
+    return s
+  end
+
+  function Docbook.display_html(s)
+    return s
+  end
+
+  function Docbook.emphasis(s)
+    return {"<emphasis>",s,"</emphasis>"}
+  end
+
+  function Docbook.strong(s)
+    return {"<emphasis role=\"strong\">",s,"</emphasis>"}
+  end
+
+  function Docbook.blockquote(s)
+    return {"<blockquote>",Docbook.containersep,s,Docbook.containersep,"</blockquote>"}
+  end
+
+  function Docbook.verbatim(s)
+    return {"<programlisting>",Docbook.string(s),"</programlisting>"}
+  end
+
+  Docbook.fenced_code = Docbook.verbatim
+
+  function Docbook.stop_document()
+    local stop = Docbook.stop_section(1) -- close section containers
+    if stop ~= "" then stop = Docbook.containersep .. stop end
+    return stop
+  end
+
+  function Docbook.header(s,level)
+    local sep = ""
+    if options.slides or options.containers then
+      local lev = (options.slides and 1) or level
+      local stop = Docbook.stop_section(lev)
+      if stop ~= "" then
+        stop = stop .. Docbook.interblocksep
+      end
+      sep = stop .. Docbook.start_section(lev) .. Docbook.containersep
+    end
+    return {sep,"<title>",s,"</title>"}
+  end
+
+  Docbook.hrule = ""
+
+  function Docbook.note(contents)
+    return {"<footnote>",Docbook.containersep,contents,Docbook.containersep,"</footnote>"}
+  end
+
+  function Docbook.definitionlist(items)
+    local buffer = {}
+    for _,item in ipairs(items) do
+      local defs = {}
+      for _,def in ipairs(item.definitions) do
+        defs[#defs + 1] = {"<listitem>",Docbook.containersep,def,Docbook.containersep,"</listitem>"}
+        defs[#defs + 1] = Docbook.containersep
+      end
+      buffer[#buffer + 1] = {"<varlistentry>",Docbook.containersep,"<term>",item.term,"</term>",Docbook.containersep,defs,"</varlistentry>"}
+    end
+    local contents = util.intersperse(buffer, Docbook.containersep)
+    return {"<variablelist>",Docbook.containersep,contents,Docbook.containersep,"</variablelist>"}
+  end
+
+  Docbook.template = [[
+<?xml version="1.0" encoding="utf-8" ?>
+<!DOCTYPE article PUBLIC "-//OASIS//DTD DocBook XML V4.4//EN" "http://www.oasis-open.org/docbook/xml/4.4/docbookx.dtd">
+<article>
+<articleinfo>
+<title>$title</title>
+</articleinfo>
+$body
+</article>
+]]
+
+  return Docbook
+end
+
+return M
diff --git a/lua-libraries/lunamark/writer/dzslides.lua b/lua-libraries/lunamark/writer/dzslides.lua
new file mode 100644
index 00000000..06ff5a66
--- /dev/null
+++ b/lua-libraries/lunamark/writer/dzslides.lua
@@ -0,0 +1,368 @@
+-- (c) 2009-2011 John MacFarlane. Released under MIT license.
+-- See the file LICENSE in the source for details.
+
+--- dzslides writer for lunamark.
+-- dzslides is a lightweight HTML5 slide engine by Paul Rouget:
+-- <https://github.com/paulrouget/dzslides>.
+-- This writer extends [lunamark.writer.html5].
+
+local M = {}
+
+local html5 = require("lunamark.writer.html5")
+
+--- Returns a new dzslides writer.
+-- `options` is as in `lunamark.writer.html5`. However,
+-- `options.slides` is ignored and set to `true`.
+-- For a list of fields, see [lunamark.writer.generic].
+function M.new(options)
+  options = options or {}
+  options.slides = true
+  local DZSlides = html5.new(options)
+
+  DZSlides.template = [===[
+<!DOCTYPE html>
+<head>
+<meta charset="utf-8">
+<title>$title</title>
+</head>
+$if{ title }[=[
+<section>
+  <h1>$title</h1>
+</section>
+]=]
+$body
+<!-- Your Style -->
+<!-- Define the style of you presentation -->
+
+<!-- Maybe a font from http://www.google.com/webfonts ? -->
+<link href='http://fonts.googleapis.com/css?family=Oswald' rel='stylesheet'>
+
+<style>
+  html { background-color: black; }
+  body { background-color: white; }
+  /* A section is a slide. Its size is 800x600, and this will never change */
+  section {
+      /* The font from Google */
+      font-family: 'Oswald', arial, serif;
+      font-size: 2em;
+      padding-left: 1em;
+  }
+  h1, h2, h3 {
+      margin-top: 50px;
+      text-align: center;
+  }
+  ul {
+      margin-left: 40px;
+  }
+  a { color: #FF0066; } a:hover { text-decoration: underline; }
+  footer { position: absolute; bottom: 50px; right: 50px; }
+
+  .images {
+    margin: 20px;
+    text-align: center;
+  }
+
+  /* Transition effect */
+  /* Feel free to change the transition effect for original
+     animations. See here:
+     https://developer.mozilla.org/en/CSS/CSS_transitions
+     How to use CSS3 Transitions: */
+  section {
+      -moz-transition: left 400ms linear 0s;
+      -webkit-transition: left 400ms linear 0s;
+      -ms-transition: left 400ms linear 0s;
+      transition: left 400ms linear 0s;
+  }
+
+  /* Before */
+  section { left: -150%; }
+  /* Now */
+  section[aria-selected] { left: 0; }
+  /* After */
+  section[aria-selected] ~ section { left: +150%; }
+
+  /* Increment with lists */
+  .incremental > * { opacity: 1; }
+  .incremental > *[aria-selected] { color: red; opacity: 1; }
+  .incremental > *[aria-selected] ~ * { opacity: 0.2; }
+  /* Increment with images */
+  .incremental > img[aria-selected] { box-shadow: 0 0 10px #000 }
+
+</style>
+
+
+<!-- {{{{ *****************  DZSlides CORE 2.0b1 *************************** -->
+<!-- *********************************************************************** -->
+<!-- *********************************************************************** -->
+<!-- *********************************************************************** -->
+<!-- *********************************************************************** -->
+
+<!-- This block of code is not supposed to be edited, but if you want to change the behavior of the slides, feel free to hack it ;) -->
+
+<!-- Default Style -->
+<style>
+  * { margin: 0; padding: 0; }
+  details { display: none; }
+  body {
+    width: 800px; height: 600px;
+    margin-left: -400px; margin-top: -300px;
+    position: absolute; top: 50%; left: 50%;
+    overflow: hidden;
+  }
+  html {
+    overflow: hidden;
+  }
+  section {
+    position: absolute;
+    pointer-events: none;
+    width: 95%; height: 100%;
+  }
+  section[aria-selected] { pointer-events: auto; }
+  body { display: none; }
+  body.loaded { display: block; }
+  .incremental {visibility: hidden}
+  .incremental[active] {visibility: visible}
+</style>
+
+<script>
+  var friendWindows = [];
+  var idx, step;
+  var slides;
+
+  /* main() */
+
+  window.onload = function() {
+    slides = document.querySelectorAll("body > section");
+    onhashchange();
+    document.body.className = "loaded";
+    setupTouchEvents();
+    onresize();
+  }
+
+  /* Handle keys */
+
+  window.onkeydown = function(e) {
+    // Don't intercept keyboard shortcuts
+    if (e.altKey || e.ctrlKey || e.metaKey || e.shiftKey) {
+      return;
+    }
+    if ( e.keyCode == 37 // left arrow
+      || e.keyCode == 38 // up arrow
+      || e.keyCode == 33 // page up
+    ) {
+      e.preventDefault();
+      back();
+    }
+    if ( e.keyCode == 39 // right arrow
+      || e.keyCode == 40 // down arrow
+      || e.keyCode == 34 // page down
+    ) {
+      e.preventDefault();
+      forward();
+    }
+    if (e.keyCode == 35) { // end
+      e.preventDefault();
+      end();
+    }
+    if (e.keyCode == 36) { // home
+      e.preventDefault();
+      start();
+    }
+
+    if ( e.keyCode == 32) { // space
+        e.preventDefault();
+        toggleContent();
+    }
+  }
+
+  /* Touch Events */
+
+  function setupTouchEvents() {
+    var orgX, newX;
+    var tracking = false;
+
+    var db = document.body;
+    db.addEventListener("touchstart", start, false);
+    db.addEventListener("touchmove", move, false);
+
+    function start(e) {
+      e.preventDefault();
+      tracking = true;
+      orgX = e.changedTouches[0].pageX;
+    }
+
+    function move(e) {
+      if (!tracking) return;
+      newX = e.changedTouches[0].pageX;
+      if (orgX - newX > 100) {
+        tracking = false;
+        forward();
+      } else {
+        if (orgX - newX < -100) {
+          tracking = false;
+          back();
+        }
+      }
+    }
+  }
+
+  /* Adapt the size of the slides to the window */
+
+  window.onresize = function() {
+    var db = document.body;
+    var sx = db.clientWidth / window.innerWidth;
+    var sy = db.clientHeight / window.innerHeight;
+    var transform = "scale(" + (1/Math.max(sx, sy)) + ")";
+    db.style.MozTransform = transform;
+    db.style.WebkitTransform = transform;
+    db.style.OTransform = transform;
+    db.style.msTransform = transform;
+    db.style.transform = transform;
+  }
+  function getDetails(idx) {
+    var s = document.querySelector("section:nth-of-type("+ idx +")");
+    var d = s.querySelector("details");
+    return d?d.innerHTML:"";
+  }
+  window.onmessage = function(e) {
+    var msg = e.data;
+    var win = e.source;
+    if (msg === "register") {
+      friendWindows.push(win);
+      win.postMessage(JSON.stringify({method: "registered", title: document.title, count: slides.length}), "*");
+      win.postMessage(JSON.stringify({method: "newslide", details: getDetails(idx), idx: idx}), "*");
+      return;
+    }
+    if (msg === "back") back();
+    if (msg === "forward") forward();
+    if (msg === "toggleContent") toggleContent();
+    // setSlide(42)
+    var r = /setSlide\((\d+)\)/.exec(msg);
+    if (r) {
+        setSlide(r[1]);
+    }
+  }
+
+  /* If a Video is present in this new slide, play it.
+     If a Video is present in the previous slide, stop it. */
+
+  function toggleContent() {
+    var s = document.querySelector("section[aria-selected]");
+    if (s) {
+        var video = s.querySelector("video");
+        if (video) {
+            if (video.ended || video.paused) {
+                video.play();
+            } else {
+                video.pause();
+            }
+        }
+    }
+  }
+
+  /* If the user change the slide number in the URL bar, jump
+     to this slide. */
+
+  function setCursor(aIdx, aStep) {
+    aStep = (aStep != 0 && typeof aStep !== "undefined") ? "." + aStep : "";
+    window.location.hash = "#" + aIdx + aStep;
+  }
+  window.onhashchange = function(e) {
+    var cursor = window.location.hash.split("#"), newidx = 1, newstep = 0;
+    if (cursor.length == 2) {
+      newidx = ~~cursor[1].split(".")[0];
+      newstep = ~~cursor[1].split(".")[1];
+    }
+    if (newidx != idx) setSlide(newidx);
+    setIncremental(newstep);
+  }
+
+  /* Slide controls */
+
+  function back() {
+    if (idx == 1 && step == 0) return;
+    if (step == 0)
+      setCursor(idx - 1, slides[idx - 2].querySelectorAll('.incremental > *').length);
+    else
+      setCursor(idx, step - 1);
+  }
+  function forward() {
+    if (idx >= slides.length && step >= slides[idx - 1].querySelectorAll('.incremental > *').length) return;
+    if (step >= slides[idx - 1].querySelectorAll('.incremental > *').length)
+      setCursor(idx + 1, 0);
+    else
+      setCursor(idx, step + 1);
+  }
+  function start() {
+    setCursor(1, 0);
+  }
+  function end() {
+    var lastIdx = slides.length;
+    var lastStep = slides[lastIdx - 1].querySelectorAll('.incremental > *').length;
+    setCursor(lastIdx, lastStep);
+  }
+
+  function setSlide(aIdx) {
+    idx = aIdx;
+    var old = document.querySelector("section[aria-selected]");
+    var next = document.querySelector("section:nth-of-type("+ idx +")");
+    if (old) {
+      old.removeAttribute("aria-selected");
+      var video = old.querySelector("video");
+      if (video) { video.pause(); }
+    }
+    if (next) {
+      next.setAttribute("aria-selected", "true");
+      var video = next.querySelector("video");
+      if (video) { video.play(); }
+    } else {
+      idx = 0;
+      for (var i = 0, l = slides.length; i < l; i++) {
+          if (slides[i].hasAttribute("aria-selected")) {
+              idx = i + 1;
+          }
+      }
+    }
+    for (var i = 0, l = friendWindows.length; i < l; i++) {
+        friendWindows[i].postMessage(JSON.stringify({method: "newslide", details: getDetails(idx), idx: idx}), "*");
+    }
+  }
+  function setIncremental(aStep) {
+    step = aStep;
+    var old = slides[idx-1].querySelector('.incremental > *[aria-selected]');
+    if (old)
+      old.removeAttribute('aria-selected');
+    var incrementals = slides[idx-1].querySelectorAll('.incremental');
+    if (step == 0) {
+      for (var i = 0; i < incrementals.length; i++) {
+        incrementals[i].removeAttribute('active');
+      }
+      return;
+    }
+    var next = slides[idx-1].querySelectorAll('.incremental > *')[step-1];
+    if (next) {
+      next.setAttribute('aria-selected', true);
+      next.parentNode.setAttribute('active', true);
+      var found = false;
+      for (var i = 0; i < incrementals.length; i++) {
+        if (incrementals[i] != next.parentNode)
+          if (found)
+            incrementals[i].removeAttribute('active');
+          else
+            incrementals[i].setAttribute('active', true);
+        else
+          found = true;
+      }
+    } else {
+      setCursor(idx, 0);
+    }
+    return next;
+  }
+</script>
+<!-- vim: set fdm=marker: }}} -->
+]===]
+
+  return DZSlides
+end
+
+return M
diff --git a/lua-libraries/lunamark/writer/generic.lua b/lua-libraries/lunamark/writer/generic.lua
new file mode 100644
index 00000000..92133e47
--- /dev/null
+++ b/lua-libraries/lunamark/writer/generic.lua
@@ -0,0 +1,294 @@
+-- (c) 2009-2011 John MacFarlane. Released under MIT license.
+-- See the file LICENSE in the source for details.
+
+--- Generic writer for lunamark.
+-- This serves as generic documentation for lunamark writers,
+-- which all export a table with the same functions defined.
+--
+-- New writers can simply modify the generic writer: for example,
+--
+--     local Xml = generic.new(options)
+--
+--     Xml.linebreak = "<linebreak />"
+--
+--     local escaped = {
+--          ["<" ] = "&lt;",
+--          [">" ] = "&gt;",
+--          ["&" ] = "&amp;",
+--          ["\"" ] = "&quot;",
+--          ["'" ] = "&#39;"
+--     }
+--
+--     function Xml.string(s)
+--       return s:gsub(".",escaped)
+--     end
+
+local util = require("lunamark.util")
+local M = {}
+local W = {}
+
+local meta = {}
+meta.__index =
+  function(_, key)
+    io.stderr:write(string.format("WARNING: Undefined writer function '%s'\n",key))
+    return (function(...) return table.concat({...}," ") end)
+  end
+setmetatable(W, meta)
+
+local rope_to_string = util.rope_to_string
+
+--- Returns a table with functions defining a generic lunamark writer,
+-- which outputs plain text with no formatting.  `options` is an optional
+-- table with the following fields:
+--
+-- `layout`
+-- :   `minimize` (no space between blocks)
+-- :   `compact` (no extra blank lines between blocks)
+-- :   `default` (blank line between blocks)
+function M.new(options)
+
+--- The table contains the following fields:
+
+  options = options or {}
+  local metadata = {}
+
+  --- Set metadata field `key` to `val`.
+  function W.set_metadata(key, val)
+    metadata[key] = val
+    return ""
+  end
+
+  --- Add `val` to an array in metadata field `key`.
+  function W.add_metadata(key, val)
+    local cur = metadata[key]
+    if type(cur) == "table" then
+      table.insert(cur,val)
+    elseif cur then
+      metadata[key] = {cur, val}
+    else
+      metadata[key] = {val}
+    end
+  end
+
+  --- Return metadata table.
+  function W.get_metadata()
+    return metadata
+  end
+
+  -- Turn list of output into final result.
+  function W.merge(result)
+    return rope_to_string(result)
+  end
+
+  --- A space (string).
+  W.space = " "
+
+  --- Setup tasks at beginning of document.
+  function W.start_document()
+    return ""
+  end
+
+  --- Finalization tasks at end of document.
+  function W.stop_document()
+    return ""
+  end
+
+  --- Plain text block (not formatted as a pragraph).
+  function W.plain(s)
+    return s
+  end
+
+  --- A line break (string).
+  W.linebreak = "\n"
+
+  --- Line breaks to use between block elements.
+  W.interblocksep = "\n\n"
+
+  --- Line breaks to use between a container (like a `<div>`
+  -- tag) and the adjacent block element.
+  W.containersep = "\n"
+
+  if options.layout == "minimize" then
+    W.interblocksep = ""
+    W.containersep = ""
+  elseif options.layout == "compact" then
+    W.interblocksep = "\n"
+    W.containersep = "\n"
+  end
+
+  --- Ellipsis (string).
+  W.ellipsis = "…"
+
+  --- Em dash (string).
+  W.mdash = "—"
+
+  --- En dash (string).
+  W.ndash = "–"
+
+  --- Non-breaking space.
+  W.nbsp = " "
+
+  --- String in curly single quotes.
+  function W.singlequoted(s)
+    return {"‘", s, "’"}
+  end
+
+  --- String in curly double quotes.
+  function W.doublequoted(s)
+    return {"“", s, "”"}
+  end
+
+  --- String, escaped as needed for the output format.
+  function W.string(s)
+    return s
+  end
+
+  --- Inline (verbatim) code.
+  function W.code(s)
+    return s
+  end
+
+  --- A link with link text `label`, uri `uri`,
+  -- and title `title`.
+  function W.link(label, uri, title)
+    return label
+  end
+
+  --- An image link with alt text `label`,
+  -- source `src`, and title `title`.
+  function W.image(label, src, title)
+    return label
+  end
+
+  --- A paragraph.
+  function W.paragraph(s)
+    return s
+  end
+
+  --- A bullet list with contents `items` (an array).  If
+  -- `tight` is true, returns a "tight" list (with
+  -- minimal space between items).
+  function W.bulletlist(items,tight)
+    return util.intersperse(items,W.interblocksep)
+  end
+
+  --- An ordered list with contents `items` (an array). If
+  -- `tight` is true, returns a "tight" list (with
+  -- minimal space between items). If optional
+  -- number `startnum` is present, use it as the
+  -- number of the first list item.
+  function W.orderedlist(items,tight,startnum)
+    return util.intersperse(items,W.interblocksep)
+  end
+
+  --- Inline HTML.
+  function W.inline_html(s)
+    return ""
+  end
+
+  --- Display HTML (HTML block).
+  function W.display_html(s)
+    return ""
+  end
+
+  --- Emphasized text.
+  function W.emphasis(s)
+    return s
+  end
+
+  --- Strongly emphasized text.
+  function W.strong(s)
+    return s
+  end
+
+  --- Block quotation.
+  function W.blockquote(s)
+    return s
+  end
+
+  --- Verbatim block.
+  function W.verbatim(s)
+    return s
+  end
+
+  --- Fenced code block, with infostring `i`.
+  function W.fenced_code(s, i)
+    return s
+  end
+
+  --- Header level `level`, with text `s`.
+  function W.header(s, level)
+    return s
+  end
+
+  --- Horizontal rule.
+  W.hrule = ""
+
+  --- A string of one or more citations. `text_cites` is a boolean, true if the
+  -- citations are in-text citations. `cites` - is an array of tables, each of
+  -- the form `{ prenote = q, name = n, postnote = e, suppress_author = s }`,
+  -- where:
+  -- - `q` is a nil or a rope that should be inserted before the citation,
+  -- - `e` is a nil or a rope that should be inserted after the citation,
+  -- - `n` is a string with the citation name, and
+  -- - `s` is a boolean, true if the author should be omitted from the
+  --   citation.
+  function W.citations(text_cites, cites)
+    local buffer = {}
+    local opened_brackets = false
+    for i, cite in ipairs(cites) do
+      if i == 1 then -- Opening in-text citation
+        if text_cites then
+          buffer[#buffer + 1] = {cite.suppress_author and "-" or "", "@",
+            cite.name}
+          if cite.postnote then
+            opened_brackets = true
+            buffer[#buffer + 1] = {" [", cite.postnote}
+          end
+        else -- Opening regular citation
+          opened_brackets = true
+          buffer[#buffer + 1] = {"[", cite.prenote and {cite.prenote, " "} or "",
+            cite.suppress_author and "-" or "", "@", cite.name, cite.postnote and
+            {" ", cite.postnote}}
+        end
+      else -- Continuation citation
+        buffer[#buffer + 1] = {"; ", cite.prenote and {cite.prenote, " "} or "",
+          cite.suppress_author and "-" or "", "@", cite.name, cite.postnote and
+          {" ", cite.postnote}}
+      end
+    end
+    if opened_brackets then
+      buffer[#buffer + 1] = "]"
+    end
+    return buffer
+  end
+
+  --- A footnote or endnote.
+  function W.note(contents)
+    return contents
+  end
+
+  --- A definition list. `items` is an array of tables,
+  -- each of the form `{ term = t, definitions = defs, tight = tight }`,
+  -- where `t` is a string and `defs` is an array of strings.
+  -- `tight` is a boolean, true if it is a tight list.
+  function W.definitionlist(items, tight)
+    local buffer = {}
+    for _,item in ipairs(items) do
+      buffer[#buffer + 1] = item.t
+      buffer[#buffer + 1] = util.intersperse(item.definitions, W.interblocksep)
+    end
+    return util.intersperse(buffer,W.interblocksep)
+  end
+
+  --- A cosmo template to be used in producing a standalone document.
+  -- `$body` is replaced with the document body, `$title` with the
+  -- title, and so on.
+  W.template = [[
+$body
+]]
+
+  return util.table_copy(W)
+end
+
+return M
diff --git a/lua-libraries/lunamark/writer/groff.lua b/lua-libraries/lunamark/writer/groff.lua
new file mode 100644
index 00000000..d722fea9
--- /dev/null
+++ b/lua-libraries/lunamark/writer/groff.lua
@@ -0,0 +1,81 @@
+-- (c) 2009-2011 John MacFarlane. Released under MIT license.
+-- See the file LICENSE in the source for details.
+
+--- Generic groff writer for lunamark.
+-- This is currently used as the basis for [lunamark.writer.man].
+-- In principle other groff-based writers could also extend it.
+
+local M = {}
+
+local util = require("lunamark.util")
+local generic = require("lunamark.writer.generic")
+
+--- Returns a new Groff writer.
+-- For a list of all fields, see [lunamark.writer.generic].
+function M.new(options)
+  options = options or {}
+  local Groff = generic.new(options)
+
+  Groff.interblocksep = "\n\n"  -- insensitive to layout
+
+  Groff.containersep = "\n"
+
+  Groff.linebreak = ".br\n"
+
+  Groff.ellipsis = "\\&..."
+
+  Groff.mdash = "\\[em]"
+
+  Groff.ndash = "\\[en]"
+
+  Groff.nbsp = "\\~"
+
+  function Groff.singlequoted(s)
+    return {"`",s,"'"}
+  end
+
+  function Groff.doublequoted(s)
+    return {"\\[lq]",s,"\\[rq]"}
+  end
+
+  Groff.escaped = {
+     ["@"] = "\\@",
+     ["\\"] = "\\\\",
+   }
+
+  local escaped_utf8_triplet = {
+    ["\226\128\156"] = "\\[lq]",
+    ["\226\128\157"] = "\\[rq]",
+    ["\226\128\152"] = "`",
+    ["\226\128\153"] = "'",
+    ["\226\128\148"] = "\\[em]",
+    ["\226\128\147"] = "\\[en]",
+    ["\194\160"]     = "\\ ",
+  }
+
+  local escape = util.escaper(Groff.escaped, escaped_utf8_triplet)
+
+  Groff.string = escape
+
+  function Groff.inline_html(s)
+  end
+
+  function Groff.display_html(s)
+  end
+
+  function Groff.code(s)
+    return {"\\f[C]",s,"\\f[]"}
+  end
+
+  function Groff.emphasis(s)
+    return {"\\f[I]",s,"\\f[]"}
+  end
+
+  function Groff.strong(s)
+    return {"\\f[B]",s,"\\f[]"}
+  end
+
+  return Groff
+end
+
+return M
diff --git a/lua-libraries/lunamark/writer/html.lua b/lua-libraries/lunamark/writer/html.lua
new file mode 100644
index 00000000..eba6e8eb
--- /dev/null
+++ b/lua-libraries/lunamark/writer/html.lua
@@ -0,0 +1,191 @@
+-- (c) 2009-2011 John MacFarlane. Released under MIT license.
+-- See the file LICENSE in the source for details.
+
+--- HTML writer for lunamark.
+-- Extends [lunamark.writer.xml].
+
+local M = {}
+
+local xml = require("lunamark.writer.xml")
+local util = require("lunamark.util")
+local flatten, intersperse, map = util.flatten, util.intersperse, util.map
+
+--- Return a new HTML writer.
+-- For a list of all fields in the writer, see [lunamark.writer.generic].
+--
+--`options` is a table that can contain the following fields:
+--
+-- `containers`
+-- :   Put sections in `<div>` tags.
+--
+-- `slides`
+-- :   Do not allow containers to nest; when a subsection begins,
+--     close the section's container and start a new one.
+--
+-- `layout`
+-- :   `minimize` removes semantically insignificant white space.
+-- :   `compact` removes unneeded blank lines.
+-- :   `default` puts blank lines between block elements.
+function M.new(options)
+  options = options or {}
+  local Html = xml.new(options)
+
+  local endnotes = {}
+  local containersep = Html.containersep
+  local interblocksep = Html.interblocksep
+
+  Html.container = "div"
+  Html.linebreak = "<br/>"
+  Html.nbsp = "&nbsp;"
+
+  function Html.code(s)
+    return {"<code>", Html.string(s), "</code>"}
+  end
+
+  function Html.link(lab,src,tit)
+    local titattr
+    if type(tit) == "string" and #tit > 0
+       then titattr = " title=\"" .. Html.string(tit) .. "\""
+       else titattr = ""
+       end
+    return {"<a href=\"", Html.string(src), "\"", titattr, ">", lab, "</a>"}
+  end
+
+  function Html.image(lab,src,tit)
+    local titattr
+    if type(tit) == "string" and #tit > 0
+       then titattr = " title=\"" .. Html.string(tit) .. "\""
+       else titattr = ""
+       end
+    return {"<img src=\"", Html.string(src), "\" alt=\"", lab, "\"", titattr, " />"}
+  end
+
+  function Html.paragraph(s)
+    return {"<p>", s, "</p>"}
+  end
+
+  local function listitem(s)
+    return {"<li>", s, "</li>"}
+  end
+
+  function Html.bulletlist(items,tight)
+    return {"<ul>", containersep, intersperse(map(items, listitem), containersep), containersep, "</ul>"}
+  end
+
+  function Html.orderedlist(items,tight,startnum)
+    local start = ""
+    if startnum and startnum ~= 1 then
+      start = " start=\"" .. startnum .. "\""
+    end
+    return {"<ol", start, ">", containersep, intersperse(map(items, listitem), containersep), containersep, "</ol>"}
+  end
+
+  function Html.inline_html(s)
+    return s
+  end
+
+  function Html.display_html(s)
+    return s
+  end
+
+  function Html.emphasis(s)
+    return {"<em>", s, "</em>"}
+  end
+
+  function Html.strong(s)
+    return {"<strong>", s, "</strong>"}
+  end
+
+  function Html.blockquote(s)
+    return {"<blockquote>", containersep, s, containersep, "</blockquote>"}
+  end
+
+  function Html.verbatim(s)
+    return {"<pre><code>", Html.string(s), "</code></pre>"}
+  end
+
+  function Html.fenced_code(s,i)
+    if i ~= "" then
+      return {'<pre><code class="language-', i:match("[^ ]*"),
+        '">', Html.string(s), "</code></pre>"}
+    else
+      return Html.verbatim(s)
+    end
+  end
+
+  function Html.header(s,level)
+    local sep = ""
+    if options.slides or options.containers then
+      local lev = (options.slides and 1) or level
+      local stop = Html.stop_section(lev)
+      if stop ~= "" then
+        stop = stop .. Html.interblocksep
+      end
+      sep = stop .. Html.start_section(lev) .. Html.containersep
+    end
+    return {sep, "<h", level, ">", s, "</h", level, ">"}
+  end
+
+  Html.hrule = "<hr />"
+
+  function Html.note(contents)
+    local num = #endnotes + 1
+    local backref = ' <a href="#fnref' .. num .. '" class="footnoteBackLink">↩</a>'
+    local contentsf = flatten(contents)
+    if contentsf[#contentsf] == "</p>" then
+      table.insert(contentsf, #contentsf, backref)
+    else
+      contentsf[#contentsf + 1] = backref
+    end
+    endnotes[num] = {'<li id="fn', num, '">', contentsf, '</li>'}
+    return {'<sup><a href="#fn', num, '" class="footnoteRef" id="fnref', num, '">', num, '</a></sup>'}
+  end
+
+  function Html.start_document()
+    endnotes = {}
+    return ""
+  end
+
+  function Html.stop_document()
+    return function()
+      local stop = Html.stop_section(1) -- close section containers
+      if stop ~= "" then stop = Html.containersep .. stop end
+      if #endnotes == 0 then
+        return stop
+      else
+        return {stop, interblocksep, '<hr />', interblocksep, '<ol class="notes">',
+           containersep, intersperse(endnotes, interblocksep), containersep, '</ol>'}
+      end
+    end
+  end
+
+  function Html.definitionlist(items, tight)
+    local buffer = {}
+    local sep
+    if tight then sep = "" else sep = Html.containersep end
+    for _,item in ipairs(items) do
+      local defs = {}
+      for _,def in ipairs(item.definitions) do
+        defs[#defs + 1] = {"<dd>", sep, def, sep, "</dd>"}
+      end
+      buffer[#buffer + 1] = {"<dt>", item.term, "</dt>", containersep, intersperse(defs, containersep)}
+    end
+    return {"<dl>", containersep, intersperse(buffer, containersep), containersep, "</dl>"}
+  end
+
+  Html.template = [[
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+<title>$title</title>
+</head>
+<body>
+$body
+</body>
+</html>
+]]
+
+  return Html
+end
+
+return M
diff --git a/lua-libraries/lunamark/writer/html5.lua b/lua-libraries/lunamark/writer/html5.lua
new file mode 100644
index 00000000..cfb1db93
--- /dev/null
+++ b/lua-libraries/lunamark/writer/html5.lua
@@ -0,0 +1,37 @@
+-- (c) 2009-2011 John MacFarlane. Released under MIT license.
+-- See the file LICENSE in the source for details.
+
+--- HTML 5 writer for lunamark.
+-- Extends [lunamark.writer.html], but uses `<section>` tags for sections
+-- if `options.containers` is true.
+
+local M = {}
+
+local html = require("lunamark.writer.html")
+
+--- Returns a new HTML 5 writer.
+-- `options` is as in `lunamark.writer.html`.
+-- For a list of fields, see [lunamark.writer.generic].
+function M.new(options)
+  options = options or {}
+  local Html5 = html.new(options)
+
+  Html5.container = "section"
+
+  Html5.template = [[
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>$title</title>
+</head>
+<body>
+$body
+</body>
+</html>
+]]
+
+  return Html5
+end
+
+return M
diff --git a/lua-libraries/lunamark/writer/latex.lua b/lua-libraries/lunamark/writer/latex.lua
new file mode 100644
index 00000000..3b9f7e3c
--- /dev/null
+++ b/lua-libraries/lunamark/writer/latex.lua
@@ -0,0 +1,260 @@
+-- (c) 2009-2011 John MacFarlane. Released under MIT license.
+-- See the file LICENSE in the source for details.
+
+--- LaTeX writer for lunamark.
+-- Extends the [lunamark.writer.tex].
+
+local M = {}
+
+local tex = require("lunamark.writer.tex")
+local util = require("lunamark.util")
+local format = string.format
+
+--- Returns a new LaTeX writer.
+--
+-- *   `options` is a table with parsing options.
+--     The following fields are significant:
+--
+--     `citations`
+--     :   Enable citations as in pandoc. Either a boolean or one of
+--         the following strings should be specified:
+--
+--         - `latex`    -- produce basic LaTeX2e citations,
+--         - `natbib`   -- produce citations for the Natbib package, or
+--         - `biblatex` -- produce citations for the BibLaTeX package.
+--
+-- For a list of fields in the writer, see [lunamark.writer.generic].
+function M.new(options)
+  options = options or {}
+  local LaTeX = tex.new(options)
+
+  function LaTeX.code(s)
+    return {"\\texttt{",LaTeX.string(s),"}"}
+  end
+
+  function LaTeX.link(lab,src,tit)
+    return {"\\href{",LaTeX.string(src),"}{",lab,"}"}
+  end
+
+  function LaTeX.image(lab,src,tit)
+    return {"\\includegraphics{",LaTeX.string(src),"}"}
+  end
+
+  local function listitem(s)
+    return {"\\item ",s}
+  end
+
+  function LaTeX.bulletlist(items)
+    local buffer = {}
+    for _,item in ipairs(items) do
+      buffer[#buffer + 1] = listitem(item)
+    end
+    local contents = util.intersperse(buffer,"\n")
+    return {"\\begin{itemize}\n",contents,"\n\\end{itemize}"}
+  end
+
+  function LaTeX.orderedlist(items)
+    local buffer = {}
+    for _,item in ipairs(items) do
+      buffer[#buffer + 1] = listitem(item)
+    end
+    local contents = util.intersperse(buffer,"\n")
+    return {"\\begin{enumerate}\n",contents,"\n\\end{enumerate}"}
+  end
+
+  function LaTeX.emphasis(s)
+    return {"\\emph{",s,"}"}
+  end
+
+  function LaTeX.strong(s)
+    return {"\\textbf{",s,"}"}
+  end
+
+  function LaTeX.blockquote(s)
+    return {"\\begin{quote}\n",s,"\n\\end{quote}"}
+  end
+
+  function LaTeX.verbatim(s)
+    return {"\\begin{verbatim}\n",s,"\\end{verbatim}"}
+  end
+
+  LaTeX.fenced_code = LaTeX.verbatim
+
+  function LaTeX.header(s,level)
+    local cmd
+    if level == 1 then
+      cmd = "\\section"
+    elseif level == 2 then
+      cmd = "\\subsection"
+    elseif level == 3 then
+      cmd = "\\subsubsection"
+    elseif level == 4 then
+      cmd = "\\paragraph"
+    elseif level == 5 then
+      cmd = "\\subparagraph"
+    else
+      cmd = ""
+    end
+    return {cmd,"{",s,"}"}
+  end
+
+  LaTeX.hrule = "\\hspace{\\fill}\\rule{.6\\linewidth}{0.4pt}\\hspace{\\fill}"
+
+  function LaTeX.note(contents)
+    return {"\\footnote{",contents,"}"}
+  end
+
+  local function citation_optargs(cite)
+    if cite.prenote and cite.postnote then
+      return {"[", cite.prenote, "][", cite.postnote, "]"}
+    elseif cite.prenote and not cite.postnote then
+      return {"[", cite.prenote, "][]"}
+    elseif not cite.prenote and cite.postnote then
+      return {"[", cite.postnote, "]"}
+    else
+      return ""
+    end
+  end
+
+  if options.citations == true or options.citations == "latex" then
+    --- Basic LaTeX2e citations
+    function LaTeX.citations(_, cites)
+      local buffer = {}
+      local opened_braces = false
+      for i, cite in ipairs(cites) do
+        if cite.prenote or cite.postnote then -- A separate complex citation
+          buffer[#buffer + 1] = {opened_braces and "}" or "",
+            cite.prenote and {i == 1 and "" or " ", cite.prenote, "~"} or
+            "", {(i == 1 or cite.prenote) and "" or " ", "\\cite"},
+            cite.postnote and {"[", cite.postnote, "]"} or "", "{", cite.name,
+            cite_postnote and {"~", cite_postnote} or "", "}"}
+          opened_braces = false
+        else -- A string of simple citations
+          buffer[#buffer + 1] = {opened_braces and ", " or {i == 1 and "" or
+            " ", "\\cite{"}, cite.name}
+          opened_braces = true
+        end
+      end
+      if opened_braces then
+        buffer[#buffer + 1] = "}"
+      end
+      return buffer
+    end
+  elseif options.citations == "natbib" then
+    --- NatBib citations
+    function LaTeX.citations(text_cites, cites)
+      if #cites == 1 then -- A single citation
+        local cite = cites[1]
+        if text_cites then
+          return {"\\citet", citation_optargs(cite), "{", cite.name, "}"}
+        else
+          return {cite.suppress_author and "\\citeyearpar" or "\\citep",
+            citation_optargs(cite), "{", cite.name, "}"}
+        end
+      else -- A string of citations
+        local complex = false
+        local last_suppressed = nil
+        for _, cite in ipairs(cites) do
+          if cite.prenote or cite.postnote or
+             cite.suppress_author == not last_suppressed then
+            complex = true
+            break
+          end
+          last_suppressed = cite.suppress_author
+        end
+        if complex then -- A string of complex citations
+          local buffer = {"\\citetext{"}
+          for i, cite in ipairs(cites) do
+            buffer[#buffer + 1] = {i ~= 1 and "; " or "", cite.suppress_author
+              and "\\citeyear" or (text_cites and "\\citealt" or "\\citealp"),
+              citation_optargs(cite), "{", cite.name, "}"}
+          end
+          buffer[#buffer + 1] = "}"
+          return buffer
+        else -- A string of simple citations
+          local buffer = {}
+          for i, cite in ipairs(cites) do
+            buffer[#buffer + 1] = {i == 1 and (text_cites and "\\citet{" or
+              "\\citep{") or ", ", cite.name}
+          end
+          buffer[#buffer + 1] = "}"
+          return buffer
+        end
+      end
+    end
+  elseif options.citations == "biblatex" then
+    --- BibLaTeX citations
+    function LaTeX.citations(text_cites, cites)
+      if #cites == 1 then -- A single citation
+        local cite = cites[1]
+        if text_cites then
+          return {"\\textcite", citation_optargs(cite), "{", cite.name, "}"}
+        else
+          return {"\\autocite", cite.suppress_author and "*" or "",
+            citation_optargs(cite), "{", cite.name, "}"}
+        end
+      else -- A string of citations
+        local buffer = {text_cites and "\\textcites" or "\\autocites"}
+        for _, cite in ipairs(cites) do
+          buffer[#buffer + 1] = {citation_optargs(cite), "{", cite.name, "}"}
+        end
+        return buffer
+      end
+    end
+  end
+
+  function LaTeX.definitionlist(items)
+    local buffer = {}
+    for _,item in ipairs(items) do
+      buffer[#buffer + 1] = format("\\item[%s]\n%s",
+        item.term, util.intersperse(item.definitions, LaTeX.interblocksep))
+    end
+    local contents = util.intersperse(buffer, LaTeX.containersep)
+    return {"\\begin{description}\n",contents,"\n\\end{description}"}
+  end
+
+  LaTeX.template = [===[
+\documentclass{article}
+\usepackage{amssymb,amsmath}
+\usepackage{ifxetex,ifluatex}
+\ifxetex
+  \usepackage{fontspec,xltxtra,xunicode}
+  \defaultfontfeatures{Mapping=tex-text,Scale=MatchLowercase}
+\else
+  \ifluatex
+    \usepackage{fontspec}
+    \defaultfontfeatures{Mapping=tex-text,Scale=MatchLowercase}
+  \else
+    \usepackage[utf8]{inputenc}
+  \fi
+\fi
+\ifxetex
+  \usepackage[setpagesize=false, % page size defined by xetex
+              unicode=false, % unicode breaks when used with xetex
+              xetex]{hyperref}
+\else
+  \usepackage[unicode=true]{hyperref}
+\fi
+\hypersetup{breaklinks=true, pdfborder={0 0 0}}
+\setlength{\parindent}{0pt}
+\setlength{\parskip}{6pt plus 2pt minus 1pt}
+\setlength{\emergencystretch}{3em}  % prevent overfull lines
+\setcounter{secnumdepth}{0}
+
+\title{$title}
+\author{$sepby{author}[=[$it]=][=[ \and ]=]}
+\date{$date}
+
+\begin{document}
+
+$if{ title }[[\maketitle
+]]
+$body
+
+\end{document}
+]===]
+
+  return LaTeX
+end
+
+return M
diff --git a/lua-libraries/lunamark/writer/man.lua b/lua-libraries/lunamark/writer/man.lua
new file mode 100644
index 00000000..db4992a6
--- /dev/null
+++ b/lua-libraries/lunamark/writer/man.lua
@@ -0,0 +1,130 @@
+-- (c) 2009-2011 John MacFarlane. Released under MIT license.
+-- See the file LICENSE in the source for details.
+
+--- Groff man writer for lunamark.
+-- Extends [lunamark.writer.groff].
+--
+-- Note: continuation paragraphs in lists are not
+-- handled properly.
+
+local M = {}
+
+local groff = require("lunamark.writer.groff")
+local util = require("lunamark.util")
+local format = string.format
+
+--- Returns a new groff writer.
+-- For a list of fields, see [lunamark.writer.generic].
+function M.new(options)
+  options = options or {}
+  local Man = groff.new(options)
+
+  local endnotes = {}
+
+  function Man.link(lab,src,tit)
+    return {lab," (",src,")"}
+  end
+
+  function Man.image(lab,src,tit)
+    return {"[IMAGE (",lab,")]"}
+  end
+
+  -- TODO handle continuations properly.
+  -- pandoc does this:
+  -- .IP \[bu] 2
+  -- one
+  -- .RS 2
+  -- .PP
+  -- cont
+  -- .RE
+
+  function Man.paragraph(contents)
+    return {".PP\n",contents}
+  end
+
+  function Man.bulletlist(items,tight)
+    local buffer = {}
+    for _,item in ipairs(items) do
+      local revitem = item
+      -- we don't want to have .IP then .PP
+      if revitem[1][1] == ".PP\n" then revitem[1][1] = "" end
+      buffer[#buffer + 1] = {".IP \\[bu] 2\n",item}
+    end
+    return util.intersperse(buffer, Man.containersep)
+  end
+
+  function Man.orderedlist(items,tight,startnum)
+    local buffer = {}
+    local num = startnum or 1
+    for _,item in ipairs(items) do
+      local revitem = item
+      -- we don't want to have .IP then .PP
+      if revitem[1][1] == ".PP\n" then revitem[1][1] = "" end
+      buffer[#buffer + 1] = {format(".IP \"%d.\" 4\n",num),item}
+      num = num + 1
+    end
+    return util.intersperse(buffer, Man.containersep)
+  end
+
+  function Man.blockquote(s)
+    return {".RS\n",s,"\n.RE"}
+  end
+
+  function Man.verbatim(s)
+    return {".IP\n.nf\n\\f[C]\n",s,".fi"}
+  end
+
+  Man.fenced_code = Man.verbatim
+
+  function Man.header(s,level)
+    local hcode = ".SS"
+    if level == 1 then hcode = ".SH" end
+    return {hcode," ",s}
+  end
+
+  Man.hrule = ".PP\n * * * * *"
+
+  function Man.note(contents)
+    local num = #endnotes + 1
+    endnotes[num] = {format(".SS [%d]\n",num),contents}
+    return format('[%d]', num)
+  end
+
+  function Man.definitionlist(items,tight)
+    local buffer = {}
+    local ds
+    for _,item in ipairs(items) do
+        if tight then
+          ds = util.intersperse(item.definitions,"\n.RS\n.RE\n")
+          buffer[#buffer + 1] = {".TP\n.B ",item.term,"\n",ds,"\n.RS\n.RE"}
+        else
+          ds = util.intersperse(item.definitions,"\n.RS\n.RE\n")
+          buffer[#buffer + 1] = {".TP\n.B ",item.term,"\n.RS\n",ds,"\n.RE"}
+        end
+    end
+    local contents = util.intersperse(buffer,"\n")
+    return contents
+  end
+
+  function Man.start_document()
+    endnotes = {}
+    return ""
+  end
+
+  function Man.stop_document()
+    if #endnotes == 0 then
+      return ""
+    else
+      return {"\n.SH NOTES\n", util.intersperse(endnotes, "\n")}
+    end
+  end
+
+  Man.template = [===[
+.TH "$title" "$section" "$date" "$left_footer" "$center_header"
+$body
+]===]
+
+  return Man
+end
+
+return M
diff --git a/lua-libraries/lunamark/writer/tex.lua b/lua-libraries/lunamark/writer/tex.lua
new file mode 100644
index 00000000..09cb24e0
--- /dev/null
+++ b/lua-libraries/lunamark/writer/tex.lua
@@ -0,0 +1,89 @@
+-- (c) 2009-2011 John MacFarlane. Released under MIT license.
+-- See the file LICENSE in the source for details.
+
+--- Generic TeX writer for lunamark.
+-- It extends [lunamark.writer.generic] and is extended by
+-- [lunamark.writer.latex] and [lunamark.writer.context].
+
+local M = {}
+
+local util = require("lunamark.util")
+local generic = require("lunamark.writer.generic")
+local format = string.format
+
+--- Returns a new TeX writer.
+-- For a list ofy fields, see [lunamark.writer.generic].
+function M.new(options)
+  options = options or {}
+  local TeX = generic.new(options)
+
+  TeX.interblocksep = "\n\n"  -- insensitive to layout
+
+  TeX.containersep = "\n"
+
+  TeX.linebreak = "\\\\"
+
+  TeX.ellipsis = "\\ldots{}"
+
+  TeX.mdash = "---"
+
+  TeX.ndash = "--"
+
+  TeX.nbsp = "~"
+
+  function TeX.singlequoted(s)
+    return format("`%s'",s)
+  end
+
+  function TeX.doublequoted(s)
+    return format("``%s''",s)
+  end
+
+  TeX.escaped = {
+     ["{"] = "\\{",
+     ["}"] = "\\}",
+     ["$"] = "\\$",
+     ["%"] = "\\%",
+     ["&"] = "\\&",
+     ["_"] = "\\_",
+     ["#"] = "\\#",
+     ["^"] = "\\^{}",
+     ["\\"] = "\\char92{}",
+     ["~"] = "\\char126{}",
+     ["|"] = "\\char124{}",
+     ["<"] = "\\char60{}",
+     [">"] = "\\char62{}",
+     ["["] = "{[}", -- to avoid interpretation as optional argument
+     ["]"] = "{]}",
+   }
+
+  local str_escaped = {
+     ["\226\128\156"] = "``",
+     ["\226\128\157"] = "''",
+     ["\226\128\152"] = "`",
+     ["\226\128\153"] = "'",
+     ["\226\128\148"] = "---",
+     ["\226\128\147"] = "--",
+     ["\194\160"]     = "~",
+   }
+
+  local escaper = util.escaper(TeX.escaped, str_escaped)
+
+  TeX.string = escaper
+
+  function TeX.inline_html(s)
+    return ""
+  end
+
+  function TeX.display_html(s)
+    return ""
+  end
+
+  function TeX.paragraph(s)
+    return s
+  end
+
+  return TeX
+end
+
+return M
diff --git a/lua-libraries/lunamark/writer/xml.lua b/lua-libraries/lunamark/writer/xml.lua
new file mode 100644
index 00000000..8d02ec1f
--- /dev/null
+++ b/lua-libraries/lunamark/writer/xml.lua
@@ -0,0 +1,60 @@
+-- (c) 2009-2011 John MacFarlane. Released under MIT license.
+-- See the file LICENSE in the source for details.
+
+--- Generic XML writer for lunamark.
+-- It extends [lunamark.writer.generic] and is extended by
+-- [lunamark.writer.html] and [lunamark.writer.docbook].
+
+local M = {}
+
+local generic = require("lunamark.writer.generic")
+local util = require("lunamark.util")
+
+--- Returns a new XML writer.
+-- For a list of fields, see [lunamark.writer.generic].
+function M.new(options)
+  options = options or {}
+  local Xml = generic.new(options)
+
+  Xml.container = "section"
+  --  {1,2} means: a second level header inside a first-level
+  local header_level_stack = {}
+
+  function Xml.start_section(level)
+    header_level_stack[#header_level_stack + 1] = level
+    return "<" .. Xml.container .. ">"
+  end
+
+  function Xml.stop_section(level)
+    local len = #header_level_stack
+    if len == 0 then
+      return ""
+    else
+      local last = header_level_stack[len]
+      local res = {}
+      while last >= level do
+        header_level_stack[len] = nil
+        table.insert(res, "</" .. Xml.container .. ">")
+        len = len - 1
+        last = (len > 0 and header_level_stack[len]) or 0
+      end
+      return table.concat(res, Xml.containersep)
+    end
+  end
+
+  Xml.linebreak = "<linebreak />"
+
+  local escape = util.escaper {
+     ["<" ] = "&lt;",
+     [">" ] = "&gt;",
+     ["&" ] = "&amp;",
+     ["\"" ] = "&quot;",
+     ["'" ] = "&#39;"
+  }
+
+  Xml.string = escape
+
+  return Xml
+end
+
+return M