`-p`, `--preserve-tabs`

: Preserve tabs instead of converting them to spaces (the default).

: Specify the number of spaces per tab (default is 4).

`--strict`

: Disable text wrapping in output. By default, text is wrapped

appropriately for the output format.

`--email-obfuscation=`*none|javascript|references*

: Specify a method for obfuscating `mailto:` links in HTML documents.

*none* leaves `mailto:` links as they are. *javascript* obfuscates

one) in the output document. This option has no effect on `man`,

`docbook`, `slidy`, or `s5` output.

: Specify the base level for headers (defaults to 1).

`--template=`*FILE*

tests/latex-reader.native,

tests/markdown-reader-more.txt,

tests/markdown-reader-more.native,

tests/rst-reader.native,

tests/rst-reader.rst,

tests/s5.basic.html,

random, extensible-exceptions,

citeproc-hs >= 0.3 && < 0.4,

pandoc-types == 1.7.*,

if impl(ghc >= 6.10)

Build-depends: base >= 4 && < 5, syb

else

-- END DUPLICATED SECTION

Exposed-Modules: Text.Pandoc,

Text.Pandoc.CharacterReferences,

Text.Pandoc.Shared,

Text.Pandoc.Parsing,

random, extensible-exceptions,

citeproc-hs >= 0.3 && < 0.4,

pandoc-types == 1.7.*,

if impl(ghc >= 6.10)

Build-depends: base >= 4 && < 5, syb

else

-> [Int] -- Indices

-> [Double] -- Fractional relative sizes of columns

widthsFromIndices _ [] = []

lengths = reverse $

case reverse lengths' of

[] -> []

go Space = " "

go (Str x) = x

go (Code x) = x

go _ = ""

-- | Change final list item from @Para@ to @Plain@ if the list contains

, writerStrictMarkdown :: Bool -- ^ Use strict markdown syntax

, writerReferenceLinks :: Bool -- ^ Use reference links in writing markdown, rst

, writerWrapText :: Bool -- ^ Wrap text to line length

, writerLiterateHaskell :: Bool -- ^ Write as literate haskell

, writerEmailObfuscation :: ObfuscationMethod -- ^ How to obfuscate emails

, writerIdentifierPrefix :: String -- ^ Prefix for section & note ids in HTML

, writerStrictMarkdown = False

, writerReferenceLinks = False

, writerWrapText = True

, writerLiterateHaskell = False

, writerEmailObfuscation = JavascriptObfuscation

, writerIdentifierPrefix = ""

{-

Copyright (C) 2006-2010 John MacFarlane <jgm@berkeley.edu>

import Text.Pandoc.Definition

import Text.Pandoc.Templates (renderTemplate)

import Text.Pandoc.Shared

import Text.ParserCombinators.Parsec ( runParser, GenParser )

import Data.List ( group, isPrefixOf, find, intersperse, transpose )

import Control.Monad.State

type Notes = [[Block]]

plainify :: Pandoc -> Pandoc

plainify = processWith go

-- | Return markdown representation of document.

pandocToMarkdown :: WriterOptions -> Pandoc -> State WriterState String

notes' <- notesToMarkdown opts (reverse $ stNotes st)

st' <- get -- note that the notes may contain refs

refs' <- refsToMarkdown opts (reverse $ stRefs st')

let context = writerVariables opts ++

, ("body", main)

] ++

[ ("titleblock", "yes") | titleblock ] ++

if writerStandalone opts

then return $ renderTemplate context $ writerTemplate opts

else return main

-- | Return markdown representation of reference key table.

refsToMarkdown :: WriterOptions -> Refs -> State WriterState Doc

refsToMarkdown opts refs = mapM (keyToMarkdown opts) refs >>= return . vcat

-- | Return markdown representation of a reference key.

keyToMarkdown :: WriterOptions

-> ([Inline], (String, String))

-> State WriterState Doc

keyToMarkdown opts (label, (src, tit)) = do

label' <- inlineListToMarkdown opts label

-- | Return markdown representation of notes.

notesToMarkdown :: WriterOptions -> [[Block]] -> State WriterState Doc

notesToMarkdown opts notes =

-- | Return markdown representation of a note.

noteToMarkdown :: WriterOptions -> Int -> [Block] -> State WriterState Doc

noteToMarkdown opts num blocks = do

contents <- blockListToMarkdown opts blocks

-- | Escape special characters for Markdown.

escapeString :: String -> String

-- | True if string begins with an ordered list marker

beginsWithOrderedListMarker :: String -> Bool

Right _ -> True

-- | Convert Pandoc block element to markdown.

blockToMarkdown :: WriterOptions -- ^ Options

-> Block -- ^ Block element

-> State WriterState Doc

blockToMarkdown _ Null = return empty

blockToMarkdown opts (Para inlines) = do

-- escape if para starts with ordered list marker

blockToMarkdown _ (RawHtml str) = do

st <- get

if stPlain st

then return empty

blockToMarkdown opts (Header level inlines) = do

contents <- inlineListToMarkdown opts inlines

st <- get

-- use setext style headers if in literate haskell mode.

-- ghc interprets '#' characters in column 1 as line number specifiers.

if writerLiterateHaskell opts || stPlain st

blockToMarkdown opts (CodeBlock _ str) = return $

blockToMarkdown opts (BlockQuote blocks) = do

st <- get

-- if we're writing literate haskell, put a space before the bird tracks

-- so they won't be interpreted as lhs...

let leader = if writerLiterateHaskell opts

else if stPlain st

contents <- blockListToMarkdown opts blocks

blockToMarkdown opts (Table caption aligns widths headers rows) = do

caption' <- inlineListToMarkdown opts caption

let caption'' = if null caption

then empty

headers' <- mapM (blockListToMarkdown opts) headers

let alignHeader alignment = case alignment of

rawRows <- mapM (mapM (blockListToMarkdown opts)) rows

let isSimple = all (==0) widths

let widthsInChars =

if isSimple

