    {-# LANGUAGE OverloadedStrings #-}
    {-# LANGUAGE ViewPatterns      #-}
    {- |
       Module      : Text.Pandoc.Readers.Textile
       Copyright   : Copyright (C) 2010-2012 Paul Rivier
                                   2010-2020 John MacFarlane
       License     : GNU GPL, version 2 or above

       Maintainer  : Paul Rivier <paul*rivier#demotera*com>
       Stability   : alpha
       Portability : portable

    Conversion from Textile to 'Pandoc' document, based on the spec
    available at http://redcloth.org/textile.

    Implemented and parsed:
     - Paragraphs
     - Code blocks
     - Lists
     - blockquote
     - Inlines : strong, emph, cite, code, deleted, superscript,
       subscript, links
     - footnotes
     - HTML-specific and CSS-specific attributes on headers

    Left to be implemented:
     - dimension sign
     - all caps
     - continued blocks (ex bq..)

    TODO : refactor common patterns across readers :
     - more ...

    -}

    module Text.Pandoc.Readers.Textile ( readTextile) where
    import Control.Monad (guard, liftM)
    import Control.Monad.Except (throwError)
    import Data.Char (digitToInt, isUpper)
    import Data.List (intersperse, transpose)
    import Data.Text (Text)
    import qualified Data.Text as T
    import Text.HTML.TagSoup (Tag (..), fromAttrib)
    import Text.HTML.TagSoup.Match
    import Text.Pandoc.Builder (Blocks, Inlines, trimInlines)
    import qualified Text.Pandoc.Builder as B
    import Text.Pandoc.Class.PandocMonad (PandocMonad (..))
    import Text.Pandoc.CSS
    import Text.Pandoc.Definition
    import Text.Pandoc.Options
    import Text.Pandoc.Parsing
    import Text.Pandoc.Readers.HTML (htmlTag, isBlockTag, isInlineTag)
    import Text.Pandoc.Readers.LaTeX (rawLaTeXBlock, rawLaTeXInline)
    import Text.Pandoc.Shared (crFilter, trim, underlineSpan, tshow)

    -- | Parse a Textile text and return a Pandoc document.
    readTextile :: PandocMonad m
                => ReaderOptions -- ^ Reader options
                -> Text          -- ^ String to parse (assuming @'\n'@ line endings)
                -> m Pandoc
    readTextile :: ReaderOptions -> Text -> m Pandoc
    readTextile opts :: ReaderOptions
    opts s :: Text
    s = do
      Either PandocError Pandoc
    parsed <- ParserT Text ParserState m Pandoc
    -> ParserState -> Text -> m (Either PandocError Pandoc)
    forall s (m :: * -> *) st a.
    (Stream s m Char, ToText s) =>
    ParserT s st m a -> st -> s -> m (Either PandocError a)
    readWithM ParserT Text ParserState m Pandoc
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Pandoc
    parseTextile ParserState
    forall a. Default a => a
    def{ stateOptions :: ReaderOptions
    stateOptions = ReaderOptions
    opts }
                    (Text -> Text
    crFilter Text
    s Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> "\n\n")
      case Either PandocError Pandoc
    parsed of
         Right result :: Pandoc
    result -> Pandoc -> m Pandoc
    forall (m :: * -> *) a. Monad m => a -> m a
    return Pandoc
    result
         Left e :: PandocError
    e       -> PandocError -> m Pandoc
    forall e (m :: * -> *) a. MonadError e m => e -> m a
    throwError PandocError
    e

    -- | Generate a Pandoc ADT from a textile document
    parseTextile :: PandocMonad m => ParserT Text ParserState m Pandoc
    parseTextile :: ParserT Text ParserState m Pandoc
    parseTextile = do
      ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m [Char]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many ParsecT Text ParserState m Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    blankline
      SourcePos
    startPos <- ParsecT Text ParserState m SourcePos
    forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
    getPosition
      -- go through once just to get list of reference keys and notes
      -- docMinusKeys is the raw document with blanks where the keys/notes were...
      let firstPassParser :: ParsecT Text ParserState m Text
    firstPassParser = ParsecT Text ParserState m Text
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Text
    noteBlock ParsecT Text ParserState m Text
    -> ParsecT Text ParserState m Text
    -> ParsecT Text ParserState m Text
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Text ParserState m Text
    forall (m :: * -> *) st. Monad m => ParserT Text st m Text
    lineClump
      ParsecT Text ParserState m Text
    -> ParsecT Text ParserState m ()
    -> ParsecT Text ParserState m [Text]
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    manyTill ParsecT Text ParserState m Text
    firstPassParser ParsecT Text ParserState m ()
    forall s (m :: * -> *) t u.
    (Stream s m t, Show t) =>
    ParsecT s u m ()
    eof ParsecT Text ParserState m [Text]
    -> ([Text] -> ParsecT Text ParserState m ())
    -> ParsecT Text ParserState m ()
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= Text -> ParsecT Text ParserState m ()
    forall (m :: * -> *) s u. Monad m => s -> ParsecT s u m ()
    setInput (Text -> ParsecT Text ParserState m ())
    -> ([Text] -> Text) -> [Text] -> ParsecT Text ParserState m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [Text] -> Text
    T.concat
      SourcePos -> ParsecT Text ParserState m ()
    forall (m :: * -> *) s u. Monad m => SourcePos -> ParsecT s u m ()
    setPosition SourcePos
    startPos
      ParserState
    st' <- ParsecT Text ParserState m ParserState
    forall (m :: * -> *) s u. Monad m => ParsecT s u m u
    getState
      let reversedNotes :: NoteTable
    reversedNotes = ParserState -> NoteTable
    stateNotes ParserState
    st'
      (ParserState -> ParserState) -> ParsecT Text ParserState m ()
    forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
    updateState ((ParserState -> ParserState) -> ParsecT Text ParserState m ())
    -> (ParserState -> ParserState) -> ParsecT Text ParserState m ()
    forall a b. (a -> b) -> a -> b
    $ \s :: ParserState
    s -> ParserState
    s { stateNotes :: NoteTable
    stateNotes = NoteTable -> NoteTable
    forall a. [a] -> [a]
    reverse NoteTable
    reversedNotes }
      -- now parse it for real...
      Meta -> [Block] -> Pandoc
    Pandoc Meta
    nullMeta ([Block] -> Pandoc)
    -> (Many Block -> [Block]) -> Many Block -> Pandoc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Many Block -> [Block]
    forall a. Many a -> [a]
    B.toList (Many Block -> Pandoc)
    -> ParsecT Text ParserState m (Many Block)
    -> ParserT Text ParserState m Pandoc
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Text ParserState m (Many Block)
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m (Many Block)
    parseBlocks -- FIXME

    noteMarker :: PandocMonad m => ParserT Text ParserState m Text
    noteMarker :: ParserT Text ParserState m Text
    noteMarker = ParsecT Text ParserState m Char -> ParsecT Text ParserState m ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m ()
    skipMany ParsecT Text ParserState m Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    spaceChar ParsecT Text ParserState m ()
    -> ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m [Char]
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> [Char] -> ParsecT Text ParserState m [Char]
    forall s (m :: * -> *) u.
    Stream s m Char =>
    [Char] -> ParsecT s u m [Char]
    string "fn" ParsecT Text ParserState m [Char]
    -> ParserT Text ParserState m Text
    -> ParserT Text ParserState m Text
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> [Char] -> Text
    T.pack ([Char] -> Text)
    -> ParsecT Text ParserState m [Char]
    -> ParserT Text ParserState m Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m [Char]
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    manyTill ParsecT Text ParserState m Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    digit (Char -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '.')

    noteBlock :: PandocMonad m => ParserT Text ParserState m Text
    noteBlock :: ParserT Text ParserState m Text
    noteBlock = ParserT Text ParserState m Text -> ParserT Text ParserState m Text
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text ParserState m Text
     -> ParserT Text ParserState m Text)
    -> ParserT Text ParserState m Text
    -> ParserT Text ParserState m Text
    forall a b. (a -> b) -> a -> b
    $ do
      SourcePos
    startPos <- ParsecT Text ParserState m SourcePos
    forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
    getPosition
      Text
    ref <- ParserT Text ParserState m Text
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Text
    noteMarker
      ParsecT Text ParserState m Char -> ParsecT Text ParserState m ()
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m ()
    optional ParsecT Text ParserState m Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    blankline
      Text
    contents <- [Text] -> Text
    T.unlines ([Text] -> Text)
    -> ParsecT Text ParserState m [Text]
    -> ParserT Text ParserState m Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParserT Text ParserState m Text
    -> ParserT Text ParserState m Text
    -> ParsecT Text ParserState m [Text]
    forall end s (m :: * -> *) t st a.
    (Show end, Stream s m t) =>
    ParserT s st m a -> ParserT s st m end -> ParserT s st m [a]
    many1Till ParserT Text ParserState m Text
    forall (m :: * -> *) st. Monad m => ParserT Text st m Text
    anyLine (ParserT Text ParserState m Text
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Text
    blanklines ParserT Text ParserState m Text
    -> ParserT Text ParserState m Text
    -> ParserT Text ParserState m Text
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParserT Text ParserState m Text
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Text
    noteBlock)
      SourcePos
    endPos <- ParsecT Text ParserState m SourcePos
    forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
    getPosition
      let newnote :: (Text, Text)
    newnote = (Text
    ref, Text
    contents Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> "\n")
      ParserState
    st <- ParsecT Text ParserState m ParserState
    forall (m :: * -> *) s u. Monad m => ParsecT s u m u
    getState
      let oldnotes :: NoteTable
    oldnotes = ParserState -> NoteTable
    stateNotes ParserState
    st
      (ParserState -> ParserState) -> ParsecT Text ParserState m ()
    forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
    updateState ((ParserState -> ParserState) -> ParsecT Text ParserState m ())
    -> (ParserState -> ParserState) -> ParsecT Text ParserState m ()
    forall a b. (a -> b) -> a -> b
    $ \s :: ParserState
    s -> ParserState
    s { stateNotes :: NoteTable
    stateNotes = (Text, Text)
    newnote (Text, Text) -> NoteTable -> NoteTable
    forall a. a -> [a] -> [a]
    : NoteTable
    oldnotes }
      -- return blanks so line count isn't affected
      Text -> ParserT Text ParserState m Text
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Text -> ParserT Text ParserState m Text)
    -> Text -> ParserT Text ParserState m Text
    forall a b. (a -> b) -> a -> b
    $ Int -> Text -> Text
    T.replicate (SourcePos -> Int
    sourceLine SourcePos
    endPos Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - SourcePos -> Int
    sourceLine SourcePos
    startPos) "\n"

    -- | Parse document blocks
    parseBlocks :: PandocMonad m => ParserT Text ParserState m Blocks
    parseBlocks :: ParserT Text ParserState m (Many Block)
    parseBlocks = [Many Block] -> Many Block
    forall a. Monoid a => [a] -> a
    mconcat ([Many Block] -> Many Block)
    -> ParsecT Text ParserState m [Many Block]
    -> ParserT Text ParserState m (Many Block)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParserT Text ParserState m (Many Block)
    -> ParsecT Text ParserState m ()
    -> ParsecT Text ParserState m [Many Block]
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    manyTill ParserT Text ParserState m (Many Block)
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m (Many Block)
    block ParsecT Text ParserState m ()
    forall s (m :: * -> *) t u.
    (Stream s m t, Show t) =>
    ParsecT s u m ()
    eof

    -- | Block parsers list tried in definition order
    blockParsers :: PandocMonad m => [ParserT Text ParserState m Blocks]
    blockParsers :: [ParserT Text ParserState m (Many Block)]
    blockParsers = [ ParserT Text ParserState m (Many Block)
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m (Many Block)
    codeBlock
                   , ParserT Text ParserState m (Many Block)
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m (Many Block)
    header
                   , ParserT Text ParserState m (Many Block)
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m (Many Block)
    blockQuote
                   , ParserT Text ParserState m (Many Block)
    forall (m :: * -> *) st.
    PandocMonad m =>
    ParserT Text st m (Many Block)
    hrule
                   , ParserT Text ParserState m (Many Block)
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m (Many Block)
    commentBlock
                   , ParserT Text ParserState m (Many Block)
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m (Many Block)
    anyList
                   , ParserT Text ParserState m (Many Block)
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m (Many Block)
    rawHtmlBlock
                   , ParserT Text ParserState m (Many Block)
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m (Many Block)
    rawLaTeXBlock'
                   , ParserT Text ParserState m (Many Block)
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m (Many Block)
    table
                   , Text
    -> ParserT Text ParserState m (Many Block)
    -> ParserT Text ParserState m (Many Block)
    forall (m :: * -> *).
    PandocMonad m =>
    Text
    -> ParserT Text ParserState m (Many Block)
    -> ParserT Text ParserState m (Many Block)
    maybeExplicitBlock "p" ParserT Text ParserState m (Many Block)
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m (Many Block)
    para
                   , Many Block
    forall a. Monoid a => a
    mempty Many Block
    -> ParsecT Text ParserState m Text
    -> ParserT Text ParserState m (Many Block)
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ ParsecT Text ParserState m Text
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Text
    blanklines
                   ]

    -- | Any block in the order of definition of blockParsers
    block :: PandocMonad m => ParserT Text ParserState m Blocks
    block :: ParserT Text ParserState m (Many Block)
    block = do
      Many Block
    res <- [ParserT Text ParserState m (Many Block)]
    -> ParserT Text ParserState m (Many Block)
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    [ParsecT s u m a] -> ParsecT s u m a
    choice [ParserT Text ParserState m (Many Block)]
    forall (m :: * -> *).
    PandocMonad m =>
    [ParserT Text ParserState m (Many Block)]
    blockParsers ParserT Text ParserState m (Many Block)
    -> [Char] -> ParserT Text ParserState m (Many Block)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> [Char] -> ParsecT s u m a
    <?> "block"
      Text -> ParsecT Text ParserState m ()
    forall (m :: * -> *). PandocMonad m => Text -> m ()
    trace (Int -> Text -> Text
    T.take 60 (Text -> Text) -> Text -> Text
    forall a b. (a -> b) -> a -> b
    $ [Block] -> Text
    forall a. Show a => a -> Text
    tshow ([Block] -> Text) -> [Block] -> Text
    forall a b. (a -> b) -> a -> b
    $ Many Block -> [Block]
    forall a. Many a -> [a]
    B.toList Many Block
    res)
      Many Block -> ParserT Text ParserState m (Many Block)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Many Block
    res

    commentBlock :: PandocMonad m => ParserT Text ParserState m Blocks
    commentBlock :: ParserT Text ParserState m (Many Block)
    commentBlock = ParserT Text ParserState m (Many Block)
    -> ParserT Text ParserState m (Many Block)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text ParserState m (Many Block)
     -> ParserT Text ParserState m (Many Block))
    -> ParserT Text ParserState m (Many Block)
    -> ParserT Text ParserState m (Many Block)
    forall a b. (a -> b) -> a -> b
    $ do
      [Char] -> ParsecT Text ParserState m [Char]
    forall s (m :: * -> *) u.
    Stream s m Char =>
    [Char] -> ParsecT s u m [Char]
    string "###."
      ParsecT Text ParserState m Text
    -> ParsecT Text ParserState m Text
    -> ParsecT Text ParserState m [Text]
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    manyTill ParsecT Text ParserState m Text
    forall (m :: * -> *) st. Monad m => ParserT Text st m Text
    anyLine ParsecT Text ParserState m Text
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Text
    blanklines
      Many Block -> ParserT Text ParserState m (Many Block)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Many Block
    forall a. Monoid a => a
    mempty

    codeBlock :: PandocMonad m => ParserT Text ParserState m Blocks
    codeBlock :: ParserT Text ParserState m (Many Block)
    codeBlock = ParserT Text ParserState m (Many Block)
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m (Many Block)
    codeBlockBc ParserT Text ParserState m (Many Block)
    -> ParserT Text ParserState m (Many Block)
    -> ParserT Text ParserState m (Many Block)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParserT Text ParserState m (Many Block)
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m (Many Block)
    codeBlockPre

    codeBlockBc :: PandocMonad m => ParserT Text ParserState m Blocks
    codeBlockBc :: ParserT Text ParserState m (Many Block)
    codeBlockBc = ParserT Text ParserState m (Many Block)
    -> ParserT Text ParserState m (Many Block)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text ParserState m (Many Block)
     -> ParserT Text ParserState m (Many Block))
    -> ParserT Text ParserState m (Many Block)
    -> ParserT Text ParserState m (Many Block)
    forall a b. (a -> b) -> a -> b
    $ do
      [Char] -> ParsecT Text ParserState m [Char]
    forall s (m :: * -> *) u.
    Stream s m Char =>
    [Char] -> ParsecT s u m [Char]
    string "bc."
      Bool
    extended <- Bool
    -> ParsecT Text ParserState m Bool
    -> ParsecT Text ParserState m Bool
    forall s (m :: * -> *) t a u.
    Stream s m t =>
    a -> ParsecT s u m a -> ParsecT s u m a
    option Bool
    False (Bool
    True Bool
    -> ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m Bool
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ Char -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '.')
      Char -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char ' '
      let starts :: [Text]
    starts = ["p", "table", "bq", "bc", "h1", "h2", "h3",
                    "h4", "h5", "h6", "pre", "###", "notextile"]
      let ender :: ParsecT Text ParserState m ()
    ender = [ParsecT Text ParserState m ()] -> ParsecT Text ParserState m ()
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    [ParsecT s u m a] -> ParsecT s u m a
    choice ([ParsecT Text ParserState m ()] -> ParsecT Text ParserState m ())
    -> [ParsecT Text ParserState m ()] -> ParsecT Text ParserState m ()
    forall a b. (a -> b) -> a -> b
    $ (Text -> ParsecT Text ParserState m ())
    -> [Text] -> [ParsecT Text ParserState m ()]
    forall a b. (a -> b) -> [a] -> [b]
    map Text -> ParsecT Text ParserState m ()
    forall (m :: * -> *).
    PandocMonad m =>
    Text -> ParserT Text ParserState m ()
    explicitBlockStart [Text]
    starts
      [Text]
    contents <- if Bool
    extended
                     then do
                       Text
    f <- ParserT Text ParserState m Text
    forall (m :: * -> *) st. Monad m => ParserT Text st m Text
    anyLine
                       [Text]
    rest <- ParserT Text ParserState m Text
    -> ParsecT Text ParserState m [Text]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many (ParsecT Text ParserState m () -> ParsecT Text ParserState m ()
    forall s (m :: * -> *) t a u.
    (Stream s m t, Show a) =>
    ParsecT s u m a -> ParsecT s u m ()
    notFollowedBy ParsecT Text ParserState m ()
    ender ParsecT Text ParserState m ()
    -> ParserT Text ParserState m Text
    -> ParserT Text ParserState m Text
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> ParserT Text ParserState m Text
    forall (m :: * -> *) st. Monad m => ParserT Text st m Text
    anyLine)
                       [Text] -> ParsecT Text ParserState m [Text]
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Text
    fText -> [Text] -> [Text]
    forall a. a -> [a] -> [a]
    :[Text]
    rest)
                     else ParserT Text ParserState m Text
    -> ParserT Text ParserState m Text
    -> ParsecT Text ParserState m [Text]
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    manyTill ParserT Text ParserState m Text
    forall (m :: * -> *) st. Monad m => ParserT Text st m Text
    anyLine ParserT Text ParserState m Text
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Text
    blanklines
      Many Block -> ParserT Text ParserState m (Many Block)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Many Block -> ParserT Text ParserState m (Many Block))
    -> Many Block -> ParserT Text ParserState m (Many Block)
    forall a b. (a -> b) -> a -> b
    $ Text -> Many Block
    B.codeBlock (Text -> Text
    trimTrailingNewlines ([Text] -> Text
    T.unlines [Text]
    contents))

    trimTrailingNewlines :: Text -> Text
    trimTrailingNewlines :: Text -> Text
    trimTrailingNewlines = (Char -> Bool) -> Text -> Text
    T.dropWhileEnd (Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    =='\n')

    -- | Code Blocks in Textile are between <pre> and </pre>
    codeBlockPre :: PandocMonad m => ParserT Text ParserState m Blocks
    codeBlockPre :: ParserT Text ParserState m (Many Block)
    codeBlockPre = ParserT Text ParserState m (Many Block)
    -> ParserT Text ParserState m (Many Block)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text ParserState m (Many Block)
     -> ParserT Text ParserState m (Many Block))
    -> ParserT Text ParserState m (Many Block)
    -> ParserT Text ParserState m (Many Block)
    forall a b. (a -> b) -> a -> b
    $ do
      (t :: Tag Text
    t@(TagOpen _ attrs :: NoteTable
    attrs),_) <- (Tag Text -> Bool) -> ParserT Text ParserState m (Tag Text, Text)
    forall st (m :: * -> *).
    (HasReaderOptions st, Monad m) =>
    (Tag Text -> Bool) -> ParserT Text st m (Tag Text, Text)
    htmlTag ((Text -> Bool) -> (NoteTable -> Bool) -> Tag Text -> Bool
    forall str.
    (str -> Bool) -> ([Attribute str] -> Bool) -> Tag str -> Bool
    tagOpen (Text -> Text -> Bool
    forall a. Eq a => a -> a -> Bool
    =="pre") (Bool -> NoteTable -> Bool
    forall a b. a -> b -> a
    const Bool
    True))
      Text
    result' <- [Char] -> Text
    T.pack ([Char] -> Text)
    -> ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Text ParserState m Char
    -> ParserT Text ParserState m (Tag Text, Text)
    -> ParsecT Text ParserState m [Char]
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    manyTill ParsecT Text ParserState m Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    anyChar ((Tag Text -> Bool) -> ParserT Text ParserState m (Tag Text, Text)
    forall st (m :: * -> *).
    (HasReaderOptions st, Monad m) =>
    (Tag Text -> Bool) -> ParserT Text st m (Tag Text, Text)
    htmlTag ((Text -> Bool) -> Tag Text -> Bool
    forall str. (str -> Bool) -> Tag str -> Bool
    tagClose (Text -> Text -> Bool
    forall a. Eq a => a -> a -> Bool
    =="pre")))
      -- drop leading newline if any
      let result'' :: Text
    result'' = case Text -> Maybe (Char, Text)
    T.uncons Text
    result' of
                       Just ('\n', xs :: Text
    xs) -> Text
    xs
                       _               -> Text
    result'
      -- drop trailing newline if any
      let result''' :: Text
    result''' = case Text -> Maybe (Text, Char)
    T.unsnoc Text
    result'' of
                        Just (xs :: Text
    xs, '\n') -> Text
    xs
                        _               -> Text
    result''
      let classes :: [Text]
    classes = Text -> [Text]
    T.words (Text -> [Text]) -> Text -> [Text]
    forall a b. (a -> b) -> a -> b
    $ Text -> Tag Text -> Text
    forall str.
    (Show str, Eq str, StringLike str) =>
    str -> Tag str -> str
    fromAttrib "class" Tag Text
    t
      let ident :: Text
    ident = Text -> Tag Text -> Text
    forall str.
    (Show str, Eq str, StringLike str) =>
    str -> Tag str -> str
    fromAttrib "id" Tag Text
    t
      let kvs :: NoteTable
    kvs = [(Text
    k,Text
    v) | (k :: Text
    k,v :: Text
    v) <- NoteTable
    attrs, Text
    k Text -> Text -> Bool
    forall a. Eq a => a -> a -> Bool
    /= "id" Bool -> Bool -> Bool
    && Text
    k Text -> Text -> Bool
    forall a. Eq a => a -> a -> Bool
    /= "class"]
      Many Block -> ParserT Text ParserState m (Many Block)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Many Block -> ParserT Text ParserState m (Many Block))
    -> Many Block -> ParserT Text ParserState m (Many Block)
    forall a b. (a -> b) -> a -> b
    $ Attr -> Text -> Many Block
    B.codeBlockWith (Text
    ident,[Text]
    classes,NoteTable
    kvs) Text
    result'''

    -- | Header of the form "hN. content" with N in 1..6
    header :: PandocMonad m => ParserT Text ParserState m Blocks
    header :: ParserT Text ParserState m (Many Block)
    header = ParserT Text ParserState m (Many Block)
    -> ParserT Text ParserState m (Many Block)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text ParserState m (Many Block)
     -> ParserT Text ParserState m (Many Block))
    -> ParserT Text ParserState m (Many Block)
    -> ParserT Text ParserState m (Many Block)
    forall a b. (a -> b) -> a -> b
    $ do
      Char -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char 'h'
      Int
    level <- Char -> Int
    digitToInt (Char -> Int)
    -> ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m Int
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> [Char] -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    [Char] -> ParsecT s u m Char
    oneOf "123456"
      Attr
    attr <- ParserT Text ParserState m Attr
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Attr
    attributes
      Char -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '.'
      ParsecT Text ParserState m Inlines
    -> ParsecT Text ParserState m Inlines
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m a
    lookAhead ParsecT Text ParserState m Inlines
    forall (m :: * -> *) st. PandocMonad m => ParserT Text st m Inlines
    whitespace
      Inlines
    name <- Inlines -> Inlines
    trimInlines (Inlines -> Inlines)
    -> ([Inlines] -> Inlines) -> [Inlines] -> Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [Inlines] -> Inlines
    forall a. Monoid a => [a] -> a
    mconcat ([Inlines] -> Inlines)
    -> ParsecT Text ParserState m [Inlines]
    -> ParsecT Text ParserState m Inlines
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Text ParserState m Inlines
    -> ParsecT Text ParserState m [Inlines]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many ParsecT Text ParserState m Inlines
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Inlines
    inline
      Attr
    attr' <- Attr -> Inlines -> ParserT Text ParserState m Attr
    forall s (m :: * -> *) a st.
    (Stream s m a, HasReaderOptions st, HasLogMessages st,
     HasIdentifierList st) =>
    Attr -> Inlines -> ParserT s st m Attr
    registerHeader Attr
    attr Inlines
    name
      Many Block -> ParserT Text ParserState m (Many Block)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Many Block -> ParserT Text ParserState m (Many Block))
    -> Many Block -> ParserT Text ParserState m (Many Block)
    forall a b. (a -> b) -> a -> b
    $ Attr -> Int -> Inlines -> Many Block
    B.headerWith Attr
    attr' Int
    level Inlines
    name

    -- | Blockquote of the form "bq. content"
    blockQuote :: PandocMonad m => ParserT Text ParserState m Blocks
    blockQuote :: ParserT Text ParserState m (Many Block)
    blockQuote = ParserT Text ParserState m (Many Block)
    -> ParserT Text ParserState m (Many Block)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text ParserState m (Many Block)
     -> ParserT Text ParserState m (Many Block))
    -> ParserT Text ParserState m (Many Block)
    -> ParserT Text ParserState m (Many Block)
    forall a b. (a -> b) -> a -> b
    $ do
      [Char] -> ParsecT Text ParserState m [Char]
    forall s (m :: * -> *) u.
    Stream s m Char =>
    [Char] -> ParsecT s u m [Char]
    string "bq" ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m Attr
    -> ParsecT Text ParserState m Attr
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> ParsecT Text ParserState m Attr
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Attr
    attributes ParsecT Text ParserState m Attr
    -> ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m Char
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> Char -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '.' ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m Inlines
    -> ParsecT Text ParserState m Inlines
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> ParsecT Text ParserState m Inlines
    forall (m :: * -> *) st. PandocMonad m => ParserT Text st m Inlines
    whitespace
      Many Block -> Many Block
    B.blockQuote (Many Block -> Many Block)
    -> ParserT Text ParserState m (Many Block)
    -> ParserT Text ParserState m (Many Block)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParserT Text ParserState m (Many Block)
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m (Many Block)
    para

    -- Horizontal rule

    hrule :: PandocMonad m => ParserT Text st m Blocks
    hrule :: ParserT Text st m (Many Block)
    hrule = ParserT Text st m (Many Block) -> ParserT Text st m (Many Block)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text st m (Many Block) -> ParserT Text st m (Many Block))
    -> ParserT Text st m (Many Block) -> ParserT Text st m (Many Block)
    forall a b. (a -> b) -> a -> b
    $ do
      ParserT Text st m ()
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m ()
    skipSpaces
      Char
    start <- [Char] -> ParsecT Text st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    [Char] -> ParsecT s u m Char
    oneOf "-*"
      Int -> ParsecT Text st m Char -> ParsecT Text st m [Char]
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    Int -> ParsecT s u m a -> ParsecT s u m [a]
    count 2 (ParserT Text st m ()
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m ()
    skipSpaces ParserT Text st m ()
    -> ParsecT Text st m Char -> ParsecT Text st m Char
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> Char -> ParsecT Text st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char Char
    start)
      ParsecT Text st m Char -> ParserT Text st m ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m ()
    skipMany (ParsecT Text st m Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    spaceChar ParsecT Text st m Char
    -> ParsecT Text st m Char -> ParsecT Text st m Char
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> Char -> ParsecT Text st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char Char
    start)
      ParsecT Text st m Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    newline
      ParsecT Text st m Text -> ParserT Text st m ()
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m ()
    optional ParsecT Text st m Text
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Text
    blanklines
      Many Block -> ParserT Text st m (Many Block)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Many Block
    B.horizontalRule

    -- Lists handling

    -- | Can be a bullet list or an ordered list. This implementation is
    -- strict in the nesting, sublist must start at exactly "parent depth
    -- plus one"
    anyList :: PandocMonad m => ParserT Text ParserState m Blocks
    anyList :: ParserT Text ParserState m (Many Block)
    anyList = ParserT Text ParserState m (Many Block)
    -> ParserT Text ParserState m (Many Block)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text ParserState m (Many Block)
     -> ParserT Text ParserState m (Many Block))
    -> ParserT Text ParserState m (Many Block)
    -> ParserT Text ParserState m (Many Block)
    forall a b. (a -> b) -> a -> b
    $ Int -> ParserT Text ParserState m (Many Block)
    forall (m :: * -> *).
    PandocMonad m =>
    Int -> ParserT Text ParserState m (Many Block)
    anyListAtDepth 1 ParserT Text ParserState m (Many Block)
    -> ParsecT Text ParserState m Text
    -> ParserT Text ParserState m (Many Block)
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT Text ParserState m Text
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Text
    blanklines

    -- | This allow one type of list to be nested into an other type,
    -- provided correct nesting
    anyListAtDepth :: PandocMonad m => Int -> ParserT Text ParserState m Blocks
    anyListAtDepth :: Int -> ParserT Text ParserState m (Many Block)
    anyListAtDepth depth :: Int
    depth = [ParserT Text ParserState m (Many Block)]
    -> ParserT Text ParserState m (Many Block)
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    [ParsecT s u m a] -> ParsecT s u m a
    choice [ Int -> ParserT Text ParserState m (Many Block)
    forall (m :: * -> *).
    PandocMonad m =>
    Int -> ParserT Text ParserState m (Many Block)
    bulletListAtDepth Int
    depth,
                                    Int -> ParserT Text ParserState m (Many Block)
    forall (m :: * -> *).
    PandocMonad m =>
    Int -> ParserT Text ParserState m (Many Block)
    orderedListAtDepth Int
    depth,
                                    ParserT Text ParserState m (Many Block)
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m (Many Block)
    definitionList ]

    -- | Bullet List of given depth, depth being the number of leading '*'
    bulletListAtDepth :: PandocMonad m => Int -> ParserT Text ParserState m Blocks
    bulletListAtDepth :: Int -> ParserT Text ParserState m (Many Block)
    bulletListAtDepth depth :: Int
    depth = ParserT Text ParserState m (Many Block)
    -> ParserT Text ParserState m (Many Block)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text ParserState m (Many Block)
     -> ParserT Text ParserState m (Many Block))
    -> ParserT Text ParserState m (Many Block)
    -> ParserT Text ParserState m (Many Block)
    forall a b. (a -> b) -> a -> b
    $ [Many Block] -> Many Block
    B.bulletList  ([Many Block] -> Many Block)
    -> ParsecT Text ParserState m [Many Block]
    -> ParserT Text ParserState m (Many Block)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParserT Text ParserState m (Many Block)
    -> ParsecT Text ParserState m [Many Block]
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m [a]
    many1 (Int -> ParserT Text ParserState m (Many Block)
    forall (m :: * -> *).
    PandocMonad m =>
    Int -> ParserT Text ParserState m (Many Block)
    bulletListItemAtDepth Int
    depth)

    -- | Bullet List Item of given depth, depth being the number of
    -- leading '*'
    bulletListItemAtDepth :: PandocMonad m => Int -> ParserT Text ParserState m Blocks
    bulletListItemAtDepth :: Int -> ParserT Text ParserState m (Many Block)
    bulletListItemAtDepth = Char -> Int -> ParserT Text ParserState m (Many Block)
    forall (m :: * -> *).
    PandocMonad m =>
    Char -> Int -> ParserT Text ParserState m (Many Block)
    genericListItemAtDepth '*'

    -- | Ordered List of given depth, depth being the number of
    -- leading '#'
    orderedListAtDepth :: PandocMonad m => Int -> ParserT Text ParserState m Blocks
    orderedListAtDepth :: Int -> ParserT Text ParserState m (Many Block)
    orderedListAtDepth depth :: Int
    depth = ParserT Text ParserState m (Many Block)
    -> ParserT Text ParserState m (Many Block)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text ParserState m (Many Block)
     -> ParserT Text ParserState m (Many Block))
    -> ParserT Text ParserState m (Many Block)
    -> ParserT Text ParserState m (Many Block)
    forall a b. (a -> b) -> a -> b
    $ do
      [Many Block]
    items <- ParserT Text ParserState m (Many Block)
    -> ParsecT Text ParserState m [Many Block]
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m [a]
    many1 (Int -> ParserT Text ParserState m (Many Block)
    forall (m :: * -> *).
    PandocMonad m =>
    Int -> ParserT Text ParserState m (Many Block)
    orderedListItemAtDepth Int
    depth)
      Many Block -> ParserT Text ParserState m (Many Block)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Many Block -> ParserT Text ParserState m (Many Block))
    -> Many Block -> ParserT Text ParserState m (Many Block)
    forall a b. (a -> b) -> a -> b
    $ [Many Block] -> Many Block
    B.orderedList [Many Block]
    items

    -- | Ordered List Item of given depth, depth being the number of
    -- leading '#'
    orderedListItemAtDepth :: PandocMonad m => Int -> ParserT Text ParserState m Blocks
    orderedListItemAtDepth :: Int -> ParserT Text ParserState m (Many Block)
    orderedListItemAtDepth = Char -> Int -> ParserT Text ParserState m (Many Block)
    forall (m :: * -> *).
    PandocMonad m =>
    Char -> Int -> ParserT Text ParserState m (Many Block)
    genericListItemAtDepth '#'

    -- | Common implementation of list items
    genericListItemAtDepth :: PandocMonad m => Char -> Int -> ParserT Text ParserState m Blocks
    genericListItemAtDepth :: Char -> Int -> ParserT Text ParserState m (Many Block)
    genericListItemAtDepth c :: Char
    c depth :: Int
    depth = ParserT Text ParserState m (Many Block)
    -> ParserT Text ParserState m (Many Block)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text ParserState m (Many Block)
     -> ParserT Text ParserState m (Many Block))
    -> ParserT Text ParserState m (Many Block)
    -> ParserT Text ParserState m (Many Block)
    forall a b. (a -> b) -> a -> b
    $ do
      Int
    -> ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m [Char]
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    Int -> ParsecT s u m a -> ParsecT s u m [a]
    count Int
    depth (Char -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char Char
    c) ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m Attr
    -> ParsecT Text ParserState m Attr
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> ParsecT Text ParserState m Attr
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Attr
    attributes ParsecT Text ParserState m Attr
    -> ParsecT Text ParserState m Inlines
    -> ParsecT Text ParserState m Inlines
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> ParsecT Text ParserState m Inlines
    forall (m :: * -> *) st. PandocMonad m => ParserT Text st m Inlines
    whitespace
      Many Block
    contents <- [Many Block] -> Many Block
    forall a. Monoid a => [a] -> a
    mconcat ([Many Block] -> Many Block)
    -> ParsecT Text ParserState m [Many Block]
    -> ParserT Text ParserState m (Many Block)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParserT Text ParserState m (Many Block)
    -> ParsecT Text ParserState m [Many Block]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many ((Inlines -> Many Block
    B.plain (Inlines -> Many Block)
    -> ([Inlines] -> Inlines) -> [Inlines] -> Many Block
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [Inlines] -> Inlines
    forall a. Monoid a => [a] -> a
    mconcat ([Inlines] -> Many Block)
    -> ParsecT Text ParserState m [Inlines]
    -> ParserT Text ParserState m (Many Block)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Text ParserState m Inlines
    -> ParsecT Text ParserState m [Inlines]
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m [a]
    many1 ParsecT Text ParserState m Inlines
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Inlines
    inline) ParserT Text ParserState m (Many Block)
    -> ParserT Text ParserState m (Many Block)
    -> ParserT Text ParserState m (Many Block)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|>
                                    ParserT Text ParserState m (Many Block)
    -> ParserT Text ParserState m (Many Block)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Text ParserState m Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    newline ParsecT Text ParserState m Char
    -> ParserT Text ParserState m (Many Block)
    -> ParserT Text ParserState m (Many Block)
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> ParserT Text ParserState m (Many Block)
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m (Many Block)
    codeBlockPre))
      ParsecT Text ParserState m Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    newline
      Many Block
    sublist <- Many Block
    -> ParserT Text ParserState m (Many Block)
    -> ParserT Text ParserState m (Many Block)
    forall s (m :: * -> *) t a u.
    Stream s m t =>
    a -> ParsecT s u m a -> ParsecT s u m a
    option Many Block
    forall a. Monoid a => a
    mempty (Int -> ParserT Text ParserState m (Many Block)
    forall (m :: * -> *).
    PandocMonad m =>
    Int -> ParserT Text ParserState m (Many Block)
    anyListAtDepth (Int
    depth Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + 1))
      Many Block -> ParserT Text ParserState m (Many Block)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Many Block -> ParserT Text ParserState m (Many Block))
    -> Many Block -> ParserT Text ParserState m (Many Block)
    forall a b. (a -> b) -> a -> b
    $ Many Block
    contents Many Block -> Many Block -> Many Block
    forall a. Semigroup a => a -> a -> a
    <> Many Block
    sublist

    -- | A definition list is a set of consecutive definition items
    definitionList :: PandocMonad m => ParserT Text ParserState m Blocks
    definitionList :: ParserT Text ParserState m (Many Block)
    definitionList = ParserT Text ParserState m (Many Block)
    -> ParserT Text ParserState m (Many Block)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text ParserState m (Many Block)
     -> ParserT Text ParserState m (Many Block))
    -> ParserT Text ParserState m (Many Block)
    -> ParserT Text ParserState m (Many Block)
    forall a b. (a -> b) -> a -> b
    $ [(Inlines, [Many Block])] -> Many Block
    B.definitionList ([(Inlines, [Many Block])] -> Many Block)
    -> ParsecT Text ParserState m [(Inlines, [Many Block])]
    -> ParserT Text ParserState m (Many Block)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Text ParserState m (Inlines, [Many Block])
    -> ParsecT Text ParserState m [(Inlines, [Many Block])]
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m [a]
    many1 ParsecT Text ParserState m (Inlines, [Many Block])
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m (Inlines, [Many Block])
    definitionListItem

    -- | List start character.
    listStart :: PandocMonad m => ParserT Text ParserState m ()
    listStart :: ParserT Text ParserState m ()
    listStart = Char -> ParserT Text ParserState m ()
    forall (m :: * -> *) st.
    PandocMonad m =>
    Char -> ParserT Text st m ()
    genericListStart '*'
            ParserT Text ParserState m ()
    -> ParserT Text ParserState m () -> ParserT Text ParserState m ()
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> () ()
    -> ParserT Text ParserState m () -> ParserT Text ParserState m ()
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ Char -> ParserT Text ParserState m ()
    forall (m :: * -> *) st.
    PandocMonad m =>
    Char -> ParserT Text st m ()
    genericListStart '#'
            ParserT Text ParserState m ()
    -> ParserT Text ParserState m () -> ParserT Text ParserState m ()
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> () ()
    -> ParsecT Text ParserState m Inlines
    -> ParserT Text ParserState m ()
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ ParsecT Text ParserState m Inlines
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Inlines
    definitionListStart

    genericListStart :: PandocMonad m => Char -> ParserT Text st m ()
    genericListStart :: Char -> ParserT Text st m ()
    genericListStart c :: Char
    c = () () -> ParsecT Text st m Inlines -> ParserT Text st m ()
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ ParsecT Text st m Inlines -> ParsecT Text st m Inlines
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Text st m Char -> ParsecT Text st m [Char]
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m [a]
    many1 (Char -> ParsecT Text st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char Char
    c) ParsecT Text st m [Char]
    -> ParsecT Text st m Inlines -> ParsecT Text st m Inlines
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> ParsecT Text st m Inlines
    forall (m :: * -> *) st. PandocMonad m => ParserT Text st m Inlines
    whitespace)

    basicDLStart :: PandocMonad m => ParserT Text ParserState m ()
    basicDLStart :: ParserT Text ParserState m ()
    basicDLStart = do
      Char -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '-'
      ParserT Text ParserState m Inlines
    forall (m :: * -> *) st. PandocMonad m => ParserT Text st m Inlines
    whitespace
      ParsecT Text ParserState m Char -> ParserT Text ParserState m ()
    forall s (m :: * -> *) t a u.
    (Stream s m t, Show a) =>
    ParsecT s u m a -> ParsecT s u m ()
    notFollowedBy ParsecT Text ParserState m Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    newline

    definitionListStart :: PandocMonad m => ParserT Text ParserState m Inlines
    definitionListStart :: ParserT Text ParserState m Inlines
    definitionListStart = ParserT Text ParserState m Inlines
    -> ParserT Text ParserState m Inlines
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text ParserState m Inlines
     -> ParserT Text ParserState m Inlines)
    -> ParserT Text ParserState m Inlines
    -> ParserT Text ParserState m Inlines
    forall a b. (a -> b) -> a -> b
    $ do
      ParserT Text ParserState m ()
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m ()
    basicDLStart
      Inlines -> Inlines
    trimInlines (Inlines -> Inlines)
    -> ([Inlines] -> Inlines) -> [Inlines] -> Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [Inlines] -> Inlines
    forall a. Monoid a => [a] -> a
    mconcat ([Inlines] -> Inlines)
    -> ParsecT Text ParserState m [Inlines]
    -> ParserT Text ParserState m Inlines
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$>
        ParserT Text ParserState m Inlines
    -> ParserT Text ParserState m ()
    -> ParsecT Text ParserState m [Inlines]
    forall end s (m :: * -> *) t st a.
    (Show end, Stream s m t) =>
    ParserT s st m a -> ParserT s st m end -> ParserT s st m [a]
    many1Till ParserT Text ParserState m Inlines
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Inlines
    inline
         (  ParserT Text ParserState m () -> ParserT Text ParserState m ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Text ParserState m Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    newline ParsecT Text ParserState m Char
    -> ParserT Text ParserState m () -> ParserT Text ParserState m ()
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> ParserT Text ParserState m () -> ParserT Text ParserState m ()
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m a
    lookAhead ParserT Text ParserState m ()
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m ()
    basicDLStart)
        ParserT Text ParserState m ()
    -> ParserT Text ParserState m () -> ParserT Text ParserState m ()
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParserT Text ParserState m () -> ParserT Text ParserState m ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text ParserState m () -> ParserT Text ParserState m ()
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m a
    lookAhead (() ()
    -> ParsecT Text ParserState m [Char]
    -> ParserT Text ParserState m ()
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ [Char] -> ParsecT Text ParserState m [Char]
    forall s (m :: * -> *) u.
    Stream s m Char =>
    [Char] -> ParsecT s u m [Char]
    string ":="))
         )

    -- | A definition list item in textile begins with '- ', followed by
    -- the term defined, then spaces and ":=". The definition follows, on
    -- the same single line, or spaned on multiple line, after a line
    -- break.
    definitionListItem :: PandocMonad m => ParserT Text ParserState m (Inlines, [Blocks])
    definitionListItem :: ParserT Text ParserState m (Inlines, [Many Block])
    definitionListItem = ParserT Text ParserState m (Inlines, [Many Block])
    -> ParserT Text ParserState m (Inlines, [Many Block])
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text ParserState m (Inlines, [Many Block])
     -> ParserT Text ParserState m (Inlines, [Many Block]))
    -> ParserT Text ParserState m (Inlines, [Many Block])
    -> ParserT Text ParserState m (Inlines, [Many Block])
    forall a b. (a -> b) -> a -> b
    $ do
      Inlines
    term <- ([Inlines] -> Inlines
    forall a. Monoid a => [a] -> a
    mconcat ([Inlines] -> Inlines)
    -> ([Inlines] -> [Inlines]) -> [Inlines] -> Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Inlines -> [Inlines] -> [Inlines]
    forall a. a -> [a] -> [a]
    intersperse Inlines
    B.linebreak) ([Inlines] -> Inlines)
    -> ParsecT Text ParserState m [Inlines]
    -> ParsecT Text ParserState m Inlines
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Text ParserState m Inlines
    -> ParsecT Text ParserState m [Inlines]
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m [a]
    many1 ParsecT Text ParserState m Inlines
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Inlines
    definitionListStart
      [Many Block]
    def' <- [Char] -> ParsecT Text ParserState m [Char]
    forall s (m :: * -> *) u.
    Stream s m Char =>
    [Char] -> ParsecT s u m [Char]
    string ":=" ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m () -> ParsecT Text ParserState m ()
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> ParsecT Text ParserState m Inlines -> ParsecT Text ParserState m ()
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m ()
    optional ParsecT Text ParserState m Inlines
    forall (m :: * -> *) st. PandocMonad m => ParserT Text st m Inlines
    whitespace ParsecT Text ParserState m ()
    -> ParsecT Text ParserState m [Many Block]
    -> ParsecT Text ParserState m [Many Block]
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> (ParsecT Text ParserState m [Many Block]
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m [Many Block]
    multilineDef ParsecT Text ParserState m [Many Block]
    -> ParsecT Text ParserState m [Many Block]
    -> ParsecT Text ParserState m [Many Block]
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Text ParserState m [Many Block]
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m [Many Block]
    inlineDef)
      (Inlines, [Many Block])
    -> ParserT Text ParserState m (Inlines, [Many Block])
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Inlines
    term, [Many Block]
    def')
      where inlineDef :: PandocMonad m => ParserT Text ParserState m [Blocks]
            inlineDef :: ParserT Text ParserState m [Many Block]
    inlineDef = (Inlines -> [Many Block])
    -> ParsecT Text ParserState m Inlines
    -> ParserT Text ParserState m [Many Block]
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM (\d :: Inlines
    d -> [Inlines -> Many Block
    B.plain Inlines
    d])
                        (ParsecT Text ParserState m Inlines
     -> ParserT Text ParserState m [Many Block])
    -> ParsecT Text ParserState m Inlines
    -> ParserT Text ParserState m [Many Block]
    forall a b. (a -> b) -> a -> b
    $ ParsecT Text ParserState m Inlines -> ParsecT Text ParserState m ()
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m ()
    optional ParsecT Text ParserState m Inlines
    forall (m :: * -> *) st. PandocMonad m => ParserT Text st m Inlines
    whitespace ParsecT Text ParserState m ()
    -> ParsecT Text ParserState m Inlines
    -> ParsecT Text ParserState m Inlines
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> (Inlines -> Inlines
    trimInlines (Inlines -> Inlines)
    -> ([Inlines] -> Inlines) -> [Inlines] -> Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [Inlines] -> Inlines
    forall a. Monoid a => [a] -> a
    mconcat ([Inlines] -> Inlines)
    -> ParsecT Text ParserState m [Inlines]
    -> ParsecT Text ParserState m Inlines
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Text ParserState m Inlines
    -> ParsecT Text ParserState m [Inlines]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many ParsecT Text ParserState m Inlines
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Inlines
    inline) ParsecT Text ParserState m Inlines
    -> ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m Inlines
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT Text ParserState m Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    newline
            multilineDef :: PandocMonad m => ParserT Text ParserState m [Blocks]
            multilineDef :: ParserT Text ParserState m [Many Block]
    multilineDef = ParserT Text ParserState m [Many Block]
    -> ParserT Text ParserState m [Many Block]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text ParserState m [Many Block]
     -> ParserT Text ParserState m [Many Block])
    -> ParserT Text ParserState m [Many Block]
    -> ParserT Text ParserState m [Many Block]
    forall a b. (a -> b) -> a -> b
    $ do
              ParsecT Text ParserState m Inlines -> ParsecT Text ParserState m ()
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m ()
    optional ParsecT Text ParserState m Inlines
    forall (m :: * -> *) st. PandocMonad m => ParserT Text st m Inlines
    whitespace ParsecT Text ParserState m ()
    -> ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m Char
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> ParsecT Text ParserState m Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    newline
              Text
    s <- [Char] -> Text
    T.pack ([Char] -> Text)
    -> ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m [Char]
    forall end s (m :: * -> *) t st a.
    (Show end, Stream s m t) =>
    ParserT s st m a -> ParserT s st m end -> ParserT s st m [a]
    many1Till ParsecT Text ParserState m Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    anyChar (ParsecT Text ParserState m Char -> ParsecT Text ParserState m Char
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try ([Char] -> ParsecT Text ParserState m [Char]
    forall s (m :: * -> *) u.
    Stream s m Char =>
    [Char] -> ParsecT s u m [Char]
    string "=:" ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m Char
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> ParsecT Text ParserState m Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    newline))
              -- this <> "\n\n" does not look very good
              Many Block
    ds <- ParserT Text ParserState m (Many Block)
    -> Text -> ParserT Text ParserState m (Many Block)
    forall s (m :: * -> *) u a.
    (Stream s m Char, IsString s, HasLastStrPosition u) =>
    ParserT s u m a -> Text -> ParserT s u m a
    parseFromString' ParserT Text ParserState m (Many Block)
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m (Many Block)
    parseBlocks (Text
    s Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> "\n\n")
              [Many Block] -> ParserT Text ParserState m [Many Block]
    forall (m :: * -> *) a. Monad m => a -> m a
    return [Many Block
    ds]

    -- raw content

    -- | A raw Html Block, optionally followed by blanklines
    rawHtmlBlock :: PandocMonad m => ParserT Text ParserState m Blocks
    rawHtmlBlock :: ParserT Text ParserState m (Many Block)
    rawHtmlBlock = ParserT Text ParserState m (Many Block)
    -> ParserT Text ParserState m (Many Block)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text ParserState m (Many Block)
     -> ParserT Text ParserState m (Many Block))
    -> ParserT Text ParserState m (Many Block)
    -> ParserT Text ParserState m (Many Block)
    forall a b. (a -> b) -> a -> b
    $ do
      ParsecT Text ParserState m Char -> ParsecT Text ParserState m ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m ()
    skipMany ParsecT Text ParserState m Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    spaceChar
      (_,b :: Text
    b) <- (Tag Text -> Bool) -> ParserT Text ParserState m (Tag Text, Text)
    forall st (m :: * -> *).
    (HasReaderOptions st, Monad m) =>
    (Tag Text -> Bool) -> ParserT Text st m (Tag Text, Text)
    htmlTag Tag Text -> Bool
    forall a. NamedTag (Tag a) => Tag a -> Bool
    isBlockTag
      ParsecT Text ParserState m Text -> ParsecT Text ParserState m ()
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m ()
    optional ParsecT Text ParserState m Text
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Text
    blanklines
      Many Block -> ParserT Text ParserState m (Many Block)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Many Block -> ParserT Text ParserState m (Many Block))
    -> Many Block -> ParserT Text ParserState m (Many Block)
    forall a b. (a -> b) -> a -> b
    $ Text -> Text -> Many Block
    B.rawBlock "html" Text
    b

    -- | Raw block of LaTeX content
    rawLaTeXBlock' :: PandocMonad m => ParserT Text ParserState m Blocks
    rawLaTeXBlock' :: ParserT Text ParserState m (Many Block)
    rawLaTeXBlock' = do
      Extension -> ParserT Text ParserState m ()
    forall s (m :: * -> *) a st.
    (Stream s m a, HasReaderOptions st) =>
    Extension -> ParserT s st m ()
    guardEnabled Extension
    Ext_raw_tex
      Text -> Text -> Many Block
    B.rawBlock "latex" (Text -> Many Block)
    -> ParsecT Text ParserState m Text
    -> ParserT Text ParserState m (Many Block)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (ParsecT Text ParserState m Text
    forall (m :: * -> *) s.
    (PandocMonad m, HasMacros s, HasReaderOptions s) =>
    ParserT Text s m Text
    rawLaTeXBlock ParsecT Text ParserState m Text
    -> ParserT Text ParserState m () -> ParsecT Text ParserState m Text
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParserT Text ParserState m ()
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m ()
    spaces)

    -- | In textile, paragraphs are separated by blank lines.
    para :: PandocMonad m => ParserT Text ParserState m Blocks
    para :: ParserT Text ParserState m (Many Block)
    para = Inlines -> Many Block
    B.para (Inlines -> Many Block)
    -> ([Inlines] -> Inlines) -> [Inlines] -> Many Block
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Inlines -> Inlines
    trimInlines (Inlines -> Inlines)
    -> ([Inlines] -> Inlines) -> [Inlines] -> Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [Inlines] -> Inlines
    forall a. Monoid a => [a] -> a
    mconcat ([Inlines] -> Many Block)
    -> ParsecT Text ParserState m [Inlines]
    -> ParserT Text ParserState m (Many Block)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Text ParserState m Inlines
    -> ParsecT Text ParserState m [Inlines]
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m [a]
    many1 ParsecT Text ParserState m Inlines
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Inlines
    inline

    -- Tables

    toAlignment :: Char -> Alignment
    toAlignment :: Char -> Alignment
    toAlignment '<' = Alignment
    AlignLeft
    toAlignment '>' = Alignment
    AlignRight
    toAlignment '=' = Alignment
    AlignCenter
    toAlignment _   = Alignment
    AlignDefault

    cellAttributes :: PandocMonad m => ParserT Text ParserState m (Bool, Alignment)
    cellAttributes :: ParserT Text ParserState m (Bool, Alignment)
    cellAttributes = ParserT Text ParserState m (Bool, Alignment)
    -> ParserT Text ParserState m (Bool, Alignment)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text ParserState m (Bool, Alignment)
     -> ParserT Text ParserState m (Bool, Alignment))
    -> ParserT Text ParserState m (Bool, Alignment)
    -> ParserT Text ParserState m (Bool, Alignment)
    forall a b. (a -> b) -> a -> b
    $ do
      Bool
    isHeader <- Bool
    -> ParsecT Text ParserState m Bool
    -> ParsecT Text ParserState m Bool
    forall s (m :: * -> *) t a u.
    Stream s m t =>
    a -> ParsecT s u m a -> ParsecT s u m a
    option Bool
    False (Bool
    True Bool
    -> ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m Bool
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ Char -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '_')
      -- we just ignore colspan and rowspan markers:
      ParsecT Text ParserState m [Char] -> ParsecT Text ParserState m ()
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m ()
    optional (ParsecT Text ParserState m [Char]
     -> ParsecT Text ParserState m ())
    -> ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m ()
    forall a b. (a -> b) -> a -> b
    $ ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m [Char]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Text ParserState m [Char]
     -> ParsecT Text ParserState m [Char])
    -> ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m [Char]
    forall a b. (a -> b) -> a -> b
    $ [Char] -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    [Char] -> ParsecT s u m Char
    oneOf "/\\" ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m [Char]
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m [Char]
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m [a]
    many1 ParsecT Text ParserState m Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    digit
      -- we pay attention to alignments:
      Alignment
    alignment <- Alignment
    -> ParsecT Text ParserState m Alignment
    -> ParsecT Text ParserState m Alignment
    forall s (m :: * -> *) t a u.
    Stream s m t =>
    a -> ParsecT s u m a -> ParsecT s u m a
    option Alignment
    AlignDefault (ParsecT Text ParserState m Alignment
     -> ParsecT Text ParserState m Alignment)
    -> ParsecT Text ParserState m Alignment
    -> ParsecT Text ParserState m Alignment
    forall a b. (a -> b) -> a -> b
    $ Char -> Alignment
    toAlignment (Char -> Alignment)
    -> ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m Alignment
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> [Char] -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    [Char] -> ParsecT s u m Char
    oneOf "<>="
      -- ignore other attributes for now:
      Attr
    _ <- ParserT Text ParserState m Attr
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Attr
    attributes
      Char -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '.'
      (Bool, Alignment) -> ParserT Text ParserState m (Bool, Alignment)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Bool
    isHeader, Alignment
    alignment)

    -- | A table cell spans until a pipe |
    tableCell :: PandocMonad m => ParserT Text ParserState m ((Bool, Alignment), Blocks)
    tableCell :: ParserT Text ParserState m ((Bool, Alignment), Many Block)
    tableCell = ParserT Text ParserState m ((Bool, Alignment), Many Block)
    -> ParserT Text ParserState m ((Bool, Alignment), Many Block)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text ParserState m ((Bool, Alignment), Many Block)
     -> ParserT Text ParserState m ((Bool, Alignment), Many Block))
    -> ParserT Text ParserState m ((Bool, Alignment), Many Block)
    -> ParserT Text ParserState m ((Bool, Alignment), Many Block)
    forall a b. (a -> b) -> a -> b
    $ do
      Char -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '|'
      (isHeader :: Bool
    isHeader, alignment :: Alignment
    alignment) <- (Bool, Alignment)
    -> ParsecT Text ParserState m (Bool, Alignment)
    -> ParsecT Text ParserState m (Bool, Alignment)
    forall s (m :: * -> *) t a u.
    Stream s m t =>
    a -> ParsecT s u m a -> ParsecT s u m a
    option (Bool
    False, Alignment
    AlignDefault) ParsecT Text ParserState m (Bool, Alignment)
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m (Bool, Alignment)
    cellAttributes
      ParsecT Text ParserState m Char -> ParsecT Text ParserState m ()
    forall s (m :: * -> *) t a u.
    (Stream s m t, Show a) =>
    ParsecT s u m a -> ParsecT s u m ()
    notFollowedBy ParsecT Text ParserState m Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    blankline
      Text
    raw <- Text -> Text
    trim (Text -> Text) -> ([Char] -> Text) -> [Char] -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [Char] -> Text
    T.pack ([Char] -> Text)
    -> ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$>
             ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m [Char]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many ([Char] -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    [Char] -> ParsecT s u m Char
    noneOf "|\n" ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m Char
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Text ParserState m Char -> ParsecT Text ParserState m Char
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (Char -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '\n' ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m () -> ParsecT Text ParserState m Char
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT Text ParserState m Char -> ParsecT Text ParserState m ()
    forall s (m :: * -> *) t a u.
    (Stream s m t, Show a) =>
    ParsecT s u m a -> ParsecT s u m ()
    notFollowedBy ParsecT Text ParserState m Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    blankline))
      Inlines
    content <- [Inlines] -> Inlines
    forall a. Monoid a => [a] -> a
    mconcat ([Inlines] -> Inlines)
    -> ParsecT Text ParserState m [Inlines]
    -> ParsecT Text ParserState m Inlines
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Text ParserState m [Inlines]
    -> Text -> ParsecT Text ParserState m [Inlines]
    forall s (m :: * -> *) u a.
    (Stream s m Char, IsString s, HasLastStrPosition u) =>
    ParserT s u m a -> Text -> ParserT s u m a
    parseFromString' (ParsecT Text ParserState m Inlines
    -> ParsecT Text ParserState m [Inlines]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many ParsecT Text ParserState m Inlines
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Inlines
    inline) Text
    raw
      ((Bool, Alignment), Many Block)
    -> ParserT Text ParserState m ((Bool, Alignment), Many Block)
    forall (m :: * -> *) a. Monad m => a -> m a
    return ((Bool
    isHeader, Alignment
    alignment), Inlines -> Many Block
    B.plain Inlines
    content)

    -- | A table row is made of many table cells
    tableRow :: PandocMonad m => ParserT Text ParserState m [((Bool, Alignment), Blocks)]
    tableRow :: ParserT Text ParserState m [((Bool, Alignment), Many Block)]
    tableRow = ParserT Text ParserState m [((Bool, Alignment), Many Block)]
    -> ParserT Text ParserState m [((Bool, Alignment), Many Block)]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text ParserState m [((Bool, Alignment), Many Block)]
     -> ParserT Text ParserState m [((Bool, Alignment), Many Block)])
    -> ParserT Text ParserState m [((Bool, Alignment), Many Block)]
    -> ParserT Text ParserState m [((Bool, Alignment), Many Block)]
    forall a b. (a -> b) -> a -> b
    $ do
      -- skip optional row attributes
      ParsecT Text ParserState m [Char] -> ParsecT Text ParserState m ()
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m ()
    optional (ParsecT Text ParserState m [Char]
     -> ParsecT Text ParserState m ())
    -> ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m ()
    forall a b. (a -> b) -> a -> b
    $ ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m [Char]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Text ParserState m [Char]
     -> ParsecT Text ParserState m [Char])
    -> ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m [Char]
    forall a b. (a -> b) -> a -> b
    $ do
        Attr
    _ <- ParserT Text ParserState m Attr
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Attr
    attributes
        Char -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '.'
        ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m [Char]
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m [a]
    many1 ParsecT Text ParserState m Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    spaceChar
      ParsecT Text ParserState m ((Bool, Alignment), Many Block)
    -> ParserT Text ParserState m [((Bool, Alignment), Many Block)]
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m [a]
    many1 ParsecT Text ParserState m ((Bool, Alignment), Many Block)
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m ((Bool, Alignment), Many Block)
    tableCell ParserT Text ParserState m [((Bool, Alignment), Many Block)]
    -> ParsecT Text ParserState m Char
    -> ParserT Text ParserState m [((Bool, Alignment), Many Block)]
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* Char -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '|' ParserT Text ParserState m [((Bool, Alignment), Many Block)]
    -> ParsecT Text ParserState m Char
    -> ParserT Text ParserState m [((Bool, Alignment), Many Block)]
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT Text ParserState m Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    blankline

    -- | A table with an optional header.
    table :: PandocMonad m => ParserT Text ParserState m Blocks
    table :: ParserT Text ParserState m (Many Block)
    table = ParserT Text ParserState m (Many Block)
    -> ParserT Text ParserState m (Many Block)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text ParserState m (Many Block)
     -> ParserT Text ParserState m (Many Block))
    -> ParserT Text ParserState m (Many Block)
    -> ParserT Text ParserState m (Many Block)
    forall a b. (a -> b) -> a -> b
    $ do
      -- ignore table attributes
      Inlines
    caption <- Inlines
    -> ParsecT Text ParserState m Inlines
    -> ParsecT Text ParserState m Inlines
    forall s (m :: * -> *) t a u.
    Stream s m t =>
    a -> ParsecT s u m a -> ParsecT s u m a
    option Inlines
    forall a. Monoid a => a
    mempty (ParsecT Text ParserState m Inlines
     -> ParsecT Text ParserState m Inlines)
    -> ParsecT Text ParserState m Inlines
    -> ParsecT Text ParserState m Inlines
    forall a b. (a -> b) -> a -> b
    $ ParsecT Text ParserState m Inlines
    -> ParsecT Text ParserState m Inlines
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Text ParserState m Inlines
     -> ParsecT Text ParserState m Inlines)
    -> ParsecT Text ParserState m Inlines
    -> ParsecT Text ParserState m Inlines
    forall a b. (a -> b) -> a -> b
    $ do
        [Char] -> ParsecT Text ParserState m [Char]
    forall s (m :: * -> *) u.
    Stream s m Char =>
    [Char] -> ParsecT s u m [Char]
    string "table"
        Attr
    _ <- ParserT Text ParserState m Attr
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Attr
    attributes
        Char -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '.'
        Text
    rawcapt <- Text -> Text
    trim (Text -> Text)
    -> ParsecT Text ParserState m Text
    -> ParsecT Text ParserState m Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Text ParserState m Text
    forall (m :: * -> *) st. Monad m => ParserT Text st m Text
    anyLine
        ParsecT Text ParserState m Inlines
    -> Text -> ParsecT Text ParserState m Inlines
    forall s (m :: * -> *) u a.
    (Stream s m Char, IsString s, HasLastStrPosition u) =>
    ParserT s u m a -> Text -> ParserT s u m a
    parseFromString' ([Inlines] -> Inlines
    forall a. Monoid a => [a] -> a
    mconcat ([Inlines] -> Inlines)
    -> ParsecT Text ParserState m [Inlines]
    -> ParsecT Text ParserState m Inlines
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Text ParserState m Inlines
    -> ParsecT Text ParserState m [Inlines]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many ParsecT Text ParserState m Inlines
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Inlines
    inline) Text
    rawcapt
      [[((Bool, Alignment), Many Block)]]
    rawrows <- ParsecT Text ParserState m [((Bool, Alignment), Many Block)]
    -> ParsecT Text ParserState m [[((Bool, Alignment), Many Block)]]
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m [a]
    many1 (ParsecT Text ParserState m [((Bool, Alignment), Many Block)]
     -> ParsecT Text ParserState m [[((Bool, Alignment), Many Block)]])
    -> ParsecT Text ParserState m [((Bool, Alignment), Many Block)]
    -> ParsecT Text ParserState m [[((Bool, Alignment), Many Block)]]
    forall a b. (a -> b) -> a -> b
    $ ParsecT Text ParserState m () -> ParsecT Text ParserState m ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m ()
    skipMany ParsecT Text ParserState m ()
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m ()
    ignorableRow ParsecT Text ParserState m ()
    -> ParsecT Text ParserState m [((Bool, Alignment), Many Block)]
    -> ParsecT Text ParserState m [((Bool, Alignment), Many Block)]
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> ParsecT Text ParserState m [((Bool, Alignment), Many Block)]
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m [((Bool, Alignment), Many Block)]
    tableRow
      ParsecT Text ParserState m () -> ParsecT Text ParserState m ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m ()
    skipMany ParsecT Text ParserState m ()
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m ()
    ignorableRow
      ParsecT Text ParserState m Text
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Text
    blanklines
      let (headers :: [((Bool, Alignment), Many Block)]
    headers, rows :: [[((Bool, Alignment), Many Block)]]
    rows) = case [[((Bool, Alignment), Many Block)]]
    rawrows of
                                 (toprow :: [((Bool, Alignment), Many Block)]
    toprow:rest :: [[((Bool, Alignment), Many Block)]]
    rest) | (((Bool, Alignment), Many Block) -> Bool)
    -> [((Bool, Alignment), Many Block)] -> Bool
    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
    any ((Bool, Alignment) -> Bool
    forall a b. (a, b) -> a
    fst ((Bool, Alignment) -> Bool)
    -> (((Bool, Alignment), Many Block) -> (Bool, Alignment))
    -> ((Bool, Alignment), Many Block)
    -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ((Bool, Alignment), Many Block) -> (Bool, Alignment)
    forall a b. (a, b) -> a
    fst) [((Bool, Alignment), Many Block)]
    toprow ->
                                    ([((Bool, Alignment), Many Block)]
    toprow, [[((Bool, Alignment), Many Block)]]
    rest)
                                 _ -> ([((Bool, Alignment), Many Block)]
    forall a. Monoid a => a
    mempty, [[((Bool, Alignment), Many Block)]]
    rawrows)
      let nbOfCols :: Int
    nbOfCols = [Int] -> Int
    forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a
    maximum ([Int] -> Int) -> [Int] -> Int
    forall a b. (a -> b) -> a -> b
    $ ([((Bool, Alignment), Many Block)] -> Int)
    -> [[((Bool, Alignment), Many Block)]] -> [Int]
    forall a b. (a -> b) -> [a] -> [b]
    map [((Bool, Alignment), Many Block)] -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    length ([((Bool, Alignment), Many Block)]
    headers[((Bool, Alignment), Many Block)]
    -> [[((Bool, Alignment), Many Block)]]
    -> [[((Bool, Alignment), Many Block)]]
    forall a. a -> [a] -> [a]
    :[[((Bool, Alignment), Many Block)]]
    rows)
      let aligns :: [Alignment]
    aligns = ([Alignment] -> Alignment) -> [[Alignment]] -> [Alignment]
    forall a b. (a -> b) -> [a] -> [b]
    map [Alignment] -> Alignment
    forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a
    minimum ([[Alignment]] -> [Alignment]) -> [[Alignment]] -> [Alignment]
    forall a b. (a -> b) -> a -> b
    $ [[Alignment]] -> [[Alignment]]
    forall a. [[a]] -> [[a]]
    transpose ([[Alignment]] -> [[Alignment]]) -> [[Alignment]] -> [[Alignment]]
    forall a b. (a -> b) -> a -> b
    $ ([((Bool, Alignment), Many Block)] -> [Alignment])
    -> [[((Bool, Alignment), Many Block)]] -> [[Alignment]]
    forall a b. (a -> b) -> [a] -> [b]
    map ((((Bool, Alignment), Many Block) -> Alignment)
    -> [((Bool, Alignment), Many Block)] -> [Alignment]
    forall a b. (a -> b) -> [a] -> [b]
    map ((Bool, Alignment) -> Alignment
    forall a b. (a, b) -> b
    snd ((Bool, Alignment) -> Alignment)
    -> (((Bool, Alignment), Many Block) -> (Bool, Alignment))
    -> ((Bool, Alignment), Many Block)
    -> Alignment
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ((Bool, Alignment), Many Block) -> (Bool, Alignment)
    forall a b. (a, b) -> a
    fst)) ([((Bool, Alignment), Many Block)]
    headers[((Bool, Alignment), Many Block)]
    -> [[((Bool, Alignment), Many Block)]]
    -> [[((Bool, Alignment), Many Block)]]
    forall a. a -> [a] -> [a]
    :[[((Bool, Alignment), Many Block)]]
    rows)
      Many Block -> ParserT Text ParserState m (Many Block)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Many Block -> ParserT Text ParserState m (Many Block))
    -> Many Block -> ParserT Text ParserState m (Many Block)
    forall a b. (a -> b) -> a -> b
    $ Inlines
    -> [(Alignment, Double)]
    -> [Many Block]
    -> [[Many Block]]
    -> Many Block
    B.table Inlines
    caption
        ([Alignment] -> [Double] -> [(Alignment, Double)]
    forall a b. [a] -> [b] -> [(a, b)]
    zip [Alignment]
    aligns (Int -> Double -> [Double]
    forall a. Int -> a -> [a]
    replicate Int
    nbOfCols 0.0))
        ((((Bool, Alignment), Many Block) -> Many Block)
    -> [((Bool, Alignment), Many Block)] -> [Many Block]
    forall a b. (a -> b) -> [a] -> [b]
    map ((Bool, Alignment), Many Block) -> Many Block
    forall a b. (a, b) -> b
    snd [((Bool, Alignment), Many Block)]
    headers)
        (([((Bool, Alignment), Many Block)] -> [Many Block])
    -> [[((Bool, Alignment), Many Block)]] -> [[Many Block]]
    forall a b. (a -> b) -> [a] -> [b]
    map ((((Bool, Alignment), Many Block) -> Many Block)
    -> [((Bool, Alignment), Many Block)] -> [Many Block]
    forall a b. (a -> b) -> [a] -> [b]
    map ((Bool, Alignment), Many Block) -> Many Block
    forall a b. (a, b) -> b
    snd) [[((Bool, Alignment), Many Block)]]
    rows)

    -- | Ignore markers for cols, thead, tfoot.
    ignorableRow :: PandocMonad m => ParserT Text ParserState m ()
    ignorableRow :: ParserT Text ParserState m ()
    ignorableRow = ParserT Text ParserState m () -> ParserT Text ParserState m ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text ParserState m () -> ParserT Text ParserState m ())
    -> ParserT Text ParserState m () -> ParserT Text ParserState m ()
    forall a b. (a -> b) -> a -> b
    $ do
      Char -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '|'
      [Char] -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    [Char] -> ParsecT s u m Char
    oneOf ":^-~"
      Attr
    _ <- ParserT Text ParserState m Attr
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Attr
    attributes
      Char -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '.'
      Text
    _ <- ParserT Text ParserState m Text
    forall (m :: * -> *) st. Monad m => ParserT Text st m Text
    anyLine
      () -> ParserT Text ParserState m ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    explicitBlockStart :: PandocMonad m => Text -> ParserT Text ParserState m ()
    explicitBlockStart :: Text -> ParserT Text ParserState m ()
    explicitBlockStart name :: Text
    name = ParserT Text ParserState m () -> ParserT Text ParserState m ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text ParserState m () -> ParserT Text ParserState m ())
    -> ParserT Text ParserState m () -> ParserT Text ParserState m ()
    forall a b. (a -> b) -> a -> b
    $ do
      [Char] -> ParsecT Text ParserState m [Char]
    forall s (m :: * -> *) u.
    Stream s m Char =>
    [Char] -> ParsecT s u m [Char]
    string (Text -> [Char]
    T.unpack Text
    name)
      ParserT Text ParserState m Attr
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Attr
    attributes
      Char -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '.'
      ParsecT Text ParserState m Inlines -> ParserT Text ParserState m ()
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m ()
    optional ParsecT Text ParserState m Inlines
    forall (m :: * -> *) st. PandocMonad m => ParserT Text st m Inlines
    whitespace
      ParsecT Text ParserState m Inlines -> ParserT Text ParserState m ()
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m ()
    optional ParsecT Text ParserState m Inlines
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Inlines
    endline

    -- | Blocks like 'p' and 'table' do not need explicit block tag.
    -- However, they can be used to set HTML/CSS attributes when needed.
    maybeExplicitBlock :: PandocMonad m
                       => Text  -- ^ block tag name
                       -> ParserT Text ParserState m Blocks -- ^ implicit block
                       -> ParserT Text ParserState m Blocks
    maybeExplicitBlock :: Text
    -> ParserT Text ParserState m (Many Block)
    -> ParserT Text ParserState m (Many Block)
    maybeExplicitBlock name :: Text
    name blk :: ParserT Text ParserState m (Many Block)
    blk = ParserT Text ParserState m (Many Block)
    -> ParserT Text ParserState m (Many Block)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text ParserState m (Many Block)
     -> ParserT Text ParserState m (Many Block))
    -> ParserT Text ParserState m (Many Block)
    -> ParserT Text ParserState m (Many Block)
    forall a b. (a -> b) -> a -> b
    $ do
      ParsecT Text ParserState m () -> ParsecT Text ParserState m ()
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m ()
    optional (ParsecT Text ParserState m () -> ParsecT Text ParserState m ())
    -> ParsecT Text ParserState m () -> ParsecT Text ParserState m ()
    forall a b. (a -> b) -> a -> b
    $ Text -> ParsecT Text ParserState m ()
    forall (m :: * -> *).
    PandocMonad m =>
    Text -> ParserT Text ParserState m ()
    explicitBlockStart Text
    name
      ParserT Text ParserState m (Many Block)
    blk

    ----------
    -- Inlines
    ----------

    -- | Any inline element
    inline :: PandocMonad m => ParserT Text ParserState m Inlines
    inline :: ParserT Text ParserState m Inlines
    inline = [ParserT Text ParserState m Inlines]
    -> ParserT Text ParserState m Inlines
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    [ParsecT s u m a] -> ParsecT s u m a
    choice [ParserT Text ParserState m Inlines]
    forall (m :: * -> *).
    PandocMonad m =>
    [ParserT Text ParserState m Inlines]
    inlineParsers ParserT Text ParserState m Inlines
    -> [Char] -> ParserT Text ParserState m Inlines
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> [Char] -> ParsecT s u m a
    <?> "inline"

    -- | Inline parsers tried in order
    inlineParsers :: PandocMonad m => [ParserT Text ParserState m Inlines]
    inlineParsers :: [ParserT Text ParserState m Inlines]
    inlineParsers = [ ParserT Text ParserState m Inlines
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Inlines
    str
                    , ParserT Text ParserState m Inlines
    forall (m :: * -> *) st. PandocMonad m => ParserT Text st m Inlines
    whitespace
                    , ParserT Text ParserState m Inlines
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Inlines
    endline
                    , ParserT Text ParserState m Inlines
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Inlines
    code
                    , ParserT Text ParserState m Inlines
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Inlines
    escapedInline
                    , ParserT Text ParserState m Inlines
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Inlines
    inlineMarkup
                    , ParserT Text ParserState m Inlines
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Inlines
    groupedInlineMarkup
                    , ParserT Text ParserState m Inlines
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Inlines
    rawHtmlInline
                    , ParserT Text ParserState m Inlines
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Inlines
    rawLaTeXInline'
                    , ParserT Text ParserState m Inlines
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Inlines
    note
                    , ParserT Text ParserState m Inlines
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Inlines
    link
                    , ParserT Text ParserState m Inlines
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Inlines
    image
                    , ParserT Text ParserState m Inlines
    forall (m :: * -> *) st. PandocMonad m => ParserT Text st m Inlines
    mark
                    , (Text -> Inlines
    B.str (Text -> Inlines) -> (Char -> Text) -> Char -> Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Char -> Text
    T.singleton) (Char -> Inlines)
    -> ParsecT Text ParserState m Char
    -> ParserT Text ParserState m Inlines
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Text ParserState m Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    characterReference
                    , ParserT Text ParserState m Inlines
    -> ParserT Text ParserState m Inlines
    forall st (m :: * -> *) s.
    (HasReaderOptions st, HasLastStrPosition st, HasQuoteContext st m,
     Stream s m Char) =>
    ParserT s st m Inlines -> ParserT s st m Inlines
    smartPunctuation ParserT Text ParserState m Inlines
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Inlines
    inline
                    , ParserT Text ParserState m Inlines
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Inlines
    symbol
                    ]

    -- | Inline markups
    inlineMarkup :: PandocMonad m => ParserT Text ParserState m Inlines
    inlineMarkup :: ParserT Text ParserState m Inlines
    inlineMarkup = [ParserT Text ParserState m Inlines]
    -> ParserT Text ParserState m Inlines
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    [ParsecT s u m a] -> ParsecT s u m a
    choice [ ParserT Text ParserState m [Char]
    -> (Inlines -> Inlines) -> ParserT Text ParserState m Inlines
    forall (m :: * -> *) t.
    PandocMonad m =>
    ParserT Text ParserState m t
    -> (Inlines -> Inlines) -> ParserT Text ParserState m Inlines
    simpleInline ([Char] -> ParserT Text ParserState m [Char]
    forall s (m :: * -> *) u.
    Stream s m Char =>
    [Char] -> ParsecT s u m [Char]
    string "??") ([Citation] -> Inlines -> Inlines
    B.cite [])
                          , ParserT Text ParserState m [Char]
    -> (Inlines -> Inlines) -> ParserT Text ParserState m Inlines
    forall (m :: * -> *) t.
    PandocMonad m =>
    ParserT Text ParserState m t
    -> (Inlines -> Inlines) -> ParserT Text ParserState m Inlines
    simpleInline ([Char] -> ParserT Text ParserState m [Char]
    forall s (m :: * -> *) u.
    Stream s m Char =>
    [Char] -> ParsecT s u m [Char]
    string "**") Inlines -> Inlines
    B.strong
                          , ParserT Text ParserState m [Char]
    -> (Inlines -> Inlines) -> ParserT Text ParserState m Inlines
    forall (m :: * -> *) t.
    PandocMonad m =>
    ParserT Text ParserState m t
    -> (Inlines -> Inlines) -> ParserT Text ParserState m Inlines
    simpleInline ([Char] -> ParserT Text ParserState m [Char]
    forall s (m :: * -> *) u.
    Stream s m Char =>
    [Char] -> ParsecT s u m [Char]
    string "__") Inlines -> Inlines
    B.emph
                          , ParserT Text ParserState m Char
    -> (Inlines -> Inlines) -> ParserT Text ParserState m Inlines
    forall (m :: * -> *) t.
    PandocMonad m =>
    ParserT Text ParserState m t
    -> (Inlines -> Inlines) -> ParserT Text ParserState m Inlines
    simpleInline (Char -> ParserT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '*') Inlines -> Inlines
    B.strong
                          , ParserT Text ParserState m Char
    -> (Inlines -> Inlines) -> ParserT Text ParserState m Inlines
    forall (m :: * -> *) t.
    PandocMonad m =>
    ParserT Text ParserState m t
    -> (Inlines -> Inlines) -> ParserT Text ParserState m Inlines
    simpleInline (Char -> ParserT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '_') Inlines -> Inlines
    B.emph
                          , ParserT Text ParserState m Char
    -> (Inlines -> Inlines) -> ParserT Text ParserState m Inlines
    forall (m :: * -> *) t.
    PandocMonad m =>
    ParserT Text ParserState m t
    -> (Inlines -> Inlines) -> ParserT Text ParserState m Inlines
    simpleInline (Char -> ParserT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '+') Inlines -> Inlines
    underlineSpan
                          , ParserT Text ParserState m Char
    -> (Inlines -> Inlines) -> ParserT Text ParserState m Inlines
    forall (m :: * -> *) t.
    PandocMonad m =>
    ParserT Text ParserState m t
    -> (Inlines -> Inlines) -> ParserT Text ParserState m Inlines
    simpleInline (Char -> ParserT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '-' ParserT Text ParserState m Char
    -> ParsecT Text ParserState m () -> ParserT Text ParserState m Char
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParserT Text ParserState m Char -> ParsecT Text ParserState m ()
    forall s (m :: * -> *) t a u.
    (Stream s m t, Show a) =>
    ParsecT s u m a -> ParsecT s u m ()
    notFollowedBy (Char -> ParserT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '-')) Inlines -> Inlines
    B.strikeout
                          , ParserT Text ParserState m Char
    -> (Inlines -> Inlines) -> ParserT Text ParserState m Inlines
    forall (m :: * -> *) t.
    PandocMonad m =>
    ParserT Text ParserState m t
    -> (Inlines -> Inlines) -> ParserT Text ParserState m Inlines
    simpleInline (Char -> ParserT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '^') Inlines -> Inlines
    B.superscript
                          , ParserT Text ParserState m Char
    -> (Inlines -> Inlines) -> ParserT Text ParserState m Inlines
    forall (m :: * -> *) t.
    PandocMonad m =>
    ParserT Text ParserState m t
    -> (Inlines -> Inlines) -> ParserT Text ParserState m Inlines
    simpleInline (Char -> ParserT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '~') Inlines -> Inlines
    B.subscript
                          , ParserT Text ParserState m Char
    -> (Inlines -> Inlines) -> ParserT Text ParserState m Inlines
    forall (m :: * -> *) t.
    PandocMonad m =>
    ParserT Text ParserState m t
    -> (Inlines -> Inlines) -> ParserT Text ParserState m Inlines
    simpleInline (Char -> ParserT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '%') Inlines -> Inlines
    forall a. a -> a
    id
                          ]

    -- | Trademark, registered, copyright
    mark :: PandocMonad m => ParserT Text st m Inlines
    mark :: ParserT Text st m Inlines
    mark = ParserT Text st m Inlines -> ParserT Text st m Inlines
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text st m Inlines -> ParserT Text st m Inlines)
    -> ParserT Text st m Inlines -> ParserT Text st m Inlines
    forall a b. (a -> b) -> a -> b
    $ Char -> ParsecT Text st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '(' ParsecT Text st m Char
    -> ParserT Text st m Inlines -> ParserT Text st m Inlines
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> (ParserT Text st m Inlines -> ParserT Text st m Inlines
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try ParserT Text st m Inlines
    forall (m :: * -> *) st. PandocMonad m => ParserT Text st m Inlines
    tm ParserT Text st m Inlines
    -> ParserT Text st m Inlines -> ParserT Text st m Inlines
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParserT Text st m Inlines -> ParserT Text st m Inlines
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try ParserT Text st m Inlines
    forall (m :: * -> *) st. PandocMonad m => ParserT Text st m Inlines
    reg ParserT Text st m Inlines
    -> ParserT Text st m Inlines -> ParserT Text st m Inlines
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParserT Text st m Inlines
    forall (m :: * -> *) st. PandocMonad m => ParserT Text st m Inlines
    copy)

    reg :: PandocMonad m => ParserT Text st m Inlines
    reg :: ParserT Text st m Inlines
    reg = do
      [Char] -> ParsecT Text st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    [Char] -> ParsecT s u m Char
    oneOf "Rr"
      Char -> ParsecT Text st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char ')'
      Inlines -> ParserT Text st m Inlines
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Inlines -> ParserT Text st m Inlines)
    -> Inlines -> ParserT Text st m Inlines
    forall a b. (a -> b) -> a -> b
    $ Text -> Inlines
    B.str "\174"

    tm :: PandocMonad m => ParserT Text st m Inlines
    tm :: ParserT Text st m Inlines
    tm = do
      [Char] -> ParsecT Text st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    [Char] -> ParsecT s u m Char
    oneOf "Tt"
      [Char] -> ParsecT Text st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    [Char] -> ParsecT s u m Char
    oneOf "Mm"
      Char -> ParsecT Text st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char ')'
      Inlines -> ParserT Text st m Inlines
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Inlines -> ParserT Text st m Inlines)
    -> Inlines -> ParserT Text st m Inlines
    forall a b. (a -> b) -> a -> b
    $ Text -> Inlines
    B.str "\8482"

    copy :: PandocMonad m => ParserT Text st m Inlines
    copy :: ParserT Text st m Inlines
    copy = do
      [Char] -> ParsecT Text st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    [Char] -> ParsecT s u m Char
    oneOf "Cc"
      Char -> ParsecT Text st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char ')'
      Inlines -> ParserT Text st m Inlines
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Inlines -> ParserT Text st m Inlines)
    -> Inlines -> ParserT Text st m Inlines
    forall a b. (a -> b) -> a -> b
    $ Text -> Inlines
    B.str "\169"

    note :: PandocMonad m => ParserT Text ParserState m Inlines
    note :: ParserT Text ParserState m Inlines
    note = ParserT Text ParserState m Inlines
    -> ParserT Text ParserState m Inlines
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text ParserState m Inlines
     -> ParserT Text ParserState m Inlines)
    -> ParserT Text ParserState m Inlines
    -> ParserT Text ParserState m Inlines
    forall a b. (a -> b) -> a -> b
    $ do
      [Char]
    ref <- Char -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '[' ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m [Char]
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m [Char]
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m [a]
    many1 ParsecT Text ParserState m Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    digit ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m [Char]
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* Char -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char ']'
      NoteTable
    notes <- ParserState -> NoteTable
    stateNotes (ParserState -> NoteTable)
    -> ParsecT Text ParserState m ParserState
    -> ParsecT Text ParserState m NoteTable
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Text ParserState m ParserState
    forall (m :: * -> *) s u. Monad m => ParsecT s u m u
    getState
      case Text -> NoteTable -> Maybe Text
    forall a b. Eq a => a -> [(a, b)] -> Maybe b
    lookup ([Char] -> Text
    T.pack [Char]
    ref) NoteTable
    notes of
        Nothing  -> [Char] -> ParserT Text ParserState m Inlines
    forall (m :: * -> *) a. MonadFail m => [Char] -> m a
    Prelude.fail "note not found"
        Just raw :: Text
    raw -> Many Block -> Inlines
    B.note (Many Block -> Inlines)
    -> ParsecT Text ParserState m (Many Block)
    -> ParserT Text ParserState m Inlines
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Text ParserState m (Many Block)
    -> Text -> ParsecT Text ParserState m (Many Block)
    forall s (m :: * -> *) u a.
    (Stream s m Char, IsString s, HasLastStrPosition u) =>
    ParserT s u m a -> Text -> ParserT s u m a
    parseFromString' ParsecT Text ParserState m (Many Block)
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m (Many Block)
    parseBlocks Text
    raw

    -- | Special chars
    markupChars :: [Char]
    markupChars :: [Char]
    markupChars = "\\*#_@~-+^|%=[]&"

    -- | Break strings on following chars. Space tab and newline break for
    --  inlines breaking. Open paren breaks for mark. Quote, dash and dot
    --  break for smart punctuation. Punctuation breaks for regular
    --  punctuation. Double quote breaks for named links. > and < break
    --  for inline html.
    stringBreakers :: [Char]
    stringBreakers :: [Char]
    stringBreakers = " \t\n\r.,\"'?!;:<>«»„“”‚‘’()[]"

    wordBoundaries :: [Char]
    wordBoundaries :: [Char]
    wordBoundaries = [Char]
    markupChars [Char] -> [Char] -> [Char]
    forall a. Semigroup a => a -> a -> a
    <> [Char]
    stringBreakers

    -- | Parse a hyphened sequence of words
    hyphenedWords :: PandocMonad m => ParserT Text ParserState m Text
    hyphenedWords :: ParserT Text ParserState m Text
    hyphenedWords = do
      Text
    x <- ParserT Text ParserState m Text
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Text
    wordChunk
      [Text]
    xs <-  ParserT Text ParserState m Text
    -> ParsecT Text ParserState m [Text]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many (ParserT Text ParserState m Text -> ParserT Text ParserState m Text
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text ParserState m Text
     -> ParserT Text ParserState m Text)
    -> ParserT Text ParserState m Text
    -> ParserT Text ParserState m Text
    forall a b. (a -> b) -> a -> b
    $ Char -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '-' ParsecT Text ParserState m Char
    -> ParserT Text ParserState m Text
    -> ParserT Text ParserState m Text
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> ParserT Text ParserState m Text
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Text
    wordChunk)
      Text -> ParserT Text ParserState m Text
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Text -> ParserT Text ParserState m Text)
    -> Text -> ParserT Text ParserState m Text
    forall a b. (a -> b) -> a -> b
    $ Text -> [Text] -> Text
    T.intercalate "-" (Text
    xText -> [Text] -> [Text]
    forall a. a -> [a] -> [a]
    :[Text]
    xs)

    wordChunk :: PandocMonad m => ParserT Text ParserState m Text
    wordChunk :: ParserT Text ParserState m Text
    wordChunk = ParserT Text ParserState m Text -> ParserT Text ParserState m Text
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text ParserState m Text
     -> ParserT Text ParserState m Text)
    -> ParserT Text ParserState m Text
    -> ParserT Text ParserState m Text
    forall a b. (a -> b) -> a -> b
    $ do
      Char
    hd <- [Char] -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    [Char] -> ParsecT s u m Char
    noneOf [Char]
    wordBoundaries
      [Char]
    tl <- ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m [Char]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many ( [Char] -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    [Char] -> ParsecT s u m Char
    noneOf [Char]
    wordBoundaries ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m Char
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|>
                   ParsecT Text ParserState m Char -> ParsecT Text ParserState m Char
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text ParserState m Inlines -> ParserT Text ParserState m ()
    forall b s (m :: * -> *) a st.
    (Show b, Stream s m a) =>
    ParserT s st m b -> ParserT s st m ()
    notFollowedBy' ParserT Text ParserState m Inlines
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Inlines
    note ParserT Text ParserState m ()
    -> ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m Char
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> [Char] -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    [Char] -> ParsecT s u m Char
    oneOf [Char]
    markupChars
                         ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m Char
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT Text ParserState m Char -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m a
    lookAhead ([Char] -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    [Char] -> ParsecT s u m Char
    noneOf [Char]
    wordBoundaries) ) )
      Text -> ParserT Text ParserState m Text
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Text -> ParserT Text ParserState m Text)
    -> Text -> ParserT Text ParserState m Text
    forall a b. (a -> b) -> a -> b
    $ [Char] -> Text
    T.pack ([Char] -> Text) -> [Char] -> Text
    forall a b. (a -> b) -> a -> b
    $ Char
    hdChar -> [Char] -> [Char]
    forall a. a -> [a] -> [a]
    :[Char]
    tl

    -- | Any string
    str :: PandocMonad m => ParserT Text ParserState m Inlines
    str :: ParserT Text ParserState m Inlines
    str = do
      Text
    baseStr <- ParserT Text ParserState m Text
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Text
    hyphenedWords
      -- RedCloth compliance : if parsed word is uppercase and immediately
      -- followed by parens, parens content is unconditionally word acronym
      Text
    fullStr <- Text
    -> ParserT Text ParserState m Text
    -> ParserT Text ParserState m Text
    forall s (m :: * -> *) t a u.
    Stream s m t =>
    a -> ParsecT s u m a -> ParsecT s u m a
    option Text
    baseStr (ParserT Text ParserState m Text
     -> ParserT Text ParserState m Text)
    -> ParserT Text ParserState m Text
    -> ParserT Text ParserState m Text
    forall a b. (a -> b) -> a -> b
    $ ParserT Text ParserState m Text -> ParserT Text ParserState m Text
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text ParserState m Text
     -> ParserT Text ParserState m Text)
    -> ParserT Text ParserState m Text
    -> ParserT Text ParserState m Text
    forall a b. (a -> b) -> a -> b
    $ do
        Bool -> ParsecT Text ParserState m ()
    forall (f :: * -> *). Alternative f => Bool -> f ()
    guard (Bool -> ParsecT Text ParserState m ())
    -> Bool -> ParsecT Text ParserState m ()
    forall a b. (a -> b) -> a -> b
    $ (Char -> Bool) -> Text -> Bool
    T.all Char -> Bool
    isUpper Text
    baseStr
        Text
    acro <- [Char] -> Text
    T.pack ([Char] -> Text)
    -> ParsecT Text ParserState m [Char]
    -> ParserT Text ParserState m Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParserT Text ParserState m Char
    -> ParserT Text ParserState m Char
    -> ParserT Text ParserState m Char
    -> ParsecT Text ParserState m [Char]
    forall end s (m :: * -> *) st t a.
    (Show end, Stream s m Char) =>
    ParserT s st m t
    -> ParserT s st m end -> ParserT s st m a -> ParserT s st m [a]
    enclosed (Char -> ParserT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '(') (Char -> ParserT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char ')') ParserT Text ParserState m Char
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Char
    anyChar'
        Text -> ParserT Text ParserState m Text
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Text -> ParserT Text ParserState m Text)
    -> Text -> ParserT Text ParserState m Text
    forall a b. (a -> b) -> a -> b
    $ [Text] -> Text
    T.concat [Text
    baseStr, " (", Text
    acro, ")"]
      ParsecT Text ParserState m ()
    forall s (m :: * -> *) a st.
    (Stream s m a, HasLastStrPosition st) =>
    ParserT s st m ()
    updateLastStrPos
      Inlines -> ParserT Text ParserState m Inlines
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Inlines -> ParserT Text ParserState m Inlines)
    -> Inlines -> ParserT Text ParserState m Inlines
    forall a b. (a -> b) -> a -> b
    $ Text -> Inlines
    B.str Text
    fullStr

    -- | Some number of space chars
    whitespace :: PandocMonad m => ParserT Text st m Inlines
    whitespace :: ParserT Text st m Inlines
    whitespace = ParsecT Text st m Char -> ParsecT Text st m [Char]
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m [a]
    many1 ParsecT Text st m Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    spaceChar ParsecT Text st m [Char]
    -> ParserT Text st m Inlines -> ParserT Text st m Inlines
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> Inlines -> ParserT Text st m Inlines
    forall (m :: * -> *) a. Monad m => a -> m a
    return Inlines
    B.space ParserT Text st m Inlines -> [Char] -> ParserT Text st m Inlines
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> [Char] -> ParsecT s u m a
    <?> "whitespace"

    -- | In Textile, an isolated endline character is a line break
    endline :: PandocMonad m => ParserT Text ParserState m Inlines
    endline :: ParserT Text ParserState m Inlines
    endline = ParserT Text ParserState m Inlines
    -> ParserT Text ParserState m Inlines
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text ParserState m Inlines
     -> ParserT Text ParserState m Inlines)
    -> ParserT Text ParserState m Inlines
    -> ParserT Text ParserState m Inlines
    forall a b. (a -> b) -> a -> b
    $ do
      ParsecT Text ParserState m Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    newline
      ParsecT Text ParserState m Char -> ParsecT Text ParserState m ()
    forall s (m :: * -> *) t a u.
    (Stream s m t, Show a) =>
    ParsecT s u m a -> ParsecT s u m ()
    notFollowedBy ParsecT Text ParserState m Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    blankline
      ParsecT Text ParserState m () -> ParsecT Text ParserState m ()
    forall s (m :: * -> *) t a u.
    (Stream s m t, Show a) =>
    ParsecT s u m a -> ParsecT s u m ()
    notFollowedBy ParsecT Text ParserState m ()
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m ()
    listStart
      ParsecT Text ParserState m (Many Block)
    -> ParsecT Text ParserState m ()
    forall s (m :: * -> *) t a u.
    (Stream s m t, Show a) =>
    ParsecT s u m a -> ParsecT s u m ()
    notFollowedBy ParsecT Text ParserState m (Many Block)
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m (Many Block)
    rawHtmlBlock
      Inlines -> ParserT Text ParserState m Inlines
    forall (m :: * -> *) a. Monad m => a -> m a
    return Inlines
    B.linebreak

    rawHtmlInline :: PandocMonad m => ParserT Text ParserState m Inlines
    rawHtmlInline :: ParserT Text ParserState m Inlines
    rawHtmlInline = Text -> Text -> Inlines
    B.rawInline "html" (Text -> Inlines)
    -> ((Tag Text, Text) -> Text) -> (Tag Text, Text) -> Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Tag Text, Text) -> Text
    forall a b. (a, b) -> b
    snd ((Tag Text, Text) -> Inlines)
    -> ParsecT Text ParserState m (Tag Text, Text)
    -> ParserT Text ParserState m Inlines
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Tag Text -> Bool) -> ParsecT Text ParserState m (Tag Text, Text)
    forall st (m :: * -> *).
    (HasReaderOptions st, Monad m) =>
    (Tag Text -> Bool) -> ParserT Text st m (Tag Text, Text)
    htmlTag Tag Text -> Bool
    forall a. NamedTag (Tag a) => Tag a -> Bool
    isInlineTag

    -- | Raw LaTeX Inline
    rawLaTeXInline' :: PandocMonad m => ParserT Text ParserState m Inlines
    rawLaTeXInline' :: ParserT Text ParserState m Inlines
    rawLaTeXInline' = ParserT Text ParserState m Inlines
    -> ParserT Text ParserState m Inlines
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text ParserState m Inlines
     -> ParserT Text ParserState m Inlines)
    -> ParserT Text ParserState m Inlines
    -> ParserT Text ParserState m Inlines
    forall a b. (a -> b) -> a -> b
    $ do
      Extension -> ParserT Text ParserState m ()
    forall s (m :: * -> *) a st.
    (Stream s m a, HasReaderOptions st) =>
    Extension -> ParserT s st m ()
    guardEnabled Extension
    Ext_raw_tex
      Text -> Text -> Inlines
    B.rawInline "latex" (Text -> Inlines)
    -> ParsecT Text ParserState m Text
    -> ParserT Text ParserState m Inlines
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Text ParserState m Text
    forall (m :: * -> *) s.
    (PandocMonad m, HasMacros s, HasReaderOptions s) =>
    ParserT Text s m Text
    rawLaTeXInline

    -- | Textile standard link syntax is "label":target. But we
    -- can also have ["label":target].
    link :: PandocMonad m => ParserT Text ParserState m Inlines
    link :: ParserT Text ParserState m Inlines
    link = ParserT Text ParserState m Inlines
    -> ParserT Text ParserState m Inlines
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text ParserState m Inlines
     -> ParserT Text ParserState m Inlines)
    -> ParserT Text ParserState m Inlines
    -> ParserT Text ParserState m Inlines
    forall a b. (a -> b) -> a -> b
    $ do
      Bool
    bracketed <- (Bool
    True Bool
    -> ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m Bool
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ Char -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '[') ParsecT Text ParserState m Bool
    -> ParsecT Text ParserState m Bool
    -> ParsecT Text ParserState m Bool
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> Bool -> ParsecT Text ParserState m Bool
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    False
      Char -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '"' ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m () -> ParsecT Text ParserState m ()
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> ParsecT Text ParserState m Char -> ParsecT Text ParserState m ()
    forall s (m :: * -> *) t a u.
    (Stream s m t, Show a) =>
    ParsecT s u m a -> ParsecT s u m ()
    notFollowedBy ([Char] -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    [Char] -> ParsecT s u m Char
    oneOf " \t\n\r")
      Attr
    attr <- ParserT Text ParserState m Attr
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Attr
    attributes
      Inlines
    name <- Inlines -> Inlines
    trimInlines (Inlines -> Inlines)
    -> ([Inlines] -> Inlines) -> [Inlines] -> Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [Inlines] -> Inlines
    forall a. Monoid a => [a] -> a
    mconcat ([Inlines] -> Inlines)
    -> ParsecT Text ParserState m [Inlines]
    -> ParserT Text ParserState m Inlines
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$>
              QuoteContext
    -> ParsecT Text ParserState m [Inlines]
    -> ParsecT Text ParserState m [Inlines]
    forall st (m :: * -> *) s a.
    HasQuoteContext st m =>
    QuoteContext -> ParsecT s st m a -> ParsecT s st m a
    withQuoteContext QuoteContext
    InDoubleQuote (ParserT Text ParserState m Inlines
    -> ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m [Inlines]
    forall end s (m :: * -> *) t st a.
    (Show end, Stream s m t) =>
    ParserT s st m a -> ParserT s st m end -> ParserT s st m [a]
    many1Till ParserT Text ParserState m Inlines
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Inlines
    inline (Char -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '"'))
      Char -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char ':'
      let stop :: ParsecT Text u m Char
    stop = if Bool
    bracketed
                    then Char -> ParsecT Text u m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char ']'
                    else ParsecT Text u m Char -> ParsecT Text u m Char
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m a
    lookAhead (ParsecT Text u m Char -> ParsecT Text u m Char)
    -> ParsecT Text u m Char -> ParsecT Text u m Char
    forall a b. (a -> b) -> a -> b
    $ ParsecT Text u m Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    space ParsecT Text u m Char
    -> ParsecT Text u m Char -> ParsecT Text u m Char
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Text u m Char
    forall (m :: * -> *) s. Monad m => ParserT Text s m Char
    eof' ParsecT Text u m Char
    -> ParsecT Text u m Char -> ParsecT Text u m Char
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|>
                           ParsecT Text u m Char -> ParsecT Text u m Char
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try ([Char] -> ParsecT Text u m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    [Char] -> ParsecT s u m Char
    oneOf "!.,;:" ParsecT Text u m Char
    -> ParsecT Text u m Char -> ParsecT Text u m Char
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *>
                                  (ParsecT Text u m Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    space ParsecT Text u m Char
    -> ParsecT Text u m Char -> ParsecT Text u m Char
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Text u m Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    newline ParsecT Text u m Char
    -> ParsecT Text u m Char -> ParsecT Text u m Char
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Text u m Char
    forall (m :: * -> *) s. Monad m => ParserT Text s m Char
    eof'))
      Text
    url <- [Char] -> Text
    T.pack ([Char] -> Text)
    -> ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m [Char]
    forall end s (m :: * -> *) t st a.
    (Show end, Stream s m t) =>
    ParserT s st m a -> ParserT s st m end -> ParserT s st m [a]
    many1Till ParsecT Text ParserState m Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    nonspaceChar ParsecT Text ParserState m Char
    forall u. ParsecT Text u m Char
    stop
      let name' :: Inlines
    name' = if Inlines -> [Inline]
    forall a. Many a -> [a]
    B.toList Inlines
    name [Inline] -> [Inline] -> Bool
    forall a. Eq a => a -> a -> Bool
    == [Text -> Inline
    Str "$"] then Text -> Inlines
    B.str Text
    url else Inlines
    name
      Inlines -> ParserT Text ParserState m Inlines
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Inlines -> ParserT Text ParserState m Inlines)
    -> Inlines -> ParserT Text ParserState m Inlines
    forall a b. (a -> b) -> a -> b
    $ if Attr
    attr Attr -> Attr -> Bool
    forall a. Eq a => a -> a -> Bool
    == Attr
    nullAttr
                  then Text -> Text -> Inlines -> Inlines
    B.link Text
    url "" Inlines
    name'
                  else Attr -> Inlines -> Inlines
    B.spanWith Attr
    attr (Inlines -> Inlines) -> Inlines -> Inlines
    forall a b. (a -> b) -> a -> b
    $ Text -> Text -> Inlines -> Inlines
    B.link Text
    url "" Inlines
    name'

    -- | image embedding
    image :: PandocMonad m => ParserT Text ParserState m Inlines
    image :: ParserT Text ParserState m Inlines
    image = ParserT Text ParserState m Inlines
    -> ParserT Text ParserState m Inlines
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text ParserState m Inlines
     -> ParserT Text ParserState m Inlines)
    -> ParserT Text ParserState m Inlines
    -> ParserT Text ParserState m Inlines
    forall a b. (a -> b) -> a -> b
    $ do
      Char -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '!' ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m () -> ParsecT Text ParserState m ()
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> ParsecT Text ParserState m Char -> ParsecT Text ParserState m ()
    forall s (m :: * -> *) t a u.
    (Stream s m t, Show a) =>
    ParsecT s u m a -> ParsecT s u m ()
    notFollowedBy ParsecT Text ParserState m Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    space
      (ident :: Text
    ident, cls :: [Text]
    cls, kvs :: NoteTable
    kvs) <- ParserT Text ParserState m Attr
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Attr
    attributes
      let attr :: Attr
    attr = case Text -> NoteTable -> Maybe Text
    forall a b. Eq a => a -> [(a, b)] -> Maybe b
    lookup "style" NoteTable
    kvs of
                   Just stls :: Text
    stls -> (Text
    ident, [Text]
    cls, [Text] -> Text -> NoteTable
    pickStylesToKVs ["width", "height"] Text
    stls)
                   Nothing   -> (Text
    ident, [Text]
    cls, NoteTable
    kvs)
      Text
    src <- [Char] -> Text
    T.pack ([Char] -> Text)
    -> ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m [Char]
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m [a]
    many1 ([Char] -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    [Char] -> ParsecT s u m Char
    noneOf " \t\n\r!(")
      Text
    alt <- ([Char] -> Text)
    -> ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap [Char] -> Text
    T.pack (ParsecT Text ParserState m [Char]
     -> ParsecT Text ParserState m Text)
    -> ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m Text
    forall a b. (a -> b) -> a -> b
    $ [Char]
    -> ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m [Char]
    forall s (m :: * -> *) t a u.
    Stream s m t =>
    a -> ParsecT s u m a -> ParsecT s u m a
    option "" (ParsecT Text ParserState m [Char]
     -> ParsecT Text ParserState m [Char])
    -> ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m [Char]
    forall a b. (a -> b) -> a -> b
    $ ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m [Char]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Text ParserState m [Char]
     -> ParsecT Text ParserState m [Char])
    -> ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m [Char]
    forall a b. (a -> b) -> a -> b
    $ Char -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '(' ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m [Char]
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m [Char]
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    manyTill ParsecT Text ParserState m Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    anyChar (Char -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char ')')
      Char -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '!'
      Inlines -> ParserT Text ParserState m Inlines
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Inlines -> ParserT Text ParserState m Inlines)
    -> Inlines -> ParserT Text ParserState m Inlines
    forall a b. (a -> b) -> a -> b
    $ Attr -> Text -> Text -> Inlines -> Inlines
    B.imageWith Attr
    attr Text
    src Text
    alt (Text -> Inlines
    B.str Text
    alt)

    escapedInline :: PandocMonad m => ParserT Text ParserState m Inlines
    escapedInline :: ParserT Text ParserState m Inlines
    escapedInline = ParserT Text ParserState m Inlines
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Inlines
    escapedEqs ParserT Text ParserState m Inlines
    -> ParserT Text ParserState m Inlines
    -> ParserT Text ParserState m Inlines
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParserT Text ParserState m Inlines
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Inlines
    escapedTag

    escapedEqs :: PandocMonad m => ParserT Text ParserState m Inlines
    escapedEqs :: ParserT Text ParserState m Inlines
    escapedEqs = Text -> Inlines
    B.str (Text -> Inlines) -> ([Char] -> Text) -> [Char] -> Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [Char] -> Text
    T.pack ([Char] -> Inlines)
    -> ParsecT Text ParserState m [Char]
    -> ParserT Text ParserState m Inlines
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$>
      ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m [Char]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try ([Char] -> ParsecT Text ParserState m [Char]
    forall s (m :: * -> *) u.
    Stream s m Char =>
    [Char] -> ParsecT s u m [Char]
    string "==" ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m [Char]
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m [Char]
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    manyTill ParsecT Text ParserState m Char
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Char
    anyChar' (ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m [Char]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Text ParserState m [Char]
     -> ParsecT Text ParserState m [Char])
    -> ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m [Char]
    forall a b. (a -> b) -> a -> b
    $ [Char] -> ParsecT Text ParserState m [Char]
    forall s (m :: * -> *) u.
    Stream s m Char =>
    [Char] -> ParsecT s u m [Char]
    string "=="))

    -- | literal text escaped btw <notextile> tags
    escapedTag :: PandocMonad m => ParserT Text ParserState m Inlines
    escapedTag :: ParserT Text ParserState m Inlines
    escapedTag = Text -> Inlines
    B.str (Text -> Inlines) -> ([Char] -> Text) -> [Char] -> Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [Char] -> Text
    T.pack ([Char] -> Inlines)
    -> ParsecT Text ParserState m [Char]
    -> ParserT Text ParserState m Inlines
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$>
      ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m [Char]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try ([Char] -> ParsecT Text ParserState m [Char]
    forall s (m :: * -> *) u.
    Stream s m Char =>
    [Char] -> ParsecT s u m [Char]
    string "<notextile>" ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m [Char]
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *>
             ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m [Char]
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    manyTill ParsecT Text ParserState m Char
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Char
    anyChar' (ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m [Char]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Text ParserState m [Char]
     -> ParsecT Text ParserState m [Char])
    -> ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m [Char]
    forall a b. (a -> b) -> a -> b
    $ [Char] -> ParsecT Text ParserState m [Char]
    forall s (m :: * -> *) u.
    Stream s m Char =>
    [Char] -> ParsecT s u m [Char]
    string "</notextile>"))

    -- | Any special symbol defined in wordBoundaries
    symbol :: PandocMonad m => ParserT Text ParserState m Inlines
    symbol :: ParserT Text ParserState m Inlines
    symbol = Text -> Inlines
    B.str (Text -> Inlines) -> (Char -> Text) -> Char -> Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Char -> Text
    T.singleton (Char -> Inlines)
    -> ParsecT Text ParserState m Char
    -> ParserT Text ParserState m Inlines
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (ParsecT Text ParserState m Char -> ParsecT Text ParserState m ()
    forall s (m :: * -> *) t a u.
    (Stream s m t, Show a) =>
    ParsecT s u m a -> ParsecT s u m ()
    notFollowedBy ParsecT Text ParserState m Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    newline ParsecT Text ParserState m ()
    -> ParsecT Text ParserState m () -> ParsecT Text ParserState m ()
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *>
                                      ParsecT Text ParserState m (Many Block)
    -> ParsecT Text ParserState m ()
    forall s (m :: * -> *) t a u.
    (Stream s m t, Show a) =>
    ParsecT s u m a -> ParsecT s u m ()
    notFollowedBy ParsecT Text ParserState m (Many Block)
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m (Many Block)
    rawHtmlBlock ParsecT Text ParserState m ()
    -> ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m Char
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *>
                                      [Char] -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    [Char] -> ParsecT s u m Char
    oneOf [Char]
    wordBoundaries)

    -- | Inline code
    code :: PandocMonad m => ParserT Text ParserState m Inlines
    code :: ParserT Text ParserState m Inlines
    code = ParserT Text ParserState m Inlines
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Inlines
    code1 ParserT Text ParserState m Inlines
    -> ParserT Text ParserState m Inlines
    -> ParserT Text ParserState m Inlines
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParserT Text ParserState m Inlines
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Inlines
    code2

    -- any character except a newline before a blank line
    anyChar' :: PandocMonad m => ParserT Text ParserState m Char
    anyChar' :: ParserT Text ParserState m Char
    anyChar' =
      (Char -> Bool) -> ParserT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    (Char -> Bool) -> ParsecT s u m Char
    satisfy (Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    /='\n') ParserT Text ParserState m Char
    -> ParserT Text ParserState m Char
    -> ParserT Text ParserState m Char
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|>
      ParserT Text ParserState m Char -> ParserT Text ParserState m Char
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (Char -> ParserT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '\n' ParserT Text ParserState m Char
    -> ParsecT Text ParserState m () -> ParserT Text ParserState m Char
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParserT Text ParserState m Char -> ParsecT Text ParserState m ()
    forall s (m :: * -> *) t a u.
    (Stream s m t, Show a) =>
    ParsecT s u m a -> ParsecT s u m ()
    notFollowedBy ParserT Text ParserState m Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    blankline)

    code1 :: PandocMonad m => ParserT Text ParserState m Inlines
    code1 :: ParserT Text ParserState m Inlines
    code1 = Text -> Inlines
    B.code (Text -> Inlines) -> ([Char] -> Text) -> [Char] -> Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [Char] -> Text
    T.pack ([Char] -> Inlines)
    -> ParsecT Text ParserState m [Char]
    -> ParserT Text ParserState m Inlines
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParserT Text ParserState m Char
    -> ParserT Text ParserState m Char
    -> ParsecT Text ParserState m [Char]
    forall (m :: * -> *) t st a.
    (PandocMonad m, Show t) =>
    ParserT Text st m t -> ParserT Text st m a -> ParserT Text st m [a]
    surrounded (Char -> ParserT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '@') ParserT Text ParserState m Char
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Char
    anyChar'

    code2 :: PandocMonad m => ParserT Text ParserState m Inlines
    code2 :: ParserT Text ParserState m Inlines
    code2 = do
      (Tag Text -> Bool) -> ParserT Text ParserState m (Tag Text, Text)
    forall st (m :: * -> *).
    (HasReaderOptions st, Monad m) =>
    (Tag Text -> Bool) -> ParserT Text st m (Tag Text, Text)
    htmlTag ((Text -> Bool) -> (NoteTable -> Bool) -> Tag Text -> Bool
    forall str.
    (str -> Bool) -> ([Attribute str] -> Bool) -> Tag str -> Bool
    tagOpen (Text -> Text -> Bool
    forall a. Eq a => a -> a -> Bool
    =="tt") NoteTable -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null)
      Text -> Inlines
    B.code (Text -> Inlines) -> ([Char] -> Text) -> [Char] -> Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [Char] -> Text
    T.pack ([Char] -> Inlines)
    -> ParsecT Text ParserState m [Char]
    -> ParserT Text ParserState m Inlines
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Text ParserState m Char
    -> ParserT Text ParserState m (Tag Text, Text)
    -> ParsecT Text ParserState m [Char]
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    manyTill ParsecT Text ParserState m Char
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Char
    anyChar' (ParserT Text ParserState m (Tag Text, Text)
    -> ParserT Text ParserState m (Tag Text, Text)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text ParserState m (Tag Text, Text)
     -> ParserT Text ParserState m (Tag Text, Text))
    -> ParserT Text ParserState m (Tag Text, Text)
    -> ParserT Text ParserState m (Tag Text, Text)
    forall a b. (a -> b) -> a -> b
    $ (Tag Text -> Bool) -> ParserT Text ParserState m (Tag Text, Text)
    forall st (m :: * -> *).
    (HasReaderOptions st, Monad m) =>
    (Tag Text -> Bool) -> ParserT Text st m (Tag Text, Text)
    htmlTag ((Tag Text -> Bool) -> ParserT Text ParserState m (Tag Text, Text))
    -> (Tag Text -> Bool)
    -> ParserT Text ParserState m (Tag Text, Text)
    forall a b. (a -> b) -> a -> b
    $ (Text -> Bool) -> Tag Text -> Bool
    forall str. (str -> Bool) -> Tag str -> Bool
    tagClose (Text -> Text -> Bool
    forall a. Eq a => a -> a -> Bool
    =="tt"))

    -- | Html / CSS attributes
    attributes :: PandocMonad m => ParserT Text ParserState m Attr
    attributes :: ParserT Text ParserState m Attr
    attributes = (Attr -> (Attr -> Attr) -> Attr) -> Attr -> [Attr -> Attr] -> Attr
    forall (t :: * -> *) b a.
    Foldable t =>
    (b -> a -> b) -> b -> t a -> b
    foldl (((Attr -> Attr) -> Attr -> Attr) -> Attr -> (Attr -> Attr) -> Attr
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip (Attr -> Attr) -> Attr -> Attr
    forall a b. (a -> b) -> a -> b
    ($)) ("",[],[]) ([Attr -> Attr] -> Attr)
    -> ParsecT Text ParserState m [Attr -> Attr]
    -> ParserT Text ParserState m Attr
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$>
      ParsecT Text ParserState m [Attr -> Attr]
    -> ParsecT Text ParserState m [Attr -> Attr]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (do Attr -> Attr
    special <- (Attr -> Attr)
    -> ParsecT Text ParserState m (Attr -> Attr)
    -> ParsecT Text ParserState m (Attr -> Attr)
    forall s (m :: * -> *) t a u.
    Stream s m t =>
    a -> ParsecT s u m a -> ParsecT s u m a
    option Attr -> Attr
    forall a. a -> a
    id ParsecT Text ParserState m (Attr -> Attr)
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m (Attr -> Attr)
    specialAttribute
              [Attr -> Attr]
    attrs <- ParsecT Text ParserState m (Attr -> Attr)
    -> ParsecT Text ParserState m [Attr -> Attr]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many ParsecT Text ParserState m (Attr -> Attr)
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m (Attr -> Attr)
    attribute
              [Attr -> Attr] -> ParsecT Text ParserState m [Attr -> Attr]
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Attr -> Attr
    special (Attr -> Attr) -> [Attr -> Attr] -> [Attr -> Attr]
    forall a. a -> [a] -> [a]
    : [Attr -> Attr]
    attrs))

    specialAttribute :: PandocMonad m => ParserT Text ParserState m (Attr -> Attr)
    specialAttribute :: ParserT Text ParserState m (Attr -> Attr)
    specialAttribute = do
      [Char]
    alignStr <- ("center" [Char]
    -> ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m [Char]
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ Char -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '=') ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m [Char]
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|>
        ("justify" [Char]
    -> ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m [Char]
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m [Char]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try ([Char] -> ParsecT Text ParserState m [Char]
    forall s (m :: * -> *) u.
    Stream s m Char =>
    [Char] -> ParsecT s u m [Char]
    string "<>")) ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m [Char]
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|>
        ("right" [Char]
    -> ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m [Char]
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ Char -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '>') ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m [Char]
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|>
        ("left" [Char]
    -> ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m [Char]
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ Char -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '<')
      ParsecT Text ParserState m Char -> ParsecT Text ParserState m ()
    forall s (m :: * -> *) t a u.
    (Stream s m t, Show a) =>
    ParsecT s u m a -> ParsecT s u m ()
    notFollowedBy ParsecT Text ParserState m Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    spaceChar
      (Attr -> Attr) -> ParserT Text ParserState m (Attr -> Attr)
    forall (m :: * -> *) a. Monad m => a -> m a
    return ((Attr -> Attr) -> ParserT Text ParserState m (Attr -> Attr))
    -> (Attr -> Attr) -> ParserT Text ParserState m (Attr -> Attr)
    forall a b. (a -> b) -> a -> b
    $ Text -> Attr -> Attr
    addStyle (Text -> Attr -> Attr) -> Text -> Attr -> Attr
    forall a b. (a -> b) -> a -> b
    $ [Char] -> Text
    T.pack ([Char] -> Text) -> [Char] -> Text
    forall a b. (a -> b) -> a -> b
    $ "text-align:" [Char] -> [Char] -> [Char]
    forall a. [a] -> [a] -> [a]
    ++ [Char]
    alignStr

    attribute :: PandocMonad m => ParserT Text ParserState m (Attr -> Attr)
    attribute :: ParserT Text ParserState m (Attr -> Attr)
    attribute = ParserT Text ParserState m (Attr -> Attr)
    -> ParserT Text ParserState m (Attr -> Attr)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text ParserState m (Attr -> Attr)
     -> ParserT Text ParserState m (Attr -> Attr))
    -> ParserT Text ParserState m (Attr -> Attr)
    -> ParserT Text ParserState m (Attr -> Attr)
    forall a b. (a -> b) -> a -> b
    $
      (ParserT Text ParserState m (Attr -> Attr)
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m (Attr -> Attr)
    classIdAttr ParserT Text ParserState m (Attr -> Attr)
    -> ParserT Text ParserState m (Attr -> Attr)
    -> ParserT Text ParserState m (Attr -> Attr)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParserT Text ParserState m (Attr -> Attr)
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m (Attr -> Attr)
    styleAttr ParserT Text ParserState m (Attr -> Attr)
    -> ParserT Text ParserState m (Attr -> Attr)
    -> ParserT Text ParserState m (Attr -> Attr)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParserT Text ParserState m (Attr -> Attr)
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m (Attr -> Attr)
    langAttr) ParserT Text ParserState m (Attr -> Attr)
    -> ParsecT Text ParserState m ()
    -> ParserT Text ParserState m (Attr -> Attr)
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT Text ParserState m Char -> ParsecT Text ParserState m ()
    forall s (m :: * -> *) t a u.
    (Stream s m t, Show a) =>
    ParsecT s u m a -> ParsecT s u m ()
    notFollowedBy ParsecT Text ParserState m Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    spaceChar

    classIdAttr :: PandocMonad m => ParserT Text ParserState m (Attr -> Attr)
    classIdAttr :: ParserT Text ParserState m (Attr -> Attr)
    classIdAttr = ParserT Text ParserState m (Attr -> Attr)
    -> ParserT Text ParserState m (Attr -> Attr)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text ParserState m (Attr -> Attr)
     -> ParserT Text ParserState m (Attr -> Attr))
    -> ParserT Text ParserState m (Attr -> Attr)
    -> ParserT Text ParserState m (Attr -> Attr)
    forall a b. (a -> b) -> a -> b
    $ do -- (class class #id)
      Char -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '('
      [Text]
    ws <- Text -> [Text]
    T.words (Text -> [Text]) -> ([Char] -> Text) -> [Char] -> [Text]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    `fmap` [Char] -> Text
    T.pack ([Char] -> [Text])
    -> ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m [Text]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m Char
    -> ParsecT Text ParserState m [Char]
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    manyTill ParsecT Text ParserState m Char
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Char
    anyChar' (Char -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char ')')
      case [Text] -> [Text]
    forall a. [a] -> [a]
    reverse [Text]
    ws of
           []
             -> (Attr -> Attr) -> ParserT Text ParserState m (Attr -> Attr)
    forall (m :: * -> *) a. Monad m => a -> m a
    return ((Attr -> Attr) -> ParserT Text ParserState m (Attr -> Attr))
    -> (Attr -> Attr) -> ParserT Text ParserState m (Attr -> Attr)
    forall a b. (a -> b) -> a -> b
    $ \(_,_,keyvals :: NoteTable
    keyvals) -> ("",[],NoteTable
    keyvals)
           ((Text -> Maybe (Char, Text)
    T.uncons -> Just ('#', ident' :: Text
    ident')):classes' :: [Text]
    classes')
             -> (Attr -> Attr) -> ParserT Text ParserState m (Attr -> Attr)
    forall (m :: * -> *) a. Monad m => a -> m a
    return ((Attr -> Attr) -> ParserT Text ParserState m (Attr -> Attr))
    -> (Attr -> Attr) -> ParserT Text ParserState m (Attr -> Attr)
    forall a b. (a -> b) -> a -> b
    $ \(_,_,keyvals :: NoteTable
    keyvals) -> (Text
    ident',[Text]
    classes',NoteTable
    keyvals)
           classes' :: [Text]
    classes'
             -> (Attr -> Attr) -> ParserT Text ParserState m (Attr -> Attr)
    forall (m :: * -> *) a. Monad m => a -> m a
    return ((Attr -> Attr) -> ParserT Text ParserState m (Attr -> Attr))
    -> (Attr -> Attr) -> ParserT Text ParserState m (Attr -> Attr)
    forall a b. (a -> b) -> a -> b
    $ \(_,_,keyvals :: NoteTable
    keyvals) -> ("",[Text]
    classes',NoteTable
    keyvals)

    styleAttr :: PandocMonad m => ParserT Text ParserState m (Attr -> Attr)
    styleAttr :: ParserT Text ParserState m (Attr -> Attr)
    styleAttr = do
      [Char]
    style <- ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m [Char]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Text ParserState m [Char]
     -> ParsecT Text ParserState m [Char])
    -> ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m [Char]
    forall a b. (a -> b) -> a -> b
    $ ParserT Text ParserState m Char
    -> ParserT Text ParserState m Char
    -> ParserT Text ParserState m Char
    -> ParsecT Text ParserState m [Char]
    forall end s (m :: * -> *) st t a.
    (Show end, Stream s m Char) =>
    ParserT s st m t
    -> ParserT s st m end -> ParserT s st m a -> ParserT s st m [a]
    enclosed (Char -> ParserT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '{') (Char -> ParserT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '}') ParserT Text ParserState m Char
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Char
    anyChar'
      (Attr -> Attr) -> ParserT Text ParserState m (Attr -> Attr)
    forall (m :: * -> *) a. Monad m => a -> m a
    return ((Attr -> Attr) -> ParserT Text ParserState m (Attr -> Attr))
    -> (Attr -> Attr) -> ParserT Text ParserState m (Attr -> Attr)
    forall a b. (a -> b) -> a -> b
    $ Text -> Attr -> Attr
    addStyle (Text -> Attr -> Attr) -> Text -> Attr -> Attr
    forall a b. (a -> b) -> a -> b
    $ [Char] -> Text
    T.pack [Char]
    style

    addStyle :: Text -> Attr -> Attr
    addStyle :: Text -> Attr -> Attr
    addStyle style :: Text
    style (id' :: Text
    id',classes :: [Text]
    classes,keyvals :: NoteTable
    keyvals) =
      (Text
    id',[Text]
    classes,NoteTable
    keyvals')
      where keyvals' :: NoteTable
    keyvals' = ("style", Text
    style') (Text, Text) -> NoteTable -> NoteTable
    forall a. a -> [a] -> [a]
    : [(Text
    k,Text
    v) | (k :: Text
    k,v :: Text
    v) <- NoteTable
    keyvals, Text
    k Text -> Text -> Bool
    forall a. Eq a => a -> a -> Bool
    /= "style"]
            style' :: Text
    style' = Text
    style Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> ";" Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> [Text] -> Text
    T.concat [Text
    v | ("style",v :: Text
    v) <- NoteTable
    keyvals]

    langAttr :: PandocMonad m => ParserT Text ParserState m (Attr -> Attr)
    langAttr :: ParserT Text ParserState m (Attr -> Attr)
    langAttr = do
      [Char]
    lang <- ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m [Char]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Text ParserState m [Char]
     -> ParsecT Text ParserState m [Char])
    -> ParsecT Text ParserState m [Char]
    -> ParsecT Text ParserState m [Char]
    forall a b. (a -> b) -> a -> b
    $ ParserT Text ParserState m Char
    -> ParserT Text ParserState m Char
    -> ParserT Text ParserState m Char
    -> ParsecT Text ParserState m [Char]
    forall end s (m :: * -> *) st t a.
    (Show end, Stream s m Char) =>
    ParserT s st m t
    -> ParserT s st m end -> ParserT s st m a -> ParserT s st m [a]
    enclosed (Char -> ParserT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '[') (Char -> ParserT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char ']') ParserT Text ParserState m Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    alphaNum
      (Attr -> Attr) -> ParserT Text ParserState m (Attr -> Attr)
    forall (m :: * -> *) a. Monad m => a -> m a
    return ((Attr -> Attr) -> ParserT Text ParserState m (Attr -> Attr))
    -> (Attr -> Attr) -> ParserT Text ParserState m (Attr -> Attr)
    forall a b. (a -> b) -> a -> b
    $ \(id' :: Text
    id',classes :: [Text]
    classes,keyvals :: NoteTable
    keyvals) -> (Text
    id',[Text]
    classes,("lang",[Char] -> Text
    T.pack [Char]
    lang)(Text, Text) -> NoteTable -> NoteTable
    forall a. a -> [a] -> [a]
    :NoteTable
    keyvals)

    -- | Parses material surrounded by a parser.
    surrounded :: (PandocMonad m, Show t)
               => ParserT Text st m t   -- ^ surrounding parser
               -> ParserT Text st m a   -- ^ content parser (to be used repeatedly)
               -> ParserT Text st m [a]
    surrounded :: ParserT Text st m t -> ParserT Text st m a -> ParserT Text st m [a]
    surrounded border :: ParserT Text st m t
    border =
      ParserT Text st m ()
    -> ParserT Text st m t
    -> ParserT Text st m a
    -> ParserT Text st m [a]
    forall end s (m :: * -> *) st t a.
    (Show end, Stream s m Char) =>
    ParserT s st m t
    -> ParserT s st m end -> ParserT s st m a -> ParserT s st m [a]
    enclosed (ParserT Text st m t
    border ParserT Text st m t -> ParserT Text st m () -> ParserT Text st m ()
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> ParsecT Text st m Char -> ParserT Text st m ()
    forall s (m :: * -> *) t a u.
    (Stream s m t, Show a) =>
    ParsecT s u m a -> ParsecT s u m ()
    notFollowedBy ([Char] -> ParsecT Text st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    [Char] -> ParsecT s u m Char
    oneOf " \t\n\r")) (ParserT Text st m t -> ParserT Text st m t
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try ParserT Text st m t
    border)

    simpleInline :: PandocMonad m
                 => ParserT Text ParserState m t        -- ^ surrounding parser
                 -> (Inlines -> Inlines)                  -- ^ Inline constructor
                 -> ParserT Text ParserState m Inlines  -- ^ content parser (to be used repeatedly)
    simpleInline :: ParserT Text ParserState m t
    -> (Inlines -> Inlines) -> ParserT Text ParserState m Inlines
    simpleInline border :: ParserT Text ParserState m t
    border construct :: Inlines -> Inlines
    construct = ParserT Text ParserState m Inlines
    -> ParserT Text ParserState m Inlines
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text ParserState m Inlines
     -> ParserT Text ParserState m Inlines)
    -> ParserT Text ParserState m Inlines
    -> ParserT Text ParserState m Inlines
    forall a b. (a -> b) -> a -> b
    $ do
      ParserT Text ParserState m Bool
    forall s (m :: * -> *) a st.
    (Stream s m a, HasLastStrPosition st) =>
    ParserT s st m Bool
    notAfterString
      ParserT Text ParserState m t
    border ParserT Text ParserState m t
    -> ParsecT Text ParserState m () -> ParsecT Text ParserState m ()
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> ParsecT Text ParserState m Char -> ParsecT Text ParserState m ()
    forall s (m :: * -> *) t a u.
    (Stream s m t, Show a) =>
    ParsecT s u m a -> ParsecT s u m ()
    notFollowedBy ([Char] -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    [Char] -> ParsecT s u m Char
    oneOf " \t\n\r")
      Attr
    attr <- ParserT Text ParserState m Attr
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Attr
    attributes
      Inlines
    body <- Inlines -> Inlines
    trimInlines (Inlines -> Inlines)
    -> ([Inlines] -> Inlines) -> [Inlines] -> Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [Inlines] -> Inlines
    forall a. Monoid a => [a] -> a
    mconcat ([Inlines] -> Inlines)
    -> ParsecT Text ParserState m [Inlines]
    -> ParserT Text ParserState m Inlines
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$>
              QuoteContext
    -> ParsecT Text ParserState m [Inlines]
    -> ParsecT Text ParserState m [Inlines]
    forall st (m :: * -> *) s a.
    HasQuoteContext st m =>
    QuoteContext -> ParsecT s st m a -> ParsecT s st m a
    withQuoteContext QuoteContext
    InSingleQuote
                (ParserT Text ParserState m Inlines
    -> ParserT Text ParserState m t
    -> ParsecT Text ParserState m [Inlines]
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    manyTill (ParsecT Text ParserState m Char -> ParsecT Text ParserState m ()
    forall s (m :: * -> *) t a u.
    (Stream s m t, Show a) =>
    ParsecT s u m a -> ParsecT s u m ()
    notFollowedBy ParsecT Text ParserState m Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    newline ParsecT Text ParserState m ()
    -> ParserT Text ParserState m Inlines
    -> ParserT Text ParserState m Inlines
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> ParserT Text ParserState m Inlines
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Inlines
    inline)
                 (ParserT Text ParserState m t -> ParserT Text ParserState m t
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try ParserT Text ParserState m t
    border ParserT Text ParserState m t
    -> ParsecT Text ParserState m () -> ParserT Text ParserState m t
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT Text ParserState m Char -> ParsecT Text ParserState m ()
    forall s (m :: * -> *) t a u.
    (Stream s m t, Show a) =>
    ParsecT s u m a -> ParsecT s u m ()
    notFollowedBy ParsecT Text ParserState m Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    alphaNum))
      Inlines -> ParserT Text ParserState m Inlines
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Inlines -> ParserT Text ParserState m Inlines)
    -> Inlines -> ParserT Text ParserState m Inlines
    forall a b. (a -> b) -> a -> b
    $ Inlines -> Inlines
    construct (Inlines -> Inlines) -> Inlines -> Inlines
    forall a b. (a -> b) -> a -> b
    $
            if Attr
    attr Attr -> Attr -> Bool
    forall a. Eq a => a -> a -> Bool
    == Attr
    nullAttr
               then Inlines
    body
               else Attr -> Inlines -> Inlines
    B.spanWith Attr
    attr Inlines
    body

    groupedInlineMarkup :: PandocMonad m => ParserT Text ParserState m Inlines
    groupedInlineMarkup :: ParserT Text ParserState m Inlines
    groupedInlineMarkup = ParserT Text ParserState m Inlines
    -> ParserT Text ParserState m Inlines
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text ParserState m Inlines
     -> ParserT Text ParserState m Inlines)
    -> ParserT Text ParserState m Inlines
    -> ParserT Text ParserState m Inlines
    forall a b. (a -> b) -> a -> b
    $ do
        Char -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '['
        Inlines
    sp1 <- Inlines
    -> ParserT Text ParserState m Inlines
    -> ParserT Text ParserState m Inlines
    forall s (m :: * -> *) t a u.
    Stream s m t =>
    a -> ParsecT s u m a -> ParsecT s u m a
    option Inlines
    forall a. Monoid a => a
    mempty (ParserT Text ParserState m Inlines
     -> ParserT Text ParserState m Inlines)
    -> ParserT Text ParserState m Inlines
    -> ParserT Text ParserState m Inlines
    forall a b. (a -> b) -> a -> b
    $ Inlines
    B.space Inlines
    -> ParserT Text ParserState m Inlines
    -> ParserT Text ParserState m Inlines
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ ParserT Text ParserState m Inlines
    forall (m :: * -> *) st. PandocMonad m => ParserT Text st m Inlines
    whitespace
        Inlines
    result <- QuoteContext
    -> ParserT Text ParserState m Inlines
    -> ParserT Text ParserState m Inlines
    forall st (m :: * -> *) s a.
    HasQuoteContext st m =>
    QuoteContext -> ParsecT s st m a -> ParsecT s st m a
    withQuoteContext QuoteContext
    InSingleQuote ParserT Text ParserState m Inlines
    forall (m :: * -> *).
    PandocMonad m =>
    ParserT Text ParserState m Inlines
    inlineMarkup
        Inlines
    sp2 <- Inlines
    -> ParserT Text ParserState m Inlines
    -> ParserT Text ParserState m Inlines
    forall s (m :: * -> *) t a u.
    Stream s m t =>
    a -> ParsecT s u m a -> ParsecT s u m a
    option Inlines
    forall a. Monoid a => a
    mempty (ParserT Text ParserState m Inlines
     -> ParserT Text ParserState m Inlines)
    -> ParserT Text ParserState m Inlines
    -> ParserT Text ParserState m Inlines
    forall a b. (a -> b) -> a -> b
    $ Inlines
    B.space Inlines
    -> ParserT Text ParserState m Inlines
    -> ParserT Text ParserState m Inlines
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ ParserT Text ParserState m Inlines
    forall (m :: * -> *) st. PandocMonad m => ParserT Text st m Inlines
    whitespace
        Char -> ParsecT Text ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char ']'
        Inlines -> ParserT Text ParserState m Inlines
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Inlines -> ParserT Text ParserState m Inlines)
    -> Inlines -> ParserT Text ParserState m Inlines
    forall a b. (a -> b) -> a -> b
    $ Inlines
    sp1 Inlines -> Inlines -> Inlines
    forall a. Semigroup a => a -> a -> a
    <> Inlines
    result Inlines -> Inlines -> Inlines
    forall a. Semigroup a => a -> a -> a
    <> Inlines
    sp2

    eof' :: Monad m => ParserT Text s m Char
    eof' :: ParserT Text s m Char
    eof' = '\n' Char -> ParsecT Text s m () -> ParserT Text s m Char
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ ParsecT Text s m ()
    forall s (m :: * -> *) t u.
    (Stream s m t, Show t) =>
    ParsecT s u m ()
    eof