    {-# LANGUAGE OverloadedStrings #-}
    {-# LANGUAGE ViewPatterns      #-}
    {- |
       Module      : Text.Pandoc.Writers.Man
       Copyright   : Copyright (C) 2007-2020 John MacFarlane
       License     : GNU GPL, version 2 or above

       Maintainer  : John MacFarlane <jgm@berkeley.edu>
       Stability   : alpha
       Portability : portable

    Conversion of 'Pandoc' documents to roff man page format.

    -}
    module Text.Pandoc.Writers.Man ( writeMan ) where
    import Control.Monad.State.Strict
    import Data.List (intersperse)
    import Data.Maybe (fromMaybe)
    import Data.Text (Text)
    import qualified Data.Text as T
    import Text.Pandoc.Builder (deleteMeta)
    import Text.Pandoc.Class.PandocMonad (PandocMonad, report)
    import Text.Pandoc.Definition
    import Text.Pandoc.Logging
    import Text.Pandoc.Options
    import Text.DocLayout
    import Text.Pandoc.Shared
    import Text.Pandoc.Walk (walk)
    import Text.Pandoc.Templates (renderTemplate)
    import Text.Pandoc.Writers.Math
    import Text.Pandoc.Writers.Shared
    import Text.Pandoc.Writers.Roff
    import Text.Printf (printf)

    -- | Convert Pandoc to Man.
    writeMan :: PandocMonad m => WriterOptions -> Pandoc -> m Text
    writeMan :: WriterOptions -> Pandoc -> m Text
    writeMan opts :: WriterOptions
    opts document :: Pandoc
    document =
      StateT WriterState m Text -> WriterState -> m Text
    forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
    evalStateT (WriterOptions -> Pandoc -> StateT WriterState m Text
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> Pandoc -> StateT WriterState m Text
    pandocToMan WriterOptions
    opts Pandoc
    document) WriterState
    defaultWriterState

    -- | Return roff man representation of document.
    pandocToMan :: PandocMonad m => WriterOptions -> Pandoc -> StateT WriterState m Text
    pandocToMan :: WriterOptions -> Pandoc -> StateT WriterState m Text
    pandocToMan opts :: WriterOptions
    opts (Pandoc meta :: Meta
    meta blocks :: [Block]
    blocks) = do
      let colwidth :: Maybe Int
    colwidth = if WriterOptions -> WrapOption
    writerWrapText WriterOptions
    opts WrapOption -> WrapOption -> Bool
    forall a. Eq a => a -> a -> Bool
    == WrapOption
    WrapAuto
                        then Int -> Maybe Int
    forall a. a -> Maybe a
    Just (Int -> Maybe Int) -> Int -> Maybe Int
    forall a b. (a -> b) -> a -> b
    $ WriterOptions -> Int
    writerColumns WriterOptions
    opts
                        else Maybe Int
    forall a. Maybe a
    Nothing
      Doc Text
    titleText <- WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    inlineListToMan WriterOptions
    opts ([Inline] -> StateT WriterState m (Doc Text))
    -> [Inline] -> StateT WriterState m (Doc Text)
    forall a b. (a -> b) -> a -> b
    $ Meta -> [Inline]
    docTitle Meta
    meta
      let title' :: Text
    title' = Maybe Int -> Doc Text -> Text
    forall a. HasChars a => Maybe Int -> Doc a -> a
    render Maybe Int
    forall a. Maybe a
    Nothing Doc Text
    titleText
      let setFieldsFromTitle :: Context Text -> Context Text
    setFieldsFromTitle =
           case (Char -> Bool) -> Text -> (Text, Text)
    T.break (Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    == ' ') Text
    title' of
               (cmdName :: Text
    cmdName, rest :: Text
    rest) -> case (Char -> Bool) -> Text -> (Text, Text)
    T.break (Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    =='(') Text
    cmdName of
                                       (xs :: Text
    xs, ys :: Text
    ys) | "(" Text -> Text -> Bool
    `T.isPrefixOf` Text
    ys
                                                    Bool -> Bool -> Bool
    && ")" Text -> Text -> Bool
    `T.isSuffixOf` Text
    ys ->
                                         Text -> Text -> Context Text -> Context Text
    forall a b. ToContext a b => Text -> b -> Context a -> Context a
    defField "title" Text
    xs (Context Text -> Context Text)
    -> (Context Text -> Context Text) -> Context Text -> Context Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .
                                         Text -> Text -> Context Text -> Context Text
    forall a b. ToContext a b => Text -> b -> Context a -> Context a
    defField "section" (Text -> Text
    T.init (Text -> Text) -> Text -> Text
    forall a b. (a -> b) -> a -> b
    $ Int -> Text -> Text
    T.drop 1 Text
    ys) (Context Text -> Context Text)
    -> (Context Text -> Context Text) -> Context Text -> Context Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .
                                         case Text -> Text -> [Text]
    T.splitOn "|" Text
    rest of
                                              (ft :: Text
    ft:hds :: [Text]
    hds) ->
                                                Text -> Text -> Context Text -> Context Text
    forall a b. ToContext a b => Text -> b -> Context a -> Context a
    defField "footer" (Text -> Text
    T.strip Text
    ft) (Context Text -> Context Text)
    -> (Context Text -> Context Text) -> Context Text -> Context Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .
                                                Text -> Text -> Context Text -> Context Text
    forall a b. ToContext a b => Text -> b -> Context a -> Context a
    defField "header"
                                                   (Text -> Text
    T.strip (Text -> Text) -> Text -> Text
    forall a b. (a -> b) -> a -> b
    $ [Text] -> Text
    forall a. Monoid a => [a] -> a
    mconcat [Text]
    hds)
                                              [] -> Context Text -> Context Text
    forall a. a -> a
    id
                                       _  -> Text -> Text -> Context Text -> Context Text
    forall a b. ToContext a b => Text -> b -> Context a -> Context a
    defField "title" Text
    title'
      Context Text
    metadata <- WriterOptions
    -> ([Block] -> StateT WriterState m (Doc Text))
    -> ([Inline] -> StateT WriterState m (Doc Text))
    -> Meta
    -> StateT WriterState m (Context Text)
    forall (m :: * -> *) a.
    (Monad m, TemplateTarget a) =>
    WriterOptions
    -> ([Block] -> m (Doc a))
    -> ([Inline] -> m (Doc a))
    -> Meta
    -> m (Context a)
    metaToContext WriterOptions
    opts
                  (WriterOptions -> [Block] -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> [Block] -> StateT WriterState m (Doc Text)
    blockListToMan WriterOptions
    opts)
                  ((Doc Text -> Doc Text)
    -> StateT WriterState m (Doc Text)
    -> StateT WriterState m (Doc Text)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Doc Text -> Doc Text
    forall a. Doc a -> Doc a
    chomp (StateT WriterState m (Doc Text)
     -> StateT WriterState m (Doc Text))
    -> ([Inline] -> StateT WriterState m (Doc Text))
    -> [Inline]
    -> StateT WriterState m (Doc Text)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    inlineListToMan WriterOptions
    opts)
                  (Meta -> StateT WriterState m (Context Text))
    -> Meta -> StateT WriterState m (Context Text)
    forall a b. (a -> b) -> a -> b
    $ Text -> Meta -> Meta
    forall a. HasMeta a => Text -> a -> a
    deleteMeta "title" Meta
    meta
      Doc Text
    body <- WriterOptions -> [Block] -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> [Block] -> StateT WriterState m (Doc Text)
    blockListToMan WriterOptions
    opts [Block]
    blocks
      [[Block]]
    notes <- (WriterState -> [[Block]]) -> StateT WriterState m [[Block]]
    forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
    gets WriterState -> [[Block]]
    stNotes
      Doc Text
    notes' <- WriterOptions -> [[Block]] -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> [[Block]] -> StateT WriterState m (Doc Text)
    notesToMan WriterOptions
    opts ([[Block]] -> [[Block]]
    forall a. [a] -> [a]
    reverse [[Block]]
    notes)
      let main :: Doc Text
    main = Doc Text
    body Doc Text -> Doc Text -> Doc Text
    forall a. Doc a -> Doc a -> Doc a
    $$ Doc Text
    notes' Doc Text -> Doc Text -> Doc Text
    forall a. Doc a -> Doc a -> Doc a
    $$ String -> Doc Text
    forall a. HasChars a => String -> Doc a
    text ""
      Bool
    hasTables <- (WriterState -> Bool) -> StateT WriterState m Bool
    forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
    gets WriterState -> Bool
    stHasTables
      let context :: Context Text
    context = Text -> Doc Text -> Context Text -> Context Text
    forall a b. ToContext a b => Text -> b -> Context a -> Context a
    defField "body" Doc Text
    main
                  (Context Text -> Context Text) -> Context Text -> Context Text
    forall a b. (a -> b) -> a -> b
    $ Context Text -> Context Text
    setFieldsFromTitle
                  (Context Text -> Context Text) -> Context Text -> Context Text
    forall a b. (a -> b) -> a -> b
    $ Text -> Bool -> Context Text -> Context Text
    forall a b. ToContext a b => Text -> b -> Context a -> Context a
    defField "has-tables" Bool
    hasTables
                  (Context Text -> Context Text) -> Context Text -> Context Text
    forall a b. (a -> b) -> a -> b
    $ Text -> Bool -> Context Text -> Context Text
    forall a b. ToContext a b => Text -> b -> Context a -> Context a
    defField "hyphenate" Bool
    True
                  (Context Text -> Context Text) -> Context Text -> Context Text
    forall a b. (a -> b) -> a -> b
    $ Text -> Text -> Context Text -> Context Text
    forall a b. ToContext a b => Text -> b -> Context a -> Context a
    defField "pandoc-version" Text
    pandocVersion Context Text
    metadata
      Text -> StateT WriterState m Text
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Text -> StateT WriterState m Text)
    -> Text -> StateT WriterState m Text
    forall a b. (a -> b) -> a -> b
    $ Maybe Int -> Doc Text -> Text
    forall a. HasChars a => Maybe Int -> Doc a -> a
    render Maybe Int
    colwidth (Doc Text -> Text) -> Doc Text -> Text
    forall a b. (a -> b) -> a -> b
    $
        case WriterOptions -> Maybe (Template Text)
    writerTemplate WriterOptions
    opts of
           Nothing  -> Doc Text
    main
           Just tpl :: Template Text
    tpl -> Template Text -> Context Text -> Doc Text
    forall a b.
    (TemplateTarget a, ToContext a b) =>
    Template a -> b -> Doc a
    renderTemplate Template Text
    tpl Context Text
    context

    escString :: WriterOptions -> Text -> Text
    escString :: WriterOptions -> Text -> Text
    escString _ = EscapeMode -> Text -> Text
    escapeString EscapeMode
    AsciiOnly -- for better portability

    -- | Return man representation of notes.
    notesToMan :: PandocMonad m => WriterOptions -> [[Block]] -> StateT WriterState m (Doc Text)
    notesToMan :: WriterOptions -> [[Block]] -> StateT WriterState m (Doc Text)
    notesToMan opts :: WriterOptions
    opts notes :: [[Block]]
    notes =
      if [[Block]] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [[Block]]
    notes
         then Doc Text -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Doc Text
    forall a. Doc a
    empty
         else (String -> Doc Text
    forall a. HasChars a => String -> Doc a
    text ".SH NOTES" Doc Text -> Doc Text -> Doc Text
    forall a. Doc a -> Doc a -> Doc a
    $$) (Doc Text -> Doc Text)
    -> ([Doc Text] -> Doc Text) -> [Doc Text] -> Doc Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [Doc Text] -> Doc Text
    forall a. [Doc a] -> Doc a
    vcat ([Doc Text] -> Doc Text)
    -> StateT WriterState m [Doc Text]
    -> StateT WriterState m (Doc Text)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Int -> [Block] -> StateT WriterState m (Doc Text))
    -> [Int] -> [[Block]] -> StateT WriterState m [Doc Text]
    forall (m :: * -> *) a b c.
    Applicative m =>
    (a -> b -> m c) -> [a] -> [b] -> m [c]
    zipWithM (WriterOptions -> Int -> [Block] -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> Int -> [Block] -> StateT WriterState m (Doc Text)
    noteToMan WriterOptions
    opts) [1..] [[Block]]
    notes

    -- | Return man representation of a note.
    noteToMan :: PandocMonad m => WriterOptions -> Int -> [Block] -> StateT WriterState m (Doc Text)
    noteToMan :: WriterOptions -> Int -> [Block] -> StateT WriterState m (Doc Text)
    noteToMan opts :: WriterOptions
    opts num :: Int
    num note :: [Block]
    note = do
      Doc Text
    contents <- WriterOptions -> [Block] -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> [Block] -> StateT WriterState m (Doc Text)
    blockListToMan WriterOptions
    opts [Block]
    note
      let marker :: Doc Text
    marker = Doc Text
    forall a. Doc a
    cr Doc Text -> Doc Text -> Doc Text
    forall a. Semigroup a => a -> a -> a
    <> String -> Doc Text
    forall a. HasChars a => String -> Doc a
    text ".SS " Doc Text -> Doc Text -> Doc Text
    forall a. Semigroup a => a -> a -> a
    <> Doc Text -> Doc Text
    forall a. HasChars a => Doc a -> Doc a
    brackets (String -> Doc Text
    forall a. HasChars a => String -> Doc a
    text (Int -> String
    forall a. Show a => a -> String
    show Int
    num))
      Doc Text -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Doc Text -> StateT WriterState m (Doc Text))
    -> Doc Text -> StateT WriterState m (Doc Text)
    forall a b. (a -> b) -> a -> b
    $ Doc Text
    marker Doc Text -> Doc Text -> Doc Text
    forall a. Doc a -> Doc a -> Doc a
    $$ Doc Text
    contents

    -- We split inline lists into sentences, and print one sentence per
    -- line.  roff treats the line-ending period differently.
    -- See http://code.google.com/p/pandoc/issues/detail?id=148.

    -- | Convert Pandoc block element to man.
    blockToMan :: PandocMonad m
               => WriterOptions -- ^ Options
               -> Block         -- ^ Block element
               -> StateT WriterState m (Doc Text)
    blockToMan :: WriterOptions -> Block -> StateT WriterState m (Doc Text)
    blockToMan _ Null = Doc Text -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Doc Text
    forall a. Doc a
    empty
    blockToMan opts :: WriterOptions
    opts (Div _ bs :: [Block]
    bs) = WriterOptions -> [Block] -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> [Block] -> StateT WriterState m (Doc Text)
    blockListToMan WriterOptions
    opts [Block]
    bs
    blockToMan opts :: WriterOptions
    opts (Plain inlines :: [Inline]
    inlines) =
      ([Doc Text] -> Doc Text)
    -> StateT WriterState m [Doc Text]
    -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM [Doc Text] -> Doc Text
    forall a. [Doc a] -> Doc a
    vcat (StateT WriterState m [Doc Text]
     -> StateT WriterState m (Doc Text))
    -> StateT WriterState m [Doc Text]
    -> StateT WriterState m (Doc Text)
    forall a b. (a -> b) -> a -> b
    $ ([Inline] -> StateT WriterState m (Doc Text))
    -> [[Inline]] -> StateT WriterState m [Doc Text]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    mapM (WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    inlineListToMan WriterOptions
    opts) ([[Inline]] -> StateT WriterState m [Doc Text])
    -> [[Inline]] -> StateT WriterState m [Doc Text]
    forall a b. (a -> b) -> a -> b
    $ [Inline] -> [[Inline]]
    splitSentences [Inline]
    inlines
    blockToMan opts :: WriterOptions
    opts (Para inlines :: [Inline]
    inlines) = do
      Doc Text
    contents <- ([Doc Text] -> Doc Text)
    -> StateT WriterState m [Doc Text]
    -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM [Doc Text] -> Doc Text
    forall a. [Doc a] -> Doc a
    vcat (StateT WriterState m [Doc Text]
     -> StateT WriterState m (Doc Text))
    -> StateT WriterState m [Doc Text]
    -> StateT WriterState m (Doc Text)
    forall a b. (a -> b) -> a -> b
    $ ([Inline] -> StateT WriterState m (Doc Text))
    -> [[Inline]] -> StateT WriterState m [Doc Text]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    mapM (WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    inlineListToMan WriterOptions
    opts) ([[Inline]] -> StateT WriterState m [Doc Text])
    -> [[Inline]] -> StateT WriterState m [Doc Text]
    forall a b. (a -> b) -> a -> b
    $
        [Inline] -> [[Inline]]
    splitSentences [Inline]
    inlines
      Doc Text -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Doc Text -> StateT WriterState m (Doc Text))
    -> Doc Text -> StateT WriterState m (Doc Text)
    forall a b. (a -> b) -> a -> b
    $ String -> Doc Text
    forall a. HasChars a => String -> Doc a
    text ".PP" Doc Text -> Doc Text -> Doc Text
    forall a. Doc a -> Doc a -> Doc a
    $$ Doc Text
    contents
    blockToMan opts :: WriterOptions
    opts (LineBlock lns :: [[Inline]]
    lns) =
      WriterOptions -> Block -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> Block -> StateT WriterState m (Doc Text)
    blockToMan WriterOptions
    opts (Block -> StateT WriterState m (Doc Text))
    -> Block -> StateT WriterState m (Doc Text)
    forall a b. (a -> b) -> a -> b
    $ [[Inline]] -> Block
    linesToPara [[Inline]]
    lns
    blockToMan _ b :: Block
    b@(RawBlock f :: Format
    f str :: Text
    str)
      | Format
    f Format -> Format -> Bool
    forall a. Eq a => a -> a -> Bool
    == Text -> Format
    Format "man" = Doc Text -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Doc Text -> StateT WriterState m (Doc Text))
    -> Doc Text -> StateT WriterState m (Doc Text)
    forall a b. (a -> b) -> a -> b
    $ Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal Text
    str
      | Bool
    otherwise         = do
          LogMessage -> StateT WriterState m ()
    forall (m :: * -> *). PandocMonad m => LogMessage -> m ()
    report (LogMessage -> StateT WriterState m ())
    -> LogMessage -> StateT WriterState m ()
    forall a b. (a -> b) -> a -> b
    $ Block -> LogMessage
    BlockNotRendered Block
    b
          Doc Text -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Doc Text
    forall a. Doc a
    empty
    blockToMan _ HorizontalRule = Doc Text -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Doc Text -> StateT WriterState m (Doc Text))
    -> Doc Text -> StateT WriterState m (Doc Text)
    forall a b. (a -> b) -> a -> b
    $ Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal ".PP" Doc Text -> Doc Text -> Doc Text
    forall a. Doc a -> Doc a -> Doc a
    $$ Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal "   *   *   *   *   *"
    blockToMan opts :: WriterOptions
    opts (Header level :: Int
    level _ inlines :: [Inline]
    inlines) = do
      Doc Text
    contents <- WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    inlineListToMan WriterOptions
    opts [Inline]
    inlines
      let heading :: Text
    heading = case Int
    level of
                      1 -> ".SH "
                      _ -> ".SS "
      Doc Text -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Doc Text -> StateT WriterState m (Doc Text))
    -> Doc Text -> StateT WriterState m (Doc Text)
    forall a b. (a -> b) -> a -> b
    $ Doc Text -> Doc Text
    forall a. IsString a => Doc a -> Doc a
    nowrap (Doc Text -> Doc Text) -> Doc Text -> Doc Text
    forall a b. (a -> b) -> a -> b
    $ Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal Text
    heading Doc Text -> Doc Text -> Doc Text
    forall a. Semigroup a => a -> a -> a
    <> Doc Text
    contents
    blockToMan opts :: WriterOptions
    opts (CodeBlock _ str :: Text
    str) = Doc Text -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Doc Text -> StateT WriterState m (Doc Text))
    -> Doc Text -> StateT WriterState m (Doc Text)
    forall a b. (a -> b) -> a -> b
    $
      Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal ".IP" Doc Text -> Doc Text -> Doc Text
    forall a. Doc a -> Doc a -> Doc a
    $$
      Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal ".nf" Doc Text -> Doc Text -> Doc Text
    forall a. Doc a -> Doc a -> Doc a
    $$
      Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal "\\f[C]" Doc Text -> Doc Text -> Doc Text
    forall a. Doc a -> Doc a -> Doc a
    $$
      ((case Text -> Maybe (Char, Text)
    T.uncons Text
    str of
        Just ('.',_) -> Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal "\\&"
        _            -> Doc Text
    forall a. Monoid a => a
    mempty) Doc Text -> Doc Text -> Doc Text
    forall a. Semigroup a => a -> a -> a
    <>
       Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal (WriterOptions -> Text -> Text
    escString WriterOptions
    opts Text
    str)) Doc Text -> Doc Text -> Doc Text
    forall a. Doc a -> Doc a -> Doc a
    $$
      Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal "\\f[R]" Doc Text -> Doc Text -> Doc Text
    forall a. Doc a -> Doc a -> Doc a
    $$
      Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal ".fi"
    blockToMan opts :: WriterOptions
    opts (BlockQuote blocks :: [Block]
    blocks) = do
      Doc Text
    contents <- WriterOptions -> [Block] -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> [Block] -> StateT WriterState m (Doc Text)
    blockListToMan WriterOptions
    opts [Block]
    blocks
      Doc Text -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Doc Text -> StateT WriterState m (Doc Text))
    -> Doc Text -> StateT WriterState m (Doc Text)
    forall a b. (a -> b) -> a -> b
    $ Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal ".RS" Doc Text -> Doc Text -> Doc Text
    forall a. Doc a -> Doc a -> Doc a
    $$ Doc Text
    contents Doc Text -> Doc Text -> Doc Text
    forall a. Doc a -> Doc a -> Doc a
    $$ Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal ".RE"
    blockToMan opts :: WriterOptions
    opts (Table caption :: [Inline]
    caption alignments :: [Alignment]
    alignments widths :: [Double]
    widths headers :: [[Block]]
    headers rows :: [[[Block]]]
    rows) =
      let aligncode :: Alignment -> p
    aligncode AlignLeft    = "l"
          aligncode AlignRight   = "r"
          aligncode AlignCenter  = "c"
          aligncode AlignDefault = "l"
      in do
      Doc Text
    caption' <- WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    inlineListToMan WriterOptions
    opts [Inline]
    caption
      (WriterState -> WriterState) -> StateT WriterState m ()
    forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
    modify ((WriterState -> WriterState) -> StateT WriterState m ())
    -> (WriterState -> WriterState) -> StateT WriterState m ()
    forall a b. (a -> b) -> a -> b
    $ \st :: WriterState
    st -> WriterState
    st{ stHasTables :: Bool
    stHasTables = Bool
    True }
      let iwidths :: [Text]
    iwidths = if (Double -> Bool) -> [Double] -> Bool
    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
    all (Double -> Double -> Bool
    forall a. Eq a => a -> a -> Bool
    == 0) [Double]
    widths
                       then Text -> [Text]
    forall a. a -> [a]
    repeat ""
                       else (Double -> Text) -> [Double] -> [Text]
    forall a b. (a -> b) -> [a] -> [b]
    map (String -> Text
    T.pack (String -> Text) -> (Double -> String) -> Double -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . String -> Double -> String
    forall r. PrintfType r => String -> r
    printf "w(%0.1fn)" (Double -> String) -> (Double -> Double) -> Double -> String
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (70 Double -> Double -> Double
    forall a. Num a => a -> a -> a
    *)) [Double]
    widths
      -- 78n default width - 8n indent = 70n
      let coldescriptions :: Doc Text
    coldescriptions = Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal (Text -> Doc Text) -> Text -> Doc Text
    forall a b. (a -> b) -> a -> b
    $ [Text] -> Text
    T.unwords
                            ((Alignment -> Text -> Text) -> [Alignment] -> [Text] -> [Text]
    forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
    zipWith (\align :: Alignment
    align width :: Text
    width -> Alignment -> Text
    forall p. IsString p => Alignment -> p
    aligncode Alignment
    align Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Text
    width)
                            [Alignment]
    alignments [Text]
    iwidths) Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> "."
      [Doc Text]
    colheadings <- ([Block] -> StateT WriterState m (Doc Text))
    -> [[Block]] -> StateT WriterState m [Doc Text]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    mapM (WriterOptions -> [Block] -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> [Block] -> StateT WriterState m (Doc Text)
    blockListToMan WriterOptions
    opts) [[Block]]
    headers
      let makeRow :: [Doc a] -> Doc a
    makeRow cols :: [Doc a]
    cols = a -> Doc a
    forall a. HasChars a => a -> Doc a
    literal "T{" Doc a -> Doc a -> Doc a
    forall a. Doc a -> Doc a -> Doc a
    $$
                         [Doc a] -> Doc a
    forall a. [Doc a] -> Doc a
    vcat (Doc a -> [Doc a] -> [Doc a]
    forall a. a -> [a] -> [a]
    intersperse (a -> Doc a
    forall a. HasChars a => a -> Doc a
    literal "T}@T{") [Doc a]
    cols) Doc a -> Doc a -> Doc a
    forall a. Doc a -> Doc a -> Doc a
    $$
                         a -> Doc a
    forall a. HasChars a => a -> Doc a
    literal "T}"
      let colheadings' :: Doc Text
    colheadings' = if ([Block] -> Bool) -> [[Block]] -> Bool
    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
    all [Block] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [[Block]]
    headers
                            then Doc Text
    forall a. Doc a
    empty
                            else [Doc Text] -> Doc Text
    forall a. HasChars a => [Doc a] -> Doc a
    makeRow [Doc Text]
    colheadings Doc Text -> Doc Text -> Doc Text
    forall a. Doc a -> Doc a -> Doc a
    $$ Char -> Doc Text
    forall a. HasChars a => Char -> Doc a
    char '_'
      [Doc Text]
    body <- ([[Block]] -> StateT WriterState m (Doc Text))
    -> [[[Block]]] -> StateT WriterState m [Doc Text]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    mapM (\row :: [[Block]]
    row -> do
                             [Doc Text]
    cols <- ([Block] -> StateT WriterState m (Doc Text))
    -> [[Block]] -> StateT WriterState m [Doc Text]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    mapM (WriterOptions -> [Block] -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> [Block] -> StateT WriterState m (Doc Text)
    blockListToMan WriterOptions
    opts) [[Block]]
    row
                             Doc Text -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Doc Text -> StateT WriterState m (Doc Text))
    -> Doc Text -> StateT WriterState m (Doc Text)
    forall a b. (a -> b) -> a -> b
    $ [Doc Text] -> Doc Text
    forall a. HasChars a => [Doc a] -> Doc a
    makeRow [Doc Text]
    cols) [[[Block]]]
    rows
      Doc Text -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Doc Text -> StateT WriterState m (Doc Text))
    -> Doc Text -> StateT WriterState m (Doc Text)
    forall a b. (a -> b) -> a -> b
    $ Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal ".PP" Doc Text -> Doc Text -> Doc Text
    forall a. Doc a -> Doc a -> Doc a
    $$ Doc Text
    caption' Doc Text -> Doc Text -> Doc Text
    forall a. Doc a -> Doc a -> Doc a
    $$
               Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal ".TS" Doc Text -> Doc Text -> Doc Text
    forall a. Doc a -> Doc a -> Doc a
    $$ Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal "tab(@);" Doc Text -> Doc Text -> Doc Text
    forall a. Doc a -> Doc a -> Doc a
    $$ Doc Text
    coldescriptions Doc Text -> Doc Text -> Doc Text
    forall a. Doc a -> Doc a -> Doc a
    $$
               Doc Text
    colheadings' Doc Text -> Doc Text -> Doc Text
    forall a. Doc a -> Doc a -> Doc a
    $$ [Doc Text] -> Doc Text
    forall a. [Doc a] -> Doc a
    vcat [Doc Text]
    body Doc Text -> Doc Text -> Doc Text
    forall a. Doc a -> Doc a -> Doc a
    $$ Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal ".TE"

    blockToMan opts :: WriterOptions
    opts (BulletList items :: [[Block]]
    items) = do
      [Doc Text]
    contents <- ([Block] -> StateT WriterState m (Doc Text))
    -> [[Block]] -> StateT WriterState m [Doc Text]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    mapM (WriterOptions -> [Block] -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> [Block] -> StateT WriterState m (Doc Text)
    bulletListItemToMan WriterOptions
    opts) [[Block]]
    items
      Doc Text -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return ([Doc Text] -> Doc Text
    forall a. [Doc a] -> Doc a
    vcat [Doc Text]
    contents)
    blockToMan opts :: WriterOptions
    opts (OrderedList attribs :: ListAttributes
    attribs items :: [[Block]]
    items) = do
      let markers :: [Text]
    markers = Int -> [Text] -> [Text]
    forall a. Int -> [a] -> [a]
    take ([[Block]] -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    length [[Block]]
    items) ([Text] -> [Text]) -> [Text] -> [Text]
    forall a b. (a -> b) -> a -> b
    $ ListAttributes -> [Text]
    orderedListMarkers ListAttributes
    attribs
      let indent :: Int
    indent = 1 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    +
                         [Int] -> Int
    forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a
    maximum ((Text -> Int) -> [Text] -> [Int]
    forall a b. (a -> b) -> [a] -> [b]
    map Text -> Int
    T.length [Text]
    markers)
      [Doc Text]
    contents <- ((Text, [Block]) -> StateT WriterState m (Doc Text))
    -> [(Text, [Block])] -> StateT WriterState m [Doc Text]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    mapM (\(num :: Text
    num, item :: [Block]
    item) -> WriterOptions
    -> Text -> Int -> [Block] -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions
    -> Text -> Int -> [Block] -> StateT WriterState m (Doc Text)
    orderedListItemToMan WriterOptions
    opts Text
    num Int
    indent [Block]
    item) ([(Text, [Block])] -> StateT WriterState m [Doc Text])
    -> [(Text, [Block])] -> StateT WriterState m [Doc Text]
    forall a b. (a -> b) -> a -> b
    $
                  [Text] -> [[Block]] -> [(Text, [Block])]
    forall a b. [a] -> [b] -> [(a, b)]
    zip [Text]
    markers [[Block]]
    items
      Doc Text -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return ([Doc Text] -> Doc Text
    forall a. [Doc a] -> Doc a
    vcat [Doc Text]
    contents)
    blockToMan opts :: WriterOptions
    opts (DefinitionList items :: [([Inline], [[Block]])]
    items) = do
      [Doc Text]
    contents <- (([Inline], [[Block]]) -> StateT WriterState m (Doc Text))
    -> [([Inline], [[Block]])] -> StateT WriterState m [Doc Text]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    mapM (WriterOptions
    -> ([Inline], [[Block]]) -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions
    -> ([Inline], [[Block]]) -> StateT WriterState m (Doc Text)
    definitionListItemToMan WriterOptions
    opts) [([Inline], [[Block]])]
    items
      Doc Text -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return ([Doc Text] -> Doc Text
    forall a. [Doc a] -> Doc a
    vcat [Doc Text]
    contents)

    -- | Convert bullet list item (list of blocks) to man.
    bulletListItemToMan :: PandocMonad m => WriterOptions -> [Block] -> StateT WriterState m (Doc Text)
    bulletListItemToMan :: WriterOptions -> [Block] -> StateT WriterState m (Doc Text)
    bulletListItemToMan _ [] = Doc Text -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Doc Text
    forall a. Doc a
    empty
    bulletListItemToMan opts :: WriterOptions
    opts (Para first :: [Inline]
    first:rest :: [Block]
    rest) =
      WriterOptions -> [Block] -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> [Block] -> StateT WriterState m (Doc Text)
    bulletListItemToMan WriterOptions
    opts ([Inline] -> Block
    Plain [Inline]
    firstBlock -> [Block] -> [Block]
    forall a. a -> [a] -> [a]
    :[Block]
    rest)
    bulletListItemToMan opts :: WriterOptions
    opts (Plain first :: [Inline]
    first:rest :: [Block]
    rest) = do
      Doc Text
    first' <- WriterOptions -> Block -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> Block -> StateT WriterState m (Doc Text)
    blockToMan WriterOptions
    opts ([Inline] -> Block
    Plain [Inline]
    first)
      Doc Text
    rest' <- WriterOptions -> [Block] -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> [Block] -> StateT WriterState m (Doc Text)
    blockListToMan WriterOptions
    opts [Block]
    rest
      let first'' :: Doc Text
    first'' = Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal ".IP \\[bu] 2" Doc Text -> Doc Text -> Doc Text
    forall a. Doc a -> Doc a -> Doc a
    $$ Doc Text
    first'
      let rest'' :: Doc Text
    rest''  = if [Block] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [Block]
    rest
                       then Doc Text
    forall a. Doc a
    empty
                       else Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal ".RS 2" Doc Text -> Doc Text -> Doc Text
    forall a. Doc a -> Doc a -> Doc a
    $$ Doc Text
    rest' Doc Text -> Doc Text -> Doc Text
    forall a. Doc a -> Doc a -> Doc a
    $$ Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal ".RE"
      Doc Text -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Doc Text
    first'' Doc Text -> Doc Text -> Doc Text
    forall a. Doc a -> Doc a -> Doc a
    $$ Doc Text
    rest'')
    bulletListItemToMan opts :: WriterOptions
    opts (first :: Block
    first:rest :: [Block]
    rest) = do
      Doc Text
    first' <- WriterOptions -> Block -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> Block -> StateT WriterState m (Doc Text)
    blockToMan WriterOptions
    opts Block
    first
      Doc Text
    rest' <- WriterOptions -> [Block] -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> [Block] -> StateT WriterState m (Doc Text)
    blockListToMan WriterOptions
    opts [Block]
    rest
      Doc Text -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Doc Text -> StateT WriterState m (Doc Text))
    -> Doc Text -> StateT WriterState m (Doc Text)
    forall a b. (a -> b) -> a -> b
    $ Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal "\\[bu] .RS 2" Doc Text -> Doc Text -> Doc Text
    forall a. Doc a -> Doc a -> Doc a
    $$ Doc Text
    first' Doc Text -> Doc Text -> Doc Text
    forall a. Doc a -> Doc a -> Doc a
    $$ Doc Text
    rest' Doc Text -> Doc Text -> Doc Text
    forall a. Doc a -> Doc a -> Doc a
    $$ Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal ".RE"

    -- | Convert ordered list item (a list of blocks) to man.
    orderedListItemToMan :: PandocMonad m
                         => WriterOptions -- ^ options
                         -> Text   -- ^ order marker for list item
                         -> Int      -- ^ number of spaces to indent
                         -> [Block]  -- ^ list item (list of blocks)
                         -> StateT WriterState m (Doc Text)
    orderedListItemToMan :: WriterOptions
    -> Text -> Int -> [Block] -> StateT WriterState m (Doc Text)
    orderedListItemToMan _ _ _ [] = Doc Text -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Doc Text
    forall a. Doc a
    empty
    orderedListItemToMan opts :: WriterOptions
    opts num :: Text
    num indent :: Int
    indent (Para first :: [Inline]
    first:rest :: [Block]
    rest) =
      WriterOptions
    -> Text -> Int -> [Block] -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions
    -> Text -> Int -> [Block] -> StateT WriterState m (Doc Text)
    orderedListItemToMan WriterOptions
    opts Text
    num Int
    indent ([Inline] -> Block
    Plain [Inline]
    firstBlock -> [Block] -> [Block]
    forall a. a -> [a] -> [a]
    :[Block]
    rest)
    orderedListItemToMan opts :: WriterOptions
    opts num :: Text
    num indent :: Int
    indent (first :: Block
    first:rest :: [Block]
    rest) = do
      Doc Text
    first' <- WriterOptions -> Block -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> Block -> StateT WriterState m (Doc Text)
    blockToMan WriterOptions
    opts Block
    first
      Doc Text
    rest' <- WriterOptions -> [Block] -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> [Block] -> StateT WriterState m (Doc Text)
    blockListToMan WriterOptions
    opts [Block]
    rest
      let num' :: String
    num' = String -> Text -> String
    forall r. PrintfType r => String -> r
    printf ("%" String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ Int -> String
    forall a. Show a => a -> String
    show (Int
    indent Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - 1) String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ "s") Text
    num
      let first'' :: Doc Text
    first'' = Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal (".IP \"" Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> String -> Text
    T.pack String
    num' Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> "\" " Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Int -> Text
    forall a. Show a => a -> Text
    tshow Int
    indent) Doc Text -> Doc Text -> Doc Text
    forall a. Doc a -> Doc a -> Doc a
    $$ Doc Text
    first'
      let rest'' :: Doc Text
    rest''  = if [Block] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [Block]
    rest
                       then Doc Text
    forall a. Doc a
    empty
                       else Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal ".RS 4" Doc Text -> Doc Text -> Doc Text
    forall a. Doc a -> Doc a -> Doc a
    $$ Doc Text
    rest' Doc Text -> Doc Text -> Doc Text
    forall a. Doc a -> Doc a -> Doc a
    $$ Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal ".RE"
      Doc Text -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Doc Text -> StateT WriterState m (Doc Text))
    -> Doc Text -> StateT WriterState m (Doc Text)
    forall a b. (a -> b) -> a -> b
    $ Doc Text
    first'' Doc Text -> Doc Text -> Doc Text
    forall a. Doc a -> Doc a -> Doc a
    $$ Doc Text
    rest''

    -- | Convert definition list item (label, list of blocks) to man.
    definitionListItemToMan :: PandocMonad m
                            => WriterOptions
                            -> ([Inline],[[Block]])
                            -> StateT WriterState m (Doc Text)
    definitionListItemToMan :: WriterOptions
    -> ([Inline], [[Block]]) -> StateT WriterState m (Doc Text)
    definitionListItemToMan opts :: WriterOptions
    opts (label :: [Inline]
    label, defs :: [[Block]]
    defs) = do
      -- in most man pages, option and other code in option lists is boldface,
      -- but not other things, so we try to reproduce this style:
      Doc Text
    labelText <- WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    inlineListToMan WriterOptions
    opts ([Inline] -> StateT WriterState m (Doc Text))
    -> [Inline] -> StateT WriterState m (Doc Text)
    forall a b. (a -> b) -> a -> b
    $ [Inline] -> [Inline]
    makeCodeBold [Inline]
    label
      Doc Text
    contents <- if [[Block]] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [[Block]]
    defs
                     then Doc Text -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Doc Text
    forall a. Doc a
    empty
                     else ([Doc Text] -> Doc Text)
    -> StateT WriterState m [Doc Text]
    -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM [Doc Text] -> Doc Text
    forall a. [Doc a] -> Doc a
    vcat (StateT WriterState m [Doc Text]
     -> StateT WriterState m (Doc Text))
    -> StateT WriterState m [Doc Text]
    -> StateT WriterState m (Doc Text)
    forall a b. (a -> b) -> a -> b
    $ [[Block]]
    -> ([Block] -> StateT WriterState m (Doc Text))
    -> StateT WriterState m [Doc Text]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    t a -> (a -> m b) -> m (t b)
    forM [[Block]]
    defs (([Block] -> StateT WriterState m (Doc Text))
     -> StateT WriterState m [Doc Text])
    -> ([Block] -> StateT WriterState m (Doc Text))
    -> StateT WriterState m [Doc Text]
    forall a b. (a -> b) -> a -> b
    $ \blocks :: [Block]
    blocks ->
                            case [Block]
    blocks of
                              (x :: Block
    x:xs :: [Block]
    xs) -> do
                                Doc Text
    first' <- WriterOptions -> Block -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> Block -> StateT WriterState m (Doc Text)
    blockToMan WriterOptions
    opts (Block -> StateT WriterState m (Doc Text))
    -> Block -> StateT WriterState m (Doc Text)
    forall a b. (a -> b) -> a -> b
    $
                                          case Block
    x of
                                               Para y :: [Inline]
    y -> [Inline] -> Block
    Plain [Inline]
    y
                                               _      -> Block
    x
                                Doc Text
    rest' <- ([Doc Text] -> Doc Text)
    -> StateT WriterState m [Doc Text]
    -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM [Doc Text] -> Doc Text
    forall a. [Doc a] -> Doc a
    vcat (StateT WriterState m [Doc Text]
     -> StateT WriterState m (Doc Text))
    -> StateT WriterState m [Doc Text]
    -> StateT WriterState m (Doc Text)
    forall a b. (a -> b) -> a -> b
    $ (Block -> StateT WriterState m (Doc Text))
    -> [Block] -> StateT WriterState m [Doc Text]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    mapM
                                            (\item :: Block
    item -> WriterOptions -> Block -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> Block -> StateT WriterState m (Doc Text)
    blockToMan WriterOptions
    opts Block
    item) [Block]
    xs
                                Doc Text -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Doc Text -> StateT WriterState m (Doc Text))
    -> Doc Text -> StateT WriterState m (Doc Text)
    forall a b. (a -> b) -> a -> b
    $ Doc Text
    first' Doc Text -> Doc Text -> Doc Text
    forall a. Doc a -> Doc a -> Doc a
    $$
                                         if [Block] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [Block]
    xs
                                            then Doc Text
    forall a. Doc a
    empty
                                            else Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal ".RS" Doc Text -> Doc Text -> Doc Text
    forall a. Doc a -> Doc a -> Doc a
    $$ Doc Text
    rest' Doc Text -> Doc Text -> Doc Text
    forall a. Doc a -> Doc a -> Doc a
    $$ Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal ".RE"
                              [] -> Doc Text -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Doc Text
    forall a. Doc a
    empty
      Doc Text -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Doc Text -> StateT WriterState m (Doc Text))
    -> Doc Text -> StateT WriterState m (Doc Text)
    forall a b. (a -> b) -> a -> b
    $ Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal ".TP" Doc Text -> Doc Text -> Doc Text
    forall a. Doc a -> Doc a -> Doc a
    $$ Doc Text -> Doc Text
    forall a. IsString a => Doc a -> Doc a
    nowrap Doc Text
    labelText Doc Text -> Doc Text -> Doc Text
    forall a. Doc a -> Doc a -> Doc a
    $$ Doc Text
    contents

    makeCodeBold :: [Inline] -> [Inline]
    makeCodeBold :: [Inline] -> [Inline]
    makeCodeBold = (Inline -> Inline) -> [Inline] -> [Inline]
    forall a b. Walkable a b => (a -> a) -> b -> b
    walk Inline -> Inline
    go
      where go :: Inline -> Inline
    go x :: Inline
    x@Code{} = [Inline] -> Inline
    Strong [Inline
    x]
            go x :: Inline
    x        = Inline
    x

    -- | Convert list of Pandoc block elements to man.
    blockListToMan :: PandocMonad m
                   => WriterOptions -- ^ Options
                   -> [Block]       -- ^ List of block elements
                   -> StateT WriterState m (Doc Text)
    blockListToMan :: WriterOptions -> [Block] -> StateT WriterState m (Doc Text)
    blockListToMan opts :: WriterOptions
    opts blocks :: [Block]
    blocks =
      [Doc Text] -> Doc Text
    forall a. [Doc a] -> Doc a
    vcat ([Doc Text] -> Doc Text)
    -> StateT WriterState m [Doc Text]
    -> StateT WriterState m (Doc Text)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Block -> StateT WriterState m (Doc Text))
    -> [Block] -> StateT WriterState m [Doc Text]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    mapM (WriterOptions -> Block -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> Block -> StateT WriterState m (Doc Text)
    blockToMan WriterOptions
    opts) [Block]
    blocks

    -- | Convert list of Pandoc inline elements to man.
    inlineListToMan :: PandocMonad m => WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    inlineListToMan :: WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    inlineListToMan opts :: WriterOptions
    opts lst :: [Inline]
    lst = [Doc Text] -> Doc Text
    forall a. [Doc a] -> Doc a
    hcat ([Doc Text] -> Doc Text)
    -> StateT WriterState m [Doc Text]
    -> StateT WriterState m (Doc Text)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Inline -> StateT WriterState m (Doc Text))
    -> [Inline] -> StateT WriterState m [Doc Text]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    mapM (WriterOptions -> Inline -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> Inline -> StateT WriterState m (Doc Text)
    inlineToMan WriterOptions
    opts) [Inline]
    lst

    -- | Convert Pandoc inline element to man.
    inlineToMan :: PandocMonad m => WriterOptions -> Inline -> StateT WriterState m (Doc Text)
    inlineToMan :: WriterOptions -> Inline -> StateT WriterState m (Doc Text)
    inlineToMan opts :: WriterOptions
    opts (Span _ ils :: [Inline]
    ils) = WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    inlineListToMan WriterOptions
    opts [Inline]
    ils
    inlineToMan opts :: WriterOptions
    opts (Emph lst :: [Inline]
    lst) =
      Char
    -> StateT WriterState m (Doc Text)
    -> StateT WriterState m (Doc Text)
    forall a (m :: * -> *).
    (HasChars a, IsString a, PandocMonad m) =>
    Char -> MS m (Doc a) -> MS m (Doc a)
    withFontFeature 'I' (WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    inlineListToMan WriterOptions
    opts [Inline]
    lst)
    inlineToMan opts :: WriterOptions
    opts (Strong lst :: [Inline]
    lst) =
      Char
    -> StateT WriterState m (Doc Text)
    -> StateT WriterState m (Doc Text)
    forall a (m :: * -> *).
    (HasChars a, IsString a, PandocMonad m) =>
    Char -> MS m (Doc a) -> MS m (Doc a)
    withFontFeature 'B' (WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    inlineListToMan WriterOptions
    opts [Inline]
    lst)
    inlineToMan opts :: WriterOptions
    opts (Strikeout lst :: [Inline]
    lst) = do
      Doc Text
    contents <- WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    inlineListToMan WriterOptions
    opts [Inline]
    lst
      Doc Text -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Doc Text -> StateT WriterState m (Doc Text))
    -> Doc Text -> StateT WriterState m (Doc Text)
    forall a b. (a -> b) -> a -> b
    $ Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal "[STRIKEOUT:" Doc Text -> Doc Text -> Doc Text
    forall a. Semigroup a => a -> a -> a
    <> Doc Text
    contents Doc Text -> Doc Text -> Doc Text
    forall a. Semigroup a => a -> a -> a
    <> Char -> Doc Text
    forall a. HasChars a => Char -> Doc a
    char ']'
    inlineToMan opts :: WriterOptions
    opts (Superscript lst :: [Inline]
    lst) = do
      Doc Text
    contents <- WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    inlineListToMan WriterOptions
    opts [Inline]
    lst
      Doc Text -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Doc Text -> StateT WriterState m (Doc Text))
    -> Doc Text -> StateT WriterState m (Doc Text)
    forall a b. (a -> b) -> a -> b
    $ Char -> Doc Text
    forall a. HasChars a => Char -> Doc a
    char '^' Doc Text -> Doc Text -> Doc Text
    forall a. Semigroup a => a -> a -> a
    <> Doc Text
    contents Doc Text -> Doc Text -> Doc Text
    forall a. Semigroup a => a -> a -> a
    <> Char -> Doc Text
    forall a. HasChars a => Char -> Doc a
    char '^'
    inlineToMan opts :: WriterOptions
    opts (Subscript lst :: [Inline]
    lst) = do
      Doc Text
    contents <- WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    inlineListToMan WriterOptions
    opts [Inline]
    lst
      Doc Text -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Doc Text -> StateT WriterState m (Doc Text))
    -> Doc Text -> StateT WriterState m (Doc Text)
    forall a b. (a -> b) -> a -> b
    $ Char -> Doc Text
    forall a. HasChars a => Char -> Doc a
    char '~' Doc Text -> Doc Text -> Doc Text
    forall a. Semigroup a => a -> a -> a
    <> Doc Text
    contents Doc Text -> Doc Text -> Doc Text
    forall a. Semigroup a => a -> a -> a
    <> Char -> Doc Text
    forall a. HasChars a => Char -> Doc a
    char '~'
    inlineToMan opts :: WriterOptions
    opts (SmallCaps lst :: [Inline]
    lst) = WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    inlineListToMan WriterOptions
    opts [Inline]
    lst -- not supported
    inlineToMan opts :: WriterOptions
    opts (Quoted SingleQuote lst :: [Inline]
    lst) = do
      Doc Text
    contents <- WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    inlineListToMan WriterOptions
    opts [Inline]
    lst
      Doc Text -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Doc Text -> StateT WriterState m (Doc Text))
    -> Doc Text -> StateT WriterState m (Doc Text)
    forall a b. (a -> b) -> a -> b
    $ Char -> Doc Text
    forall a. HasChars a => Char -> Doc a
    char '`' Doc Text -> Doc Text -> Doc Text
    forall a. Semigroup a => a -> a -> a
    <> Doc Text
    contents Doc Text -> Doc Text -> Doc Text
    forall a. Semigroup a => a -> a -> a
    <> Char -> Doc Text
    forall a. HasChars a => Char -> Doc a
    char '\''
    inlineToMan opts :: WriterOptions
    opts (Quoted DoubleQuote lst :: [Inline]
    lst) = do
      Doc Text
    contents <- WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    inlineListToMan WriterOptions
    opts [Inline]
    lst
      Doc Text -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Doc Text -> StateT WriterState m (Doc Text))
    -> Doc Text -> StateT WriterState m (Doc Text)
    forall a b. (a -> b) -> a -> b
    $ Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal "\\[lq]" Doc Text -> Doc Text -> Doc Text
    forall a. Semigroup a => a -> a -> a
    <> Doc Text
    contents Doc Text -> Doc Text -> Doc Text
    forall a. Semigroup a => a -> a -> a
    <> Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal "\\[rq]"
    inlineToMan opts :: WriterOptions
    opts (Cite _ lst :: [Inline]
    lst) =
      WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    inlineListToMan WriterOptions
    opts [Inline]
    lst
    inlineToMan opts :: WriterOptions
    opts (Code _ str :: Text
    str) =
      Char
    -> StateT WriterState m (Doc Text)
    -> StateT WriterState m (Doc Text)
    forall a (m :: * -> *).
    (HasChars a, IsString a, PandocMonad m) =>
    Char -> MS m (Doc a) -> MS m (Doc a)
    withFontFeature 'C' (Doc Text -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal (Text -> Doc Text) -> Text -> Doc Text
    forall a b. (a -> b) -> a -> b
    $ WriterOptions -> Text -> Text
    escString WriterOptions
    opts Text
    str))
    inlineToMan opts :: WriterOptions
    opts (Str str :: Text
    str@(Text -> Maybe (Char, Text)
    T.uncons -> Just ('.',_))) =
      Doc Text -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Doc Text -> StateT WriterState m (Doc Text))
    -> Doc Text -> StateT WriterState m (Doc Text)
    forall a b. (a -> b) -> a -> b
    $ Text -> Doc Text
    forall a. Text -> Doc a
    afterBreak "\\&" Doc Text -> Doc Text -> Doc Text
    forall a. Semigroup a => a -> a -> a
    <> Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal (WriterOptions -> Text -> Text
    escString WriterOptions
    opts Text
    str)
    inlineToMan opts :: WriterOptions
    opts (Str str :: Text
    str) = Doc Text -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Doc Text -> StateT WriterState m (Doc Text))
    -> Doc Text -> StateT WriterState m (Doc Text)
    forall a b. (a -> b) -> a -> b
    $ Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal (Text -> Doc Text) -> Text -> Doc Text
    forall a b. (a -> b) -> a -> b
    $ WriterOptions -> Text -> Text
    escString WriterOptions
    opts Text
    str
    inlineToMan opts :: WriterOptions
    opts (Math InlineMath str :: Text
    str) =
      m [Inline] -> StateT WriterState m [Inline]
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (MathType -> Text -> m [Inline]
    forall (m :: * -> *).
    PandocMonad m =>
    MathType -> Text -> m [Inline]
    texMathToInlines MathType
    InlineMath Text
    str) StateT WriterState m [Inline]
    -> ([Inline] -> StateT WriterState m (Doc Text))
    -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    inlineListToMan WriterOptions
    opts
    inlineToMan opts :: WriterOptions
    opts (Math DisplayMath str :: Text
    str) = do
      Doc Text
    contents <- m [Inline] -> StateT WriterState m [Inline]
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (MathType -> Text -> m [Inline]
    forall (m :: * -> *).
    PandocMonad m =>
    MathType -> Text -> m [Inline]
    texMathToInlines MathType
    DisplayMath Text
    str) StateT WriterState m [Inline]
    -> ([Inline] -> StateT WriterState m (Doc Text))
    -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    inlineListToMan WriterOptions
    opts
      Doc Text -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Doc Text -> StateT WriterState m (Doc Text))
    -> Doc Text -> StateT WriterState m (Doc Text)
    forall a b. (a -> b) -> a -> b
    $ Doc Text
    forall a. Doc a
    cr Doc Text -> Doc Text -> Doc Text
    forall a. Semigroup a => a -> a -> a
    <> Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal ".RS" Doc Text -> Doc Text -> Doc Text
    forall a. Doc a -> Doc a -> Doc a
    $$ Doc Text
    contents Doc Text -> Doc Text -> Doc Text
    forall a. Doc a -> Doc a -> Doc a
    $$ Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal ".RE"
    inlineToMan _ il :: Inline
    il@(RawInline f :: Format
    f str :: Text
    str)
      | Format
    f Format -> Format -> Bool
    forall a. Eq a => a -> a -> Bool
    == Text -> Format
    Format "man" = Doc Text -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Doc Text -> StateT WriterState m (Doc Text))
    -> Doc Text -> StateT WriterState m (Doc Text)
    forall a b. (a -> b) -> a -> b
    $ Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal Text
    str
      | Bool
    otherwise         = do
          LogMessage -> StateT WriterState m ()
    forall (m :: * -> *). PandocMonad m => LogMessage -> m ()
    report (LogMessage -> StateT WriterState m ())
    -> LogMessage -> StateT WriterState m ()
    forall a b. (a -> b) -> a -> b
    $ Inline -> LogMessage
    InlineNotRendered Inline
    il
          Doc Text -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Doc Text
    forall a. Doc a
    empty
    inlineToMan _ LineBreak = Doc Text -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Doc Text -> StateT WriterState m (Doc Text))
    -> Doc Text -> StateT WriterState m (Doc Text)
    forall a b. (a -> b) -> a -> b
    $
      Doc Text
    forall a. Doc a
    cr Doc Text -> Doc Text -> Doc Text
    forall a. Semigroup a => a -> a -> a
    <> Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal ".PD 0" Doc Text -> Doc Text -> Doc Text
    forall a. Doc a -> Doc a -> Doc a
    $$ Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal ".P" Doc Text -> Doc Text -> Doc Text
    forall a. Doc a -> Doc a -> Doc a
    $$ Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal ".PD" Doc Text -> Doc Text -> Doc Text
    forall a. Semigroup a => a -> a -> a
    <> Doc Text
    forall a. Doc a
    cr
    inlineToMan _ SoftBreak = Doc Text -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Doc Text
    forall a. Doc a
    space
    inlineToMan _ Space = Doc Text -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Doc Text
    forall a. Doc a
    space
    inlineToMan opts :: WriterOptions
    opts (Link _ txt :: [Inline]
    txt (src :: Text
    src, _))
      | Bool -> Bool
    not (Text -> Bool
    isURI Text
    src) = WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    inlineListToMan WriterOptions
    opts [Inline]
    txt -- skip relative links
      | Bool
    otherwise       = do
      Doc Text
    linktext <- WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> [Inline] -> StateT WriterState m (Doc Text)
    inlineListToMan WriterOptions
    opts [Inline]
    txt
      let srcSuffix :: Text
    srcSuffix = Text -> Maybe Text -> Text
    forall a. a -> Maybe a -> a
    fromMaybe Text
    src (Text -> Text -> Maybe Text
    T.stripPrefix "mailto:" Text
    src)
      Doc Text -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Doc Text -> StateT WriterState m (Doc Text))
    -> Doc Text -> StateT WriterState m (Doc Text)
    forall a b. (a -> b) -> a -> b
    $ case [Inline]
    txt of
               [Str s :: Text
    s]
                 | Text -> Text
    escapeURI Text
    s Text -> Text -> Bool
    forall a. Eq a => a -> a -> Bool
    == Text
    srcSuffix ->
                                     Char -> Doc Text
    forall a. HasChars a => Char -> Doc a
    char '<' Doc Text -> Doc Text -> Doc Text
    forall a. Semigroup a => a -> a -> a
    <> Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal Text
    srcSuffix Doc Text -> Doc Text -> Doc Text
    forall a. Semigroup a => a -> a -> a
    <> Char -> Doc Text
    forall a. HasChars a => Char -> Doc a
    char '>'
               _                  -> Doc Text
    linktext Doc Text -> Doc Text -> Doc Text
    forall a. Semigroup a => a -> a -> a
    <> Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal " (" Doc Text -> Doc Text -> Doc Text
    forall a. Semigroup a => a -> a -> a
    <> Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal Text
    src Doc Text -> Doc Text -> Doc Text
    forall a. Semigroup a => a -> a -> a
    <> Char -> Doc Text
    forall a. HasChars a => Char -> Doc a
    char ')'
    inlineToMan opts :: WriterOptions
    opts (Image attr :: Attr
    attr alternate :: [Inline]
    alternate (source :: Text
    source, tit :: Text
    tit)) = do
      let txt :: [Inline]
    txt = if [Inline] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [Inline]
    alternate Bool -> Bool -> Bool
    || ([Inline]
    alternate [Inline] -> [Inline] -> Bool
    forall a. Eq a => a -> a -> Bool
    == [Text -> Inline
    Str ""]) Bool -> Bool -> Bool
    ||
                   ([Inline]
    alternate [Inline] -> [Inline] -> Bool
    forall a. Eq a => a -> a -> Bool
    == [Text -> Inline
    Str Text
    source]) -- to prevent autolinks
                   then [Text -> Inline
    Str "image"]
                   else [Inline]
    alternate
      Doc Text
    linkPart <- WriterOptions -> Inline -> StateT WriterState m (Doc Text)
    forall (m :: * -> *).
    PandocMonad m =>
    WriterOptions -> Inline -> StateT WriterState m (Doc Text)
    inlineToMan WriterOptions
    opts (Attr -> [Inline] -> (Text, Text) -> Inline
    Link Attr
    attr [Inline]
    txt (Text
    source, Text
    tit))
      Doc Text -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Doc Text -> StateT WriterState m (Doc Text))
    -> Doc Text -> StateT WriterState m (Doc Text)
    forall a b. (a -> b) -> a -> b
    $ Char -> Doc Text
    forall a. HasChars a => Char -> Doc a
    char '[' Doc Text -> Doc Text -> Doc Text
    forall a. Semigroup a => a -> a -> a
    <> Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal "IMAGE: " Doc Text -> Doc Text -> Doc Text
    forall a. Semigroup a => a -> a -> a
    <> Doc Text
    linkPart Doc Text -> Doc Text -> Doc Text
    forall a. Semigroup a => a -> a -> a
    <> Char -> Doc Text
    forall a. HasChars a => Char -> Doc a
    char ']'
    inlineToMan _ (Note contents :: [Block]
    contents) = do
      -- add to notes in state
      (WriterState -> WriterState) -> StateT WriterState m ()
    forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
    modify ((WriterState -> WriterState) -> StateT WriterState m ())
    -> (WriterState -> WriterState) -> StateT WriterState m ()
    forall a b. (a -> b) -> a -> b
    $ \st :: WriterState
    st -> WriterState
    st{ stNotes :: [[Block]]
    stNotes = [Block]
    contents [Block] -> [[Block]] -> [[Block]]
    forall a. a -> [a] -> [a]
    : WriterState -> [[Block]]
    stNotes WriterState
    st }
      [[Block]]
    notes <- (WriterState -> [[Block]]) -> StateT WriterState m [[Block]]
    forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
    gets WriterState -> [[Block]]
    stNotes
      let ref :: Text
    ref = Int -> Text
    forall a. Show a => a -> Text
    tshow ([[Block]] -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    length [[Block]]
    notes)
      Doc Text -> StateT WriterState m (Doc Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Doc Text -> StateT WriterState m (Doc Text))
    -> Doc Text -> StateT WriterState m (Doc Text)
    forall a b. (a -> b) -> a -> b
    $ Char -> Doc Text
    forall a. HasChars a => Char -> Doc a
    char '[' Doc Text -> Doc Text -> Doc Text
    forall a. Semigroup a => a -> a -> a
    <> Text -> Doc Text
    forall a. HasChars a => a -> Doc a
    literal Text
    ref Doc Text -> Doc Text -> Doc Text
    forall a. Semigroup a => a -> a -> a
    <> Char -> Doc Text
    forall a. HasChars a => Char -> Doc a
    char ']'