Add a writer for Markua 0.10 (#7729)

Markua is a markdown variant used by Leanpub.
More information about Markua can be found at https://leanpub.com/markua/read.

Adds a new exported function `writeMarkua` from T.P.Writers.Markdown.
[API change]

Closes #1871.

Co-authored by Tim Wisotzki and Samuel Lemmenmeier.

7 files changed, 217 insertions, 70 deletions

diff --git a/src/Text/Pandoc/App/FormatHeuristics.hs b/src/Text/Pandoc/App/FormatHeuristics.hs
index a2acfc6d6..e5fe7ad81 100644
--- a/src/Text/Pandoc/App/FormatHeuristics.hs
+++ b/src/Text/Pandoc/App/FormatHeuristics.hs
@@ -54,6 +54,7 @@ formatFromFilePath x =
     ".lhs"      -> Just "markdown+lhs"
     ".ltx"      -> Just "latex"
     ".markdown" -> Just "markdown"
+    ".markua"   -> Just "markua"
     ".mkdn"     -> Just "markdown"
     ".mkd"      -> Just "markdown"
     ".mdwn"     -> Just "markdown"
diff --git a/src/Text/Pandoc/Extensions.hs b/src/Text/Pandoc/Extensions.hs
index ce6a95458..33f615740 100644
--- a/src/Text/Pandoc/Extensions.hs
+++ b/src/Text/Pandoc/Extensions.hs
@@ -432,6 +432,8 @@ getDefaultExtensions "jats_archiving"  = getDefaultExtensions "jats"
 getDefaultExtensions "jats_publishing" = getDefaultExtensions "jats"
 getDefaultExtensions "jats_articleauthoring" = getDefaultExtensions "jats"
 getDefaultExtensions "opml"            = pandocExtensions -- affects notes
+getDefaultExtensions "markua"          = extensionsFromList
+                                          []
 getDefaultExtensions _                 = extensionsFromList
                                           [Ext_auto_identifiers]
 
diff --git a/src/Text/Pandoc/Shared.hs b/src/Text/Pandoc/Shared.hs
index eb0b4acbf..50abe6937 100644
--- a/src/Text/Pandoc/Shared.hs
+++ b/src/Text/Pandoc/Shared.hs
@@ -25,6 +25,7 @@ module Text.Pandoc.Shared (
                      ordNub,
                      findM,
                      -- * Text processing
+                     inquotes,
                      tshow,
                      elemText,
                      notElemText,
@@ -186,6 +187,10 @@ findM p = foldr go (pure Nothing)
 -- Text processing
 --
 
+-- | Wrap double quotes around a Text
+inquotes :: T.Text -> T.Text
+inquotes txt = T.cons '\"' (T.snoc txt '\"')
+
 tshow :: Show a => a -> T.Text
 tshow = T.pack . show
 
diff --git a/src/Text/Pandoc/Writers.hs b/src/Text/Pandoc/Writers.hs
index c348477c2..960b9074c 100644
--- a/src/Text/Pandoc/Writers.hs
+++ b/src/Text/Pandoc/Writers.hs
@@ -51,6 +51,7 @@ module Text.Pandoc.Writers
     , writeLaTeX
     , writeMan
     , writeMarkdown
+    , writeMarkua
     , writeMediaWiki
     , writeMs
     , writeMuse
@@ -190,6 +191,7 @@ writers = [
   ,("csljson"      , TextWriter writeCslJson)
   ,("bibtex"       , TextWriter writeBibTeX)
   ,("biblatex"     , TextWriter writeBibLaTeX)
+  ,("markua"       , TextWriter writeMarkua)
   ]
 
 -- | Retrieve writer, extensions based on formatSpec (format+extensions).
diff --git a/src/Text/Pandoc/Writers/Markdown.hs b/src/Text/Pandoc/Writers/Markdown.hs
index 022dbc24f..bb68d9fee 100644
--- a/src/Text/Pandoc/Writers/Markdown.hs
+++ b/src/Text/Pandoc/Writers/Markdown.hs
@@ -18,6 +18,7 @@ Markdown:  <https://daringfireball.net/projects/markdown/>
 module Text.Pandoc.Writers.Markdown (
   writeMarkdown,
   writeCommonMark,
+  writeMarkua,
   writePlain) where
 import Control.Monad.Reader
 import Control.Monad.State.Strict
@@ -42,7 +43,10 @@ import Text.Pandoc.Templates (renderTemplate)
 import Text.DocTemplates (Val(..), Context(..), FromContext(..))
 import Text.Pandoc.Walk
 import Text.Pandoc.Writers.HTML (writeHtml5String)
-import Text.Pandoc.Writers.Markdown.Inline (inlineListToMarkdown, linkAttributes, attrsToMarkdown)
+import Text.Pandoc.Writers.Markdown.Inline (inlineListToMarkdown, 
+                                            linkAttributes, 
+                                            attrsToMarkdown, 
+                                            attrsToMarkua)
 import Text.Pandoc.Writers.Markdown.Types (MarkdownVariant(..),
                                            WriterState(..),
                                            WriterEnv(..),
@@ -77,6 +81,26 @@ writeCommonMark opts document =
                    enableExtension Ext_intraword_underscores $
                      writerExtensions opts }
 
+-- | Convert Pandoc to Markua.
+writeMarkua :: PandocMonad m => WriterOptions -> Pandoc -> m Text
+writeMarkua opts document =
+  evalMD (pandocToMarkdown opts' document) def{ envVariant = Markua } def
+ where
+  opts' = opts{   writerExtensions =
+                  enableExtension Ext_hard_line_breaks $
+                  enableExtension Ext_pipe_tables $
+                  -- required for fancy list enumerators
+                  enableExtension Ext_fancy_lists $
+                  enableExtension Ext_startnum $
+                  enableExtension Ext_strikeout $
+                  enableExtension Ext_subscript $
+                  enableExtension Ext_superscript $
+                  enableExtension Ext_definition_lists $
+                  enableExtension Ext_smart $
+                  enableExtension Ext_footnotes
+                    mempty }
+
+
 pandocTitleBlock :: Doc Text -> [Doc Text] -> Doc Text -> Doc Text
 pandocTitleBlock tit auths dat =
   hang 2 (text "% ") tit <> cr <>
@@ -327,8 +351,15 @@ blockToMarkdown' opts (Div attrs ils) = do
   contents <- blockListToMarkdown opts ils
   variant <- asks envVariant
   return $
-    case () of
-         _ | isEnabled Ext_fenced_divs opts &&
+     case () of
+         _ | variant == Markua -> 
+                   case () of
+                        () | "blurb" `elem` classes' -> prefixed "B> " contents <> blankline
+                           | "aside" `elem` classes' -> prefixed "A> " contents <> blankline
+                           -- | necessary to enable option to create a bibliography
+                           | (take 3 (T.unpack id')) == "ref" -> contents <> blankline
+                           | otherwise -> contents <> blankline
+           | isEnabled Ext_fenced_divs opts &&
              attrs /= nullAttr ->
                 let attrsToMd = if variant == Commonmark
                                 then attrsToMarkdown
@@ -408,6 +439,7 @@ blockToMarkdown' opts b@(RawBlock f str) = do
       | f `elem` ["markdown", "markdown_github", "markdown_phpextra",
                   "markdown_mmd", "markdown_strict"]
          -> return $ literal str <> literal "\n"
+    Markua -> renderEmpty
     _ | isEnabled Ext_raw_attribute opts -> rawAttribBlock
       | f `elem` ["html", "html5", "html4"]
       , isEnabled Ext_markdown_attribute opts
@@ -419,17 +451,19 @@ blockToMarkdown' opts b@(RawBlock f str) = do
       , isEnabled Ext_raw_tex opts
          -> return $ literal str <> literal "\n"
     _ -> renderEmpty
-blockToMarkdown' opts HorizontalRule =
-  return $ blankline <> literal (T.replicate (writerColumns opts) "-") <> blankline
+blockToMarkdown' opts HorizontalRule = do
+  variant <- asks envVariant
+  let indicator = case variant of
+                        Markua -> "* * *"
+                        _ -> T.replicate (writerColumns opts) "-"
+  return $ blankline <> literal indicator <> blankline
 blockToMarkdown' opts (Header level attr inlines) = do
-
   -- first, if we're putting references at the end of a section, we
   -- put them here.
   blkLevel <- asks envBlockLevel
   refs <- if writerReferenceLocation opts == EndOfSection && blkLevel == 1
           then notesAndRefs opts
           else return empty
-
   variant <- asks envVariant
   -- we calculate the id that would be used by auto_identifiers
   -- so we know whether to print an explicit identifier
@@ -442,7 +476,8 @@ blockToMarkdown' opts (Header level attr inlines) = do
                                  && id' == autoId -> empty
                    (id',_,_)   | isEnabled Ext_mmd_header_identifiers opts ->
                                     space <> brackets (literal id')
-                   _ | isEnabled Ext_header_attributes opts ||
+                   _ | variant == Markua -> attrsToMarkua attr
+                     | isEnabled Ext_header_attributes opts ||
                        isEnabled Ext_attributes opts ->
                                     space <> attrsToMarkdown attr
                      | otherwise -> empty
@@ -476,6 +511,8 @@ blockToMarkdown' opts (Header level attr inlines) = do
             -- ghc interprets '#' characters in column 1 as linenum specifiers.
             _ | variant == PlainText || isEnabled Ext_literate_haskell opts ->
                 contents <> blankline
+            _ | variant == Markua -> attr' <> cr <> literal (T.replicate level "#") 
+                                        <> space <> contents <> blankline
             _ -> literal (T.replicate level "#") <> space <> contents <> attr' <> blankline
 
   return $ refs <> hdr
@@ -492,9 +529,11 @@ blockToMarkdown' opts (CodeBlock attribs str) = do
           backticks <> attrs <> cr <> literal str <> cr <> backticks <> blankline
            | isEnabled Ext_fenced_code_blocks opts ->
           tildes <> attrs <> cr <> literal str <> cr <> tildes <> blankline
-     _ -> nest (writerTabStop opts) (literal str) <> blankline
+     _ | variant == Markua -> blankline <> attrsToMarkua attribs <> cr <> backticks <> cr <> 
+                                literal str <> cr <> backticks <> cr <> blankline
+       | otherwise -> nest (writerTabStop opts) (literal str) <> blankline
    where
-     endlineLen c = maybe 3 ((+1) . maximum) $ nonEmpty $
+     endlineLen c = maybe 3 ((+1) . maximum) $ nonEmpty
                         [T.length ln
                          | ln <- map trim (T.lines str)
                          , T.pack [c,c,c] `T.isPrefixOf` ln
@@ -581,24 +620,29 @@ blockToMarkdown' opts t@(Table _ blkCapt specs thead tbody tfoot) = do
   return $ nst (tbl $$ caption'') $$ blankline
 blockToMarkdown' opts (BulletList items) = do
   contents <- inList $ mapM (bulletListItemToMarkdown opts) items
-  return $ (if isTightList items then vcat else vsep) contents <> blankline
+  return $ (if isTightList items then vcat else vsep) 
+                  contents <> blankline
 blockToMarkdown' opts (OrderedList (start,sty,delim) items) = do
   variant <- asks envVariant
   let start' = if variant == Commonmark || isEnabled Ext_startnum opts
                   then start
                   else 1
   let sty'   = if isEnabled Ext_fancy_lists opts then sty else DefaultStyle
-  let delim' = if isEnabled Ext_fancy_lists opts
-                  then delim
-                  else if variant == Commonmark &&
-                           (delim == OneParen || delim == TwoParens)
-                       then OneParen -- commonmark only supports one paren
-                       else DefaultDelim
+  let delim' | isEnabled Ext_fancy_lists opts =
+               case variant of 
+                   -- Markua supports 'fancy' enumerators, but no TwoParens
+                   Markua -> if delim == TwoParens then OneParen else delim
+                   _ -> delim
+             | variant == Commonmark && --commonmark only supports one paren
+                   (delim == OneParen || delim == TwoParens) = OneParen
+             | otherwise = DefaultDelim
   let attribs = (start', sty', delim')
   let markers  = orderedListMarkers attribs
-  let markers' = map (\m -> if T.length m < 3
-                               then m <> T.replicate (3 - T.length m) " "
-                               else m) markers
+  let markers' = case variant of
+                        Markua -> markers
+                        _ -> map (\m -> if T.length m < 3
+                                   then m <> T.replicate (3 - T.length m) " "
+                                   else m) markers
   contents <- inList $
               zipWithM (orderedListItemToMarkdown opts) markers' items
   return $ (if isTightList items then vcat else vsep) contents <> blankline
@@ -712,10 +756,13 @@ itemEndsWithTightList bs =
 -- | Convert bullet list item (list of blocks) to markdown.
 bulletListItemToMarkdown :: PandocMonad m => WriterOptions -> [Block] -> MD m (Doc Text)
 bulletListItemToMarkdown opts bs = do
+  variant <- asks envVariant
   let exts = writerExtensions opts
   contents <- blockListToMarkdown opts $ taskListItemToAscii exts bs
   let sps = T.replicate (writerTabStop opts - 2) " "
-  let start = literal $ "- " <> sps
+  let start = case variant of
+              Markua -> literal "* "
+              _      -> literal $ "- " <> sps
   -- remove trailing blank line if item ends with a tight list
   let contents' = if itemEndsWithTightList bs
                      then chomp contents <> cr
@@ -725,19 +772,22 @@ bulletListItemToMarkdown opts bs = do
 -- | Convert ordered list item (a list of blocks) to markdown.
 orderedListItemToMarkdown :: PandocMonad m
                           => WriterOptions -- ^ options
-                          -> Text        -- ^ list item marker
+                          -> Text          -- ^ list item marker
                           -> [Block]       -- ^ list item (list of blocks)
                           -> MD m (Doc Text)
 orderedListItemToMarkdown opts marker bs = do
   let exts = writerExtensions opts
   contents <- blockListToMarkdown opts $ taskListItemToAscii exts bs
+  variant <- asks envVariant
   let sps = case writerTabStop opts - T.length marker of
                    n | n > 0 -> literal $ T.replicate n " "
                    _ -> literal " "
   let ind = if isEnabled Ext_four_space_rule opts
                then writerTabStop opts
                else max (writerTabStop opts) (T.length marker + 1)
-  let start = literal marker <> sps
+  let start = case variant of
+              Markua -> literal marker <> " "
+              _      -> literal marker <> sps
   -- remove trailing blank line if item ends with a tight list
   let contents' = if itemEndsWithTightList bs
                      then chomp contents <> cr
@@ -756,7 +806,10 @@ definitionListItemToMarkdown opts (label, defs) = do
      then do
        let tabStop = writerTabStop opts
        variant <- asks envVariant
-       let leader  = if variant == PlainText then "   " else ":  "
+       let leader  = case variant of
+                        PlainText -> "   "
+                        Markua -> ":"
+                        _ -> ":  "
        let sps = case writerTabStop opts - 3 of
                       n | n > 0   -> literal $ T.replicate n " "
                       _ -> literal " "
@@ -827,6 +880,7 @@ blockListToMarkdown opts blocks = do
       isListBlock _                  = False
       commentSep
         | variant == PlainText        = Null
+        | variant == Markua           = Null
         | isEnabled Ext_raw_html opts = RawBlock "html" "<!-- -->\n"
         | otherwise                   = RawBlock "markdown" "&nbsp;\n"
   mconcat <$> mapM (blockToMarkdown opts) (fixBlocks blocks)
diff --git a/src/Text/Pandoc/Writers/Markdown/Inline.hs b/src/Text/Pandoc/Writers/Markdown/Inline.hs
index d299d31b2..0bf70e80e 100644
--- a/src/Text/Pandoc/Writers/Markdown/Inline.hs
+++ b/src/Text/Pandoc/Writers/Markdown/Inline.hs
@@ -13,7 +13,8 @@
 module Text.Pandoc.Writers.Markdown.Inline (
   inlineListToMarkdown,
   linkAttributes,
-  attrsToMarkdown
+  attrsToMarkdown,
+  attrsToMarkua
   ) where
 import Control.Monad.Reader
 import Control.Monad.State.Strict
@@ -95,6 +96,11 @@ escapeText opts = T.pack . go' . T.unpack
                   , isAlphaNum x -> c : '_' : x : go xs
                 _                -> c : go cs
 
+-- Escape the escape character, as well as formatting pairs
+escapeMarkuaString :: Text -> Text
+escapeMarkuaString s = foldr (uncurry T.replace) s [("--","~-~-"),
+                        ("**","~*~*"),("//","~/~/"),("^^","~^~^"),(",,","~,~,")]
+ 
 attrsToMarkdown :: Attr -> Doc Text
 attrsToMarkdown attribs = braces $ hsep [attribId, attribClasses, attribKeys]
         where attribId = case attribs of
@@ -116,9 +122,56 @@ attrsToMarkdown attribs = braces $ hsep [attribId, attribClasses, attribKeys]
               escAttrChar '\\' = literal "\\\\"
               escAttrChar c    = literal $ T.singleton c
 
+attrsToMarkua:: Attr -> Doc Text
+attrsToMarkua attributes
+     | null list = empty
+     | otherwise = braces $ intercalateDocText list
+        where attrId = case attributes of
+                        ("",_,_) -> []
+                        (i,_,_)  -> [literal $ "id: " <> i]
+              -- all non explicit (key,value) attributes besides id are getting
+              -- a default class key to be Markua conform
+              attrClasses = case attributes of
+                             (_,[],_) -> []
+                             (_,classes,_) -> map (escAttr . ("class: " <>))
+                                classes
+              attrKeyValues = case attributes of
+                               (_,_,[]) -> []
+                               (_,_,keyvalues) -> map ((\(k,v) -> escAttr k
+                                              <> ": " <> escAttr v) . 
+                                              preprocessKeyValues) keyvalues
+              escAttr          = mconcat . map escAttrChar . T.unpack
+              escAttrChar '"'  = literal "\""
+              escAttrChar c    = literal $ T.singleton c
+
+              list = concat [attrId, attrClasses, attrKeyValues]
+
+              -- if attribute key is alt, caption, title then content
+              -- gets wrapped inside quotes
+              -- attribute gets removed
+              preprocessKeyValues :: (Text, Text) -> (Text, Text)
+              preprocessKeyValues (key,value)
+                 | key == "alt" ||
+                   key == "caption" ||
+                   key == "title" = (key, inquotes value)
+                 | otherwise = (key,value)
+              intercalateDocText :: [Doc Text] -> Doc Text
+              intercalateDocText [] = empty
+              intercalateDocText [x] = x
+              intercalateDocText (x:xs) = x <> ", " <> (intercalateDocText xs)
+
+-- | Add a (key, value) pair to Pandoc attr type
+addKeyValueToAttr :: Attr -> (Text,Text) -> Attr
+addKeyValueToAttr (ident,classes,kvs) (key,value) 
+    | not (T.null key) && not (T.null value) = (ident,
+                                                classes,
+                                                (key,value): kvs)
+    | otherwise = (ident,classes,kvs)
+
 linkAttributes :: WriterOptions -> Attr -> Doc Text
 linkAttributes opts attr =
-  if (isEnabled Ext_link_attributes opts || isEnabled Ext_attributes opts) && attr /= nullAttr
+  if (isEnabled Ext_link_attributes opts || 
+        isEnabled Ext_attributes opts) && attr /= nullAttr
      then attrsToMarkdown attr
      else empty
 
@@ -283,6 +336,7 @@ inlineToMarkdown opts (Span attrs ils) = do
              _ -> id
          $ case variant of
                 PlainText -> contents
+                Markua -> "`" <> contents <> "`" <> attrsToMarkua attrs
                 _     | attrs == nullAttr -> contents
                       | isEnabled Ext_bracketed_spans opts ->
                         let attrs' = if attrs /= nullAttr
@@ -396,60 +450,75 @@ inlineToMarkdown opts (Quoted DoubleQuote lst) = do
                    then "&ldquo;" <> contents <> "&rdquo;"
                    else "“" <> contents <> "”"
 inlineToMarkdown opts (Code attr str) = do
+  variant <- asks envVariant
   let tickGroups   = filter (T.any (== '`')) $ T.group str
   let longest      = maybe 0 maximum $ nonEmpty $ map T.length tickGroups
   let marker       = T.replicate (longest + 1) "`"
   let spacer       = if longest == 0 then "" else " "
   let attrsEnabled = isEnabled Ext_inline_code_attributes opts ||
                      isEnabled Ext_attributes opts
-  let attrs        = if attrsEnabled && attr /= nullAttr
-                        then attrsToMarkdown attr
-                        else empty
-  variant <- asks envVariant
+  let attrs = case variant of
+                       Markua -> attrsToMarkua attr
+                       _   -> if attrsEnabled && attr /= nullAttr
+                                        then attrsToMarkdown attr
+                                        else empty
   case variant of
      PlainText -> return $ literal str
      _     ->  return $ literal
                   (marker <> spacer <> str <> spacer <> marker) <> attrs
 inlineToMarkdown opts (Str str) = do
   variant <- asks envVariant
-  let str' = (if writerPreferAscii opts
-                 then toHtml5Entities
-                 else id) .
-             (if isEnabled Ext_smart opts
-                 then unsmartify opts
-                 else id) .
-             (if variant == PlainText
-                 then id
-                 else escapeText opts) $ str
+  let str' = case variant of
+                Markua -> escapeMarkuaString str
+                _ -> (if writerPreferAscii opts
+                        then toHtml5Entities
+                        else id) .
+                     (if isEnabled Ext_smart opts
+                        then unsmartify opts
+                        else id) .
+                     (if variant == PlainText
+                        then id
+                        else escapeText opts) $ str
   return $ literal str'
-inlineToMarkdown opts (Math InlineMath str) =
-  case writerHTMLMathMethod opts of
-       WebTeX url -> inlineToMarkdown opts
-                       (Image nullAttr [Str str] (url <> urlEncode str, str))
-       _ | isEnabled Ext_tex_math_dollars opts ->
-             return $ "$" <> literal str <> "$"
-         | isEnabled Ext_tex_math_single_backslash opts ->
-             return $ "\\(" <> literal str <> "\\)"
-         | isEnabled Ext_tex_math_double_backslash opts ->
-             return $ "\\\\(" <> literal str <> "\\\\)"
-         | otherwise -> do
-             variant <- asks envVariant
-             texMathToInlines InlineMath str >>=
-               inlineListToMarkdown opts .
-                 (if variant == PlainText then makeMathPlainer else id)
-inlineToMarkdown opts (Math DisplayMath str) =
-  case writerHTMLMathMethod opts of
-      WebTeX url -> (\x -> blankline <> x <> blankline) `fmap`
-             inlineToMarkdown opts (Image nullAttr [Str str]
-                    (url <> urlEncode str, str))
-      _ | isEnabled Ext_tex_math_dollars opts ->
-            return $ "$$" <> literal str <> "$$"
-        | isEnabled Ext_tex_math_single_backslash opts ->
-            return $ "\\[" <> literal str <> "\\]"
-        | isEnabled Ext_tex_math_double_backslash opts ->
-            return $ "\\\\[" <> literal str <> "\\\\]"
-        | otherwise -> (\x -> cr <> x <> cr) `fmap`
-            (texMathToInlines DisplayMath str >>= inlineListToMarkdown opts)
+inlineToMarkdown opts (Math InlineMath str) = do
+  variant <- asks envVariant
+  case () of
+    _ | variant == Markua -> return $ "`" <> literal str <> "`" <> "$"
+      | otherwise -> case writerHTMLMathMethod opts of
+          WebTeX url -> inlineToMarkdown opts
+                          (Image nullAttr [Str str] (url <> urlEncode str, str))
+          _ | isEnabled Ext_tex_math_dollars opts ->
+                return $ "$" <> literal str <> "$"
+            | isEnabled Ext_tex_math_single_backslash opts ->
+                return $ "\\(" <> literal str <> "\\)"
+            | isEnabled Ext_tex_math_double_backslash opts ->
+                return $ "\\\\(" <> literal str <> "\\\\)"
+            | otherwise -> 
+                texMathToInlines InlineMath str >>=
+                  inlineListToMarkdown opts .
+                    (if variant == PlainText then makeMathPlainer else id)
+     
+inlineToMarkdown opts (Math DisplayMath str) = do
+  variant <- asks envVariant
+  case () of
+    _ | variant == Markua -> do
+        let attributes = attrsToMarkua (addKeyValueToAttr ("",[],[]) 
+                                                        ("format", "latex"))
+        return $ blankline <> attributes <> cr <> literal "```" <> cr 
+            <> literal str <> cr <> literal "```" <> blankline
+      | otherwise -> case writerHTMLMathMethod opts of
+          WebTeX url -> (\x -> blankline <> x <> blankline) `fmap`
+                 inlineToMarkdown opts (Image nullAttr [Str str]
+                        (url <> urlEncode str, str))
+          _ | isEnabled Ext_tex_math_dollars opts ->
+                return $ "$$" <> literal str <> "$$"
+            | isEnabled Ext_tex_math_single_backslash opts ->
+                return $ "\\[" <> literal str <> "\\]"
+            | isEnabled Ext_tex_math_double_backslash opts ->
+                return $ "\\\\[" <> literal str <> "\\\\]"
+            | otherwise -> (\x -> cr <> x <> cr) `fmap`
+                (texMathToInlines DisplayMath str >>= inlineListToMarkdown opts)
+
 inlineToMarkdown opts il@(RawInline f str) = do
   let tickGroups = filter (T.any (== '`')) $ T.group str
   let numticks   = 1 + maybe 0 maximum (nonEmpty (map T.length tickGroups))
@@ -469,6 +538,7 @@ inlineToMarkdown opts il@(RawInline f str) = do
       | f `elem` ["markdown", "markdown_github", "markdown_phpextra",
                   "markdown_mmd", "markdown_strict"]
          -> return $ literal str
+    Markua -> renderEmpty
     _ | isEnabled Ext_raw_attribute opts -> rawAttribInline
       | f `elem` ["html", "html5", "html4"]
       , isEnabled Ext_raw_html opts
@@ -563,6 +633,11 @@ inlineToMarkdown opts lnk@(Link attr@(ident,classes,kvs) txt (src, tit)) = do
     PlainText
       | useAuto -> return $ literal srcSuffix
       | otherwise -> return linktext
+    Markua
+      | T.null tit -> return $ result <> attrsToMarkua attr
+      | otherwise ->  return $ result <> attrsToMarkua attributes
+        where result = "[" <> linktext <> "](" <> (literal src) <> ")"
+              attributes = addKeyValueToAttr attr ("title", tit)
     _ | useAuto -> return $ "<" <> literal srcSuffix <> ">"
       | useRefLinks ->
            let first  = "[" <> linktext <> "]"
@@ -594,9 +669,16 @@ inlineToMarkdown opts img@(Image attr alternate (source, tit))
                then [Str ""]
                else alternate
   linkPart <- inlineToMarkdown opts (Link attr txt (source, tit))
+  alt <- inlineListToMarkdown opts alternate
+  let attributes | variant == Markua = attrsToMarkua $ 
+            addKeyValueToAttr (addKeyValueToAttr attr ("title", tit)) 
+            ("alt", render (Just (writerColumns opts)) alt) 
+                 | otherwise = empty
   return $ case variant of
-             PlainText -> "[" <> linkPart <> "]"
-             _     -> "!" <> linkPart
+                PlainText -> "[" <> linkPart <> "]"
+                Markua -> cr <> attributes <> cr <> literal "![](" <> 
+                            literal source <> ")" <> cr
+                _ -> "!" <> linkPart
 inlineToMarkdown opts (Note contents) = do
   modify (\st -> st{ stNotes = contents : stNotes st })
   st <- get
diff --git a/src/Text/Pandoc/Writers/Markdown/Types.hs b/src/Text/Pandoc/Writers/Markdown/Types.hs
index a1d0d14e4..060446811 100644
--- a/src/Text/Pandoc/Writers/Markdown/Types.hs
+++ b/src/Text/Pandoc/Writers/Markdown/Types.hs
@@ -45,7 +45,8 @@ data WriterEnv = WriterEnv { envInList          :: Bool
                            }
 
 data MarkdownVariant =
-      PlainText
+      Markua
+    | PlainText
     | Commonmark
     | Markdown
     deriving (Show, Eq)