then map ((+2) . numChars) $ transpose (headers' : rawRows)

let rows' = map makeRow rawRows

let head' = makeRow headers'

let border = if maxRowHeight > 1

else if all null headers

then underline

else empty

let head'' = if all null headers

then empty

let bottom = if all null headers

then underline

else border

blockToMarkdown opts (BulletList items) = do

contents <- mapM (bulletListItemToMarkdown opts) items

blockToMarkdown opts (OrderedList attribs items) = do

let markers = orderedListMarkers attribs

let markers' = map (\m -> if length m < 3

then m ++ replicate (3 - length m) ' '

contents <- mapM (\(item, num) -> orderedListItemToMarkdown opts item num) $

blockToMarkdown opts (DefinitionList items) = do

contents <- mapM (definitionListItemToMarkdown opts) items

-- | Convert bullet list item (list of blocks) to markdown.

bulletListItemToMarkdown :: WriterOptions -> [Block] -> State WriterState Doc

bulletListItemToMarkdown opts items = do

contents <- blockListToMarkdown opts items

-- | Convert ordered list item (a list of blocks) to markdown.

orderedListItemToMarkdown :: WriterOptions -- ^ options

-> State WriterState Doc

orderedListItemToMarkdown opts marker items = do

contents <- blockListToMarkdown opts items

-- | Convert definition list item (label, list of blocks) to markdown.

definitionListItemToMarkdown :: WriterOptions

labelText <- inlineListToMarkdown opts label

let tabStop = writerTabStop opts

st <- get

-- | Convert list of Pandoc block elements to markdown.

blockListToMarkdown :: WriterOptions -- ^ Options

-> [Block] -- ^ List of block elements

-> State WriterState Doc

blockListToMarkdown opts blocks =

-- | Get reference for target; if none exists, create unique one and return.

-- Prefer label if possible; otherwise, generate a unique key.

-- | Convert list of Pandoc inline elements to markdown.

inlineListToMarkdown :: WriterOptions -> [Inline] -> State WriterState Doc

inlineListToMarkdown opts lst =

-- | Convert Pandoc inline element to markdown.

inlineToMarkdown :: WriterOptions -> Inline -> State WriterState Doc

inlineToMarkdown opts (Emph lst) = do

contents <- inlineListToMarkdown opts lst

inlineToMarkdown opts (Strong lst) = do

contents <- inlineListToMarkdown opts lst

inlineToMarkdown opts (Strikeout lst) = do

contents <- inlineListToMarkdown opts lst

inlineToMarkdown opts (Superscript lst) = do

inlineToMarkdown opts (Subscript lst) = do

inlineToMarkdown opts (SmallCaps lst) = inlineListToMarkdown opts lst

inlineToMarkdown opts (Quoted SingleQuote lst) = do

contents <- inlineListToMarkdown opts lst

inlineToMarkdown opts (Quoted DoubleQuote lst) = do

contents <- inlineListToMarkdown opts lst

inlineToMarkdown _ (Code str) =

let tickGroups = filter (\s -> '`' `elem` s) $ group str

longest = if null tickGroups

if stPlain st

then return $ text str

else return $ text $ escapeString str

inlineToMarkdown _ (TeX str) = return $ text str

inlineToMarkdown _ (HtmlInline str) = return $ text str

inlineToMarkdown opts (Cite (c:cs) lst)

| writerCiteMethod opts == Citeproc = inlineListToMarkdown opts lst

| citationMode c == AuthorInText = do

suffs <- inlineListToMarkdown opts $ citationSuffix c

rest <- mapM convertOne cs

let inbr = suffs <+> joincits rest

return $ text ("@" ++ citationId c) <+> br

| otherwise = do

cits <- mapM convertOne (c:cs)

return $ text "[" <> joincits cits <> text "]"

where

convertOne Citation { citationId = k

, citationPrefix = pinlines

, citationSuffix = sinlines

inlineToMarkdown _ (Cite _ _) = return $ text ""

inlineToMarkdown opts (Link txt (src', tit)) = do

linktext <- inlineListToMarkdown opts txt

let src = unescapeURI src'

let srcSuffix = if isPrefixOf "mailto:" src then drop 7 src else src

let useRefLinks = writerReferenceLinks opts

ref <- if useRefLinks then getReference txt (src, tit) else return []

reftext <- inlineListToMarkdown opts ref

return $ if useAuto

else if useRefLinks

second = if txt == ref

in first <> second

inlineToMarkdown opts (Image alternate (source, tit)) = do

let txt = if (null alternate) || (alternate == [Str ""]) ||

(alternate == [Str source]) -- to prevent autolinks

then [Str "image"]

else alternate

linkPart <- inlineToMarkdown opts (Link txt (unescapeURI source, tit))

inlineToMarkdown _ (Note contents) = do

modify (\st -> st{ stNotes = contents : stNotes st })

st <- get

let ref = show $ (length $ stNotes st)

{-

Copyright (C) 2006-2010 Puneeth Chaganti <punchagan@gmail.com>

module Text.Pandoc.Writers.Org ( writeOrg) where

import Text.Pandoc.Definition

import Text.Pandoc.Shared

import Text.Pandoc.Templates (renderTemplate)

import Data.List ( intersect, intersperse, transpose )

import Control.Monad.State

import Control.Applicative ( (<$>) )

notes <- liftM (reverse . stNotes) get >>= notesToOrg

-- note that the notes may contain refs, so we do them first

hasMath <- liftM stHasMath get

let context = writerVariables opts ++

[ ("body", main)

[ ("math", "yes") | hasMath ] ++

if writerStandalone opts

then return $ renderTemplate context $ writerTemplate opts

else return main

notesToOrg :: [[Block]] -> State WriterState Doc

notesToOrg notes =

mapM (\(num, note) -> noteToOrg num note) (zip [1..] notes) >>=

-- | Return Org representation of a note.

noteToOrg :: Int -> [Block] -> State WriterState Doc

noteToOrg num note = do

contents <- blockListToOrg note

-- | Escape special characters for Org.

escapeString :: String -> String

titleToOrg [] = return empty

titleToOrg lst = do

contents <- inlineListToOrg lst

-- | Convert Pandoc block element to Org.

blockToOrg :: Block -- ^ Block element

-> State WriterState Doc

blockToOrg Null = return empty

blockToOrg (Para [Image txt (src,tit)]) = do

capt <- inlineListToOrg txt

img <- inlineToOrg (Image txt (src,tit))

blockToOrg (Para inlines) = do

blockToOrg (RawHtml str) =

blockToOrg (Header level inlines) = do

contents <- inlineListToOrg inlines

let headerStr = text $ if level > 999 then " " else replicate level '*'

blockToOrg (CodeBlock (_,classes,_) str) = do

opts <- stOptions <$> get

let tabstop = writerTabStop opts

let (beg, end) = if null at

then ("#+BEGIN_EXAMPLE", "#+END_EXAMPLE")

else ("#+BEGIN_SRC" ++ head at, "#+END_SRC")

blockToOrg (BlockQuote blocks) = do

contents <- blockListToOrg blocks

blockToOrg (Table caption' _ _ headers rows) = do

caption'' <- inlineListToOrg caption'

let caption = if null caption'

then empty

headers' <- mapM blockListToOrg headers

rawRows <- mapM (mapM blockListToOrg) rows

-- FIXME: width is not being used.

let widthsInChars =

map ((+2) . numChars) $ transpose (headers' : rawRows)

-- FIXME: Org doesn't allow blocks with height more than 1.

let head' = makeRow headers'

rows' <- mapM (\row -> do cols <- mapM blockListToOrg row

return $ makeRow cols) rows

(hcat $ intersperse (char ch <> char '+' <> char ch) $

map (\l -> text $ replicate l ch) widthsInChars) <>

char ch <> char '|'

let head'' = if all null headers

then empty

blockToOrg (BulletList items) = do

contents <- mapM bulletListItemToOrg items

-- ensure that sublists have preceding blank line

let markers = take (length items) $ orderedListMarkers

let maxMarkerLength = maximum $ map length markers

let markers' = map (\m -> let s = maxMarkerLength - length m

in m ++ replicate s ' ') markers

contents <- mapM (\(item, num) -> orderedListItemToOrg item num) $

-- ensure that sublists have preceding blank line

blockToOrg (DefinitionList items) = do

contents <- mapM definitionListItemToOrg items

-- | Convert bullet list item (list of blocks) to Org.

bulletListItemToOrg :: [Block] -> State WriterState Doc

bulletListItemToOrg items = do

contents <- blockListToOrg items

-- | Convert ordered list item (a list of blocks) to Org.

orderedListItemToOrg :: String -- ^ marker for list item

-> State WriterState Doc

orderedListItemToOrg marker items = do

contents <- blockListToOrg items

-- | Convert defintion list item (label, list of blocks) to Org.

definitionListItemToOrg :: ([Inline], [[Block]]) -> State WriterState Doc

definitionListItemToOrg (label, defs) = do

label' <- inlineListToOrg label

contents <- liftM vcat $ mapM blockListToOrg defs

-- | Convert list of Pandoc block elements to Org.

blockListToOrg :: [Block] -- ^ List of block elements

inlineToOrg :: Inline -> State WriterState Doc

inlineToOrg (Emph lst) = do

contents <- inlineListToOrg lst

inlineToOrg (Strong lst) = do

contents <- inlineListToOrg lst

inlineToOrg (Strikeout lst) = do

contents <- inlineListToOrg lst

inlineToOrg (Superscript lst) = do

contents <- inlineListToOrg lst

inlineToOrg (Subscript lst) = do

contents <- inlineListToOrg lst

inlineToOrg (SmallCaps lst) = inlineListToOrg lst

inlineToOrg (Quoted SingleQuote lst) = do

contents <- inlineListToOrg lst

inlineToOrg (Quoted DoubleQuote lst) = do

contents <- inlineListToOrg lst

inlineToOrg (Str str) = return $ text $ escapeString str

inlineToOrg (Math t str) = do

modify $ \st -> st{ stHasMath = True }

return $ if t == InlineMath

inlineToOrg (TeX str) = return $ text str

inlineToOrg (HtmlInline _) = return empty

inlineToOrg (Link txt (src, _)) = do

case txt of

[Code x] | x == src -> -- autolink

do modify $ \s -> s{ stLinks = True }

_ -> do contents <- inlineListToOrg txt

modify $ \s -> s{ stLinks = True }

inlineToOrg (Image _ (source', _)) = do

let source = unescapeURI source'

modify $ \s -> s{ stImages = True }

inlineToOrg (Note contents) = do

-- add to notes in state

notes <- get >>= (return . stNotes)

modify $ \st -> st { stNotes = contents:notes }

let ref = show $ (length notes) + 1

{-

Copyright (C) 2006-2010 John MacFarlane <jgm@berkeley.edu>

module Text.Pandoc.Writers.RST ( writeRST) where

import Text.Pandoc.Definition

import Text.Pandoc.Shared

import Text.Pandoc.Templates (renderTemplate)

import Control.Monad.State

import Control.Applicative ( (<$>) )

refs <- liftM (reverse . stLinks) get >>= refsToRST

pics <- liftM (reverse . stImages) get >>= pictRefsToRST

hasMath <- liftM stHasMath get

let context = writerVariables opts ++

[ ("body", main)

[ ("math", "yes") | hasMath ] ++

if writerStandalone opts

then return $ renderTemplate context $ writerTemplate opts

else return main

-- | Return RST representation of reference key table.

refsToRST :: Refs -> State WriterState Doc

refsToRST refs = mapM keyToRST refs >>= return . vcat

-- | Return RST representation of a reference key.

keyToRST :: ([Inline], (String, String))

-> State WriterState Doc

keyToRST (label, (src, _)) = do

label' <- inlineListToRST label

then char '`' <> label' <> char '`'

else label'

-- | Return RST representation of notes.

notesToRST :: [[Block]] -> State WriterState Doc

notesToRST notes =

-- | Return RST representation of a note.

noteToRST :: Int -> [Block] -> State WriterState Doc

noteToRST num note = do

contents <- blockListToRST note

return $ marker $$ nest 3 contents

-- | Return RST representation of picture reference table.

pictRefsToRST :: Refs -> State WriterState Doc

pictRefsToRST refs = mapM pictToRST refs >>= return . vcat

-- | Return RST representation of a picture substitution reference.

pictToRST :: ([Inline], (String, String))

-> State WriterState Doc

pictToRST (label, (src, _)) = do

label' <- inlineListToRST label

-- | Escape special characters for RST.

escapeString :: String -> String

titleToRST [] = return empty

titleToRST lst = do

contents <- inlineListToRST lst

let border = text (replicate titleLength '=')

-- | Convert Pandoc block element to RST.

blockToRST :: Block -- ^ Block element

-> State WriterState Doc

blockToRST Null = return empty

blockToRST (Para [Image txt (src,tit)]) = do

capt <- inlineListToRST txt

blockToRST (Para inlines) = do

blockToRST (Header level inlines) = do

contents <- inlineListToRST inlines

let headerChar = if level > 5 then ' ' else "=-~^'" !! (level - 1)

blockToRST (CodeBlock (_,classes,_) str) = do

opts <- stOptions <$> get

let tabstop = writerTabStop opts

if "haskell" `elem` classes && "literate" `elem` classes &&

writerLiterateHaskell opts

blockToRST (BlockQuote blocks) = do

tabstop <- get >>= (return . writerTabStop . stOptions)

contents <- blockListToRST blocks

blockToRST (Table caption _ widths headers rows) = do

caption' <- inlineListToRST caption

let caption'' = if null caption

then empty

headers' <- mapM blockListToRST headers

rawRows <- mapM (mapM blockListToRST) rows

let isSimple = all (==0) widths && all (all (\bs -> length bs == 1)) rows

let widthsInChars =

if isSimple

then map ((+2) . numChars) $ transpose (headers' : rawRows)

let head' = makeRow headers'

rows' <- mapM (\row -> do cols <- mapM blockListToRST row

return $ makeRow cols) rows

(hcat $ intersperse (char ch <> char '+' <> char ch) $

map (\l -> text $ replicate l ch) widthsInChars) <>

char ch <> char '+'

let head'' = if all null headers

then empty

blockToRST (BulletList items) = do

contents <- mapM bulletListItemToRST items

-- ensure that sublists have preceding blank line

blockToRST (OrderedList (start, style', delim) items) = do

let markers = if start == 1 && style' == DefaultStyle && delim == DefaultDelim

then take (length items) $ repeat "#."

let markers' = map (\m -> let s = maxMarkerLength - length m

in m ++ replicate s ' ') markers

contents <- mapM (\(item, num) -> orderedListItemToRST item num) $

-- ensure that sublists have preceding blank line

blockToRST (DefinitionList items) = do

contents <- mapM definitionListItemToRST items

-- | Convert bullet list item (list of blocks) to RST.

bulletListItemToRST :: [Block] -> State WriterState Doc

bulletListItemToRST items = do

contents <- blockListToRST items

-- | Convert ordered list item (a list of blocks) to RST.

orderedListItemToRST :: String -- ^ marker for list item

-> State WriterState Doc

orderedListItemToRST marker items = do

contents <- blockListToRST items

-- | Convert defintion list item (label, list of blocks) to RST.

definitionListItemToRST :: ([Inline], [[Block]]) -> State WriterState Doc

label' <- inlineListToRST label

contents <- liftM vcat $ mapM blockListToRST defs

tabstop <- get >>= (return . writerTabStop . stOptions)

-- | Convert list of Pandoc block elements to RST.

blockListToRST :: [Block] -- ^ List of block elements

inlineToRST :: Inline -> State WriterState Doc

inlineToRST (Emph lst) = do

contents <- inlineListToRST lst

inlineToRST (Strong lst) = do

contents <- inlineListToRST lst

inlineToRST (Strikeout lst) = do

contents <- inlineListToRST lst

inlineToRST (Superscript lst) = do

contents <- inlineListToRST lst

inlineToRST (Subscript lst) = do

contents <- inlineListToRST lst

inlineToRST (SmallCaps lst) = inlineListToRST lst

inlineToRST (Quoted SingleQuote lst) = do

contents <- inlineListToRST lst

inlineToRST (Quoted DoubleQuote lst) = do

contents <- inlineListToRST lst

inlineToRST (Cite _ lst) =

inlineListToRST lst

inlineToRST EmDash = return $ char '\8212'

inlineToRST EnDash = return $ char '\8211'

inlineToRST Apostrophe = return $ char '\8217'

inlineToRST Ellipses = return $ char '\8230'

inlineToRST (Str str) = return $ text $ escapeString str

inlineToRST (Math t str) = do

modify $ \st -> st{ stHasMath = True }

return $ if t == InlineMath

inlineToRST (TeX _) = return empty

inlineToRST (HtmlInline _) = return empty

inlineToRST (Link [Code str] (src, _)) | src == str ||

src == "mailto:" ++ str = do

let srcSuffix = if isPrefixOf "mailto:" src then drop 7 src else src

return $ text $ unescapeURI srcSuffix

inlineToRST (Link txt (src', tit)) = do

let src = unescapeURI src'

linktext <- inlineListToRST $ normalizeSpaces txt

if useReferenceLinks

let refs' = if (txt, (src, tit)) `elem` refs

then refs

else (txt, (src, tit)):refs

modify $ \st -> st { stLinks = refs' }

inlineToRST (Image alternate (source', tit)) = do

let source = unescapeURI source'

let labelsUsed = map fst pics

alternate `elem` labelsUsed

then [Str $ "image" ++ show (length pics)]

else alternate

else (txt, (source, tit)):pics

modify $ \st -> st { stImages = pics' }

label <- inlineListToRST txt

inlineToRST (Note contents) = do

-- add to notes in state

modify $ \st -> st { stNotes = contents:notes }

let ref = show $ (length notes) + 1

#ifdef _HIGHLIGHTING

import Text.Pandoc.Highlighting ( languages )

#endif

import System.Exit ( exitWith, ExitCode (..) )

import System.FilePath

import System.Console.GetOpt

import Data.List ( intercalate, isSuffixOf )

import System.Directory ( getAppUserDataDirectory, doesFileExist )

import System.IO ( stdout, stderr )

, optStrict :: Bool -- ^ Use strict markdown syntax

, optReferenceLinks :: Bool -- ^ Use reference links in writing markdown, rst

, optWrapText :: Bool -- ^ Wrap text

, optPlugins :: [Pandoc -> IO Pandoc] -- ^ Plugins to apply

, optEmailObfuscation :: ObfuscationMethod

, optIdentifierPrefix :: String

, optStrict = False

, optReferenceLinks = False

, optWrapText = True

, optPlugins = []

, optEmailObfuscation = JavascriptObfuscation

, optIdentifierPrefix = ""

, Option "" ["tab-stop"]

(ReqArg

"" -- "Tab stop (default 4)"

, Option "" ["strict"]

(\opt -> return opt { optWrapText = False }))

"" -- "Do not wrap text in output"

, Option "" ["email-obfuscation"]

(ReqArg

(\arg opt -> do

, Option "" ["base-header-level"]

(ReqArg

"" -- "Headers base level"

, Option "" ["template"]

, optStrict = strict

, optReferenceLinks = referenceLinks

, optWrapText = wrap

, optEmailObfuscation = obfuscationMethod

, optIdentifierPrefix = idPrefix

, optIndentedCodeClasses = codeBlockClasses

Right t -> t

Left e -> error (show e)

let standalone' = standalone || isNonTextOutput writerName'

variables' <- case (writerName', standalone', offline) of

writerStrictMarkdown = strict,

writerReferenceLinks = referenceLinks,

writerWrapText = wrap,

writerLiterateHaskell = "+lhs" `isSuffixOf` writerName' ||

lhsExtension [outputFile],

writerEmailObfuscation = if strict

"testsuite.native" "testsuite.native"

r14s <- mapM (\style -> runTest ("markdown reader (citations) (" ++ style ++ ")") ["-r", "markdown", "-w", "markdown", "--bibliography", "biblio.bib", "--csl", style ++ ".csl", "--no-wrap"] "markdown-citations.txt" ("markdown-citations." ++ style ++ ".txt")) ["chicago-author-date","ieee","mhra"]

let citopts = ["--bibliography", "biblio.bib", "--csl", "chicago-author-date.csl", "--no-citeproc"]

"markdown-citations.txt" "markdown-citations.txt"

r16s <- runLatexCitationTests citopts "biblatex"

r17s <- runLatexCitationTests citopts "natbib"

runLatexCitationTests :: [String] -> String -> IO [Bool]

runLatexCitationTests o n

f "markdown-citations.txt"

"markdown-citations.txt" f

]

where

runWriterTest :: String -> IO Bool

runWriterTest format = do

return (r1 && r2)

runS5WriterTest :: String -> [String] -> String -> IO Bool

let inpPath = inp

let normPath = norm

hFlush stdout

ec <- waitForProcess ph

result <- if ec == ExitSuccess

then do

$title$

$endif$

#+AUTHOR: $for(author)$$author$$sep$; $endfor$

$if(date)$

#+DATE: $date$

\textcites{item1}[p.~30]{item2}[see also][]{item3} says blah.

\item

\item

A citation group

Another one \autocite[see][p.~34--35]{item1}.

\item

\item

Citation with a suffix and locator

Citation with suffix only \autocite[and nowhere else]{item1}.

\item

\item

With some markup \autocite[\emph{see}][p. \textbf{32}]{item1}.

- With some markup (*see* Doe 2005, 32).

# References

Doe, John. 2005. *First Book*. Cambridge: Cambridge University Press.

Doe, John, and Jenny Roe. 2007. Why Water Is Wet. In *Third Book*, ed. Sam Smith. Oxford: Oxford University Press.

- With some markup [1].

# References

[1] J. Doe, *First Book*, Cambridge: Cambridge University Press, 2005.

[3] J. Doe and J. Roe, “Why Water Is Wet,” *Third Book*, Smith, S., Ed., Oxford: Oxford University Press, 2007.

- With some markup.[^12]

# References

Doe, John, ‘Article’, *Journal of Generic Studies*, 6 (2006), 33-34.

Doe, John, and Jenny Roe, ‘Why Water Is Wet’, in *Third Book*, ed by Sam Smith (Oxford: Oxford University Press, 2007).

- And another one in a note.[^2]

- Citation with suffix only [@item1 and nowhere else].

# References

\citet[p.~30, with suffix]{item1} says blah.

\item

\item

\item

\item

Another one \citep[see][p.~34--35]{item1}.

\item

\item

\item

Citation with suffix only \citep[and nowhere else]{item1}.

\item

\item

With some markup \citep[\emph{see}][p. \textbf{32}]{item1}.

12 12 12 12

123 123 123 123

1 1 1 1

: Demonstration of simple table syntax.

Simple table without caption:

12 12 12 12

123 123 123 123

1 1 1 1

: Demonstration of simple table syntax.

Multiline table with caption:

--------------------------------------------------------------

Centered Left Right Default aligned

----------- ---------- ------------ --------------------------

First row 12.0 Example of a row that

spans multiple lines.

Second row 5.0 Here's another one. Note

the blank line between

rows.

--------------------------------------------------------------

: Here's the caption. It may span multiple lines.

Multiline table without caption:

--------------------------------------------------------------

Centered Left Right Default aligned

----------- ---------- ------------ --------------------------

First row 12.0 Example of a row that

spans multiple lines.

Second row 5.0 Here's another one. Note

the blank line between

rows.

----------- ---------- ------------ --------------------------

First row 12.0 Example of a row that

spans multiple lines.

Second row 5.0 Here's another one. Note

the blank line between

rows.

----------- ---------- ------------ --------------------------

12 12 12 12

123 123 123 123

1 1 1 1

: Demonstration of simple table syntax.

Simple table without caption:

12 12 12 12

123 123 123 123

1 1 1 1

: Demonstration of simple table syntax.

Multiline table with caption:

--------------------------------------------------------------

Centered Left Right Default aligned

----------- ---------- ------------ --------------------------

First row 12.0 Example of a row that

spans multiple lines.

Second row 5.0 Here's another one. Note

the blank line between

rows.

--------------------------------------------------------------

: Here's the caption. It may span multiple lines.

Multiline table without caption:

--------------------------------------------------------------

Centered Left Right Default aligned

----------- ---------- ------------ --------------------------

First row 12.0 Example of a row that

spans multiple lines.

Second row 5.0 Here's another one. Note

the blank line between

rows.

----------- ---------- ------------ --------------------------

First row 12.0 Example of a row that

spans multiple lines.

Second row 5.0 Here's another one. Note

the blank line between

rows.

----------- ---------- ------------ --------------------------

% John MacFarlane; Anonymous

% July 17, 2006

* * * * *

with no blank line

* * * * *

# Paragraphs

Here’s a regular paragraph.

Here’s one with a bullet. \* criminey.

There should be a hard line break

here.

* * * * *

# Block Quotes

> This is a block quote. It is pretty short.

> Code in a block quote:

> sub status {

> print "working";

> }

> A list:

> 1. item one

> 2. item two

> Nested block quotes:

> > nested

> > nested

This should not be a block quote: 2 \> 1.

And a following paragraph.

* * * * *

# Code Blocks

Code:

---- (should be four hyphens)

sub status {

print "working";

}

this code block is indented by one tab

And:

this code block is indented by two tabs

* * * * *

- asterisk 3

Pluses tight:

- Plus 1

- Plus 3

Minuses tight:

- Minus 1

- Minus 3

## Ordered

Tight:

3. Third

and using spaces:

1. One

3. Three

Multiple paragraphs:

1. Item 1, graf one.

2. Item 2.

3. Item 3.

## Nested

- Tab

- Tab

- Tab

Here’s another:

1. First

3. Third

## Tabs and spaces

- this is a list item indented with tabs

- this is an example list item indented with spaces

## Fancy list markers

(2) begins with 2

(A) a subsublist

(B) a subsublist

Nesting:

A. Upper Alpha

(6) Decimal start with 6

c) Lower alpha with paren

Autonumbering:

1. Autonumber.

2. More.

1. Nested.

Should not be a list item:

M.A. 2007

B. Williams

* * * * *

# Definition Lists

banana

~ yellow fruit

Multiple blocks with italics:

*apple*

> orange block quote

Multiple definitions, tight:

apple

~ bank

Blank line after term, indented marker, alternate markers:

apple

1. sublist

2. sublist

# HTML Blocks

Simple block on one line:

<hr class="foo" id="bar">

* * * * *

# Inline Markup

Subscripts: H~2~O, H~23~O, H~many of them~O.

* * * * *

‘He said, “I want to go.”’ Were you alive in the 70’s?

Some dashes: one—two — three—four — five.

Ellipses…and…and….

* * * * *

# LaTeX

- $p$-Tree

- Here’s some display math:

$$\frac{d}{dx}f(x)=\lim_{h\to 0}\frac{f(x+h)-f(x)}{h}$$

These shouldn’t be math:

- To get the famous equation, write `$e = mc^2$`.

- Shoes ($20) and socks ($5).

- Escaped `$`: $73 *this should be emphasized* 23$.

Cat & 1 \\ \hline

\end{tabular}

* * * * *

# Special Characters

Minus: -

* * * * *

# Links

## With ampersands

Here’s a link with an amersand in the link text:

[AT&T](http://att.com/ "AT&T").

or here: <http://example.com/>

* * * * *

# Images

Here is a movie  icon.

* * * * *

# Footnotes

> Notes can go in quotes.[^4]

1. And in list items.[^5]

{ <code> }

[links](http://google.com) and `]` verbatim characters, as well as

[bracketed text].

#+AUTHOR: John MacFarlane; Anonymous

#+DATE: July 17, 2006

--------------

Here's a regular paragraph.

Here's one with a bullet. * criminey.

E-mail style:

#+BEGIN_QUOTE

This is a block quote. It is pretty short.

#+END_QUOTE

#+BEGIN_QUOTE

Code in a block quote:

#+BEGIN_EXAMPLE

print "working";

}

#+END_EXAMPLE

A list:

1. item one

2. item two

Nested block quotes:

nested

nested

#+END_QUOTE

This should not be a block quote: 2 > 1.

#+BEGIN_EXAMPLE

---- (should be four hyphens)

sub status {

print "working";

}

this code block is indented by one tab

#+END_EXAMPLE

And:

#+BEGIN_EXAMPLE

this code block is indented by two tabs

These should not be escaped: \$ \\ \> \[ \{

#+END_EXAMPLE

--------------

* Lists

Asterisks tight:

- asterisk 1

- asterisk 2

- asterisk 3

Asterisks loose:

- asterisk 1

- asterisk 2

- asterisk 3

Pluses tight:

- Plus 1

- Plus 2

- Plus 3

Pluses loose:

- Plus 1

- Plus 2

- Plus 3

Minuses tight:

- Minus 1

- Minus 2

- Minus 3

Minuses loose:

- Minus 1

- Minus 2

- Minus 3

** Ordered

Tight:

1. First

2. Second

3. Third

and:

1. One

2. Two

3. Three

Loose using tabs:

1. First

2. Second

3. Third

and using spaces:

1. One

2. Two

3. Three

Multiple paragraphs:

1. Item 1, graf one.

2. Item 2.

3. Item 3.

** Nested

- Tab

Here's another:

1. First

2. Second:

- Fee

- Fie

- Foe

Same thing but with paragraphs:

1. First

2. Second:

- Fee

- Fie

- Foe

3. Third

** Tabs and spaces

- this is a list item indented with tabs

- this is a list item indented with spaces

- this is an example list item indented with tabs

- this is an example list item indented with spaces

** Fancy list markers

Nesting:

Autonumbering:

1. Autonumber.

2. More.

Should not be a list item:

- banana :: yellow fruit

Multiple blocks with italics:

- /apple/ :: red fruit

- /orange/ :: orange fruit

Multiple definitions, tight:

- apple :: red fruit

- orange :: orange fruit

Multiple definitions, loose:

- apple :: red fruit

- orange :: orange fruit

Blank line after term, indented marker, alternate markers:

- apple :: red fruit

- orange :: orange fruit

* HTML Blocks

Simple block on one line:

#+BEGIN_HTML

<div>

#+END_HTML

foo

#+BEGIN_HTML

</div>

#+END_HTML

And nested without indentation:

#+BEGIN_HTML

<div>

<div>

<div>

#+END_HTML

foo

#+BEGIN_HTML

</div>

</div>

<div>

#+END_HTML

bar

#+BEGIN_HTML

</div>

</div>

#+END_HTML

Interpreted markdown in a table:

#+BEGIN_HTML

<table>

<tr>

<td>

#+END_HTML

This is /emphasized/

#+BEGIN_HTML

</td>

<td>

#+END_HTML

And this is *strong*

#+BEGIN_HTML

</td>

</tr>

</table>

#+END_HTML

Here's a simple block:

#+BEGIN_HTML

<div>

#+END_HTML

foo

#+BEGIN_HTML

</div>

#+END_HTML

This should be a code block, though:

foo

</div>

#+END_EXAMPLE

As should this:

#+BEGIN_EXAMPLE

<div>foo</div>

#+END_EXAMPLE

#+BEGIN_HTML

<div>

<div>

<div>

#+END_HTML

foo

#+BEGIN_HTML

</div>

</div>

</div>

#+END_HTML

This should just be an HTML comment:

#+BEGIN_HTML

<!-- Comment -->

#+END_HTML

Multiline:

#+BEGIN_HTML

<!--

Blah

Blah

-->

<!--

This is another comment.

-->

#+END_HTML

Code block:

#+BEGIN_EXAMPLE

<!-- Comment -->

#+END_EXAMPLE

#+BEGIN_HTML

<!-- foo -->

#+END_HTML

Code:

#+BEGIN_EXAMPLE

<hr />

#+END_EXAMPLE

#+BEGIN_HTML

<hr>

<hr />

<hr />

<hr>

<hr />

<hr />

<hr class="foo" id="bar" />

<hr class="foo" id="bar" />

#+END_HTML

--------------

Subscripts: H_{2}O, H_{23}O, H_{many of them}O.

--------------

'He said, "I want to go."' Were you alive in the 70's?

Some dashes: one---two --- three---four --- five.

* LaTeX

- \cite[22-23]{smith.1899}

- $2+2=4$

- $x \in y$

- $p$-Tree

- Here's some display math:

$$\frac{d}{dx}f(x)=\lim_{h\to 0}\frac{f(x+h)-f(x)}{h}$$

These shouldn't be math:

- To get the famous equation, write =$e = mc^2$=.

- Shoes ($20) and socks ($5).

- Escaped =$=: $73 /this should be emphasized/ 23$.

Here is some unicode:

- I hat: Î

- o umlaut: ö

- section: §

#+BEGIN_EXAMPLE

[not]: /url

#+END_EXAMPLE

Foo [[/url/][bar]].

Foo [[/url/][biz]].

** With ampersands

Here's an [[/script?foo=1&bar=2][inline link]].

With an ampersand: [[http://example.com/?foo=1&bar=2]]

- In a list?

- [[http://example.com/]]

- It should.

#+BEGIN_QUOTE

Blockquoted: [[http://example.com/]]

#+END_QUOTE

Auto-links should not occur here: =<http://example.com/>=

#+BEGIN_EXAMPLE

or here: <http://example.com/>

#+END_EXAMPLE

--------------

* Images

* Footnotes

#+BEGIN_QUOTE

Notes can go in quotes. [4]

#+END_QUOTE

1. And in list items. [5]

[2] Here's the long note. This one contains multiple blocks.

#+BEGIN_EXAMPLE

{ <code> }

#+END_EXAMPLE

[3] This is /easier/ to type. Inline notes may contain

[4] In quote.

John MacFarlane; Anonymous

July 17, 2006

* * * * *

with no blank line

* * * * *

Paragraphs

Here’s a regular paragraph.

Here’s one with a bullet. * criminey.

There should be a hard line break

here.

* * * * *

Block Quotes

This is a block quote. It is pretty short.

Code in a block quote:

sub status {

print "working";

}

A list:

1. item one

2. item two

Nested block quotes:

nested

nested

This should not be a block quote: 2 > 1.

And a following paragraph.

* * * * *

Code Blocks

Code:

---- (should be four hyphens)

sub status {

print "working";

}

this code block is indented by one tab

And:

this code block is indented by two tabs

* * * * *

- asterisk 3

Pluses tight:

- Plus 1

- Plus 3

Minuses tight:

- Minus 1

- Minus 3

Ordered

-------

3. Third

and using spaces:

1. One

3. Three

Multiple paragraphs:

1. Item 1, graf one.

2. Item 2.

3. Item 3.

Nested

------

- Tab

- Tab

Here’s another:

1. First

3. Third

Tabs and spaces

---------------

- this is an example list item indented with spaces

Fancy list markers

------------------

(A) a subsublist

(B) a subsublist

Nesting:

A. Upper Alpha

(6) Decimal start with 6

c) Lower alpha with paren

Autonumbering:

1. Autonumber.

2. More.

1. Nested.

Should not be a list item:

M.A. 2007

B. Williams

* * * * *

Definition Lists

banana

yellow fruit

Multiple blocks with italics:

apple

orange block quote

Multiple definitions, tight:

apple

bank

Blank line after term, indented marker, alternate markers:

apple

1. sublist

2. sublist

HTML Blocks

===========

Hr’s:

* * * * *

Inline Markup

Subscripts: H2O, H23O, Hmany of themO.

* * * * *

Ellipses…and…and….

* * * * *

LaTeX

- p-Tree

- Here’s some display math:

\frac{d}{dx}f(x)=\lim_{h\to 0}\frac{f(x+h)-f(x)}{h}

These shouldn’t be math:

- To get the famous equation, write $e = mc^2$.

- Shoes ($20) and socks ($5).

- Escaped $: $73 this should be emphasized 23$.

Here’s a LaTeX table:

* * * * *

Special Characters

Minus: -

* * * * *

Links

or here: <http://example.com/>

* * * * *

Images

From “Voyage dans la Lune” by Georges Melies (1902):

* * * * *

Footnotes

=========

Notes can go in quotes.[^4]

1. And in list items.[^5]

{ <code> }

.. role:: math(raw)

:format: html latex

--------------

Here’s a regular paragraph.

Here’s one with a bullet. \* criminey.

This is a block quote. It is pretty short.

Code in a block quote:

::

A list:

1. item one

2. item two

nested

nested

This should not be a block quote: 2 > 1.

And a following paragraph.

::

---- (should be four hyphens)

sub status {

print "working";

}

this code block is indented by one tab

And:

::

this code block is indented by two tabs

These should not be escaped: \$ \\ \> \[ \{

--------------

Asterisks tight:

- asterisk 1

- asterisk 2

- asterisk 3

Asterisks loose:

- asterisk 1

- asterisk 2

- asterisk 3

Pluses tight:

- Plus 1

- Plus 2

- Plus 3

Pluses loose:

- Plus 1

- Plus 2

- Plus 3

Minuses tight:

- Minus 1

- Minus 2

- Minus 3

Minuses loose:

- Minus 1

- Minus 2

- Minus 3

Ordered

-------

Tight:

1. First

2. Second

3. Third

and:

1. One

2. Two

3. Three

Loose using tabs:

1. First

2. Second

3. Third

and using spaces:

1. One

2. Two

3. Three

Multiple paragraphs:

1. Item 1, graf one.

2. Item 2.

3. Item 3.

Nested

------

- Tab

Here’s another:

1. First

2. Second:

- Fee

- Fie

- Foe

Same thing but with paragraphs:

1. First

2. Second:

- Fee

- Fie

- Foe

3. Third

Tabs and spaces

---------------

- this is a list item indented with tabs

- this is a list item indented with spaces

- this is an example list item indented with tabs

- this is an example list item indented with spaces

Fancy list markers

------------------

(2) begins with 2

(3) and now 3

with a continuation

iv. sublist with roman numerals, starting with 4

v. more items

(A) a subsublist

(B) a subsublist

Nesting:

A. Upper Alpha

Autonumbering:

#. Autonumber.

#. More.

Should not be a list item:

banana

yellow fruit

Multiple blocks with italics:

*apple*

orange block quote

Multiple definitions, tight:

apple

bank

Blank line after term, indented marker, alternate markers:

apple

orange

orange fruit

1. sublist

2. sublist

HTML Blocks

===========

Simple block on one line:

.. raw:: html

<div>

foo

.. raw:: html

</div>

.. raw:: html

<div>

<div>

<div>

foo

.. raw:: html

</div>

</div>

<div>

bar

.. raw:: html

</div>

</div>

.. raw:: html

<table>

<tr>

<td>

This is *emphasized*

.. raw:: html

</td>

<td>

And this is **strong**

.. raw:: html

</td>

</tr>

</table>

<script type="text/javascript">document.write('This *should not* be interpreted as markdown');</script>

.. raw:: html

<div>

foo

.. raw:: html

</div>

This should be a code block, though:

::

Now, nested:

.. raw:: html

<div>

<div>

<div>

foo

.. raw:: html

</div>

</div>

</div>

.. raw:: html

<!-- Comment -->

.. raw:: html

Blah

Blah

-->

<!--

This is another comment.

-->

Code block:

::

Just plain comment, with trailing spaces on the line:

.. raw:: html

<!-- foo -->

Code:

::

Hr’s:

.. raw:: html

<hr>

<hr />

<hr />

<hr>

<hr />

<hr />

<hr class="foo" id="bar" />

<hr class="foo" id="bar" />

<hr class="foo" id="bar">

--------------

Inline Markup

[STRIKEOUT:This is *strikeout*.]

--------------

‘He said, “I want to go.”’ Were you alive in the 70’s?

Some dashes: one—two — three—four — five.

LaTeX

=====

-

- :math:`$2+2=4$`

- :math:`$x \in y$`

These shouldn’t be math:

- To get the famous equation, write ``$e = mc^2$``.

- Shoes ($20) and socks ($5).

- Escaped ``$``: $73 *this should be emphasized* 23$.

Here’s a LaTeX table:

--------------

Special Characters

Here is some unicode:

- I hat: Î

- o umlaut: ö

- section: §

With ampersands

---------------

Here’s an `inline link </script?foo=1&bar=2>`_.

With an ampersand: http://example.com/?foo=1&bar=2

- In a list?

- http://example.com/

- It should.

Blockquoted: http://example.com/

Auto-links should not occur here: ``<http://example.com/>``

::

.. figure:: lalune.jpg

:align: center

:alt: Voyage dans la Lune

Here is a movie |movie| icon.

--------------

Footnotes

=========

Notes can go in quotes. [4]_

1. And in list items. [5]_

.. [1]

.. [2]

Here’s the long note. This one contains multiple blocks.

::

{ <code> }

.. [3]

This is *easier* to type. Inline notes may contain

.. [4]

In quote.