    {-# LANGUAGE CPP                        #-}
    {-# LANGUAGE ExplicitForAll             #-}
    {-# LANGUAGE FlexibleContexts           #-}
    {-# LANGUAGE FlexibleInstances          #-}
    {-# LANGUAGE GeneralizedNewtypeDeriving #-}
    {-# LANGUAGE IncoherentInstances        #-}
    {-# LANGUAGE MultiParamTypeClasses      #-}
    {-# LANGUAGE ViewPatterns               #-}
    {-# LANGUAGE OverloadedStrings          #-}
    {- |
       Module      : Text.Pandoc.Parsing
       Copyright   : Copyright (C) 2006-2020 John MacFarlane
       License     : GNU GPL, version 2 or above

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

    A utility library with parsers used in pandoc readers.
    -}

    module Text.Pandoc.Parsing ( take1WhileP,
                                 takeP,
                                 countChar,
                                 textStr,
                                 anyLine,
                                 anyLineNewline,
                                 indentWith,
                                 manyChar,
                                 many1Char,
                                 manyTillChar,
                                 many1TillChar,
                                 many1Till,
                                 manyUntil,
                                 manyUntilChar,
                                 sepBy1',
                                 notFollowedBy',
                                 oneOfStrings,
                                 oneOfStringsCI,
                                 spaceChar,
                                 nonspaceChar,
                                 skipSpaces,
                                 blankline,
                                 blanklines,
                                 gobbleSpaces,
                                 gobbleAtMostSpaces,
                                 enclosed,
                                 stringAnyCase,
                                 parseFromString,
                                 parseFromString',
                                 lineClump,
                                 charsInBalanced,
                                 romanNumeral,
                                 emailAddress,
                                 uri,
                                 mathInline,
                                 mathDisplay,
                                 withHorizDisplacement,
                                 withRaw,
                                 escaped,
                                 characterReference,
                                 upperRoman,
                                 lowerRoman,
                                 decimal,
                                 lowerAlpha,
                                 upperAlpha,
                                 anyOrderedListMarker,
                                 orderedListMarker,
                                 charRef,
                                 lineBlockLines,
                                 tableWith,
                                 widthsFromIndices,
                                 gridTableWith,
                                 gridTableWith',
                                 readWith,
                                 readWithM,
                                 testStringWith,
                                 guardEnabled,
                                 guardDisabled,
                                 updateLastStrPos,
                                 notAfterString,
                                 logMessage,
                                 reportLogMessages,
                                 ParserState (..),
                                 HasReaderOptions (..),
                                 HasIdentifierList (..),
                                 HasMacros (..),
                                 HasLogMessages (..),
                                 HasLastStrPosition (..),
                                 HasIncludeFiles (..),
                                 defaultParserState,
                                 HeaderType (..),
                                 ParserContext (..),
                                 QuoteContext (..),
                                 HasQuoteContext (..),
                                 NoteTable,
                                 NoteTable',
                                 KeyTable,
                                 SubstTable,
                                 Key (..),
                                 toKey,
                                 registerHeader,
                                 smartPunctuation,
                                 singleQuoteStart,
                                 singleQuoteEnd,
                                 doubleQuoteStart,
                                 doubleQuoteEnd,
                                 ellipses,
                                 apostrophe,
                                 dash,
                                 nested,
                                 citeKey,
                                 Parser,
                                 ParserT,
                                 F,
                                 Future(..),
                                 runF,
                                 askF,
                                 asksF,
                                 returnF,
                                 trimInlinesF,
                                 token,
                                 (<+?>),
                                 extractIdClass,
                                 insertIncludedFile,
                                 insertIncludedFileF,
                                 -- * Re-exports from Text.Parsec
                                 Stream,
                                 runParser,
                                 runParserT,
                                 parse,
                                 tokenPrim,
                                 anyToken,
                                 getInput,
                                 setInput,
                                 unexpected,
                                 char,
                                 letter,
                                 digit,
                                 alphaNum,
                                 skipMany,
                                 skipMany1,
                                 spaces,
                                 space,
                                 anyChar,
                                 satisfy,
                                 newline,
                                 string,
                                 count,
                                 eof,
                                 noneOf,
                                 oneOf,
                                 lookAhead,
                                 notFollowedBy,
                                 many,
                                 many1,
                                 manyTill,
                                 (<|>),
                                 (<?>),
                                 choice,
                                 try,
                                 sepBy,
                                 sepBy1,
                                 sepEndBy,
                                 sepEndBy1,
                                 endBy,
                                 endBy1,
                                 option,
                                 optional,
                                 optionMaybe,
                                 getState,
                                 setState,
                                 updateState,
                                 SourcePos,
                                 getPosition,
                                 setPosition,
                                 sourceColumn,
                                 sourceLine,
                                 setSourceColumn,
                                 setSourceLine,
                                 incSourceColumn,
                                 newPos,
                                 Line,
                                 Column
                                 )
    where

    import Control.Monad.Identity
    import Control.Monad.Reader
    import Data.Char (chr, isAlphaNum, isAscii, isAsciiUpper,
                      isPunctuation, isSpace, ord, toLower, toUpper)
    import Data.Default
    import Data.Functor (($>))
    import Data.List (intercalate, transpose)
    import qualified Data.Map as M
    import Data.Maybe (mapMaybe, fromMaybe)
    import qualified Data.Set as Set
    import Data.String
    import Data.Text (Text)
    import qualified Data.Text as T
    import Text.HTML.TagSoup.Entity (lookupEntity)
    import Text.Pandoc.Asciify (toAsciiChar)
    import Text.Pandoc.Builder (Blocks, HasMeta (..), Inlines, trimInlines)
    import qualified Text.Pandoc.Builder as B
    import Text.Pandoc.Class.PandocMonad (PandocMonad, readFileFromDirs, report)
    import Text.Pandoc.Definition
    import Text.Pandoc.Logging
    import Text.Pandoc.Options
    import Text.Pandoc.Readers.LaTeX.Types (Macro)
    import Text.Pandoc.Shared
    import qualified Text.Pandoc.UTF8 as UTF8 (putStrLn)
    import Text.Pandoc.XML (fromEntities)
    import Text.Parsec hiding (token)
    import Text.Parsec.Pos (initialPos, newPos, updatePosString)

    import Control.Monad.Except
    import Text.Pandoc.Error

    type Parser t s = Parsec t s

    type ParserT = ParsecT

    -- | Reader monad wrapping the parser state. This is used to possibly delay
    -- evaluation until all relevant information has been parsed and made available
    -- in the parser state.
    newtype Future s a = Future { Future s a -> Reader s a
    runDelayed :: Reader s a }
      deriving (Applicative (Future s)
    a -> Future s a
    Applicative (Future s) =>
    (forall a b. Future s a -> (a -> Future s b) -> Future s b)
    -> (forall a b. Future s a -> Future s b -> Future s b)
    -> (forall a. a -> Future s a)
    -> Monad (Future s)
    Future s a -> (a -> Future s b) -> Future s b
    Future s a -> Future s b -> Future s b
    forall s. Applicative (Future s)
    forall a. a -> Future s a
    forall s a. a -> Future s a
    forall a b. Future s a -> Future s b -> Future s b
    forall a b. Future s a -> (a -> Future s b) -> Future s b
    forall s a b. Future s a -> Future s b -> Future s b
    forall s a b. Future s a -> (a -> Future s b) -> Future s b
    forall (m :: * -> *).
    Applicative m =>
    (forall a b. m a -> (a -> m b) -> m b)
    -> (forall a b. m a -> m b -> m b)
    -> (forall a. a -> m a)
    -> Monad m
    return :: a -> Future s a
    $creturn :: forall s a. a -> Future s a
    >> :: Future s a -> Future s b -> Future s b
    $c>> :: forall s a b. Future s a -> Future s b -> Future s b
    >>= :: Future s a -> (a -> Future s b) -> Future s b
    $c>>= :: forall s a b. Future s a -> (a -> Future s b) -> Future s b
    $cp1Monad :: forall s. Applicative (Future s)
    Monad, Functor (Future s)
    a -> Future s a
    Functor (Future s) =>
    (forall a. a -> Future s a)
    -> (forall a b. Future s (a -> b) -> Future s a -> Future s b)
    -> (forall a b c.
        (a -> b -> c) -> Future s a -> Future s b -> Future s c)
    -> (forall a b. Future s a -> Future s b -> Future s b)
    -> (forall a b. Future s a -> Future s b -> Future s a)
    -> Applicative (Future s)
    Future s a -> Future s b -> Future s b
    Future s a -> Future s b -> Future s a
    Future s (a -> b) -> Future s a -> Future s b
    (a -> b -> c) -> Future s a -> Future s b -> Future s c
    forall s. Functor (Future s)
    forall a. a -> Future s a
    forall s a. a -> Future s a
    forall a b. Future s a -> Future s b -> Future s a
    forall a b. Future s a -> Future s b -> Future s b
    forall a b. Future s (a -> b) -> Future s a -> Future s b
    forall s a b. Future s a -> Future s b -> Future s a
    forall s a b. Future s a -> Future s b -> Future s b
    forall s a b. Future s (a -> b) -> Future s a -> Future s b
    forall a b c.
    (a -> b -> c) -> Future s a -> Future s b -> Future s c
    forall s a b c.
    (a -> b -> c) -> Future s a -> Future s b -> Future s c
    forall (f :: * -> *).
    Functor f =>
    (forall a. a -> f a)
    -> (forall a b. f (a -> b) -> f a -> f b)
    -> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
    -> (forall a b. f a -> f b -> f b)
    -> (forall a b. f a -> f b -> f a)
    -> Applicative f
    <* :: Future s a -> Future s b -> Future s a
    $c<* :: forall s a b. Future s a -> Future s b -> Future s a
    *> :: Future s a -> Future s b -> Future s b
    $c*> :: forall s a b. Future s a -> Future s b -> Future s b
    liftA2 :: (a -> b -> c) -> Future s a -> Future s b -> Future s c
    $cliftA2 :: forall s a b c.
    (a -> b -> c) -> Future s a -> Future s b -> Future s c
    <*> :: Future s (a -> b) -> Future s a -> Future s b
    $c<*> :: forall s a b. Future s (a -> b) -> Future s a -> Future s b
    pure :: a -> Future s a
    $cpure :: forall s a. a -> Future s a
    $cp1Applicative :: forall s. Functor (Future s)
    Applicative, a -> Future s b -> Future s a
    (a -> b) -> Future s a -> Future s b
    (forall a b. (a -> b) -> Future s a -> Future s b)
    -> (forall a b. a -> Future s b -> Future s a)
    -> Functor (Future s)
    forall a b. a -> Future s b -> Future s a
    forall a b. (a -> b) -> Future s a -> Future s b
    forall s a b. a -> Future s b -> Future s a
    forall s a b. (a -> b) -> Future s a -> Future s b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    <$ :: a -> Future s b -> Future s a
    $c<$ :: forall s a b. a -> Future s b -> Future s a
    fmap :: (a -> b) -> Future s a -> Future s b
    $cfmap :: forall s a b. (a -> b) -> Future s a -> Future s b
    Functor)

    type F = Future ParserState

    runF :: Future s a -> s -> a
    runF :: Future s a -> s -> a
    runF = Reader s a -> s -> a
    forall r a. Reader r a -> r -> a
    runReader (Reader s a -> s -> a)
    -> (Future s a -> Reader s a) -> Future s a -> s -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Future s a -> Reader s a
    forall s a. Future s a -> Reader s a
    runDelayed

    askF :: Future s s
    askF :: Future s s
    askF = Reader s s -> Future s s
    forall s a. Reader s a -> Future s a
    Future Reader s s
    forall r (m :: * -> *). MonadReader r m => m r
    ask

    asksF :: (s -> a) -> Future s a
    asksF :: (s -> a) -> Future s a
    asksF f :: s -> a
    f = Reader s a -> Future s a
    forall s a. Reader s a -> Future s a
    Future (Reader s a -> Future s a) -> Reader s a -> Future s a
    forall a b. (a -> b) -> a -> b
    $ (s -> a) -> Reader s a
    forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
    asks s -> a
    f

    returnF :: Monad m => a -> m (Future s a)
    returnF :: a -> m (Future s a)
    returnF = Future s a -> m (Future s a)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Future s a -> m (Future s a))
    -> (a -> Future s a) -> a -> m (Future s a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> Future s a
    forall (m :: * -> *) a. Monad m => a -> m a
    return

    trimInlinesF :: Future s Inlines -> Future s Inlines
    trimInlinesF :: Future s Inlines -> Future s Inlines
    trimInlinesF = (Inlines -> Inlines) -> Future s Inlines -> Future s Inlines
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM Inlines -> Inlines
    trimInlines

    instance Semigroup a => Semigroup (Future s a) where
      <> :: Future s a -> Future s a -> Future s a
    (<>) = (a -> a -> a) -> Future s a -> Future s a -> Future s a
    forall (m :: * -> *) a1 a2 r.
    Monad m =>
    (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
    liftM2 a -> a -> a
    forall a. Semigroup a => a -> a -> a
    (<>)
    instance (Semigroup a, Monoid a) => Monoid (Future s a) where
      mempty :: Future s a
    mempty = a -> Future s a
    forall (m :: * -> *) a. Monad m => a -> m a
    return a
    forall a. Monoid a => a
    mempty
      mappend :: Future s a -> Future s a -> Future s a
    mappend = Future s a -> Future s a -> Future s a
    forall a. Semigroup a => a -> a -> a
    (<>)

    -- | Like @count@, but packs its result
    countChar :: (Stream s m Char, Monad m)
              => Int
              -> ParsecT s st m Char
              -> ParsecT s st m Text
    countChar :: Int -> ParsecT s st m Char -> ParsecT s st m Text
    countChar n :: Int
    n = (String -> Text) -> ParsecT s st m String -> ParsecT s st m Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap String -> Text
    T.pack (ParsecT s st m String -> ParsecT s st m Text)
    -> (ParsecT s st m Char -> ParsecT s st m String)
    -> ParsecT s st m Char
    -> ParsecT s st m Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> ParsecT s st m Char -> ParsecT s st m String
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    Int -> ParsecT s u m a -> ParsecT s u m [a]
    count Int
    n

    -- | Like @string@, but uses @Text@.
    textStr :: Stream s m Char => Text -> ParsecT s u m Text
    textStr :: Text -> ParsecT s u m Text
    textStr t :: Text
    t = String -> ParsecT s u m String
    forall s (m :: * -> *) u.
    Stream s m Char =>
    String -> ParsecT s u m String
    string (Text -> String
    T.unpack Text
    t) ParsecT s u m String -> Text -> ParsecT s u m Text
    forall (f :: * -> *) a b. Functor f => f a -> b -> f b
    $> Text
    t

    -- | Parse characters while a predicate is true.
    take1WhileP :: Monad m
               => (Char -> Bool)
               -> ParserT Text st m Text
    take1WhileP :: (Char -> Bool) -> ParserT Text st m Text
    take1WhileP f :: Char -> Bool
    f = do
      -- needed to persuade parsec that this won't match an empty string:
      Char
    c <- (Char -> Bool) -> ParsecT Text st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    (Char -> Bool) -> ParsecT s u m Char
    satisfy Char -> Bool
    f
      Text
    inp <- ParserT Text st m Text
    forall (m :: * -> *) s u. Monad m => ParsecT s u m s
    getInput
      SourcePos
    pos <- ParsecT Text st m SourcePos
    forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
    getPosition
      let (t :: Text
    t, rest :: Text
    rest) = (Char -> Bool) -> Text -> (Text, Text)
    T.span Char -> Bool
    f Text
    inp
      Text -> ParsecT Text st m ()
    forall (m :: * -> *) s u. Monad m => s -> ParsecT s u m ()
    setInput Text
    rest
      SourcePos -> ParsecT Text st m ()
    forall (m :: * -> *) s u. Monad m => SourcePos -> ParsecT s u m ()
    setPosition (SourcePos -> ParsecT Text st m ())
    -> SourcePos -> ParsecT Text st m ()
    forall a b. (a -> b) -> a -> b
    $
        if Char -> Bool
    f '\t' Bool -> Bool -> Bool
    || Char -> Bool
    f '\n'
           then SourcePos -> String -> SourcePos
    updatePosString SourcePos
    pos (String -> SourcePos) -> String -> SourcePos
    forall a b. (a -> b) -> a -> b
    $ Text -> String
    T.unpack Text
    t
           else SourcePos -> Int -> SourcePos
    incSourceColumn SourcePos
    pos (Text -> Int
    T.length Text
    t)
      Text -> ParserT Text st m Text
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Text -> ParserT Text st m Text) -> Text -> ParserT Text st m Text
    forall a b. (a -> b) -> a -> b
    $ Char -> Text
    T.singleton Char
    c Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Text
    t

    -- Parse n characters of input (or the rest of the input if
    -- there aren't n characters).
    takeP :: Monad m => Int -> ParserT Text st m Text
    takeP :: Int -> ParserT Text st m Text
    takeP n :: Int
    n = do
      Bool -> ParsecT Text st m ()
    forall (f :: * -> *). Alternative f => Bool -> f ()
    guard (Int
    n Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    > 0)
      -- faster than 'count n anyChar'
      Text
    inp <- ParserT Text st m Text
    forall (m :: * -> *) s u. Monad m => ParsecT s u m s
    getInput
      SourcePos
    pos <- ParsecT Text st m SourcePos
    forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
    getPosition
      let (xs :: Text
    xs, rest :: Text
    rest) = Int -> Text -> (Text, Text)
    T.splitAt Int
    n Text
    inp
      -- needed to persuade parsec that this won't match an empty string:
      ParsecT Text st m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    anyChar
      Text -> ParsecT Text st m ()
    forall (m :: * -> *) s u. Monad m => s -> ParsecT s u m ()
    setInput Text
    rest
      SourcePos -> ParsecT Text st m ()
    forall (m :: * -> *) s u. Monad m => SourcePos -> ParsecT s u m ()
    setPosition (SourcePos -> ParsecT Text st m ())
    -> SourcePos -> ParsecT Text st m ()
    forall a b. (a -> b) -> a -> b
    $ SourcePos -> String -> SourcePos
    updatePosString SourcePos
    pos (String -> SourcePos) -> String -> SourcePos
    forall a b. (a -> b) -> a -> b
    $ Text -> String
    T.unpack Text
    xs
      Text -> ParserT Text st m Text
    forall (m :: * -> *) a. Monad m => a -> m a
    return Text
    xs

    -- | Parse any line of text
    anyLine :: Monad m => ParserT Text st m Text
    anyLine :: ParserT Text st m Text
    anyLine = do
      -- This is much faster than:
      -- manyTill anyChar newline
      Text
    inp <- ParserT Text st m Text
    forall (m :: * -> *) s u. Monad m => ParsecT s u m s
    getInput
      SourcePos
    pos <- ParsecT Text st m SourcePos
    forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
    getPosition
      case (Char -> Bool) -> Text -> (Text, Text)
    T.break (Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    =='\n') Text
    inp of
           (this :: Text
    this, Text -> Maybe (Char, Text)
    T.uncons -> Just ('\n', rest :: Text
    rest)) -> do
             -- needed to persuade parsec that this won't match an empty string:
             ParsecT Text st m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    anyChar
             Text -> ParsecT Text st m ()
    forall (m :: * -> *) s u. Monad m => s -> ParsecT s u m ()
    setInput Text
    rest
             SourcePos -> ParsecT Text st m ()
    forall (m :: * -> *) s u. Monad m => SourcePos -> ParsecT s u m ()
    setPosition (SourcePos -> ParsecT Text st m ())
    -> SourcePos -> ParsecT Text st m ()
    forall a b. (a -> b) -> a -> b
    $ SourcePos -> Int -> SourcePos
    incSourceLine (SourcePos -> Int -> SourcePos
    setSourceColumn SourcePos
    pos 1) 1
             Text -> ParserT Text st m Text
    forall (m :: * -> *) a. Monad m => a -> m a
    return Text
    this
           _ -> ParserT Text st m Text
    forall (m :: * -> *) a. MonadPlus m => m a
    mzero

    -- | Parse any line, include the final newline in the output
    anyLineNewline :: Monad m => ParserT Text st m Text
    anyLineNewline :: ParserT Text st m Text
    anyLineNewline = (Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> "\n") (Text -> Text) -> ParserT Text st m Text -> ParserT Text st m Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParserT Text st m Text
    forall (m :: * -> *) st. Monad m => ParserT Text st m Text
    anyLine

    -- | Parse indent by specified number of spaces (or equiv. tabs)
    indentWith :: Stream s m Char
               => HasReaderOptions st
               => Int -> ParserT s st m Text
    indentWith :: Int -> ParserT s st m Text
    indentWith num :: Int
    num = do
      Int
    tabStop <- (ReaderOptions -> Int) -> ParserT s st m Int
    forall st s (m :: * -> *) t b.
    (HasReaderOptions st, Stream s m t) =>
    (ReaderOptions -> b) -> ParserT s st m b
    getOption ReaderOptions -> Int
    readerTabStop
      if Int
    num Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    < Int
    tabStop
         then Int -> ParsecT s st m Char -> ParserT s st m Text
    forall s (m :: * -> *) st.
    (Stream s m Char, Monad m) =>
    Int -> ParsecT s st m Char -> ParsecT s st m Text
    countChar Int
    num (Char -> ParsecT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char ' ')
         else [ParserT s st m Text] -> ParserT s st m Text
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    [ParsecT s u m a] -> ParsecT s u m a
    choice [ ParserT s st m Text -> ParserT s st m Text
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (Int -> ParsecT s st m Char -> ParserT s st m Text
    forall s (m :: * -> *) st.
    (Stream s m Char, Monad m) =>
    Int -> ParsecT s st m Char -> ParsecT s st m Text
    countChar Int
    num (Char -> ParsecT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char ' '))
                     , ParserT s st m Text -> ParserT s st m Text
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (Char -> ParsecT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '\t' ParsecT s st m Char -> ParserT s st m Text -> ParserT s st m Text
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> Int -> ParserT s st m Text
    forall s (m :: * -> *) st.
    (Stream s m Char, HasReaderOptions st) =>
    Int -> ParserT s st m Text
    indentWith (Int
    num Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    tabStop)) ]

    -- | Like @many@, but packs its result.
    manyChar :: Stream s m t
             => ParserT s st m Char
             -> ParserT s st m Text
    manyChar :: ParserT s st m Char -> ParserT s st m Text
    manyChar = (String -> Text) -> ParsecT s st m String -> ParserT s st m Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap String -> Text
    T.pack (ParsecT s st m String -> ParserT s st m Text)
    -> (ParserT s st m Char -> ParsecT s st m String)
    -> ParserT s st m Char
    -> ParserT s st m Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ParserT s st m Char -> ParsecT s st m String
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many

    -- | Like @many1@, but packs its result.
    many1Char :: Stream s m t
              => ParserT s st m Char
              -> ParserT s st m Text
    many1Char :: ParserT s st m Char -> ParserT s st m Text
    many1Char = (String -> Text) -> ParsecT s st m String -> ParserT s st m Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap String -> Text
    T.pack (ParsecT s st m String -> ParserT s st m Text)
    -> (ParserT s st m Char -> ParsecT s st m String)
    -> ParserT s st m Char
    -> ParserT s st m Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ParserT s st m Char -> ParsecT s st m String
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m [a]
    many1

    -- | Like @manyTill@, but packs its result.
    manyTillChar :: Stream s m t
                 => ParserT s st m Char
                 -> ParserT s st m a
                 -> ParserT s st m Text
    manyTillChar :: ParserT s st m Char -> ParserT s st m a -> ParserT s st m Text
    manyTillChar p :: ParserT s st m Char
    p = (String -> Text) -> ParsecT s st m String -> ParserT s st m Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap String -> Text
    T.pack (ParsecT s st m String -> ParserT s st m Text)
    -> (ParserT s st m a -> ParsecT s st m String)
    -> ParserT s st m a
    -> ParserT s st m Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ParserT s st m Char -> ParserT s st m a -> ParsecT s st m String
    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 s st m Char
    p

    -- | Like @manyTill@, but reads at least one item.
    many1Till :: (Show end, Stream s m t)
              => ParserT s st m a
              -> ParserT s st m end
              -> ParserT s st m [a]
    many1Till :: ParserT s st m a -> ParserT s st m end -> ParserT s st m [a]
    many1Till p :: ParserT s st m a
    p end :: ParserT s st m end
    end = do
             ParserT s st m end -> ParserT s st m ()
    forall b s (m :: * -> *) a st.
    (Show b, Stream s m a) =>
    ParserT s st m b -> ParserT s st m ()
    notFollowedBy' ParserT s st m end
    end
             a
    first <- ParserT s st m a
    p
             [a]
    rest <- ParserT s st m a -> ParserT s st m end -> ParserT s st m [a]
    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 s st m a
    p ParserT s st m end
    end
             [a] -> ParserT s st m [a]
    forall (m :: * -> *) a. Monad m => a -> m a
    return (a
    firsta -> [a] -> [a]
    forall a. a -> [a] -> [a]
    :[a]
    rest)

    -- | Like @many1Till@, but packs its result
    many1TillChar :: (Show end, Stream s m t)
                  => ParserT s st m Char
                  -> ParserT s st m end
                  -> ParserT s st m Text
    many1TillChar :: ParserT s st m Char -> ParserT s st m end -> ParserT s st m Text
    many1TillChar p :: ParserT s st m Char
    p = (String -> Text) -> ParsecT s st m String -> ParserT s st m Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap String -> Text
    T.pack (ParsecT s st m String -> ParserT s st m Text)
    -> (ParserT s st m end -> ParsecT s st m String)
    -> ParserT s st m end
    -> ParserT s st m Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ParserT s st m Char -> ParserT s st m end -> ParsecT s st m String
    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 s st m Char
    p

    -- | Like @manyTill@, but also returns the result of end parser.
    manyUntil :: ParserT s u m a
              -> ParserT s u m b
              -> ParserT s u m ([a], b)
    manyUntil :: ParserT s u m a -> ParserT s u m b -> ParserT s u m ([a], b)
    manyUntil p :: ParserT s u m a
    p end :: ParserT s u m b
    end = ParserT s u m ([a], b)
    scan
      where scan :: ParserT s u m ([a], b)
    scan =
              (do b
    e <- ParserT s u m b
    end
                  ([a], b) -> ParserT s u m ([a], b)
    forall (m :: * -> *) a. Monad m => a -> m a
    return ([], b
    e)
              ) ParserT s u m ([a], b)
    -> ParserT s u m ([a], b) -> ParserT s u m ([a], b)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|>
              (do a
    x <- ParserT s u m a
    p
                  (xs :: [a]
    xs, e :: b
    e) <- ParserT s u m ([a], b)
    scan
                  ([a], b) -> ParserT s u m ([a], b)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (a
    xa -> [a] -> [a]
    forall a. a -> [a] -> [a]
    :[a]
    xs, b
    e))

    -- | Like @manyUntil@, but also packs its result.
    manyUntilChar :: ParserT s u m Char
                  -> ParserT s u m b
                  -> ParserT s u m (Text, b)
    manyUntilChar :: ParserT s u m Char -> ParserT s u m b -> ParserT s u m (Text, b)
    manyUntilChar p :: ParserT s u m Char
    p = ((String, b) -> (Text, b))
    -> ParsecT s u m (String, b) -> ParserT s u m (Text, b)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (String, b) -> (Text, b)
    forall b. (String, b) -> (Text, b)
    go (ParsecT s u m (String, b) -> ParserT s u m (Text, b))
    -> (ParserT s u m b -> ParsecT s u m (String, b))
    -> ParserT s u m b
    -> ParserT s u m (Text, b)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ParserT s u m Char -> ParserT s u m b -> ParsecT s u m (String, b)
    forall s u (m :: * -> *) a b.
    ParserT s u m a -> ParserT s u m b -> ParserT s u m ([a], b)
    manyUntil ParserT s u m Char
    p
      where
        go :: (String, b) -> (Text, b)
    go (x :: String
    x, y :: b
    y) = (String -> Text
    T.pack String
    x, b
    y)

    -- | Like @sepBy1@ from Parsec,
    -- but does not fail if it @sep@ succeeds and @p@ fails.
    sepBy1' :: ParsecT s u m a
            -> ParsecT s u m sep
            -> ParsecT s u m [a]
    sepBy1' :: ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
    sepBy1' p :: ParsecT s u m a
    p sep :: ParsecT s u m sep
    sep = (:) (a -> [a] -> [a]) -> ParsecT s u m a -> ParsecT s u m ([a] -> [a])
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT s u m a
    p ParsecT s u m ([a] -> [a])
    -> ParsecT s u m [a] -> ParsecT s u m [a]
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ParsecT s u m a -> ParsecT s u m [a]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many (ParsecT s u m a -> ParsecT s u m a
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT s u m a -> ParsecT s u m a)
    -> ParsecT s u m a -> ParsecT s u m a
    forall a b. (a -> b) -> a -> b
    $ ParsecT s u m sep
    sep ParsecT s u m sep -> ParsecT s u m a -> ParsecT s u m a
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> ParsecT s u m a
    p)

    -- | A more general form of @notFollowedBy@.  This one allows any
    -- type of parser to be specified, and succeeds only if that parser fails.
    -- It does not consume any input.
    notFollowedBy' :: (Show b, Stream s m a) => ParserT s st m b -> ParserT s st m ()
    notFollowedBy' :: ParserT s st m b -> ParserT s st m ()
    notFollowedBy' p :: ParserT s st m b
    p  = ParserT s st m () -> ParserT s st m ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT s st m () -> ParserT s st m ())
    -> ParserT s st m () -> ParserT s st m ()
    forall a b. (a -> b) -> a -> b
    $ ParsecT s st m (ParserT s st m ()) -> ParserT s st m ()
    forall (m :: * -> *) a. Monad m => m (m a) -> m a
    join (ParsecT s st m (ParserT s st m ()) -> ParserT s st m ())
    -> ParsecT s st m (ParserT s st m ()) -> ParserT s st m ()
    forall a b. (a -> b) -> a -> b
    $  do  b
    a <- ParserT s st m b -> ParserT s st m b
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try ParserT s st m b
    p
                                          ParserT s st m () -> ParsecT s st m (ParserT s st m ())
    forall (m :: * -> *) a. Monad m => a -> m a
    return (String -> ParserT s st m ()
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    String -> ParsecT s u m a
    unexpected (b -> String
    forall a. Show a => a -> String
    show b
    a))
                                      ParsecT s st m (ParserT s st m ())
    -> ParsecT s st m (ParserT s st m ())
    -> ParsecT s st m (ParserT s st m ())
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|>
                                      ParserT s st m () -> ParsecT s st m (ParserT s st m ())
    forall (m :: * -> *) a. Monad m => a -> m a
    return (() -> ParserT s st m ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ())
    -- (This version due to Andrew Pimlott on the Haskell mailing list.)

    oneOfStrings' :: Stream s m Char => (Char -> Char -> Bool) -> [Text] -> ParserT s st m Text
    oneOfStrings' :: (Char -> Char -> Bool) -> [Text] -> ParserT s st m Text
    oneOfStrings' f :: Char -> Char -> Bool
    f = (String -> Text) -> ParsecT s st m String -> ParserT s st m Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap String -> Text
    T.pack (ParsecT s st m String -> ParserT s st m Text)
    -> ([Text] -> ParsecT s st m String)
    -> [Text]
    -> ParserT s st m Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Char -> Char -> Bool) -> [String] -> ParsecT s st m String
    forall s (m :: * -> *) st.
    Stream s m Char =>
    (Char -> Char -> Bool) -> [String] -> ParserT s st m String
    oneOfStrings'' Char -> Char -> Bool
    f ([String] -> ParsecT s st m String)
    -> ([Text] -> [String]) -> [Text] -> ParsecT s st m String
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Text -> String) -> [Text] -> [String]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Text -> String
    T.unpack

    -- TODO: This should be re-implemented in a Text-aware way
    oneOfStrings'' :: Stream s m Char => (Char -> Char -> Bool) -> [String] -> ParserT s st m String
    oneOfStrings'' :: (Char -> Char -> Bool) -> [String] -> ParserT s st m String
    oneOfStrings'' _ []   = String -> ParserT s st m String
    forall (m :: * -> *) a. MonadFail m => String -> m a
    Prelude.fail "no strings"
    oneOfStrings'' matches :: Char -> Char -> Bool
    matches strs :: [String]
    strs = ParserT s st m String -> ParserT s st m String
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT s st m String -> ParserT s st m String)
    -> ParserT s st m String -> ParserT s st m String
    forall a b. (a -> b) -> a -> b
    $ do
      Char
    c <- ParsecT s st m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    anyChar
      let strs' :: [String]
    strs' = [String
    xs | (x :: Char
    x:xs :: String
    xs) <- [String]
    strs, Char
    x Char -> Char -> Bool
    `matches` Char
    c]
      case [String]
    strs' of
           []  -> String -> ParserT s st m String
    forall (m :: * -> *) a. MonadFail m => String -> m a
    Prelude.fail "not found"
           _   -> (Char
    cChar -> String -> String
    forall a. a -> [a] -> [a]
    :) (String -> String)
    -> ParserT s st m String -> ParserT s st m String
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Char -> Char -> Bool) -> [String] -> ParserT s st m String
    forall s (m :: * -> *) st.
    Stream s m Char =>
    (Char -> Char -> Bool) -> [String] -> ParserT s st m String
    oneOfStrings'' Char -> Char -> Bool
    matches [String]
    strs'
                   ParserT s st m String
    -> ParserT s st m String -> ParserT s st m String
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> if "" String -> [String] -> Bool
    forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
    `elem` [String]
    strs'
                          then String -> ParserT s st m String
    forall (m :: * -> *) a. Monad m => a -> m a
    return [Char
    c]
                          else String -> ParserT s st m String
    forall (m :: * -> *) a. MonadFail m => String -> m a
    Prelude.fail "not found"

    -- | Parses one of a list of strings.  If the list contains
    -- two strings one of which is a prefix of the other, the longer
    -- string will be matched if possible.
    oneOfStrings :: Stream s m Char => [Text] -> ParserT s st m Text
    oneOfStrings :: [Text] -> ParserT s st m Text
    oneOfStrings = (Char -> Char -> Bool) -> [Text] -> ParserT s st m Text
    forall s (m :: * -> *) st.
    Stream s m Char =>
    (Char -> Char -> Bool) -> [Text] -> ParserT s st m Text
    oneOfStrings' Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    (==)

    -- | Parses one of a list of strings (tried in order), case insensitive.

    -- TODO: This will not be accurate with general Unicode (neither
    -- Text.toLower nor Text.toCaseFold can be implemented with a map)
    oneOfStringsCI :: Stream s m Char => [Text] -> ParserT s st m Text
    oneOfStringsCI :: [Text] -> ParserT s st m Text
    oneOfStringsCI = (Char -> Char -> Bool) -> [Text] -> ParserT s st m Text
    forall s (m :: * -> *) st.
    Stream s m Char =>
    (Char -> Char -> Bool) -> [Text] -> ParserT s st m Text
    oneOfStrings' Char -> Char -> Bool
    ciMatch
      where ciMatch :: Char -> Char -> Bool
    ciMatch x :: Char
    x y :: Char
    y = Char -> Char
    toLower' Char
    x Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    == Char -> Char
    toLower' Char
    y
            -- this optimizes toLower by checking common ASCII case
            -- first, before calling the expensive unicode-aware
            -- function:
            toLower' :: Char -> Char
    toLower' c :: Char
    c | Char -> Bool
    isAsciiUpper Char
    c = Int -> Char
    chr (Char -> Int
    ord Char
    c Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + 32)
                       | Char -> Bool
    isAscii Char
    c = Char
    c
                       | Bool
    otherwise = Char -> Char
    toLower Char
    c

    -- | Parses a space or tab.
    spaceChar :: Stream s m Char => ParserT s st m Char
    spaceChar :: ParserT s st m Char
    spaceChar = (Char -> Bool) -> ParserT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    (Char -> Bool) -> ParsecT s u m Char
    satisfy ((Char -> Bool) -> ParserT s st m Char)
    -> (Char -> Bool) -> ParserT s st m Char
    forall a b. (a -> b) -> a -> b
    $ \c :: Char
    c -> Char
    c Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    == ' ' Bool -> Bool -> Bool
    || Char
    c Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    == '\t'

    -- | Parses a nonspace, nonnewline character.
    nonspaceChar :: Stream s m Char => ParserT s st m Char
    nonspaceChar :: ParserT s st m Char
    nonspaceChar = String -> ParserT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    String -> ParsecT s u m Char
    noneOf ['\t', '\n', ' ', '\r']

    -- | Skips zero or more spaces or tabs.
    skipSpaces :: Stream s m Char => ParserT s st m ()
    skipSpaces :: ParserT s st m ()
    skipSpaces = ParsecT s st m Char -> ParserT s st m ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m ()
    skipMany ParsecT s st m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    spaceChar

    -- | Skips zero or more spaces or tabs, then reads a newline.
    blankline :: Stream s m Char => ParserT s st m Char
    blankline :: ParserT s st m Char
    blankline = ParserT s st m Char -> ParserT s st m Char
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT s st m Char -> ParserT s st m Char)
    -> ParserT s st m Char -> ParserT s st m Char
    forall a b. (a -> b) -> a -> b
    $ ParserT s st m ()
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m ()
    skipSpaces ParserT s st m () -> ParserT s st m Char -> ParserT s st m Char
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> ParserT s st m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    newline

    -- | Parses one or more blank lines and returns a string of newlines.
    blanklines :: Stream s m Char => ParserT s st m Text
    blanklines :: ParserT s st m Text
    blanklines = String -> Text
    T.pack (String -> Text) -> ParsecT s st m String -> ParserT s st m Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT s st m Char -> ParsecT s st m String
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m [a]
    many1 ParsecT s st m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    blankline

    -- | Gobble n spaces; if tabs are encountered, expand them
    -- and gobble some or all of their spaces, leaving the rest.
    gobbleSpaces :: (HasReaderOptions st, Monad m)
                 => Int -> ParserT Text st m ()
    gobbleSpaces :: Int -> ParserT Text st m ()
    gobbleSpaces 0 = () -> ParserT Text st m ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()
    gobbleSpaces n :: Int
    n
      | Int
    n Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    < 0     = String -> ParserT Text st m ()
    forall a. HasCallStack => String -> a
    error "gobbleSpaces called with negative number"
      | Bool
    otherwise = ParserT Text st m () -> ParserT Text st m ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text st m () -> ParserT Text st m ())
    -> ParserT Text st m () -> ParserT Text st m ()
    forall a b. (a -> b) -> a -> b
    $ do
          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
    -> 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
    <|> ParsecT Text st m Char
    forall st (m :: * -> *).
    (HasReaderOptions st, Monad m) =>
    ParserT Text st m Char
    eatOneSpaceOfTab
          Int -> ParserT Text st m ()
    forall st (m :: * -> *).
    (HasReaderOptions st, Monad m) =>
    Int -> ParserT Text st m ()
    gobbleSpaces (Int
    n Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - 1)

    eatOneSpaceOfTab :: (HasReaderOptions st, Monad m) => ParserT Text st m Char
    eatOneSpaceOfTab :: ParserT Text st m Char
    eatOneSpaceOfTab = do
      Char -> ParserT Text st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '\t'
      Int
    tabstop <- (ReaderOptions -> Int) -> ParserT Text st m Int
    forall st s (m :: * -> *) t b.
    (HasReaderOptions st, Stream s m t) =>
    (ReaderOptions -> b) -> ParserT s st m b
    getOption ReaderOptions -> Int
    readerTabStop
      Text
    inp <- ParsecT Text st m Text
    forall (m :: * -> *) s u. Monad m => ParsecT s u m s
    getInput
      Text -> ParsecT Text st m ()
    forall (m :: * -> *) s u. Monad m => s -> ParsecT s u m ()
    setInput (Text -> ParsecT Text st m ()) -> Text -> ParsecT Text st m ()
    forall a b. (a -> b) -> a -> b
    $ Int -> Text -> Text
    T.replicate (Int
    tabstop Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - 1) " " Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Text
    inp
      Char -> ParserT Text st m Char
    forall (m :: * -> *) a. Monad m => a -> m a
    return ' '

    -- | Gobble up to n spaces; if tabs are encountered, expand them
    -- and gobble some or all of their spaces, leaving the rest.
    gobbleAtMostSpaces :: (HasReaderOptions st, Monad m)
                       => Int -> ParserT Text st m Int
    gobbleAtMostSpaces :: Int -> ParserT Text st m Int
    gobbleAtMostSpaces 0 = Int -> ParserT Text st m Int
    forall (m :: * -> *) a. Monad m => a -> m a
    return 0
    gobbleAtMostSpaces n :: Int
    n
      | Int
    n Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    < 0     = String -> ParserT Text st m Int
    forall a. HasCallStack => String -> a
    error "gobbleAtMostSpaces called with negative number"
      | Bool
    otherwise = Int -> ParserT Text st m Int -> ParserT Text st m Int
    forall s (m :: * -> *) t a u.
    Stream s m t =>
    a -> ParsecT s u m a -> ParsecT s u m a
    option 0 (ParserT Text st m Int -> ParserT Text st m Int)
    -> ParserT Text st m Int -> ParserT Text st m Int
    forall a b. (a -> b) -> a -> b
    $ do
          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
    -> 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
    <|> ParsecT Text st m Char
    forall st (m :: * -> *).
    (HasReaderOptions st, Monad m) =>
    ParserT Text st m Char
    eatOneSpaceOfTab
          (Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + 1) (Int -> Int) -> ParserT Text st m Int -> ParserT Text st m Int
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Int -> ParserT Text st m Int
    forall st (m :: * -> *).
    (HasReaderOptions st, Monad m) =>
    Int -> ParserT Text st m Int
    gobbleAtMostSpaces (Int
    n Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - 1)

    -- | Parses material enclosed between start and end parsers.
    enclosed :: (Show end, Stream s  m Char) => ParserT s st m t   -- ^ start parser
             -> ParserT s st m end  -- ^ end parser
             -> ParserT s st m a    -- ^ content parser (to be used repeatedly)
             -> ParserT s st m [a]
    enclosed :: ParserT s st m t
    -> ParserT s st m end -> ParserT s st m a -> ParserT s st m [a]
    enclosed start :: ParserT s st m t
    start end :: ParserT s st m end
    end parser :: ParserT s st m a
    parser = ParserT s st m [a] -> ParserT s st m [a]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT s st m [a] -> ParserT s st m [a])
    -> ParserT s st m [a] -> ParserT s st m [a]
    forall a b. (a -> b) -> a -> b
    $
      ParserT s st m t
    start ParserT s st m t -> ParsecT s st m () -> ParsecT s st m ()
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> ParsecT s st m Char -> ParsecT s st m ()
    forall s (m :: * -> *) t a u.
    (Stream s m t, Show a) =>
    ParsecT s u m a -> ParsecT s u m ()
    notFollowedBy ParsecT s st m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    space ParsecT s st m () -> ParserT s st m [a] -> ParserT s st m [a]
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> ParserT s st m a -> ParserT s st m end -> ParserT s st m [a]
    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 s st m a
    parser ParserT s st m end
    end

    -- | Parse string, case insensitive.
    stringAnyCase :: Stream s m Char => Text -> ParserT s st m Text
    stringAnyCase :: Text -> ParserT s st m Text
    stringAnyCase = (String -> Text) -> ParsecT s st m String -> ParserT s st m Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap String -> Text
    T.pack (ParsecT s st m String -> ParserT s st m Text)
    -> (Text -> ParsecT s st m String) -> Text -> ParserT s st m Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . String -> ParsecT s st m String
    forall s (m :: * -> *) u.
    Stream s m Char =>
    String -> ParsecT s u m String
    stringAnyCase' (String -> ParsecT s st m String)
    -> (Text -> String) -> Text -> ParsecT s st m String
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> String
    T.unpack

    stringAnyCase' :: Stream s m Char => String -> ParserT s st m String
    stringAnyCase' :: String -> ParserT s st m String
    stringAnyCase' [] = String -> ParserT s st m String
    forall s (m :: * -> *) u.
    Stream s m Char =>
    String -> ParsecT s u m String
    string ""
    stringAnyCase' (x :: Char
    x:xs :: String
    xs) = do
      Char
    firstChar <- Char -> ParsecT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char (Char -> Char
    toUpper Char
    x) ParsecT s st m Char -> ParsecT s st m Char -> ParsecT s 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 s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char (Char -> Char
    toLower Char
    x)
      String
    rest <- String -> ParserT s st m String
    forall s (m :: * -> *) u.
    Stream s m Char =>
    String -> ParsecT s u m String
    stringAnyCase' String
    xs
      String -> ParserT s st m String
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Char
    firstCharChar -> String -> String
    forall a. a -> [a] -> [a]
    :String
    rest)

    -- | Parse contents of 'str' using 'parser' and return result.
    parseFromString :: (Stream s m Char, IsString s)
                    => ParserT s st m r
                    -> Text
                    -> ParserT s st m r
    parseFromString :: ParserT s st m r -> Text -> ParserT s st m r
    parseFromString parser :: ParserT s st m r
    parser str :: Text
    str = do
      SourcePos
    oldPos <- ParsecT s st m SourcePos
    forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
    getPosition
      SourcePos -> ParsecT s st m ()
    forall (m :: * -> *) s u. Monad m => SourcePos -> ParsecT s u m ()
    setPosition (SourcePos -> ParsecT s st m ()) -> SourcePos -> ParsecT s st m ()
    forall a b. (a -> b) -> a -> b
    $ String -> SourcePos
    initialPos "chunk"
      s
    oldInput <- ParsecT s st m s
    forall (m :: * -> *) s u. Monad m => ParsecT s u m s
    getInput
      s -> ParsecT s st m ()
    forall (m :: * -> *) s u. Monad m => s -> ParsecT s u m ()
    setInput (s -> ParsecT s st m ()) -> s -> ParsecT s st m ()
    forall a b. (a -> b) -> a -> b
    $ String -> s
    forall a. IsString a => String -> a
    fromString (String -> s) -> String -> s
    forall a b. (a -> b) -> a -> b
    $ Text -> String
    T.unpack Text
    str
      r
    result <- ParserT s st m r
    parser
      ParsecT s st m ()
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m ()
    spaces
      ParsecT s st m ()
    forall s (m :: * -> *) t u.
    (Stream s m t, Show t) =>
    ParsecT s u m ()
    eof
      s -> ParsecT s st m ()
    forall (m :: * -> *) s u. Monad m => s -> ParsecT s u m ()
    setInput s
    oldInput
      SourcePos -> ParsecT s st m ()
    forall (m :: * -> *) s u. Monad m => SourcePos -> ParsecT s u m ()
    setPosition SourcePos
    oldPos
      r -> ParserT s st m r
    forall (m :: * -> *) a. Monad m => a -> m a
    return r
    result

    -- | Like 'parseFromString' but specialized for 'ParserState'.
    -- This resets 'stateLastStrPos', which is almost always what we want.
    parseFromString' :: (Stream s m Char, IsString s, HasLastStrPosition u)
                     => ParserT s u m a
                     -> Text
                     -> ParserT s u m a
    parseFromString' :: ParserT s u m a -> Text -> ParserT s u m a
    parseFromString' parser :: ParserT s u m a
    parser str :: Text
    str = do
      Maybe SourcePos
    oldLastStrPos <- u -> Maybe SourcePos
    forall st. HasLastStrPosition st => st -> Maybe SourcePos
    getLastStrPos (u -> Maybe SourcePos)
    -> ParsecT s u m u -> ParsecT s u m (Maybe SourcePos)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT s u m u
    forall (m :: * -> *) s u. Monad m => ParsecT s u m u
    getState
      (u -> u) -> ParsecT s u m ()
    forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
    updateState ((u -> u) -> ParsecT s u m ()) -> (u -> u) -> ParsecT s u m ()
    forall a b. (a -> b) -> a -> b
    $ Maybe SourcePos -> u -> u
    forall st. HasLastStrPosition st => Maybe SourcePos -> st -> st
    setLastStrPos Maybe SourcePos
    forall a. Maybe a
    Nothing
      a
    res <- ParserT s u m a -> Text -> ParserT s u m a
    forall s (m :: * -> *) st r.
    (Stream s m Char, IsString s) =>
    ParserT s st m r -> Text -> ParserT s st m r
    parseFromString ParserT s u m a
    parser Text
    str
      (u -> u) -> ParsecT s u m ()
    forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
    updateState ((u -> u) -> ParsecT s u m ()) -> (u -> u) -> ParsecT s u m ()
    forall a b. (a -> b) -> a -> b
    $ Maybe SourcePos -> u -> u
    forall st. HasLastStrPosition st => Maybe SourcePos -> st -> st
    setLastStrPos Maybe SourcePos
    oldLastStrPos
      a -> ParserT s u m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return a
    res

    -- | Parse raw line block up to and including blank lines.
    lineClump :: Monad m => ParserT Text st m Text
    lineClump :: ParserT Text st m Text
    lineClump = ParserT Text st m Text
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Text
    blanklines
              ParserT Text st m Text
    -> ParserT Text st m Text -> ParserT Text st m Text
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ([Text] -> Text
    T.unlines ([Text] -> Text)
    -> ParsecT Text st m [Text] -> ParserT Text st m Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParserT Text st m Text -> ParsecT Text st m [Text]
    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 -> ParsecT 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 ParsecT Text st m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    blankline ParsecT Text st m ()
    -> ParserT Text st m Text -> ParserT Text st m Text
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> ParserT Text st m Text
    forall (m :: * -> *) st. Monad m => ParserT Text st m Text
    anyLine))

    -- | Parse a string of characters between an open character
    -- and a close character, including text between balanced
    -- pairs of open and close, which must be different. For example,
    -- @charsInBalanced '(' ')' anyChar@ will parse "(hello (there))"
    -- and return "hello (there)".
    charsInBalanced :: Stream s m Char => Char -> Char -> ParserT s st m Char
                    -> ParserT s st m Text
    charsInBalanced :: Char -> Char -> ParserT s st m Char -> ParserT s st m Text
    charsInBalanced open :: Char
    open close :: Char
    close parser :: ParserT s st m Char
    parser = ParserT s st m Text -> ParserT s st m Text
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT s st m Text -> ParserT s st m Text)
    -> ParserT s st m Text -> ParserT s st m Text
    forall a b. (a -> b) -> a -> b
    $ do
      Char -> ParserT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char Char
    open
      let isDelim :: Char -> Bool
    isDelim c :: Char
    c = Char
    c Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    == Char
    open Bool -> Bool -> Bool
    || Char
    c Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    == Char
    close
      [Text]
    raw <- ParserT s st m Text -> ParsecT s st m [Text]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many (ParserT s st m Text -> ParsecT s st m [Text])
    -> ParserT s st m Text -> ParsecT s st m [Text]
    forall a b. (a -> b) -> a -> b
    $  String -> Text
    T.pack (String -> Text) -> ParsecT s st m String -> ParserT s st m Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParserT s st m Char -> ParsecT s st m String
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m [a]
    many1 (ParserT s st m Char -> ParsecT s 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 -> Bool) -> ParserT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    (Char -> Bool) -> ParsecT s u m Char
    satisfy Char -> Bool
    isDelim) ParsecT s st m () -> ParserT s st m Char -> ParserT s st m Char
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> ParserT s st m Char
    parser)
                 ParserT s st m Text -> ParserT s st m Text -> ParserT s st m Text
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> (do Text
    res <- Char -> Char -> ParserT s st m Char -> ParserT s st m Text
    forall s (m :: * -> *) st.
    Stream s m Char =>
    Char -> Char -> ParserT s st m Char -> ParserT s st m Text
    charsInBalanced Char
    open Char
    close ParserT s st m Char
    parser
                         Text -> ParserT s st m Text
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Text -> ParserT s st m Text) -> Text -> ParserT s st m Text
    forall a b. (a -> b) -> a -> b
    $ Char -> Text
    T.singleton Char
    open Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Text
    res Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Char -> Text
    T.singleton Char
    close)
      Char -> ParserT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char Char
    close
      Text -> ParserT s st m Text
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Text -> ParserT s st m Text) -> Text -> ParserT s st m Text
    forall a b. (a -> b) -> a -> b
    $ [Text] -> Text
    T.concat [Text]
    raw

    -- old charsInBalanced would be:
    -- charsInBalanced open close (noneOf "\n" <|> char '\n' >> notFollowedBy blankline)
    -- old charsInBalanced' would be:
    -- charsInBalanced open close anyChar

    -- Auxiliary functions for romanNumeral:

    -- | Parses a roman numeral (uppercase or lowercase), returns number.
    romanNumeral :: Stream s m Char => Bool                  -- ^ Uppercase if true
                 -> ParserT s st m Int
    romanNumeral :: Bool -> ParserT s st m Int
    romanNumeral upperCase :: Bool
    upperCase = do
        let rchar :: Char -> ParsecT s u m Char
    rchar uc :: Char
    uc = Char -> ParsecT s u m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char (Char -> ParsecT s u m Char) -> Char -> ParsecT s u m Char
    forall a b. (a -> b) -> a -> b
    $ if Bool
    upperCase then Char
    uc else Char -> Char
    toLower Char
    uc
        let one :: ParsecT s u m Char
    one         = Char -> ParsecT s u m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    rchar 'I'
        let five :: ParsecT s u m Char
    five        = Char -> ParsecT s u m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    rchar 'V'
        let ten :: ParsecT s u m Char
    ten         = Char -> ParsecT s u m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    rchar 'X'
        let fifty :: ParsecT s u m Char
    fifty       = Char -> ParsecT s u m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    rchar 'L'
        let hundred :: ParsecT s u m Char
    hundred     = Char -> ParsecT s u m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    rchar 'C'
        let fivehundred :: ParsecT s u m Char
    fivehundred = Char -> ParsecT s u m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    rchar 'D'
        let thousand :: ParsecT s u m Char
    thousand    = Char -> ParsecT s u m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    rchar 'M'
        ParsecT s st m Char -> ParsecT s st m Char
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m a
    lookAhead (ParsecT s st m Char -> ParsecT s st m Char)
    -> ParsecT s st m Char -> ParsecT s st m Char
    forall a b. (a -> b) -> a -> b
    $ [ParsecT s st m Char] -> ParsecT s st m Char
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    [ParsecT s u m a] -> ParsecT s u m a
    choice [ParsecT s st m Char
    forall u. ParsecT s u m Char
    one, ParsecT s st m Char
    forall u. ParsecT s u m Char
    five, ParsecT s st m Char
    forall u. ParsecT s u m Char
    ten, ParsecT s st m Char
    forall u. ParsecT s u m Char
    fifty, ParsecT s st m Char
    forall u. ParsecT s u m Char
    hundred, ParsecT s st m Char
    forall u. ParsecT s u m Char
    fivehundred, ParsecT s st m Char
    forall u. ParsecT s u m Char
    thousand]
        Int
    thousands <- ((1000 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    *) (Int -> Int) -> (String -> Int) -> String -> Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . String -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    length) (String -> Int) -> ParsecT s st m String -> ParserT s st m Int
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT s st m Char -> ParsecT s st m String
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many ParsecT s st m Char
    forall u. ParsecT s u m Char
    thousand
        Int
    ninehundreds <- Int -> ParserT s st m Int -> ParserT s st m Int
    forall s (m :: * -> *) t a u.
    Stream s m t =>
    a -> ParsecT s u m a -> ParsecT s u m a
    option 0 (ParserT s st m Int -> ParserT s st m Int)
    -> ParserT s st m Int -> ParserT s st m Int
    forall a b. (a -> b) -> a -> b
    $ ParserT s st m Int -> ParserT s st m Int
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT s st m Int -> ParserT s st m Int)
    -> ParserT s st m Int -> ParserT s st m Int
    forall a b. (a -> b) -> a -> b
    $ ParsecT s st m Char
    forall u. ParsecT s u m Char
    hundred ParsecT s st m Char -> ParsecT s st m Char -> ParsecT s st m Char
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> ParsecT s st m Char
    forall u. ParsecT s u m Char
    thousand ParsecT s st m Char -> ParserT s st m Int -> ParserT s st m Int
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> Int -> ParserT s st m Int
    forall (m :: * -> *) a. Monad m => a -> m a
    return 900
        Int
    fivehundreds <- Int -> ParserT s st m Int -> ParserT s st m Int
    forall s (m :: * -> *) t a u.
    Stream s m t =>
    a -> ParsecT s u m a -> ParsecT s u m a
    option 0 (ParserT s st m Int -> ParserT s st m Int)
    -> ParserT s st m Int -> ParserT s st m Int
    forall a b. (a -> b) -> a -> b
    $ 500 Int -> ParsecT s st m Char -> ParserT s st m Int
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ ParsecT s st m Char
    forall u. ParsecT s u m Char
    fivehundred
        Int
    fourhundreds <- Int -> ParserT s st m Int -> ParserT s st m Int
    forall s (m :: * -> *) t a u.
    Stream s m t =>
    a -> ParsecT s u m a -> ParsecT s u m a
    option 0 (ParserT s st m Int -> ParserT s st m Int)
    -> ParserT s st m Int -> ParserT s st m Int
    forall a b. (a -> b) -> a -> b
    $ ParserT s st m Int -> ParserT s st m Int
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT s st m Int -> ParserT s st m Int)
    -> ParserT s st m Int -> ParserT s st m Int
    forall a b. (a -> b) -> a -> b
    $ ParsecT s st m Char
    forall u. ParsecT s u m Char
    hundred ParsecT s st m Char -> ParsecT s st m Char -> ParsecT s st m Char
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> ParsecT s st m Char
    forall u. ParsecT s u m Char
    fivehundred ParsecT s st m Char -> ParserT s st m Int -> ParserT s st m Int
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> Int -> ParserT s st m Int
    forall (m :: * -> *) a. Monad m => a -> m a
    return 400
        Int
    hundreds <- ((100 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    *) (Int -> Int) -> (String -> Int) -> String -> Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . String -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    length) (String -> Int) -> ParsecT s st m String -> ParserT s st m Int
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT s st m Char -> ParsecT s st m String
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many ParsecT s st m Char
    forall u. ParsecT s u m Char
    hundred
        Int
    nineties <- Int -> ParserT s st m Int -> ParserT s st m Int
    forall s (m :: * -> *) t a u.
    Stream s m t =>
    a -> ParsecT s u m a -> ParsecT s u m a
    option 0 (ParserT s st m Int -> ParserT s st m Int)
    -> ParserT s st m Int -> ParserT s st m Int
    forall a b. (a -> b) -> a -> b
    $ ParserT s st m Int -> ParserT s st m Int
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT s st m Int -> ParserT s st m Int)
    -> ParserT s st m Int -> ParserT s st m Int
    forall a b. (a -> b) -> a -> b
    $ ParsecT s st m Char
    forall u. ParsecT s u m Char
    ten ParsecT s st m Char -> ParsecT s st m Char -> ParsecT s st m Char
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> ParsecT s st m Char
    forall u. ParsecT s u m Char
    hundred ParsecT s st m Char -> ParserT s st m Int -> ParserT s st m Int
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> Int -> ParserT s st m Int
    forall (m :: * -> *) a. Monad m => a -> m a
    return 90
        Int
    fifties <- Int -> ParserT s st m Int -> ParserT s st m Int
    forall s (m :: * -> *) t a u.
    Stream s m t =>
    a -> ParsecT s u m a -> ParsecT s u m a
    option 0 (50 Int -> ParsecT s st m Char -> ParserT s st m Int
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ ParsecT s st m Char
    forall u. ParsecT s u m Char
    fifty)
        Int
    forties <- Int -> ParserT s st m Int -> ParserT s st m Int
    forall s (m :: * -> *) t a u.
    Stream s m t =>
    a -> ParsecT s u m a -> ParsecT s u m a
    option 0 (ParserT s st m Int -> ParserT s st m Int)
    -> ParserT s st m Int -> ParserT s st m Int
    forall a b. (a -> b) -> a -> b
    $ ParserT s st m Int -> ParserT s st m Int
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT s st m Int -> ParserT s st m Int)
    -> ParserT s st m Int -> ParserT s st m Int
    forall a b. (a -> b) -> a -> b
    $ ParsecT s st m Char
    forall u. ParsecT s u m Char
    ten ParsecT s st m Char -> ParsecT s st m Char -> ParsecT s st m Char
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> ParsecT s st m Char
    forall u. ParsecT s u m Char
    fifty ParsecT s st m Char -> ParserT s st m Int -> ParserT s st m Int
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> Int -> ParserT s st m Int
    forall (m :: * -> *) a. Monad m => a -> m a
    return 40
        Int
    tens <- ((10 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    *) (Int -> Int) -> (String -> Int) -> String -> Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . String -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    length) (String -> Int) -> ParsecT s st m String -> ParserT s st m Int
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT s st m Char -> ParsecT s st m String
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many ParsecT s st m Char
    forall u. ParsecT s u m Char
    ten
        Int
    nines <- Int -> ParserT s st m Int -> ParserT s st m Int
    forall s (m :: * -> *) t a u.
    Stream s m t =>
    a -> ParsecT s u m a -> ParsecT s u m a
    option 0 (ParserT s st m Int -> ParserT s st m Int)
    -> ParserT s st m Int -> ParserT s st m Int
    forall a b. (a -> b) -> a -> b
    $ ParserT s st m Int -> ParserT s st m Int
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT s st m Int -> ParserT s st m Int)
    -> ParserT s st m Int -> ParserT s st m Int
    forall a b. (a -> b) -> a -> b
    $ ParsecT s st m Char
    forall u. ParsecT s u m Char
    one ParsecT s st m Char -> ParsecT s st m Char -> ParsecT s st m Char
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> ParsecT s st m Char
    forall u. ParsecT s u m Char
    ten ParsecT s st m Char -> ParserT s st m Int -> ParserT s st m Int
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> Int -> ParserT s st m Int
    forall (m :: * -> *) a. Monad m => a -> m a
    return 9
        Int
    fives <- Int -> ParserT s st m Int -> ParserT s st m Int
    forall s (m :: * -> *) t a u.
    Stream s m t =>
    a -> ParsecT s u m a -> ParsecT s u m a
    option 0 (5 Int -> ParsecT s st m Char -> ParserT s st m Int
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ ParsecT s st m Char
    forall u. ParsecT s u m Char
    five)
        Int
    fours <- Int -> ParserT s st m Int -> ParserT s st m Int
    forall s (m :: * -> *) t a u.
    Stream s m t =>
    a -> ParsecT s u m a -> ParsecT s u m a
    option 0 (ParserT s st m Int -> ParserT s st m Int)
    -> ParserT s st m Int -> ParserT s st m Int
    forall a b. (a -> b) -> a -> b
    $ ParserT s st m Int -> ParserT s st m Int
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT s st m Int -> ParserT s st m Int)
    -> ParserT s st m Int -> ParserT s st m Int
    forall a b. (a -> b) -> a -> b
    $ ParsecT s st m Char
    forall u. ParsecT s u m Char
    one ParsecT s st m Char -> ParsecT s st m Char -> ParsecT s st m Char
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> ParsecT s st m Char
    forall u. ParsecT s u m Char
    five ParsecT s st m Char -> ParserT s st m Int -> ParserT s st m Int
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> Int -> ParserT s st m Int
    forall (m :: * -> *) a. Monad m => a -> m a
    return 4
        Int
    ones <- String -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    length (String -> Int) -> ParsecT s st m String -> ParserT s st m Int
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT s st m Char -> ParsecT s st m String
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many ParsecT s st m Char
    forall u. ParsecT s u m Char
    one
        let total :: Int
    total = Int
    thousands Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    ninehundreds Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    fivehundreds Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    fourhundreds Int -> Int -> Int
    forall a. Num a => a -> a -> a
    +
                    Int
    hundreds Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    nineties Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    fifties Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    forties Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    tens Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    nines Int -> Int -> Int
    forall a. Num a => a -> a -> a
    +
                    Int
    fives Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    fours Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    ones
        if Int
    total Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == 0
           then String -> ParserT s st m Int
    forall (m :: * -> *) a. MonadFail m => String -> m a
    Prelude.fail "not a roman numeral"
           else Int -> ParserT s st m Int
    forall (m :: * -> *) a. Monad m => a -> m a
    return Int
    total

    -- Parsers for email addresses and URIs

    -- | Parses an email address; returns original and corresponding
    -- escaped mailto: URI.
    emailAddress :: Stream s m Char => ParserT s st m (Text, Text)
    emailAddress :: ParserT s st m (Text, Text)
    emailAddress = ParserT s st m (Text, Text) -> ParserT s st m (Text, Text)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT s st m (Text, Text) -> ParserT s st m (Text, Text))
    -> ParserT s st m (Text, Text) -> ParserT s st m (Text, Text)
    forall a b. (a -> b) -> a -> b
    $ String -> String -> (Text, Text)
    toResult (String -> String -> (Text, Text))
    -> ParsecT s st m String -> ParsecT s st m (String -> (Text, Text))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT s st m String
    forall u. ParsecT s u m String
    mailbox ParsecT s st m (String -> (Text, Text))
    -> ParsecT s st m String -> ParserT s st m (Text, Text)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Char -> ParsecT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '@' ParsecT s st m Char
    -> ParsecT s st m String -> ParsecT s st m String
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> ParsecT s st m String
    forall u. ParsecT s u m String
    domain)
     where toResult :: String -> String -> (Text, Text)
    toResult mbox :: String
    mbox dom :: String
    dom = let full :: Text
    full = Text -> Text
    fromEntities (Text -> Text) -> Text -> Text
    forall a b. (a -> b) -> a -> b
    $ String -> Text
    T.pack (String -> Text) -> String -> Text
    forall a b. (a -> b) -> a -> b
    $ String
    mbox String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ '@'Char -> String -> String
    forall a. a -> [a] -> [a]
    :String
    dom
                               in  (Text
    full, Text -> Text
    escapeURI (Text -> Text) -> Text -> Text
    forall a b. (a -> b) -> a -> b
    $ "mailto:" Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Text
    full)
           mailbox :: ParsecT s u m String
    mailbox           = String -> [String] -> String
    forall a. [a] -> [[a]] -> [a]
    intercalate "." ([String] -> String)
    -> ParsecT s u m [String] -> ParsecT s u m String
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (ParsecT s u m String
    forall u. ParsecT s u m String
    emailWord ParsecT s u m String
    -> ParsecT s u m Char -> ParsecT s u m [String]
    forall s u (m :: * -> *) a sep.
    ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
    `sepBy1'` ParsecT s u m Char
    forall u. ParsecT s u m Char
    dot)
           domain :: ParsecT s u m String
    domain            = String -> [String] -> String
    forall a. [a] -> [[a]] -> [a]
    intercalate "." ([String] -> String)
    -> ParsecT s u m [String] -> ParsecT s u m String
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (ParsecT s u m String
    forall u. ParsecT s u m String
    subdomain ParsecT s u m String
    -> ParsecT s u m Char -> ParsecT s u m [String]
    forall s u (m :: * -> *) a sep.
    ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
    `sepBy1'` ParsecT s u m Char
    forall u. ParsecT s u m Char
    dot)
           dot :: ParsecT s u m Char
    dot               = Char -> ParsecT s u m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '.'
           subdomain :: ParsecT s u m String
    subdomain         = ParsecT s u m Char -> ParsecT s u m String
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m [a]
    many1 (ParsecT s u m Char -> ParsecT s u m String)
    -> ParsecT s u m Char -> ParsecT s u m String
    forall a b. (a -> b) -> a -> b
    $ ParsecT s u m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    alphaNum ParsecT s u m Char -> ParsecT s u m Char -> ParsecT s u m Char
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT s u m Char
    forall u. ParsecT s u m Char
    innerPunct
           -- this excludes some valid email addresses, since an
           -- email could contain e.g. '__', but gives better results
           -- for our purposes, when combined with markdown parsing:
           innerPunct :: ParsecT s u m Char
    innerPunct        = ParsecT s u m Char -> ParsecT s u m Char
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try ((Char -> Bool) -> ParsecT s u m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    (Char -> Bool) -> ParsecT s u m Char
    satisfy (\c :: Char
    c -> Char -> Bool
    isEmailPunct Char
    c Bool -> Bool -> Bool
    || Char
    c Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    == '@')
                                     ParsecT s u m Char -> ParsecT s u m () -> ParsecT s u m Char
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT s u m Char -> ParsecT s u m ()
    forall s (m :: * -> *) t a u.
    (Stream s m t, Show a) =>
    ParsecT s u m a -> ParsecT s u m ()
    notFollowedBy ParsecT s u m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    space
                                     ParsecT s u m Char -> ParsecT s u m () -> ParsecT s u m Char
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT s u m Char -> ParsecT s u m ()
    forall s (m :: * -> *) t a u.
    (Stream s m t, Show a) =>
    ParsecT s u m a -> ParsecT s u m ()
    notFollowedBy ((Char -> Bool) -> ParsecT s u m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    (Char -> Bool) -> ParsecT s u m Char
    satisfy Char -> Bool
    isPunctuation))
           -- technically an email address could begin with a symbol,
           -- but allowing this creates too many problems.
           -- See e.g. https://github.com/jgm/pandoc/issues/2940
           emailWord :: ParsecT s u m String
    emailWord         = do Char
    x <- (Char -> Bool) -> ParsecT s u m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    (Char -> Bool) -> ParsecT s u m Char
    satisfy Char -> Bool
    isAlphaNum
                                  String
    xs <- ParsecT s u m Char -> ParsecT s u m String
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many ((Char -> Bool) -> ParsecT s u m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    (Char -> Bool) -> ParsecT s u m Char
    satisfy Char -> Bool
    isEmailChar)
                                  String -> ParsecT s u m String
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Char
    xChar -> String -> String
    forall a. a -> [a] -> [a]
    :String
    xs)
           isEmailChar :: Char -> Bool
    isEmailChar c :: Char
    c     = Char -> Bool
    isAlphaNum Char
    c Bool -> Bool -> Bool
    || Char -> Bool
    isEmailPunct Char
    c
           isEmailPunct :: Char -> Bool
    isEmailPunct c :: Char
    c    = (Char -> Bool) -> Text -> Bool
    T.any (Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    == Char
    c) "!\"#$%&'*+-/=?^_{|}~;"

    uriScheme :: Stream s m Char => ParserT s st m Text
    uriScheme :: ParserT s st m Text
    uriScheme = [Text] -> ParserT s st m Text
    forall s (m :: * -> *) st.
    Stream s m Char =>
    [Text] -> ParserT s st m Text
    oneOfStringsCI (Set Text -> [Text]
    forall a. Set a -> [a]
    Set.toList Set Text
    schemes)

    -- | Parses a URI. Returns pair of original and URI-escaped version.
    uri :: Stream s m Char => ParserT s st m (Text, Text)
    uri :: ParserT s st m (Text, Text)
    uri = ParserT s st m (Text, Text) -> ParserT s st m (Text, Text)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT s st m (Text, Text) -> ParserT s st m (Text, Text))
    -> ParserT s st m (Text, Text) -> ParserT s st m (Text, Text)
    forall a b. (a -> b) -> a -> b
    $ do
      Text
    scheme <- ParserT s st m Text
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Text
    uriScheme
      Char -> ParsecT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char ':'
      -- Avoid parsing e.g. "**Notes:**" as a raw URI:
      ParsecT s st m Char -> ParsecT s st m ()
    forall s (m :: * -> *) t a u.
    (Stream s m t, Show a) =>
    ParsecT s u m a -> ParsecT s u m ()
    notFollowedBy (String -> ParsecT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    String -> ParsecT s u m Char
    oneOf "*_]")
      -- We allow sentence punctuation except at the end, since
      -- we don't want the trailing '.' in 'http://google.com.' We want to allow
      -- http://en.wikipedia.org/wiki/State_of_emergency_(disambiguation)
      -- as a URL, while NOT picking up the closing paren in
      -- (http://wikipedia.org). So we include balanced parens in the URL.
      Text
    str <- [Text] -> Text
    T.concat ([Text] -> Text) -> ParsecT s st m [Text] -> ParserT s st m Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParserT s st m Text -> ParsecT s st m [Text]
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m [a]
    many1 (Char -> Char -> ParserT s st m Text
    forall u. Char -> Char -> ParsecT s u m Text
    uriChunkBetween '(' ')'
                            ParserT s st m Text -> ParserT s st m Text -> ParserT s st m Text
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> Char -> Char -> ParserT s st m Text
    forall u. Char -> Char -> ParsecT s u m Text
    uriChunkBetween '{' '}'
                            ParserT s st m Text -> ParserT s st m Text -> ParserT s st m Text
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> Char -> Char -> ParserT s st m Text
    forall u. Char -> Char -> ParsecT s u m Text
    uriChunkBetween '[' ']'
                            ParserT s st m Text -> ParserT s st m Text -> ParserT s st m Text
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> String -> Text
    T.pack (String -> Text) -> ParsecT s st m String -> ParserT s st m Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT s st m String
    forall u. ParsecT s u m String
    uriChunk)
      Text
    str' <- Text -> ParserT s st m Text -> ParserT s st 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
    str (ParserT s st m Text -> ParserT s st m Text)
    -> ParserT s st m Text -> ParserT s st m Text
    forall a b. (a -> b) -> a -> b
    $ Char -> ParsecT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '/' ParsecT s st m Char -> ParserT s st m Text -> ParserT s st m Text
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> Text -> ParserT s st m Text
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Text
    str Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> "/")
      let uri' :: Text
    uri' = Text
    scheme Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> ":" Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Text -> Text
    fromEntities Text
    str'
      (Text, Text) -> ParserT s st m (Text, Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Text
    uri', Text -> Text
    escapeURI Text
    uri')
      where
        wordChar :: ParsecT s u m Char
    wordChar = ParsecT s u m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    alphaNum ParsecT s u m Char -> ParsecT s u m Char -> ParsecT s u m Char
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> String -> ParsecT s u m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    String -> ParsecT s u m Char
    oneOf "#$%+/@\\_-&="
        percentEscaped :: ParsecT s u m String
    percentEscaped = ParsecT s u m String -> ParsecT s u m String
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT s u m String -> ParsecT s u m String)
    -> ParsecT s u m String -> ParsecT s u m String
    forall a b. (a -> b) -> a -> b
    $ (:) (Char -> String -> String)
    -> ParsecT s u m Char -> ParsecT s u m (String -> String)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Char -> ParsecT s u m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '%' ParsecT s u m (String -> String)
    -> ParsecT s u m String -> ParsecT s u m String
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ParsecT s u m Char -> ParsecT s u m String
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m [a]
    many1 ParsecT s u m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    hexDigit
        entity :: ParsecT s u m String
    entity = ParsecT s u m String -> ParsecT s u m String
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT s u m String -> ParsecT s u m String)
    -> ParsecT s u m String -> ParsecT s u m String
    forall a b. (a -> b) -> a -> b
    $ Char -> String
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Char -> String) -> ParsecT s u m Char -> ParsecT s u m String
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT s u m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    characterReference
        punct :: ParsecT s u m String
    punct = ParsecT s u m String -> ParsecT s u m String
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT s u m String -> ParsecT s u m String)
    -> ParsecT s u m String -> ParsecT s u m String
    forall a b. (a -> b) -> a -> b
    $ ParsecT s u m Char -> ParsecT s u m String
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m [a]
    many1 (Char -> ParsecT s u m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char ',') ParsecT s u m String
    -> ParsecT s u m String -> ParsecT s u m String
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> (Char -> String) -> ParsecT s u m Char -> ParsecT s u m String
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Char -> String
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure ((Char -> Bool) -> ParsecT s u m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    (Char -> Bool) -> ParsecT s u m Char
    satisfy (\c :: Char
    c -> Bool -> Bool
    not (Char -> Bool
    isSpace Char
    c) Bool -> Bool -> Bool
    && Char
    c Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    /= '<' Bool -> Bool -> Bool
    && Char
    c Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    /= '>'))
        uriChunk :: ParsecT s u m String
    uriChunk = ParsecT s u m Char -> ParsecT s u m String
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m [a]
    many1 ParsecT s u m Char
    forall u. ParsecT s u m Char
    wordChar
               ParsecT s u m String
    -> ParsecT s u m String -> ParsecT s u m String
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT s u m String
    forall u. ParsecT s u m String
    percentEscaped
               ParsecT s u m String
    -> ParsecT s u m String -> ParsecT s u m String
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT s u m String
    forall u. ParsecT s u m String
    entity
               ParsecT s u m String
    -> ParsecT s u m String -> ParsecT s u m String
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT s u m String -> ParsecT s u m String
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT s u m String
    forall u. ParsecT s u m String
    punct ParsecT s u m String -> ParsecT s u m () -> ParsecT s u m String
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT s u m () -> ParsecT s u m ()
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m a
    lookAhead (ParsecT s u m Char -> ParsecT s u m ()
    forall (f :: * -> *) a. Functor f => f a -> f ()
    void ParsecT s u m Char
    forall u. ParsecT s u m Char
    wordChar ParsecT s u m () -> ParsecT s u m () -> ParsecT s u m ()
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT s u m String -> ParsecT s u m ()
    forall (f :: * -> *) a. Functor f => f a -> f ()
    void ParsecT s u m String
    forall u. ParsecT s u m String
    percentEscaped))
        uriChunkBetween :: Char -> Char -> ParsecT s u m Text
    uriChunkBetween l :: Char
    l r :: Char
    r = ParsecT s u m Text -> ParsecT s u m Text
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT s u m Text -> ParsecT s u m Text)
    -> ParsecT s u m Text -> ParsecT s u m Text
    forall a b. (a -> b) -> a -> b
    $ do String
    chunk <- ParsecT s u m Char
    -> ParsecT s u m Char
    -> ParsecT s u m String
    -> ParsecT s u m String
    forall s (m :: * -> *) t u open close a.
    Stream s m t =>
    ParsecT s u m open
    -> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
    between (Char -> ParsecT s u m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char Char
    l) (Char -> ParsecT s u m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char Char
    r) ParsecT s u m String
    forall u. ParsecT s u m String
    uriChunk
                                       Text -> ParsecT s u m Text
    forall (m :: * -> *) a. Monad m => a -> m a
    return (String -> Text
    T.pack (String -> Text) -> String -> Text
    forall a b. (a -> b) -> a -> b
    $ [Char
    l] String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    chunk String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ [Char
    r])

    mathInlineWith :: Stream s m Char  => Text -> Text -> ParserT s st m Text
    mathInlineWith :: Text -> Text -> ParserT s st m Text
    mathInlineWith op :: Text
    op cl :: Text
    cl = ParserT s st m Text -> ParserT s st m Text
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT s st m Text -> ParserT s st m Text)
    -> ParserT s st m Text -> ParserT s st m Text
    forall a b. (a -> b) -> a -> b
    $ do
      Text -> ParserT s st m Text
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Text -> ParsecT s u m Text
    textStr Text
    op
      Bool -> ParsecT s st m () -> ParsecT s st m ()
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    when (Text
    op Text -> Text -> Bool
    forall a. Eq a => a -> a -> Bool
    == "$") (ParsecT s st m () -> ParsecT s st m ())
    -> ParsecT s st m () -> ParsecT s st m ()
    forall a b. (a -> b) -> a -> b
    $ ParsecT s st m Char -> ParsecT s st m ()
    forall s (m :: * -> *) t a u.
    (Stream s m t, Show a) =>
    ParsecT s u m a -> ParsecT s u m ()
    notFollowedBy ParsecT s st m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    space
      [Text]
    words' <- ParserT s st m Text -> ParserT s st m Text -> ParserT s st 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 (Int -> ParsecT s st m Char -> ParserT s st m Text
    forall s (m :: * -> *) st.
    (Stream s m Char, Monad m) =>
    Int -> ParsecT s st m Char -> ParsecT s st m Text
    countChar 1 (String -> ParsecT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    String -> ParsecT s u m Char
    noneOf " \t\n\\")
                       ParserT s st m Text -> ParserT s st m Text -> ParserT s st m Text
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> (Char -> ParsecT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '\\' ParsecT s st m Char -> ParserT s st m Text -> ParserT s st m Text
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >>
                               -- This next clause is needed because \text{..} can
                               -- contain $, \(\), etc.
                               (ParserT s st m Text -> ParserT s st m Text
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (String -> ParsecT s st m String
    forall s (m :: * -> *) u.
    Stream s m Char =>
    String -> ParsecT s u m String
    string "text" ParsecT s st m String -> ParserT s st m Text -> ParserT s st m Text
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >>
                                     (("\\text" Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <>) (Text -> Text) -> ParserT s st m Text -> ParserT s st m Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Int -> Text -> ParserT s st m Text
    forall s (m :: * -> *) st.
    Stream s m Char =>
    Int -> Text -> ParserT s st m Text
    inBalancedBraces 0 ""))
                                ParserT s st m Text -> ParserT s st m Text -> ParserT s st m Text
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|>  (\c :: Char
    c -> String -> Text
    T.pack ['\\',Char
    c]) (Char -> Text) -> ParsecT s st m Char -> ParserT s st m Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT s st m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    anyChar))
                       ParserT s st m Text -> ParserT s st m Text -> ParserT s st m Text
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> do (ParsecT s st m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    blankline ParsecT s st m Char -> ParsecT s st m () -> ParsecT s st m Char
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT s st m Char -> ParsecT s st m ()
    forall b s (m :: * -> *) a st.
    (Show b, Stream s m a) =>
    ParserT s st m b -> ParserT s st m ()
    notFollowedBy' ParsecT s st m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    blankline) ParsecT s st m Char -> ParsecT s st m Char -> ParsecT s st m Char
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|>
                                 (String -> ParsecT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    String -> ParsecT s u m Char
    oneOf " \t" ParsecT s st m Char -> ParsecT s st m () -> ParsecT s st m Char
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT s st m Char -> ParsecT s st m ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m ()
    skipMany (String -> ParsecT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    String -> ParsecT s u m Char
    oneOf " \t"))
                              ParsecT s st m Char -> ParsecT s 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 s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '$')
                              Text -> ParserT s st m Text
    forall (m :: * -> *) a. Monad m => a -> m a
    return " "
                        ) (ParserT s st m Text -> ParserT s st m Text
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT s st m Text -> ParserT s st m Text)
    -> ParserT s st m Text -> ParserT s st m Text
    forall a b. (a -> b) -> a -> b
    $ Text -> ParserT s st m Text
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Text -> ParsecT s u m Text
    textStr Text
    cl)
      ParsecT s st m Char -> ParsecT s st m ()
    forall s (m :: * -> *) t a u.
    (Stream s m t, Show a) =>
    ParsecT s u m a -> ParsecT s u m ()
    notFollowedBy ParsecT s st m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    digit  -- to prevent capture of $5
      Text -> ParserT s st m Text
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Text -> ParserT s st m Text) -> Text -> ParserT s st m Text
    forall a b. (a -> b) -> a -> b
    $ Text -> Text
    trimMath (Text -> Text) -> Text -> Text
    forall a b. (a -> b) -> a -> b
    $ [Text] -> Text
    T.concat [Text]
    words'
     where
      inBalancedBraces :: Stream s m Char => Int -> Text -> ParserT s st m Text
      inBalancedBraces :: Int -> Text -> ParserT s st m Text
    inBalancedBraces n :: Int
    n = (String -> Text) -> ParsecT s st m String -> ParserT s st m Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap String -> Text
    T.pack (ParsecT s st m String -> ParserT s st m Text)
    -> (Text -> ParsecT s st m String) -> Text -> ParserT s st m Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> String -> ParsecT s st m String
    forall s (m :: * -> *) st.
    Stream s m Char =>
    Int -> String -> ParserT s st m String
    inBalancedBraces' Int
    n (String -> ParsecT s st m String)
    -> (Text -> String) -> Text -> ParsecT s st m String
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> String
    T.unpack

      inBalancedBraces' :: Stream s m Char => Int -> String -> ParserT s st m String
      inBalancedBraces' :: Int -> String -> ParserT s st m String
    inBalancedBraces' 0 "" = do
        Char
    c <- ParsecT s st m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    anyChar
        if Char
    c Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    == '{'
           then Int -> String -> ParserT s st m String
    forall s (m :: * -> *) st.
    Stream s m Char =>
    Int -> String -> ParserT s st m String
    inBalancedBraces' 1 "{"
           else ParserT s st m String
    forall (m :: * -> *) a. MonadPlus m => m a
    mzero
      inBalancedBraces' 0 s :: String
    s = String -> ParserT s st m String
    forall (m :: * -> *) a. Monad m => a -> m a
    return (String -> ParserT s st m String)
    -> String -> ParserT s st m String
    forall a b. (a -> b) -> a -> b
    $ String -> String
    forall a. [a] -> [a]
    reverse String
    s
      inBalancedBraces' numOpen :: Int
    numOpen ('\\':xs :: String
    xs) = do
        Char
    c <- ParsecT s st m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    anyChar
        Int -> String -> ParserT s st m String
    forall s (m :: * -> *) st.
    Stream s m Char =>
    Int -> String -> ParserT s st m String
    inBalancedBraces' Int
    numOpen (Char
    cChar -> String -> String
    forall a. a -> [a] -> [a]
    :'\\'Char -> String -> String
    forall a. a -> [a] -> [a]
    :String
    xs)
      inBalancedBraces' numOpen :: Int
    numOpen xs :: String
    xs = do
        Char
    c <- ParsecT s st m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    anyChar
        case Char
    c of
             '}' -> Int -> String -> ParserT s st m String
    forall s (m :: * -> *) st.
    Stream s m Char =>
    Int -> String -> ParserT s st m String
    inBalancedBraces' (Int
    numOpen Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - 1) (Char
    cChar -> String -> String
    forall a. a -> [a] -> [a]
    :String
    xs)
             '{' -> Int -> String -> ParserT s st m String
    forall s (m :: * -> *) st.
    Stream s m Char =>
    Int -> String -> ParserT s st m String
    inBalancedBraces' (Int
    numOpen Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + 1) (Char
    cChar -> String -> String
    forall a. a -> [a] -> [a]
    :String
    xs)
             _   -> Int -> String -> ParserT s st m String
    forall s (m :: * -> *) st.
    Stream s m Char =>
    Int -> String -> ParserT s st m String
    inBalancedBraces' Int
    numOpen (Char
    cChar -> String -> String
    forall a. a -> [a] -> [a]
    :String
    xs)

    mathDisplayWith :: Stream s m Char => Text -> Text -> ParserT s st m Text
    mathDisplayWith :: Text -> Text -> ParserT s st m Text
    mathDisplayWith op :: Text
    op cl :: Text
    cl = ParserT s st m Text -> ParserT s st m Text
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT s st m Text -> ParserT s st m Text)
    -> ParserT s st m Text -> ParserT s st m Text
    forall a b. (a -> b) -> a -> b
    $ (String -> Text) -> ParsecT s st m String -> ParserT s st m Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap String -> Text
    T.pack (ParsecT s st m String -> ParserT s st m Text)
    -> ParsecT s st m String -> ParserT s st m Text
    forall a b. (a -> b) -> a -> b
    $ do
      Text -> ParserT s st m Text
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Text -> ParsecT s u m Text
    textStr Text
    op
      ParserT s st m Char -> ParserT s st m Text -> ParsecT s st m String
    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 (String -> ParserT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    String -> ParsecT s u m Char
    noneOf "\n" ParserT s st m Char -> ParserT s st m Char -> ParserT s st m Char
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> (ParserT s st m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    newline ParserT s st m Char -> ParsecT s st m () -> ParserT s st m Char
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParserT s st m Char -> ParsecT s st m ()
    forall b s (m :: * -> *) a st.
    (Show b, Stream s m a) =>
    ParserT s st m b -> ParserT s st m ()
    notFollowedBy' ParserT s st m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    blankline)) (ParserT s st m Text -> ParserT s st m Text
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT s st m Text -> ParserT s st m Text)
    -> ParserT s st m Text -> ParserT s st m Text
    forall a b. (a -> b) -> a -> b
    $ Text -> ParserT s st m Text
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Text -> ParsecT s u m Text
    textStr Text
    cl)

    mathDisplay :: (HasReaderOptions st, Stream s m Char)
                => ParserT s st m Text
    mathDisplay :: ParserT s st m Text
    mathDisplay =
          (Extension -> ParserT s st m ()
    forall s (m :: * -> *) a st.
    (Stream s m a, HasReaderOptions st) =>
    Extension -> ParserT s st m ()
    guardEnabled Extension
    Ext_tex_math_dollars ParserT s st m () -> ParserT s st m Text -> ParserT s st m Text
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> Text -> Text -> ParserT s st m Text
    forall s (m :: * -> *) st.
    Stream s m Char =>
    Text -> Text -> ParserT s st m Text
    mathDisplayWith "$$" "$$")
      ParserT s st m Text -> ParserT s st m Text -> ParserT s st m Text
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> (Extension -> ParserT s st m ()
    forall s (m :: * -> *) a st.
    (Stream s m a, HasReaderOptions st) =>
    Extension -> ParserT s st m ()
    guardEnabled Extension
    Ext_tex_math_single_backslash ParserT s st m () -> ParserT s st m Text -> ParserT s st m Text
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >>
           Text -> Text -> ParserT s st m Text
    forall s (m :: * -> *) st.
    Stream s m Char =>
    Text -> Text -> ParserT s st m Text
    mathDisplayWith "\\[" "\\]")
      ParserT s st m Text -> ParserT s st m Text -> ParserT s st m Text
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> (Extension -> ParserT s st m ()
    forall s (m :: * -> *) a st.
    (Stream s m a, HasReaderOptions st) =>
    Extension -> ParserT s st m ()
    guardEnabled Extension
    Ext_tex_math_double_backslash ParserT s st m () -> ParserT s st m Text -> ParserT s st m Text
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >>
           Text -> Text -> ParserT s st m Text
    forall s (m :: * -> *) st.
    Stream s m Char =>
    Text -> Text -> ParserT s st m Text
    mathDisplayWith "\\\\[" "\\\\]")

    mathInline :: (HasReaderOptions st , Stream s m Char)
               => ParserT s st m Text
    mathInline :: ParserT s st m Text
    mathInline =
          (Extension -> ParserT s st m ()
    forall s (m :: * -> *) a st.
    (Stream s m a, HasReaderOptions st) =>
    Extension -> ParserT s st m ()
    guardEnabled Extension
    Ext_tex_math_dollars ParserT s st m () -> ParserT s st m Text -> ParserT s st m Text
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> Text -> Text -> ParserT s st m Text
    forall s (m :: * -> *) st.
    Stream s m Char =>
    Text -> Text -> ParserT s st m Text
    mathInlineWith "$" "$")
      ParserT s st m Text -> ParserT s st m Text -> ParserT s st m Text
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> (Extension -> ParserT s st m ()
    forall s (m :: * -> *) a st.
    (Stream s m a, HasReaderOptions st) =>
    Extension -> ParserT s st m ()
    guardEnabled Extension
    Ext_tex_math_single_backslash ParserT s st m () -> ParserT s st m Text -> ParserT s st m Text
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >>
           Text -> Text -> ParserT s st m Text
    forall s (m :: * -> *) st.
    Stream s m Char =>
    Text -> Text -> ParserT s st m Text
    mathInlineWith "\\(" "\\)")
      ParserT s st m Text -> ParserT s st m Text -> ParserT s st m Text
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> (Extension -> ParserT s st m ()
    forall s (m :: * -> *) a st.
    (Stream s m a, HasReaderOptions st) =>
    Extension -> ParserT s st m ()
    guardEnabled Extension
    Ext_tex_math_double_backslash ParserT s st m () -> ParserT s st m Text -> ParserT s st m Text
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >>
           Text -> Text -> ParserT s st m Text
    forall s (m :: * -> *) st.
    Stream s m Char =>
    Text -> Text -> ParserT s st m Text
    mathInlineWith "\\\\(" "\\\\)")

    -- | Applies a parser, returns tuple of its results and its horizontal
    -- displacement (the difference between the source column at the end
    -- and the source column at the beginning). Vertical displacement
    -- (source row) is ignored.
    withHorizDisplacement :: Stream s m Char
                          => ParserT s st m a  -- ^ Parser to apply
                          -> ParserT s st m (a, Int) -- ^ (result, displacement)
    withHorizDisplacement :: ParserT s st m a -> ParserT s st m (a, Int)
    withHorizDisplacement parser :: ParserT s st m a
    parser = do
      SourcePos
    pos1 <- ParsecT s st m SourcePos
    forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
    getPosition
      a
    result <- ParserT s st m a
    parser
      SourcePos
    pos2 <- ParsecT s st m SourcePos
    forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
    getPosition
      (a, Int) -> ParserT s st m (a, Int)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (a
    result, SourcePos -> Int
    sourceColumn SourcePos
    pos2 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - SourcePos -> Int
    sourceColumn SourcePos
    pos1)

    -- | Applies a parser and returns the raw string that was parsed,
    -- along with the value produced by the parser.
    withRaw :: Monad m
            => ParsecT Text st m a
            -> ParsecT Text st m (a, Text)
    withRaw :: ParsecT Text st m a -> ParsecT Text st m (a, Text)
    withRaw parser :: ParsecT Text st m a
    parser = do
      SourcePos
    pos1 <- ParsecT Text st m SourcePos
    forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
    getPosition
      Text
    inp <- ParsecT Text st m Text
    forall (m :: * -> *) s u. Monad m => ParsecT s u m s
    getInput
      a
    result <- ParsecT Text st m a
    parser
      SourcePos
    pos2 <- ParsecT Text st m SourcePos
    forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
    getPosition
      let (l1 :: Int
    l1,c1 :: Int
    c1) = (SourcePos -> Int
    sourceLine SourcePos
    pos1, SourcePos -> Int
    sourceColumn SourcePos
    pos1)
      let (l2 :: Int
    l2,c2 :: Int
    c2) = (SourcePos -> Int
    sourceLine SourcePos
    pos2, SourcePos -> Int
    sourceColumn SourcePos
    pos2)
      let inplines :: [Text]
    inplines = Int -> [Text] -> [Text]
    forall a. Int -> [a] -> [a]
    take ((Int
    l2 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    l1) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + 1) ([Text] -> [Text]) -> [Text] -> [Text]
    forall a b. (a -> b) -> a -> b
    $ Text -> [Text]
    T.lines Text
    inp
      let raw :: Text
    raw = case [Text]
    inplines of
                    []  -> ""
                    [l :: Text
    l] -> Int -> Text -> Text
    T.take (Int
    c2 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    c1) Text
    l
                    ls :: [Text]
    ls  -> [Text] -> Text
    T.unlines ([Text] -> [Text]
    forall a. [a] -> [a]
    init [Text]
    ls) Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Int -> Text -> Text
    T.take (Int
    c2 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - 1) ([Text] -> Text
    forall a. [a] -> a
    last [Text]
    ls)
      (a, Text) -> ParsecT Text st m (a, Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (a
    result, Text
    raw)

    -- | Parses backslash, then applies character parser.
    escaped :: Stream s m Char
            => ParserT s st m Char  -- ^ Parser for character to escape
            -> ParserT s st m Char
    escaped :: ParserT s st m Char -> ParserT s st m Char
    escaped parser :: ParserT s st m Char
    parser = ParserT s st m Char -> ParserT s st m Char
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT s st m Char -> ParserT s st m Char)
    -> ParserT s st m Char -> ParserT s st m Char
    forall a b. (a -> b) -> a -> b
    $ Char -> ParserT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '\\' ParserT s st m Char -> ParserT s st m Char -> ParserT s st m Char
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> ParserT s st m Char
    parser

    -- | Parse character entity.
    characterReference :: Stream s m Char => ParserT s st m Char
    characterReference :: ParserT s st m Char
    characterReference = ParserT s st m Char -> ParserT s st m Char
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT s st m Char -> ParserT s st m Char)
    -> ParserT s st m Char -> ParserT s st m Char
    forall a b. (a -> b) -> a -> b
    $ do
      Char -> ParserT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '&'
      String
    ent <- ParserT s st m Char -> ParserT s st m Char -> ParserT s st m String
    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 s st m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    nonspaceChar (Char -> ParserT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char ';')
      let ent' :: String
    ent' = case String
    ent of
                      '#':'X':xs :: String
    xs -> '#'Char -> String -> String
    forall a. a -> [a] -> [a]
    :'x'Char -> String -> String
    forall a. a -> [a] -> [a]
    :String
    xs  -- workaround tagsoup bug
                      '#':_      -> String
    ent
                      _          -> String
    ent String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ ";"
      case String -> Maybe String
    lookupEntity String
    ent' of
           Just (c :: Char
    c : _) -> Char -> ParserT s st m Char
    forall (m :: * -> *) a. Monad m => a -> m a
    return Char
    c
           _            -> String -> ParserT s st m Char
    forall (m :: * -> *) a. MonadFail m => String -> m a
    Prelude.fail "entity not found"

    -- | Parses an uppercase roman numeral and returns (UpperRoman, number).
    upperRoman :: Stream s m Char => ParserT s st m (ListNumberStyle, Int)
    upperRoman :: ParserT s st m (ListNumberStyle, Int)
    upperRoman = do
      Int
    num <- Bool -> ParserT s st m Int
    forall s (m :: * -> *) st.
    Stream s m Char =>
    Bool -> ParserT s st m Int
    romanNumeral Bool
    True
      (ListNumberStyle, Int) -> ParserT s st m (ListNumberStyle, Int)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (ListNumberStyle
    UpperRoman, Int
    num)

    -- | Parses a lowercase roman numeral and returns (LowerRoman, number).
    lowerRoman :: Stream s m Char => ParserT s st m (ListNumberStyle, Int)
    lowerRoman :: ParserT s st m (ListNumberStyle, Int)
    lowerRoman = do
      Int
    num <- Bool -> ParserT s st m Int
    forall s (m :: * -> *) st.
    Stream s m Char =>
    Bool -> ParserT s st m Int
    romanNumeral Bool
    False
      (ListNumberStyle, Int) -> ParserT s st m (ListNumberStyle, Int)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (ListNumberStyle
    LowerRoman, Int
    num)

    -- | Parses a decimal numeral and returns (Decimal, number).
    decimal :: Stream s m Char => ParserT s st m (ListNumberStyle, Int)
    decimal :: ParserT s st m (ListNumberStyle, Int)
    decimal = do
      String
    num <- ParsecT s st m Char -> ParsecT s st m String
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m [a]
    many1 ParsecT s st m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    digit
      (ListNumberStyle, Int) -> ParserT s st m (ListNumberStyle, Int)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (ListNumberStyle
    Decimal, Int -> Maybe Int -> Int
    forall a. a -> Maybe a -> a
    fromMaybe 1 (Maybe Int -> Int) -> Maybe Int -> Int
    forall a b. (a -> b) -> a -> b
    $ Text -> Maybe Int
    forall (m :: * -> *) a. (MonadPlus m, Read a) => Text -> m a
    safeRead (Text -> Maybe Int) -> Text -> Maybe Int
    forall a b. (a -> b) -> a -> b
    $ String -> Text
    T.pack String
    num)

    -- | Parses a '@' and optional label and
    -- returns (DefaultStyle, [next example number]).  The next
    -- example number is incremented in parser state, and the label
    -- (if present) is added to the label table.
    exampleNum :: Stream s m Char
               => ParserT s ParserState m (ListNumberStyle, Int)
    exampleNum :: ParserT s ParserState m (ListNumberStyle, Int)
    exampleNum = do
      Char -> ParsecT s ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '@'
      Text
    lab <- String -> Text
    T.pack (String -> Text)
    -> ParsecT s ParserState m String -> ParsecT s ParserState m Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT s ParserState m Char -> ParsecT s ParserState m String
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many (ParsecT s ParserState m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    alphaNum ParsecT s ParserState m Char
    -> ParsecT s ParserState m Char -> ParsecT s ParserState m Char
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> (Char -> Bool) -> ParsecT s ParserState m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    (Char -> Bool) -> ParsecT s u m Char
    satisfy (\c :: Char
    c -> Char
    c Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    == '_' Bool -> Bool -> Bool
    || Char
    c Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    == '-'))
      ParserState
    st <- ParsecT s ParserState m ParserState
    forall (m :: * -> *) s u. Monad m => ParsecT s u m u
    getState
      let num :: Int
    num = ParserState -> Int
    stateNextExample ParserState
    st
      let newlabels :: Map Text Int
    newlabels = if Text -> Bool
    T.null Text
    lab
                         then ParserState -> Map Text Int
    stateExamples ParserState
    st
                         else Text -> Int -> Map Text Int -> Map Text Int
    forall k a. Ord k => k -> a -> Map k a -> Map k a
    M.insert Text
    lab Int
    num (Map Text Int -> Map Text Int) -> Map Text Int -> Map Text Int
    forall a b. (a -> b) -> a -> b
    $ ParserState -> Map Text Int
    stateExamples ParserState
    st
      (ParserState -> ParserState) -> ParsecT s ParserState m ()
    forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
    updateState ((ParserState -> ParserState) -> ParsecT s ParserState m ())
    -> (ParserState -> ParserState) -> ParsecT s ParserState m ()
    forall a b. (a -> b) -> a -> b
    $ \s :: ParserState
    s -> ParserState
    s{ stateNextExample :: Int
    stateNextExample = Int
    num Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + 1
                           , stateExamples :: Map Text Int
    stateExamples    = Map Text Int
    newlabels }
      (ListNumberStyle, Int)
    -> ParserT s ParserState m (ListNumberStyle, Int)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (ListNumberStyle
    Example, Int
    num)

    -- | Parses a '#' returns (DefaultStyle, 1).
    defaultNum :: Stream s m Char => ParserT s st m (ListNumberStyle, Int)
    defaultNum :: ParserT s st m (ListNumberStyle, Int)
    defaultNum = do
      Char -> ParsecT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '#'
      (ListNumberStyle, Int) -> ParserT s st m (ListNumberStyle, Int)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (ListNumberStyle
    DefaultStyle, 1)

    -- | Parses a lowercase letter and returns (LowerAlpha, number).
    lowerAlpha :: Stream s m Char => ParserT s st m (ListNumberStyle, Int)
    lowerAlpha :: ParserT s st m (ListNumberStyle, Int)
    lowerAlpha = do
      Char
    ch <- String -> ParsecT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    String -> ParsecT s u m Char
    oneOf ['a'..'z']
      (ListNumberStyle, Int) -> ParserT s st m (ListNumberStyle, Int)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (ListNumberStyle
    LowerAlpha, Char -> Int
    ord Char
    ch Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Char -> Int
    ord 'a' Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + 1)

    -- | Parses an uppercase letter and returns (UpperAlpha, number).
    upperAlpha :: Stream s m Char => ParserT s st m (ListNumberStyle, Int)
    upperAlpha :: ParserT s st m (ListNumberStyle, Int)
    upperAlpha = do
      Char
    ch <- String -> ParsecT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    String -> ParsecT s u m Char
    oneOf ['A'..'Z']
      (ListNumberStyle, Int) -> ParserT s st m (ListNumberStyle, Int)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (ListNumberStyle
    UpperAlpha, Char -> Int
    ord Char
    ch Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Char -> Int
    ord 'A' Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + 1)

    -- | Parses a roman numeral i or I
    romanOne :: Stream s m Char => ParserT s st m (ListNumberStyle, Int)
    romanOne :: ParserT s st m (ListNumberStyle, Int)
    romanOne = (Char -> ParsecT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char 'i' ParsecT s st m Char
    -> ParserT s st m (ListNumberStyle, Int)
    -> ParserT s st m (ListNumberStyle, Int)
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> (ListNumberStyle, Int) -> ParserT s st m (ListNumberStyle, Int)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (ListNumberStyle
    LowerRoman, 1)) ParserT s st m (ListNumberStyle, Int)
    -> ParserT s st m (ListNumberStyle, Int)
    -> ParserT s st m (ListNumberStyle, Int)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|>
               (Char -> ParsecT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char 'I' ParsecT s st m Char
    -> ParserT s st m (ListNumberStyle, Int)
    -> ParserT s st m (ListNumberStyle, Int)
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> (ListNumberStyle, Int) -> ParserT s st m (ListNumberStyle, Int)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (ListNumberStyle
    UpperRoman, 1))

    -- | Parses an ordered list marker and returns list attributes.
    anyOrderedListMarker :: Stream s m Char => ParserT s ParserState m ListAttributes
    anyOrderedListMarker :: ParserT s ParserState m ListAttributes
    anyOrderedListMarker = [ParserT s ParserState m ListAttributes]
    -> ParserT s ParserState m ListAttributes
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    [ParsecT s u m a] -> ParsecT s u m a
    choice
      [ParserT s ParserState m (ListNumberStyle, Int)
    -> ParserT s ParserState m ListAttributes
    delimParser ParserT s ParserState m (ListNumberStyle, Int)
    numParser | ParserT s ParserState m (ListNumberStyle, Int)
    -> ParserT s ParserState m ListAttributes
    delimParser <- [ParserT s ParserState m (ListNumberStyle, Int)
    -> ParserT s ParserState m ListAttributes
    forall s (m :: * -> *) st.
    Stream s m Char =>
    ParserT s st m (ListNumberStyle, Int)
    -> ParserT s st m ListAttributes
    inPeriod, ParserT s ParserState m (ListNumberStyle, Int)
    -> ParserT s ParserState m ListAttributes
    forall s (m :: * -> *) st.
    Stream s m Char =>
    ParserT s st m (ListNumberStyle, Int)
    -> ParserT s st m ListAttributes
    inOneParen, ParserT s ParserState m (ListNumberStyle, Int)
    -> ParserT s ParserState m ListAttributes
    forall s (m :: * -> *) st.
    Stream s m Char =>
    ParserT s st m (ListNumberStyle, Int)
    -> ParserT s st m ListAttributes
    inTwoParens],
                               ParserT s ParserState m (ListNumberStyle, Int)
    numParser <- [ParserT s ParserState m (ListNumberStyle, Int)
    forall s (m :: * -> *) st.
    Stream s m Char =>
    ParserT s st m (ListNumberStyle, Int)
    decimal, ParserT s ParserState m (ListNumberStyle, Int)
    forall s (m :: * -> *).
    Stream s m Char =>
    ParserT s ParserState m (ListNumberStyle, Int)
    exampleNum, ParserT s ParserState m (ListNumberStyle, Int)
    forall s (m :: * -> *) st.
    Stream s m Char =>
    ParserT s st m (ListNumberStyle, Int)
    defaultNum, ParserT s ParserState m (ListNumberStyle, Int)
    forall s (m :: * -> *) st.
    Stream s m Char =>
    ParserT s st m (ListNumberStyle, Int)
    romanOne,
                               ParserT s ParserState m (ListNumberStyle, Int)
    forall s (m :: * -> *) st.
    Stream s m Char =>
    ParserT s st m (ListNumberStyle, Int)
    lowerAlpha, ParserT s ParserState m (ListNumberStyle, Int)
    forall s (m :: * -> *) st.
    Stream s m Char =>
    ParserT s st m (ListNumberStyle, Int)
    lowerRoman, ParserT s ParserState m (ListNumberStyle, Int)
    forall s (m :: * -> *) st.
    Stream s m Char =>
    ParserT s st m (ListNumberStyle, Int)
    upperAlpha, ParserT s ParserState m (ListNumberStyle, Int)
    forall s (m :: * -> *) st.
    Stream s m Char =>
    ParserT s st m (ListNumberStyle, Int)
    upperRoman]]

    -- | Parses a list number (num) followed by a period, returns list attributes.
    inPeriod :: Stream s m Char
             => ParserT s st m (ListNumberStyle, Int)
             -> ParserT s st m ListAttributes
    inPeriod :: ParserT s st m (ListNumberStyle, Int)
    -> ParserT s st m ListAttributes
    inPeriod num :: ParserT s st m (ListNumberStyle, Int)
    num = ParserT s st m ListAttributes -> ParserT s st m ListAttributes
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT s st m ListAttributes -> ParserT s st m ListAttributes)
    -> ParserT s st m ListAttributes -> ParserT s st m ListAttributes
    forall a b. (a -> b) -> a -> b
    $ do
      (style :: ListNumberStyle
    style, start :: Int
    start) <- ParserT s st m (ListNumberStyle, Int)
    num
      Char -> ParsecT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '.'
      let delim :: ListNumberDelim
    delim = if ListNumberStyle
    style ListNumberStyle -> ListNumberStyle -> Bool
    forall a. Eq a => a -> a -> Bool
    == ListNumberStyle
    DefaultStyle
                     then ListNumberDelim
    DefaultDelim
                     else ListNumberDelim
    Period
      ListAttributes -> ParserT s st m ListAttributes
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int
    start, ListNumberStyle
    style, ListNumberDelim
    delim)

    -- | Parses a list number (num) followed by a paren, returns list attributes.
    inOneParen :: Stream s m Char
               => ParserT s st m (ListNumberStyle, Int)
               -> ParserT s st m ListAttributes
    inOneParen :: ParserT s st m (ListNumberStyle, Int)
    -> ParserT s st m ListAttributes
    inOneParen num :: ParserT s st m (ListNumberStyle, Int)
    num = ParserT s st m ListAttributes -> ParserT s st m ListAttributes
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT s st m ListAttributes -> ParserT s st m ListAttributes)
    -> ParserT s st m ListAttributes -> ParserT s st m ListAttributes
    forall a b. (a -> b) -> a -> b
    $ do
      (style :: ListNumberStyle
    style, start :: Int
    start) <- ParserT s st m (ListNumberStyle, Int)
    num
      Char -> ParsecT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char ')'
      ListAttributes -> ParserT s st m ListAttributes
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int
    start, ListNumberStyle
    style, ListNumberDelim
    OneParen)

    -- | Parses a list number (num) enclosed in parens, returns list attributes.
    inTwoParens :: Stream s m Char
                => ParserT s st m (ListNumberStyle, Int)
                -> ParserT s st m ListAttributes
    inTwoParens :: ParserT s st m (ListNumberStyle, Int)
    -> ParserT s st m ListAttributes
    inTwoParens num :: ParserT s st m (ListNumberStyle, Int)
    num = ParserT s st m ListAttributes -> ParserT s st m ListAttributes
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT s st m ListAttributes -> ParserT s st m ListAttributes)
    -> ParserT s st m ListAttributes -> ParserT s st m ListAttributes
    forall a b. (a -> b) -> a -> b
    $ do
      Char -> ParsecT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '('
      (style :: ListNumberStyle
    style, start :: Int
    start) <- ParserT s st m (ListNumberStyle, Int)
    num
      Char -> ParsecT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char ')'
      ListAttributes -> ParserT s st m ListAttributes
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int
    start, ListNumberStyle
    style, ListNumberDelim
    TwoParens)

    -- | Parses an ordered list marker with a given style and delimiter,
    -- returns number.
    orderedListMarker :: Stream s m Char
                      => ListNumberStyle
                      -> ListNumberDelim
                      -> ParserT s ParserState m Int
    orderedListMarker :: ListNumberStyle -> ListNumberDelim -> ParserT s ParserState m Int
    orderedListMarker style :: ListNumberStyle
    style delim :: ListNumberDelim
    delim = do
      let num :: ParsecT s ParserState m (ListNumberStyle, Int)
    num = ParsecT s ParserState m (ListNumberStyle, Int)
    forall s (m :: * -> *) st.
    Stream s m Char =>
    ParserT s st m (ListNumberStyle, Int)
    defaultNum ParsecT s ParserState m (ListNumberStyle, Int)
    -> ParsecT s ParserState m (ListNumberStyle, Int)
    -> ParsecT s ParserState m (ListNumberStyle, Int)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|>  -- # can continue any kind of list
                case ListNumberStyle
    style of
                   DefaultStyle -> ParsecT s ParserState m (ListNumberStyle, Int)
    forall s (m :: * -> *) st.
    Stream s m Char =>
    ParserT s st m (ListNumberStyle, Int)
    decimal
                   Example      -> ParsecT s ParserState m (ListNumberStyle, Int)
    forall s (m :: * -> *).
    Stream s m Char =>
    ParserT s ParserState m (ListNumberStyle, Int)
    exampleNum
                   Decimal      -> ParsecT s ParserState m (ListNumberStyle, Int)
    forall s (m :: * -> *) st.
    Stream s m Char =>
    ParserT s st m (ListNumberStyle, Int)
    decimal
                   UpperRoman   -> ParsecT s ParserState m (ListNumberStyle, Int)
    forall s (m :: * -> *) st.
    Stream s m Char =>
    ParserT s st m (ListNumberStyle, Int)
    upperRoman
                   LowerRoman   -> ParsecT s ParserState m (ListNumberStyle, Int)
    forall s (m :: * -> *) st.
    Stream s m Char =>
    ParserT s st m (ListNumberStyle, Int)
    lowerRoman
                   UpperAlpha   -> ParsecT s ParserState m (ListNumberStyle, Int)
    forall s (m :: * -> *) st.
    Stream s m Char =>
    ParserT s st m (ListNumberStyle, Int)
    upperAlpha
                   LowerAlpha   -> ParsecT s ParserState m (ListNumberStyle, Int)
    forall s (m :: * -> *) st.
    Stream s m Char =>
    ParserT s st m (ListNumberStyle, Int)
    lowerAlpha
      let context :: ParserT s st m (ListNumberStyle, Int)
    -> ParserT s st m ListAttributes
    context = case ListNumberDelim
    delim of
                   DefaultDelim -> ParserT s st m (ListNumberStyle, Int)
    -> ParserT s st m ListAttributes
    forall s (m :: * -> *) st.
    Stream s m Char =>
    ParserT s st m (ListNumberStyle, Int)
    -> ParserT s st m ListAttributes
    inPeriod
                   Period       -> ParserT s st m (ListNumberStyle, Int)
    -> ParserT s st m ListAttributes
    forall s (m :: * -> *) st.
    Stream s m Char =>
    ParserT s st m (ListNumberStyle, Int)
    -> ParserT s st m ListAttributes
    inPeriod
                   OneParen     -> ParserT s st m (ListNumberStyle, Int)
    -> ParserT s st m ListAttributes
    forall s (m :: * -> *) st.
    Stream s m Char =>
    ParserT s st m (ListNumberStyle, Int)
    -> ParserT s st m ListAttributes
    inOneParen
                   TwoParens    -> ParserT s st m (ListNumberStyle, Int)
    -> ParserT s st m ListAttributes
    forall s (m :: * -> *) st.
    Stream s m Char =>
    ParserT s st m (ListNumberStyle, Int)
    -> ParserT s st m ListAttributes
    inTwoParens
      (start :: Int
    start, _, _) <- ParsecT s ParserState m (ListNumberStyle, Int)
    -> ParserT s ParserState m ListAttributes
    forall st.
    ParserT s st m (ListNumberStyle, Int)
    -> ParserT s st m ListAttributes
    context ParsecT s ParserState m (ListNumberStyle, Int)
    num
      Int -> ParserT s ParserState m Int
    forall (m :: * -> *) a. Monad m => a -> m a
    return Int
    start

    -- | Parses a character reference and returns a Str element.
    charRef :: Stream s m Char => ParserT s st m Inline
    charRef :: ParserT s st m Inline
    charRef = Text -> Inline
    Str (Text -> Inline) -> (Char -> Text) -> Char -> Inline
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Char -> Text
    T.singleton (Char -> Inline) -> ParsecT s st m Char -> ParserT s st m Inline
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT s st m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    characterReference

    lineBlockLine :: Monad m => ParserT Text st m Text
    lineBlockLine :: ParserT Text st m Text
    lineBlockLine = ParserT Text st m Text -> ParserT Text st m Text
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text st m Text -> ParserT Text st m Text)
    -> ParserT Text st m Text -> ParserT Text st m Text
    forall a b. (a -> b) -> a -> b
    $ do
      Char -> ParsecT Text st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '|'
      Char -> ParsecT Text st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char ' '
      Text
    white <- String -> Text
    T.pack (String -> Text)
    -> ParsecT Text st m String -> ParserT Text st m Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Text st m Char -> ParsecT Text st m String
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many (ParsecT Text st m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    spaceChar ParsecT Text st m Char
    -> 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 (m :: * -> *) a. Monad m => a -> m a
    return '\160')
      ParsecT Text st m Char -> ParsecT 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 ParsecT Text st m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    newline
      Text
    line <- ParserT Text st m Text
    forall (m :: * -> *) st. Monad m => ParserT Text st m Text
    anyLine
      [Text]
    continuations <- ParserT Text st m Text -> ParsecT Text st m [Text]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many (ParserT Text st m Text -> ParserT Text st m Text
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text st m Text -> ParserT Text st m Text)
    -> ParserT Text st m Text -> ParserT Text st m Text
    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 Text -> ParserT Text st m Text
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> ParserT Text st m Text
    forall (m :: * -> *) st. Monad m => ParserT Text st m Text
    anyLine)
      Text -> ParserT Text st m Text
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Text -> ParserT Text st m Text) -> Text -> ParserT Text st m Text
    forall a b. (a -> b) -> a -> b
    $ Text
    white Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> [Text] -> Text
    T.unwords (Text
    line Text -> [Text] -> [Text]
    forall a. a -> [a] -> [a]
    : [Text]
    continuations)

    blankLineBlockLine :: Stream s m Char => ParserT s st m Char
    blankLineBlockLine :: ParserT s st m Char
    blankLineBlockLine = ParserT s st m Char -> ParserT s st m Char
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (Char -> ParserT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '|' ParserT s st m Char -> ParserT s st m Char -> ParserT s st m Char
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> ParserT s st m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    blankline)

    -- | Parses an RST-style line block and returns a list of strings.
    lineBlockLines :: Monad m => ParserT Text st m [Text]
    lineBlockLines :: ParserT Text st m [Text]
    lineBlockLines = ParserT Text st m [Text] -> ParserT Text st m [Text]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text st m [Text] -> ParserT Text st m [Text])
    -> ParserT Text st m [Text] -> ParserT Text st m [Text]
    forall a b. (a -> b) -> a -> b
    $ do
      [Text]
    lines' <- ParsecT Text st m Text -> ParserT Text st m [Text]
    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 Text
    forall (m :: * -> *) st. Monad m => ParserT Text st m Text
    lineBlockLine ParsecT Text st m Text
    -> ParsecT Text st m Text -> ParsecT Text st m Text
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> (Char -> Text
    T.singleton (Char -> Text) -> ParsecT Text st m Char -> ParsecT Text st m Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Text st m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    blankLineBlockLine))
      ParsecT Text st m Char -> ParsecT 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 :: * -> *) u. Stream s m Char => ParsecT s u m Char
    blankline
      [Text] -> ParserT Text st m [Text]
    forall (m :: * -> *) a. Monad m => a -> m a
    return [Text]
    lines'

    -- | Parse a table using 'headerParser', 'rowParser',
    -- 'lineParser', and 'footerParser'.
    tableWith :: (Stream s m Char, HasReaderOptions st, Monad mf)
              => ParserT s st m (mf [Blocks], [Alignment], [Int])
              -> ([Int] -> ParserT s st m (mf [Blocks]))
              -> ParserT s st m sep
              -> ParserT s st m end
              -> ParserT s st m (mf Blocks)
    tableWith :: ParserT s st m (mf [Blocks], [Alignment], [Int])
    -> ([Int] -> ParserT s st m (mf [Blocks]))
    -> ParserT s st m sep
    -> ParserT s st m end
    -> ParserT s st m (mf Blocks)
    tableWith headerParser :: ParserT s st m (mf [Blocks], [Alignment], [Int])
    headerParser rowParser :: [Int] -> ParserT s st m (mf [Blocks])
    rowParser lineParser :: ParserT s st m sep
    lineParser footerParser :: ParserT s st m end
    footerParser = ParserT s st m (mf Blocks) -> ParserT s st m (mf Blocks)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT s st m (mf Blocks) -> ParserT s st m (mf Blocks))
    -> ParserT s st m (mf Blocks) -> ParserT s st m (mf Blocks)
    forall a b. (a -> b) -> a -> b
    $ do
      (aligns :: [Alignment]
    aligns, widths :: [Double]
    widths, heads :: mf [Blocks]
    heads, rows :: mf [[Blocks]]
    rows) <- ParserT s st m (mf [Blocks], [Alignment], [Int])
    -> ([Int] -> ParserT s st m (mf [Blocks]))
    -> ParserT s st m sep
    -> ParserT s st m end
    -> ParserT
         s st m ([Alignment], [Double], mf [Blocks], mf [[Blocks]])
    forall s (m :: * -> *) st (mf :: * -> *) sep end.
    (Stream s m Char, HasReaderOptions st, Monad mf) =>
    ParserT s st m (mf [Blocks], [Alignment], [Int])
    -> ([Int] -> ParserT s st m (mf [Blocks]))
    -> ParserT s st m sep
    -> ParserT s st m end
    -> ParserT s st m (TableComponents mf)
    tableWith' ParserT s st m (mf [Blocks], [Alignment], [Int])
    headerParser [Int] -> ParserT s st m (mf [Blocks])
    rowParser
                                                    ParserT s st m sep
    lineParser ParserT s st m end
    footerParser
      mf Blocks -> ParserT s st m (mf Blocks)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (mf Blocks -> ParserT s st m (mf Blocks))
    -> mf Blocks -> ParserT s st m (mf Blocks)
    forall a b. (a -> b) -> a -> b
    $ Inlines
    -> [(Alignment, Double)] -> [Blocks] -> [[Blocks]] -> Blocks
    B.table Inlines
    forall a. Monoid a => a
    mempty ([Alignment] -> [Double] -> [(Alignment, Double)]
    forall a b. [a] -> [b] -> [(a, b)]
    zip [Alignment]
    aligns [Double]
    widths) ([Blocks] -> [[Blocks]] -> Blocks)
    -> mf [Blocks] -> mf ([[Blocks]] -> Blocks)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> mf [Blocks]
    heads mf ([[Blocks]] -> Blocks) -> mf [[Blocks]] -> mf Blocks
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> mf [[Blocks]]
    rows

    type TableComponents mf = ([Alignment], [Double], mf [Blocks], mf [[Blocks]])

    tableWith' :: (Stream s m Char, HasReaderOptions st, Monad mf)
               => ParserT s st m (mf [Blocks], [Alignment], [Int])
               -> ([Int] -> ParserT s st m (mf [Blocks]))
               -> ParserT s st m sep
               -> ParserT s st m end
               -> ParserT s st m (TableComponents mf)
    tableWith' :: ParserT s st m (mf [Blocks], [Alignment], [Int])
    -> ([Int] -> ParserT s st m (mf [Blocks]))
    -> ParserT s st m sep
    -> ParserT s st m end
    -> ParserT s st m (TableComponents mf)
    tableWith' headerParser :: ParserT s st m (mf [Blocks], [Alignment], [Int])
    headerParser rowParser :: [Int] -> ParserT s st m (mf [Blocks])
    rowParser lineParser :: ParserT s st m sep
    lineParser footerParser :: ParserT s st m end
    footerParser = ParserT s st m (TableComponents mf)
    -> ParserT s st m (TableComponents mf)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT s st m (TableComponents mf)
     -> ParserT s st m (TableComponents mf))
    -> ParserT s st m (TableComponents mf)
    -> ParserT s st m (TableComponents mf)
    forall a b. (a -> b) -> a -> b
    $ do
        (heads :: mf [Blocks]
    heads, aligns :: [Alignment]
    aligns, indices :: [Int]
    indices) <- ParserT s st m (mf [Blocks], [Alignment], [Int])
    headerParser
        mf [[Blocks]]
    lines' <- [mf [Blocks]] -> mf [[Blocks]]
    forall (t :: * -> *) (m :: * -> *) a.
    (Traversable t, Monad m) =>
    t (m a) -> m (t a)
    sequence ([mf [Blocks]] -> mf [[Blocks]])
    -> ParsecT s st m [mf [Blocks]] -> ParsecT s st m (mf [[Blocks]])
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> [Int] -> ParserT s st m (mf [Blocks])
    rowParser [Int]
    indices ParserT s st m (mf [Blocks])
    -> ParserT s st m sep -> ParsecT s st m [mf [Blocks]]
    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]
    `sepEndBy1` ParserT s st m sep
    lineParser
        ParserT s st m end
    footerParser
        Int
    numColumns <- (ReaderOptions -> Int) -> ParserT s st m Int
    forall st s (m :: * -> *) t b.
    (HasReaderOptions st, Stream s m t) =>
    (ReaderOptions -> b) -> ParserT s st m b
    getOption ReaderOptions -> Int
    readerColumns
        let widths :: [Double]
    widths = if [Int] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [Int]
    indices
                        then Int -> Double -> [Double]
    forall a. Int -> a -> [a]
    replicate ([Alignment] -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    length [Alignment]
    aligns) 0.0
                        else Int -> [Int] -> [Double]
    widthsFromIndices Int
    numColumns [Int]
    indices
        TableComponents mf -> ParserT s st m (TableComponents mf)
    forall (m :: * -> *) a. Monad m => a -> m a
    return ([Alignment]
    aligns, [Double]
    widths, mf [Blocks]
    heads, mf [[Blocks]]
    lines')

    -- Calculate relative widths of table columns, based on indices
    widthsFromIndices :: Int      -- Number of columns on terminal
                      -> [Int]    -- Indices
                      -> [Double] -- Fractional relative sizes of columns
    widthsFromIndices :: Int -> [Int] -> [Double]
    widthsFromIndices _ [] = []
    widthsFromIndices numColumns' :: Int
    numColumns' indices :: [Int]
    indices =
      let numColumns :: Int
    numColumns = Int -> Int -> Int
    forall a. Ord a => a -> a -> a
    max Int
    numColumns' (if [Int] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [Int]
    indices then 0 else [Int] -> Int
    forall a. [a] -> a
    last [Int]
    indices)
          lengths' :: [Int]
    lengths' = (Int -> Int -> Int) -> [Int] -> [Int] -> [Int]
    forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
    zipWith (-) [Int]
    indices (0Int -> [Int] -> [Int]
    forall a. a -> [a] -> [a]
    :[Int]
    indices)
          lengths :: [Int]
    lengths  = [Int] -> [Int]
    forall a. [a] -> [a]
    reverse ([Int] -> [Int]) -> [Int] -> [Int]
    forall a b. (a -> b) -> a -> b
    $
                     case [Int] -> [Int]
    forall a. [a] -> [a]
    reverse [Int]
    lengths' of
                          []       -> []
                          [x :: Int
    x]      -> [Int
    x]
                          -- compensate for the fact that intercolumn
                          -- spaces are counted in widths of all columns
                          -- but the last...
                          (x :: Int
    x:y :: Int
    y:zs :: [Int]
    zs) -> if Int
    x Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    < Int
    y Bool -> Bool -> Bool
    && Int
    y Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    x Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    <= 2
                                         then Int
    yInt -> [Int] -> [Int]
    forall a. a -> [a] -> [a]
    :Int
    yInt -> [Int] -> [Int]
    forall a. a -> [a] -> [a]
    :[Int]
    zs
                                         else Int
    xInt -> [Int] -> [Int]
    forall a. a -> [a] -> [a]
    :Int
    yInt -> [Int] -> [Int]
    forall a. a -> [a] -> [a]
    :[Int]
    zs
          totLength :: Int
    totLength = [Int] -> Int
    forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
    sum [Int]
    lengths
          quotient :: Double
    quotient = if Int
    totLength Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    > Int
    numColumns
                       then Int -> Double
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    totLength
                       else Int -> Double
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    numColumns
          fracs :: [Double]
    fracs = (Int -> Double) -> [Int] -> [Double]
    forall a b. (a -> b) -> [a] -> [b]
    map (\l :: Int
    l -> Int -> Double
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    l Double -> Double -> Double
    forall a. Fractional a => a -> a -> a
    / Double
    quotient) [Int]
    lengths in
      [Double] -> [Double]
    forall a. [a] -> [a]
    tail [Double]
    fracs

    ---

    -- Parse a grid table:  starts with row of '-' on top, then header
    -- (which may be grid), then the rows,
    -- which may be grid, separated by blank lines, and
    -- ending with a footer (dashed line followed by blank line).
    gridTableWith :: (Stream s m Char, HasReaderOptions st, HasLastStrPosition st,
                      Monad mf, IsString s)
                  => ParserT s st m (mf Blocks)  -- ^ Block list parser
                  -> Bool                        -- ^ Headerless table
                  -> ParserT s st m (mf Blocks)
    gridTableWith :: ParserT s st m (mf Blocks) -> Bool -> ParserT s st m (mf Blocks)
    gridTableWith blocks :: ParserT s st m (mf Blocks)
    blocks headless :: Bool
    headless =
      ParserT s st m (mf [Blocks], [Alignment], [Int])
    -> ([Int] -> ParserT s st m (mf [Blocks]))
    -> ParserT s st m Char
    -> ParserT s st m Text
    -> ParserT s st m (mf Blocks)
    forall s (m :: * -> *) st (mf :: * -> *) sep end.
    (Stream s m Char, HasReaderOptions st, Monad mf) =>
    ParserT s st m (mf [Blocks], [Alignment], [Int])
    -> ([Int] -> ParserT s st m (mf [Blocks]))
    -> ParserT s st m sep
    -> ParserT s st m end
    -> ParserT s st m (mf Blocks)
    tableWith (Bool
    -> ParserT s st m (mf Blocks)
    -> ParserT s st m (mf [Blocks], [Alignment], [Int])
    forall s (m :: * -> *) (mf :: * -> *) st.
    (Stream s m Char, Monad mf, IsString s, HasLastStrPosition st) =>
    Bool
    -> ParserT s st m (mf Blocks)
    -> ParserT s st m (mf [Blocks], [Alignment], [Int])
    gridTableHeader Bool
    headless ParserT s st m (mf Blocks)
    blocks) (ParserT s st m (mf Blocks) -> [Int] -> ParserT s st m (mf [Blocks])
    forall s (m :: * -> *) (mf :: * -> *) st.
    (Stream s m Char, Monad mf, IsString s, HasLastStrPosition st) =>
    ParserT s st m (mf Blocks) -> [Int] -> ParserT s st m (mf [Blocks])
    gridTableRow ParserT s st m (mf Blocks)
    blocks)
                (Char -> ParserT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    gridTableSep '-') ParserT s st m Text
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Text
    gridTableFooter

    gridTableWith' :: (Stream s m Char, HasReaderOptions st, HasLastStrPosition st,
                       Monad mf, IsString s)
                   => ParserT s st m (mf Blocks)  -- ^ Block list parser
                   -> Bool                        -- ^ Headerless table
                   -> ParserT s st m (TableComponents mf)
    gridTableWith' :: ParserT s st m (mf Blocks)
    -> Bool -> ParserT s st m (TableComponents mf)
    gridTableWith' blocks :: ParserT s st m (mf Blocks)
    blocks headless :: Bool
    headless =
      ParserT s st m (mf [Blocks], [Alignment], [Int])
    -> ([Int] -> ParserT s st m (mf [Blocks]))
    -> ParserT s st m Char
    -> ParserT s st m Text
    -> ParserT s st m (TableComponents mf)
    forall s (m :: * -> *) st (mf :: * -> *) sep end.
    (Stream s m Char, HasReaderOptions st, Monad mf) =>
    ParserT s st m (mf [Blocks], [Alignment], [Int])
    -> ([Int] -> ParserT s st m (mf [Blocks]))
    -> ParserT s st m sep
    -> ParserT s st m end
    -> ParserT s st m (TableComponents mf)
    tableWith' (Bool
    -> ParserT s st m (mf Blocks)
    -> ParserT s st m (mf [Blocks], [Alignment], [Int])
    forall s (m :: * -> *) (mf :: * -> *) st.
    (Stream s m Char, Monad mf, IsString s, HasLastStrPosition st) =>
    Bool
    -> ParserT s st m (mf Blocks)
    -> ParserT s st m (mf [Blocks], [Alignment], [Int])
    gridTableHeader Bool
    headless ParserT s st m (mf Blocks)
    blocks) (ParserT s st m (mf Blocks) -> [Int] -> ParserT s st m (mf [Blocks])
    forall s (m :: * -> *) (mf :: * -> *) st.
    (Stream s m Char, Monad mf, IsString s, HasLastStrPosition st) =>
    ParserT s st m (mf Blocks) -> [Int] -> ParserT s st m (mf [Blocks])
    gridTableRow ParserT s st m (mf Blocks)
    blocks)
                 (Char -> ParserT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    gridTableSep '-') ParserT s st m Text
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Text
    gridTableFooter

    gridTableSplitLine :: [Int] -> Text -> [Text]
    gridTableSplitLine :: [Int] -> Text -> [Text]
    gridTableSplitLine indices :: [Int]
    indices line :: Text
    line = (Text -> Text) -> [Text] -> [Text]
    forall a b. (a -> b) -> [a] -> [b]
    map Text -> Text
    removeFinalBar ([Text] -> [Text]) -> [Text] -> [Text]
    forall a b. (a -> b) -> a -> b
    $ [Text] -> [Text]
    forall a. [a] -> [a]
    tail ([Text] -> [Text]) -> [Text] -> [Text]
    forall a b. (a -> b) -> a -> b
    $
      [Int] -> Text -> [Text]
    splitTextByIndices ([Int] -> [Int]
    forall a. [a] -> [a]
    init [Int]
    indices) (Text -> [Text]) -> Text -> [Text]
    forall a b. (a -> b) -> a -> b
    $ Text -> Text
    trimr Text
    line

    gridPart :: Stream s m Char => Char -> ParserT s st m ((Int, Int), Alignment)
    gridPart :: Char -> ParserT s st m ((Int, Int), Alignment)
    gridPart ch :: Char
    ch = do
      Bool
    leftColon <- Bool -> ParsecT s st m Bool -> ParsecT s st 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 s st m Char -> ParsecT s st m Bool
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ Char -> ParsecT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char ':')
      String
    dashes <- ParsecT s st m Char -> ParsecT s st m String
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m [a]
    many1 (Char -> ParsecT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char Char
    ch)
      Bool
    rightColon <- Bool -> ParsecT s st m Bool -> ParsecT s st 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 s st m Char -> ParsecT s st m Bool
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ Char -> ParsecT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char ':')
      Char -> ParsecT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '+'
      let lengthDashes :: Int
    lengthDashes = String -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    length String
    dashes Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (if Bool
    leftColon then 1 else 0) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    +
                           (if Bool
    rightColon then 1 else 0)
      let alignment :: Alignment
    alignment = case (Bool
    leftColon, Bool
    rightColon) of
                           (True, True)   -> Alignment
    AlignCenter
                           (True, False)  -> Alignment
    AlignLeft
                           (False, True)  -> Alignment
    AlignRight
                           (False, False) -> Alignment
    AlignDefault
      ((Int, Int), Alignment) -> ParserT s st m ((Int, Int), Alignment)
    forall (m :: * -> *) a. Monad m => a -> m a
    return ((Int
    lengthDashes, Int
    lengthDashes Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + 1), Alignment
    alignment)

    gridDashedLines :: Stream s m Char => Char -> ParserT s st m [((Int, Int), Alignment)]
    gridDashedLines :: Char -> ParserT s st m [((Int, Int), Alignment)]
    gridDashedLines ch :: Char
    ch = ParserT s st m [((Int, Int), Alignment)]
    -> ParserT s st m [((Int, Int), Alignment)]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT s st m [((Int, Int), Alignment)]
     -> ParserT s st m [((Int, Int), Alignment)])
    -> ParserT s st m [((Int, Int), Alignment)]
    -> ParserT s st m [((Int, Int), Alignment)]
    forall a b. (a -> b) -> a -> b
    $ Char -> ParsecT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '+' ParsecT s st m Char
    -> ParserT s st m [((Int, Int), Alignment)]
    -> ParserT s st m [((Int, Int), Alignment)]
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> ParsecT s st m ((Int, Int), Alignment)
    -> ParserT s st m [((Int, Int), Alignment)]
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m [a]
    many1 (Char -> ParsecT s st m ((Int, Int), Alignment)
    forall s (m :: * -> *) st.
    Stream s m Char =>
    Char -> ParserT s st m ((Int, Int), Alignment)
    gridPart Char
    ch) ParserT s st m [((Int, Int), Alignment)]
    -> ParsecT s st m Char -> ParserT s st m [((Int, Int), Alignment)]
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT s st m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    blankline

    removeFinalBar :: Text -> Text
    removeFinalBar :: Text -> Text
    removeFinalBar = (Char -> Bool) -> Text -> Text
    T.dropWhileEnd Char -> Bool
    go (Text -> Text) -> (Text -> Text) -> Text -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Char -> Bool) -> Text -> Text
    T.dropWhileEnd (Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    =='|')
      where
        go :: Char -> Bool
    go c :: Char
    c = (Char -> Bool) -> Text -> Bool
    T.any (Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    == Char
    c) " \t"

    -- | Separator between rows of grid table.
    gridTableSep :: Stream s m Char => Char -> ParserT s st m Char
    gridTableSep :: Char -> ParserT s st m Char
    gridTableSep ch :: Char
    ch = ParserT s st m Char -> ParserT s st m Char
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT s st m Char -> ParserT s st m Char)
    -> ParserT s st m Char -> ParserT s st m Char
    forall a b. (a -> b) -> a -> b
    $ Char -> ParserT s st m [((Int, Int), Alignment)]
    forall s (m :: * -> *) st.
    Stream s m Char =>
    Char -> ParserT s st m [((Int, Int), Alignment)]
    gridDashedLines Char
    ch ParserT s st m [((Int, Int), Alignment)]
    -> ParserT s st m Char -> ParserT s st m Char
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> Char -> ParserT s st m Char
    forall (m :: * -> *) a. Monad m => a -> m a
    return '\n'

    -- | Parse header for a grid table.
    gridTableHeader :: (Stream s m Char, Monad mf, IsString s, HasLastStrPosition st)
                    => Bool -- ^ Headerless table
                    -> ParserT s st m (mf Blocks)
                    -> ParserT s st m (mf [Blocks], [Alignment], [Int])
    gridTableHeader :: Bool
    -> ParserT s st m (mf Blocks)
    -> ParserT s st m (mf [Blocks], [Alignment], [Int])
    gridTableHeader headless :: Bool
    headless blocks :: ParserT s st m (mf Blocks)
    blocks = ParserT s st m (mf [Blocks], [Alignment], [Int])
    -> ParserT s st m (mf [Blocks], [Alignment], [Int])
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT s st m (mf [Blocks], [Alignment], [Int])
     -> ParserT s st m (mf [Blocks], [Alignment], [Int]))
    -> ParserT s st m (mf [Blocks], [Alignment], [Int])
    -> ParserT s st m (mf [Blocks], [Alignment], [Int])
    forall a b. (a -> b) -> a -> b
    $ do
      ParsecT s st m Text -> ParsecT s st m ()
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m ()
    optional ParsecT s st m Text
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Text
    blanklines
      [((Int, Int), Alignment)]
    dashes <- Char -> ParserT s st m [((Int, Int), Alignment)]
    forall s (m :: * -> *) st.
    Stream s m Char =>
    Char -> ParserT s st m [((Int, Int), Alignment)]
    gridDashedLines '-'
      [Text]
    rawContent  <- if Bool
    headless
                        then [Text] -> ParsecT s st m [Text]
    forall (m :: * -> *) a. Monad m => a -> m a
    return ([Text] -> ParsecT s st m [Text])
    -> [Text] -> ParsecT s st m [Text]
    forall a b. (a -> b) -> a -> b
    $ Text -> [Text]
    forall a. a -> [a]
    repeat ""
                        else ParsecT s st m Text -> ParsecT s st m [Text]
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m [a]
    many1
                             (ParsecT s st m Char -> ParsecT s 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 s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    gridTableSep '=') ParsecT s st m () -> ParsecT s st m Char -> ParsecT s st m Char
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> Char -> ParsecT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '|' ParsecT s st m Char -> ParsecT s st m Text -> ParsecT s st m Text
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >>
                               String -> Text
    T.pack (String -> Text) -> ParsecT s st m String -> ParsecT s st m Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT s st m Char -> ParsecT s st m Char -> ParsecT s st m String
    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 s st m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    anyChar ParsecT s st m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    newline)
      [((Int, Int), Alignment)]
    underDashes <- if Bool
    headless
                        then [((Int, Int), Alignment)]
    -> ParserT s st m [((Int, Int), Alignment)]
    forall (m :: * -> *) a. Monad m => a -> m a
    return [((Int, Int), Alignment)]
    dashes
                        else Char -> ParserT s st m [((Int, Int), Alignment)]
    forall s (m :: * -> *) st.
    Stream s m Char =>
    Char -> ParserT s st m [((Int, Int), Alignment)]
    gridDashedLines '='
      Bool -> ParsecT s st m ()
    forall (f :: * -> *). Alternative f => Bool -> f ()
    guard (Bool -> ParsecT s st m ()) -> Bool -> ParsecT s st m ()
    forall a b. (a -> b) -> a -> b
    $ [((Int, Int), Alignment)] -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    length [((Int, Int), Alignment)]
    dashes Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == [((Int, Int), Alignment)] -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    length [((Int, Int), Alignment)]
    underDashes
      let lines' :: [Int]
    lines'   = (((Int, Int), Alignment) -> Int)
    -> [((Int, Int), Alignment)] -> [Int]
    forall a b. (a -> b) -> [a] -> [b]
    map ((Int, Int) -> Int
    forall a b. (a, b) -> b
    snd ((Int, Int) -> Int)
    -> (((Int, Int), Alignment) -> (Int, Int))
    -> ((Int, Int), Alignment)
    -> Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ((Int, Int), Alignment) -> (Int, Int)
    forall a b. (a, b) -> a
    fst) [((Int, Int), Alignment)]
    underDashes
      let indices :: [Int]
    indices  = (Int -> Int -> Int) -> Int -> [Int] -> [Int]
    forall b a. (b -> a -> b) -> b -> [a] -> [b]
    scanl Int -> Int -> Int
    forall a. Num a => a -> a -> a
    (+) 0 [Int]
    lines'
      let aligns :: [Alignment]
    aligns   = (((Int, Int), Alignment) -> Alignment)
    -> [((Int, Int), Alignment)] -> [Alignment]
    forall a b. (a -> b) -> [a] -> [b]
    map ((Int, Int), Alignment) -> Alignment
    forall a b. (a, b) -> b
    snd [((Int, Int), Alignment)]
    underDashes
      let rawHeads :: [Text]
    rawHeads = if Bool
    headless
                        then Int -> Text -> [Text]
    forall a. Int -> a -> [a]
    replicate ([((Int, Int), Alignment)] -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    length [((Int, Int), Alignment)]
    underDashes) ""
                        else ([Text] -> Text) -> [[Text]] -> [Text]
    forall a b. (a -> b) -> [a] -> [b]
    map ([Text] -> Text
    T.unlines ([Text] -> Text) -> ([Text] -> [Text]) -> [Text] -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Text -> Text) -> [Text] -> [Text]
    forall a b. (a -> b) -> [a] -> [b]
    map Text -> Text
    trim) ([[Text]] -> [Text]) -> [[Text]] -> [Text]
    forall a b. (a -> b) -> a -> b
    $ [[Text]] -> [[Text]]
    forall a. [[a]] -> [[a]]
    transpose
                           ([[Text]] -> [[Text]]) -> [[Text]] -> [[Text]]
    forall a b. (a -> b) -> a -> b
    $ (Text -> [Text]) -> [Text] -> [[Text]]
    forall a b. (a -> b) -> [a] -> [b]
    map ([Int] -> Text -> [Text]
    gridTableSplitLine [Int]
    indices) [Text]
    rawContent
      mf [Blocks]
    heads <- [mf Blocks] -> mf [Blocks]
    forall (t :: * -> *) (m :: * -> *) a.
    (Traversable t, Monad m) =>
    t (m a) -> m (t a)
    sequence ([mf Blocks] -> mf [Blocks])
    -> ParsecT s st m [mf Blocks] -> ParsecT s st m (mf [Blocks])
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Text -> ParserT s st m (mf Blocks))
    -> [Text] -> ParsecT s st m [mf Blocks]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    mapM (ParserT s st m (mf Blocks) -> Text -> ParserT s st m (mf Blocks)
    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 s st m (mf Blocks)
    blocks (Text -> ParserT s st m (mf Blocks))
    -> (Text -> Text) -> Text -> ParserT s st m (mf Blocks)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Text
    trim) [Text]
    rawHeads
      (mf [Blocks], [Alignment], [Int])
    -> ParserT s st m (mf [Blocks], [Alignment], [Int])
    forall (m :: * -> *) a. Monad m => a -> m a
    return (mf [Blocks]
    heads, [Alignment]
    aligns, [Int]
    indices)

    gridTableRawLine :: Stream s m Char => [Int] -> ParserT s st m [Text]
    gridTableRawLine :: [Int] -> ParserT s st m [Text]
    gridTableRawLine indices :: [Int]
    indices = do
      Char -> ParsecT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '|'
      String
    line <- ParsecT s st m Char -> ParsecT s st m Char -> ParserT s st m String
    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 s st m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    anyChar ParsecT s st m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    newline
      [Text] -> ParserT s st m [Text]
    forall (m :: * -> *) a. Monad m => a -> m a
    return ([Int] -> Text -> [Text]
    gridTableSplitLine [Int]
    indices (Text -> [Text]) -> Text -> [Text]
    forall a b. (a -> b) -> a -> b
    $ String -> Text
    T.pack String
    line)

    -- | Parse row of grid table.
    gridTableRow :: (Stream s m Char, Monad mf, IsString s, HasLastStrPosition st)
                 => ParserT s st m (mf Blocks)
                 -> [Int]
                 -> ParserT s st m (mf [Blocks])
    gridTableRow :: ParserT s st m (mf Blocks) -> [Int] -> ParserT s st m (mf [Blocks])
    gridTableRow blocks :: ParserT s st m (mf Blocks)
    blocks indices :: [Int]
    indices = do
      [[Text]]
    colLines <- ParsecT s st m [Text] -> ParsecT s st m [[Text]]
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m [a]
    many1 ([Int] -> ParsecT s st m [Text]
    forall s (m :: * -> *) st.
    Stream s m Char =>
    [Int] -> ParserT s st m [Text]
    gridTableRawLine [Int]
    indices)
      let cols :: [Text]
    cols = ([Text] -> Text) -> [[Text]] -> [Text]
    forall a b. (a -> b) -> [a] -> [b]
    map ((Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> "\n") (Text -> Text) -> ([Text] -> Text) -> [Text] -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [Text] -> Text
    T.unlines ([Text] -> Text) -> ([Text] -> [Text]) -> [Text] -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [Text] -> [Text]
    removeOneLeadingSpace) ([[Text]] -> [Text]) -> [[Text]] -> [Text]
    forall a b. (a -> b) -> a -> b
    $
                   [[Text]] -> [[Text]]
    forall a. [[a]] -> [[a]]
    transpose [[Text]]
    colLines
          compactifyCell :: Blocks -> Blocks
    compactifyCell bs :: Blocks
    bs = case [Blocks] -> [Blocks]
    compactify [Blocks
    bs] of
                                []  -> Blocks
    forall a. Monoid a => a
    mempty
                                x :: Blocks
    x:_ -> Blocks
    x
      mf [Blocks]
    cells <- [mf Blocks] -> mf [Blocks]
    forall (t :: * -> *) (m :: * -> *) a.
    (Traversable t, Monad m) =>
    t (m a) -> m (t a)
    sequence ([mf Blocks] -> mf [Blocks])
    -> ParsecT s st m [mf Blocks] -> ParserT s st m (mf [Blocks])
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Text -> ParserT s st m (mf Blocks))
    -> [Text] -> ParsecT s st m [mf Blocks]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    mapM (ParserT s st m (mf Blocks) -> Text -> ParserT s st m (mf Blocks)
    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 s st m (mf Blocks)
    blocks) [Text]
    cols
      mf [Blocks] -> ParserT s st m (mf [Blocks])
    forall (m :: * -> *) a. Monad m => a -> m a
    return (mf [Blocks] -> ParserT s st m (mf [Blocks]))
    -> mf [Blocks] -> ParserT s st m (mf [Blocks])
    forall a b. (a -> b) -> a -> b
    $ ([Blocks] -> [Blocks]) -> mf [Blocks] -> mf [Blocks]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap ((Blocks -> Blocks) -> [Blocks] -> [Blocks]
    forall a b. (a -> b) -> [a] -> [b]
    map Blocks -> Blocks
    compactifyCell) mf [Blocks]
    cells

    removeOneLeadingSpace :: [Text] -> [Text]
    removeOneLeadingSpace :: [Text] -> [Text]
    removeOneLeadingSpace xs :: [Text]
    xs =
      if (Text -> Bool) -> [Text] -> Bool
    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
    all Text -> Bool
    startsWithSpace [Text]
    xs
         then (Text -> Text) -> [Text] -> [Text]
    forall a b. (a -> b) -> [a] -> [b]
    map (Int -> Text -> Text
    T.drop 1) [Text]
    xs
         else [Text]
    xs
       where startsWithSpace :: Text -> Bool
    startsWithSpace t :: Text
    t = case Text -> Maybe (Char, Text)
    T.uncons Text
    t of
               Nothing     -> Bool
    True
               Just (c :: Char
    c, _) -> Char
    c Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    == ' '

    -- | Parse footer for a grid table.
    gridTableFooter :: Stream s m Char => ParserT s st m Text
    gridTableFooter :: ParserT s st m Text
    gridTableFooter = ParserT s st m Text
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Text
    blanklines

    ---

    -- | Removes the ParsecT layer from the monad transformer stack
    readWithM :: (Stream s m Char, ToText s)
              => ParserT s st m a    -- ^ parser
              -> st                  -- ^ initial state
              -> s                   -- ^ input
              -> m (Either PandocError a)
    readWithM :: ParserT s st m a -> st -> s -> m (Either PandocError a)
    readWithM parser :: ParserT s st m a
    parser state :: st
    state input :: s
    input =
        (ParseError -> PandocError)
    -> Either ParseError a -> Either PandocError a
    forall a b c. (a -> b) -> Either a c -> Either b c
    mapLeft (Text -> ParseError -> PandocError
    PandocParsecError (Text -> ParseError -> PandocError)
    -> Text -> ParseError -> PandocError
    forall a b. (a -> b) -> a -> b
    $ s -> Text
    forall a. ToText a => a -> Text
    toText s
    input) (Either ParseError a -> Either PandocError a)
    -> m (Either ParseError a) -> m (Either PandocError a)
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    `liftM` ParserT s st m a -> st -> String -> s -> m (Either ParseError a)
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> u -> String -> s -> m (Either ParseError a)
    runParserT ParserT s st m a
    parser st
    state "source" s
    input

    -- | Parse a string with a given parser and state
    readWith :: Parser Text st a
             -> st
             -> Text
             -> Either PandocError a
    readWith :: Parser Text st a -> st -> Text -> Either PandocError a
    readWith p :: Parser Text st a
    p t :: st
    t inp :: Text
    inp = Identity (Either PandocError a) -> Either PandocError a
    forall a. Identity a -> a
    runIdentity (Identity (Either PandocError a) -> Either PandocError a)
    -> Identity (Either PandocError a) -> Either PandocError a
    forall a b. (a -> b) -> a -> b
    $ Parser Text st a -> st -> Text -> Identity (Either PandocError a)
    forall s (m :: * -> *) st a.
    (Stream s m Char, ToText s) =>
    ParserT s st m a -> st -> s -> m (Either PandocError a)
    readWithM Parser Text st a
    p st
    t Text
    inp

    -- | Parse a string with @parser@ (for testing).
    testStringWith :: Show a
                   => ParserT Text ParserState Identity a
                   -> Text
                   -> IO ()
    testStringWith :: ParserT Text ParserState Identity a -> Text -> IO ()
    testStringWith parser :: ParserT Text ParserState Identity a
    parser str :: Text
    str = String -> IO ()
    UTF8.putStrLn (String -> IO ()) -> String -> IO ()
    forall a b. (a -> b) -> a -> b
    $ Either PandocError a -> String
    forall a. Show a => a -> String
    show (Either PandocError a -> String) -> Either PandocError a -> String
    forall a b. (a -> b) -> a -> b
    $
                                ParserT Text ParserState Identity a
    -> ParserState -> Text -> Either PandocError a
    forall st a. Parser Text st a -> st -> Text -> Either PandocError a
    readWith ParserT Text ParserState Identity a
    parser ParserState
    defaultParserState Text
    str

    -- | Parsing options.
    data ParserState = ParserState
        { ParserState -> ReaderOptions
    stateOptions           :: ReaderOptions, -- ^ User options
          ParserState -> ParserContext
    stateParserContext     :: ParserContext, -- ^ Inside list?
          ParserState -> QuoteContext
    stateQuoteContext      :: QuoteContext,  -- ^ Inside quoted environment?
          ParserState -> Bool
    stateAllowLinks        :: Bool,          -- ^ Allow parsing of links
          ParserState -> Bool
    stateAllowLineBreaks   :: Bool,          -- ^ Allow parsing of line breaks
          ParserState -> Int
    stateMaxNestingLevel   :: Int,           -- ^ Max # of nested Strong/Emph
          ParserState -> Maybe SourcePos
    stateLastStrPos        :: Maybe SourcePos, -- ^ Position after last str parsed
          ParserState -> KeyTable
    stateKeys              :: KeyTable,      -- ^ List of reference keys
          ParserState -> KeyTable
    stateHeaderKeys        :: KeyTable,      -- ^ List of implicit header ref keys
          ParserState -> SubstTable
    stateSubstitutions     :: SubstTable,    -- ^ List of substitution references
          ParserState -> NoteTable
    stateNotes             :: NoteTable,     -- ^ List of notes (raw bodies)
          ParserState -> NoteTable'
    stateNotes'            :: NoteTable',    -- ^ List of notes (parsed bodies)
          ParserState -> Set Text
    stateNoteRefs          :: Set.Set Text, -- ^ List of note references used
          ParserState -> Meta
    stateMeta              :: Meta,          -- ^ Document metadata
          ParserState -> F Meta
    stateMeta'             :: F Meta,        -- ^ Document metadata
          ParserState -> Map Text Text
    stateCitations         :: M.Map Text Text, -- ^ RST-style citations
          ParserState -> [HeaderType]
    stateHeaderTable       :: [HeaderType],  -- ^ Ordered list of header types used
          ParserState -> Set Text
    stateIdentifiers       :: Set.Set Text, -- ^ Header identifiers used
          ParserState -> Int
    stateNextExample       :: Int,           -- ^ Number of next example
          ParserState -> Map Text Int
    stateExamples          :: M.Map Text Int, -- ^ Map from example labels to numbers
          ParserState -> Map Text Macro
    stateMacros            :: M.Map Text Macro, -- ^ Table of macros defined so far
          ParserState -> Text
    stateRstDefaultRole    :: Text,        -- ^ Current rST default interpreted text role
          ParserState -> Maybe Text
    stateRstHighlight      :: Maybe Text,  -- ^ Current rST literal block language
          ParserState -> Map Text (Text, Maybe Text, Attr)
    stateRstCustomRoles    :: M.Map Text (Text, Maybe Text, Attr), -- ^ Current rST custom text roles
          -- Triple represents: 1) Base role, 2) Optional format (only for :raw:
          -- roles), 3) Additional classes (rest of Attr is unused)).
          ParserState -> Maybe Inlines
    stateCaption           :: Maybe Inlines, -- ^ Caption in current environment
          ParserState -> Maybe Text
    stateInHtmlBlock       :: Maybe Text,  -- ^ Tag type of HTML block being parsed
          ParserState -> Int
    stateFencedDivLevel    :: Int,           -- ^ Depth of fenced div
          ParserState -> [Text]
    stateContainers        :: [Text],      -- ^ parent include files
          ParserState -> [LogMessage]
    stateLogMessages       :: [LogMessage],  -- ^ log messages
          ParserState -> Bool
    stateMarkdownAttribute :: Bool         -- ^ True if in markdown=1 context
        }

    instance Default ParserState where
      def :: ParserState
    def = ParserState
    defaultParserState

    instance HasMeta ParserState where
      setMeta :: Text -> b -> ParserState -> ParserState
    setMeta field :: Text
    field val :: b
    val st :: ParserState
    st =
        ParserState
    st{ stateMeta :: Meta
    stateMeta = Text -> b -> Meta -> Meta
    forall a b. (HasMeta a, ToMetaValue b) => Text -> b -> a -> a
    setMeta Text
    field b
    val (Meta -> Meta) -> Meta -> Meta
    forall a b. (a -> b) -> a -> b
    $ ParserState -> Meta
    stateMeta ParserState
    st }
      deleteMeta :: Text -> ParserState -> ParserState
    deleteMeta field :: Text
    field st :: ParserState
    st =
        ParserState
    st{ stateMeta :: Meta
    stateMeta = Text -> Meta -> Meta
    forall a. HasMeta a => Text -> a -> a
    deleteMeta Text
    field (Meta -> Meta) -> Meta -> Meta
    forall a b. (a -> b) -> a -> b
    $ ParserState -> Meta
    stateMeta ParserState
    st }

    class HasReaderOptions st where
      extractReaderOptions :: st -> ReaderOptions
      getOption            :: (Stream s m t) => (ReaderOptions -> b) -> ParserT s st m b
      -- default
      getOption  f :: ReaderOptions -> b
    f         = (ReaderOptions -> b
    f (ReaderOptions -> b) -> (st -> ReaderOptions) -> st -> b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . st -> ReaderOptions
    forall st. HasReaderOptions st => st -> ReaderOptions
    extractReaderOptions) (st -> b) -> ParsecT s st m st -> ParserT s st m b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT s st m st
    forall (m :: * -> *) s u. Monad m => ParsecT s u m u
    getState

    instance HasReaderOptions ParserState where
      extractReaderOptions :: ParserState -> ReaderOptions
    extractReaderOptions = ParserState -> ReaderOptions
    stateOptions

    class HasQuoteContext st m where
      getQuoteContext :: (Stream s m t) => ParsecT s st m QuoteContext
      withQuoteContext :: QuoteContext -> ParsecT s st m a -> ParsecT s st m a

    instance Monad m => HasQuoteContext ParserState m where
      getQuoteContext :: ParsecT s ParserState m QuoteContext
    getQuoteContext = ParserState -> QuoteContext
    stateQuoteContext (ParserState -> QuoteContext)
    -> ParsecT s ParserState m ParserState
    -> ParsecT s ParserState m QuoteContext
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT s ParserState m ParserState
    forall (m :: * -> *) s u. Monad m => ParsecT s u m u
    getState
      withQuoteContext :: QuoteContext
    -> ParsecT s ParserState m a -> ParsecT s ParserState m a
    withQuoteContext context :: QuoteContext
    context parser :: ParsecT s ParserState m a
    parser = do
        ParserState
    oldState <- ParsecT s ParserState m ParserState
    forall (m :: * -> *) s u. Monad m => ParsecT s u m u
    getState
        let oldQuoteContext :: QuoteContext
    oldQuoteContext = ParserState -> QuoteContext
    stateQuoteContext ParserState
    oldState
        ParserState -> ParsecT s ParserState m ()
    forall (m :: * -> *) u s. Monad m => u -> ParsecT s u m ()
    setState ParserState
    oldState { stateQuoteContext :: QuoteContext
    stateQuoteContext = QuoteContext
    context }
        a
    result <- ParsecT s ParserState m a
    parser
        ParserState
    newState <- ParsecT s ParserState m ParserState
    forall (m :: * -> *) s u. Monad m => ParsecT s u m u
    getState
        ParserState -> ParsecT s ParserState m ()
    forall (m :: * -> *) u s. Monad m => u -> ParsecT s u m ()
    setState ParserState
    newState { stateQuoteContext :: QuoteContext
    stateQuoteContext = QuoteContext
    oldQuoteContext }
        a -> ParsecT s ParserState m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return a
    result

    class HasIdentifierList st where
      extractIdentifierList  :: st -> Set.Set Text
      updateIdentifierList   :: (Set.Set Text -> Set.Set Text) -> st -> st

    instance HasIdentifierList ParserState where
      extractIdentifierList :: ParserState -> Set Text
    extractIdentifierList     = ParserState -> Set Text
    stateIdentifiers
      updateIdentifierList :: (Set Text -> Set Text) -> ParserState -> ParserState
    updateIdentifierList f :: Set Text -> Set Text
    f st :: ParserState
    st = ParserState
    st{ stateIdentifiers :: Set Text
    stateIdentifiers = Set Text -> Set Text
    f (Set Text -> Set Text) -> Set Text -> Set Text
    forall a b. (a -> b) -> a -> b
    $ ParserState -> Set Text
    stateIdentifiers ParserState
    st }

    class HasMacros st where
      extractMacros         :: st -> M.Map Text Macro
      updateMacros          :: (M.Map Text Macro -> M.Map Text Macro) -> st -> st

    instance HasMacros ParserState where
      extractMacros :: ParserState -> Map Text Macro
    extractMacros        = ParserState -> Map Text Macro
    stateMacros
      updateMacros :: (Map Text Macro -> Map Text Macro) -> ParserState -> ParserState
    updateMacros f :: Map Text Macro -> Map Text Macro
    f st :: ParserState
    st    = ParserState
    st{ stateMacros :: Map Text Macro
    stateMacros = Map Text Macro -> Map Text Macro
    f (Map Text Macro -> Map Text Macro)
    -> Map Text Macro -> Map Text Macro
    forall a b. (a -> b) -> a -> b
    $ ParserState -> Map Text Macro
    stateMacros ParserState
    st }

    class HasLastStrPosition st where
      setLastStrPos  :: Maybe SourcePos -> st -> st
      getLastStrPos  :: st -> Maybe SourcePos

    instance HasLastStrPosition ParserState where
      setLastStrPos :: Maybe SourcePos -> ParserState -> ParserState
    setLastStrPos pos :: Maybe SourcePos
    pos st :: ParserState
    st = ParserState
    st{ stateLastStrPos :: Maybe SourcePos
    stateLastStrPos = Maybe SourcePos
    pos }
      getLastStrPos :: ParserState -> Maybe SourcePos
    getLastStrPos st :: ParserState
    st     = ParserState -> Maybe SourcePos
    stateLastStrPos ParserState
    st

    class HasLogMessages st where
      addLogMessage :: LogMessage -> st -> st
      getLogMessages :: st -> [LogMessage]

    instance HasLogMessages ParserState where
      addLogMessage :: LogMessage -> ParserState -> ParserState
    addLogMessage msg :: LogMessage
    msg st :: ParserState
    st = ParserState
    st{ stateLogMessages :: [LogMessage]
    stateLogMessages = LogMessage
    msg LogMessage -> [LogMessage] -> [LogMessage]
    forall a. a -> [a] -> [a]
    : ParserState -> [LogMessage]
    stateLogMessages ParserState
    st }
      getLogMessages :: ParserState -> [LogMessage]
    getLogMessages st :: ParserState
    st = [LogMessage] -> [LogMessage]
    forall a. [a] -> [a]
    reverse ([LogMessage] -> [LogMessage]) -> [LogMessage] -> [LogMessage]
    forall a b. (a -> b) -> a -> b
    $ ParserState -> [LogMessage]
    stateLogMessages ParserState
    st

    class HasIncludeFiles st where
      getIncludeFiles :: st -> [Text]
      addIncludeFile :: Text -> st -> st
      dropLatestIncludeFile :: st -> st

    instance HasIncludeFiles ParserState where
      getIncludeFiles :: ParserState -> [Text]
    getIncludeFiles = ParserState -> [Text]
    stateContainers
      addIncludeFile :: Text -> ParserState -> ParserState
    addIncludeFile f :: Text
    f s :: ParserState
    s = ParserState
    s{ stateContainers :: [Text]
    stateContainers = Text
    f Text -> [Text] -> [Text]
    forall a. a -> [a] -> [a]
    : ParserState -> [Text]
    stateContainers ParserState
    s }
      dropLatestIncludeFile :: ParserState -> ParserState
    dropLatestIncludeFile s :: ParserState
    s = ParserState
    s { stateContainers :: [Text]
    stateContainers = Int -> [Text] -> [Text]
    forall a. Int -> [a] -> [a]
    drop 1 ([Text] -> [Text]) -> [Text] -> [Text]
    forall a b. (a -> b) -> a -> b
    $ ParserState -> [Text]
    stateContainers ParserState
    s }

    defaultParserState :: ParserState
    defaultParserState :: ParserState
    defaultParserState =
        ParserState :: ReaderOptions
    -> ParserContext
    -> QuoteContext
    -> Bool
    -> Bool
    -> Int
    -> Maybe SourcePos
    -> KeyTable
    -> KeyTable
    -> SubstTable
    -> NoteTable
    -> NoteTable'
    -> Set Text
    -> Meta
    -> F Meta
    -> Map Text Text
    -> [HeaderType]
    -> Set Text
    -> Int
    -> Map Text Int
    -> Map Text Macro
    -> Text
    -> Maybe Text
    -> Map Text (Text, Maybe Text, Attr)
    -> Maybe Inlines
    -> Maybe Text
    -> Int
    -> [Text]
    -> [LogMessage]
    -> Bool
    -> ParserState
    ParserState { stateOptions :: ReaderOptions
    stateOptions         = ReaderOptions
    forall a. Default a => a
    def,
                      stateParserContext :: ParserContext
    stateParserContext   = ParserContext
    NullState,
                      stateQuoteContext :: QuoteContext
    stateQuoteContext    = QuoteContext
    NoQuote,
                      stateAllowLinks :: Bool
    stateAllowLinks      = Bool
    True,
                      stateAllowLineBreaks :: Bool
    stateAllowLineBreaks = Bool
    True,
                      stateMaxNestingLevel :: Int
    stateMaxNestingLevel = 6,
                      stateLastStrPos :: Maybe SourcePos
    stateLastStrPos      = Maybe SourcePos
    forall a. Maybe a
    Nothing,
                      stateKeys :: KeyTable
    stateKeys            = KeyTable
    forall k a. Map k a
    M.empty,
                      stateHeaderKeys :: KeyTable
    stateHeaderKeys      = KeyTable
    forall k a. Map k a
    M.empty,
                      stateSubstitutions :: SubstTable
    stateSubstitutions   = SubstTable
    forall k a. Map k a
    M.empty,
                      stateNotes :: NoteTable
    stateNotes           = [],
                      stateNotes' :: NoteTable'
    stateNotes'          = NoteTable'
    forall k a. Map k a
    M.empty,
                      stateNoteRefs :: Set Text
    stateNoteRefs        = Set Text
    forall a. Set a
    Set.empty,
                      stateMeta :: Meta
    stateMeta            = Meta
    nullMeta,
                      stateMeta' :: F Meta
    stateMeta'           = Meta -> F Meta
    forall (m :: * -> *) a. Monad m => a -> m a
    return Meta
    nullMeta,
                      stateCitations :: Map Text Text
    stateCitations       = Map Text Text
    forall k a. Map k a
    M.empty,
                      stateHeaderTable :: [HeaderType]
    stateHeaderTable     = [],
                      stateIdentifiers :: Set Text
    stateIdentifiers     = Set Text
    forall a. Set a
    Set.empty,
                      stateNextExample :: Int
    stateNextExample     = 1,
                      stateExamples :: Map Text Int
    stateExamples        = Map Text Int
    forall k a. Map k a
    M.empty,
                      stateMacros :: Map Text Macro
    stateMacros          = Map Text Macro
    forall k a. Map k a
    M.empty,
                      stateRstDefaultRole :: Text
    stateRstDefaultRole  = "title-reference",
                      stateRstHighlight :: Maybe Text
    stateRstHighlight    = Maybe Text
    forall a. Maybe a
    Nothing,
                      stateRstCustomRoles :: Map Text (Text, Maybe Text, Attr)
    stateRstCustomRoles  = Map Text (Text, Maybe Text, Attr)
    forall k a. Map k a
    M.empty,
                      stateCaption :: Maybe Inlines
    stateCaption         = Maybe Inlines
    forall a. Maybe a
    Nothing,
                      stateInHtmlBlock :: Maybe Text
    stateInHtmlBlock     = Maybe Text
    forall a. Maybe a
    Nothing,
                      stateFencedDivLevel :: Int
    stateFencedDivLevel  = 0,
                      stateContainers :: [Text]
    stateContainers      = [],
                      stateLogMessages :: [LogMessage]
    stateLogMessages     = [],
                      stateMarkdownAttribute :: Bool
    stateMarkdownAttribute = Bool
    False
                      }

    -- | Add a log message.
    logMessage :: (Stream s m a, HasLogMessages st)
               => LogMessage -> ParserT s st m ()
    logMessage :: LogMessage -> ParserT s st m ()
    logMessage msg :: LogMessage
    msg = (st -> st) -> ParserT s st m ()
    forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
    updateState (LogMessage -> st -> st
    forall st. HasLogMessages st => LogMessage -> st -> st
    addLogMessage LogMessage
    msg)

    -- | Report all the accumulated log messages, according to verbosity level.
    reportLogMessages :: (PandocMonad m, HasLogMessages st) => ParserT s st m ()
    reportLogMessages :: ParserT s st m ()
    reportLogMessages = do
      [LogMessage]
    msgs <- st -> [LogMessage]
    forall st. HasLogMessages st => st -> [LogMessage]
    getLogMessages (st -> [LogMessage])
    -> ParsecT s st m st -> ParsecT s st m [LogMessage]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT s st m st
    forall (m :: * -> *) s u. Monad m => ParsecT s u m u
    getState
      (LogMessage -> ParserT s st m ())
    -> [LogMessage] -> ParserT s st m ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    (a -> m b) -> t a -> m ()
    mapM_ LogMessage -> ParserT s st m ()
    forall (m :: * -> *). PandocMonad m => LogMessage -> m ()
    report [LogMessage]
    msgs

    -- | Succeed only if the extension is enabled.
    guardEnabled :: (Stream s m a,  HasReaderOptions st) => Extension -> ParserT s st m ()
    guardEnabled :: Extension -> ParserT s st m ()
    guardEnabled ext :: Extension
    ext = (ReaderOptions -> Extensions) -> ParserT s st m Extensions
    forall st s (m :: * -> *) t b.
    (HasReaderOptions st, Stream s m t) =>
    (ReaderOptions -> b) -> ParserT s st m b
    getOption ReaderOptions -> Extensions
    readerExtensions ParserT s st m Extensions
    -> (Extensions -> ParserT s st m ()) -> ParserT s st m ()
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= Bool -> ParserT s st m ()
    forall (f :: * -> *). Alternative f => Bool -> f ()
    guard (Bool -> ParserT s st m ())
    -> (Extensions -> Bool) -> Extensions -> ParserT s st m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Extension -> Extensions -> Bool
    extensionEnabled Extension
    ext

    -- | Succeed only if the extension is disabled.
    guardDisabled :: (Stream s m a, HasReaderOptions st) => Extension -> ParserT s st m ()
    guardDisabled :: Extension -> ParserT s st m ()
    guardDisabled ext :: Extension
    ext = (ReaderOptions -> Extensions) -> ParserT s st m Extensions
    forall st s (m :: * -> *) t b.
    (HasReaderOptions st, Stream s m t) =>
    (ReaderOptions -> b) -> ParserT s st m b
    getOption ReaderOptions -> Extensions
    readerExtensions ParserT s st m Extensions
    -> (Extensions -> ParserT s st m ()) -> ParserT s st m ()
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= Bool -> ParserT s st m ()
    forall (f :: * -> *). Alternative f => Bool -> f ()
    guard (Bool -> ParserT s st m ())
    -> (Extensions -> Bool) -> Extensions -> ParserT s st m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Bool
    not (Bool -> Bool) -> (Extensions -> Bool) -> Extensions -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Extension -> Extensions -> Bool
    extensionEnabled Extension
    ext

    -- | Update the position on which the last string ended.
    updateLastStrPos :: (Stream s m a, HasLastStrPosition st) => ParserT s st m ()
    updateLastStrPos :: ParserT s st m ()
    updateLastStrPos = ParsecT s st m SourcePos
    forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
    getPosition ParsecT s st m SourcePos
    -> (SourcePos -> ParserT s st m ()) -> ParserT s st m ()
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= (st -> st) -> ParserT s st m ()
    forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
    updateState ((st -> st) -> ParserT s st m ())
    -> (SourcePos -> st -> st) -> SourcePos -> ParserT s st m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Maybe SourcePos -> st -> st
    forall st. HasLastStrPosition st => Maybe SourcePos -> st -> st
    setLastStrPos (Maybe SourcePos -> st -> st)
    -> (SourcePos -> Maybe SourcePos) -> SourcePos -> st -> st
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . SourcePos -> Maybe SourcePos
    forall a. a -> Maybe a
    Just

    -- | Whether we are right after the end of a string.
    notAfterString :: (Stream s m a, HasLastStrPosition st) => ParserT s st m Bool
    notAfterString :: ParserT s st m Bool
    notAfterString = do
      SourcePos
    pos <- ParsecT s st m SourcePos
    forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
    getPosition
      st
    st  <- ParsecT s st m st
    forall (m :: * -> *) s u. Monad m => ParsecT s u m u
    getState
      Bool -> ParserT s st m Bool
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Bool -> ParserT s st m Bool) -> Bool -> ParserT s st m Bool
    forall a b. (a -> b) -> a -> b
    $ st -> Maybe SourcePos
    forall st. HasLastStrPosition st => st -> Maybe SourcePos
    getLastStrPos st
    st Maybe SourcePos -> Maybe SourcePos -> Bool
    forall a. Eq a => a -> a -> Bool
    /= SourcePos -> Maybe SourcePos
    forall a. a -> Maybe a
    Just SourcePos
    pos

    data HeaderType
        = SingleHeader Char  -- ^ Single line of characters underneath
        | DoubleHeader Char  -- ^ Lines of characters above and below
        deriving (HeaderType -> HeaderType -> Bool
    (HeaderType -> HeaderType -> Bool)
    -> (HeaderType -> HeaderType -> Bool) -> Eq HeaderType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: HeaderType -> HeaderType -> Bool
    $c/= :: HeaderType -> HeaderType -> Bool
    == :: HeaderType -> HeaderType -> Bool
    $c== :: HeaderType -> HeaderType -> Bool
    Eq, Int -> HeaderType -> String -> String
    [HeaderType] -> String -> String
    HeaderType -> String
    (Int -> HeaderType -> String -> String)
    -> (HeaderType -> String)
    -> ([HeaderType] -> String -> String)
    -> Show HeaderType
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [HeaderType] -> String -> String
    $cshowList :: [HeaderType] -> String -> String
    show :: HeaderType -> String
    $cshow :: HeaderType -> String
    showsPrec :: Int -> HeaderType -> String -> String
    $cshowsPrec :: Int -> HeaderType -> String -> String
    Show)

    data ParserContext
        = ListItemState   -- ^ Used when running parser on list item contents
        | NullState       -- ^ Default state
        deriving (ParserContext -> ParserContext -> Bool
    (ParserContext -> ParserContext -> Bool)
    -> (ParserContext -> ParserContext -> Bool) -> Eq ParserContext
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: ParserContext -> ParserContext -> Bool
    $c/= :: ParserContext -> ParserContext -> Bool
    == :: ParserContext -> ParserContext -> Bool
    $c== :: ParserContext -> ParserContext -> Bool
    Eq, Int -> ParserContext -> String -> String
    [ParserContext] -> String -> String
    ParserContext -> String
    (Int -> ParserContext -> String -> String)
    -> (ParserContext -> String)
    -> ([ParserContext] -> String -> String)
    -> Show ParserContext
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [ParserContext] -> String -> String
    $cshowList :: [ParserContext] -> String -> String
    show :: ParserContext -> String
    $cshow :: ParserContext -> String
    showsPrec :: Int -> ParserContext -> String -> String
    $cshowsPrec :: Int -> ParserContext -> String -> String
    Show)

    data QuoteContext
        = InSingleQuote   -- ^ Used when parsing inside single quotes
        | InDoubleQuote   -- ^ Used when parsing inside double quotes
        | NoQuote         -- ^ Used when not parsing inside quotes
        deriving (QuoteContext -> QuoteContext -> Bool
    (QuoteContext -> QuoteContext -> Bool)
    -> (QuoteContext -> QuoteContext -> Bool) -> Eq QuoteContext
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: QuoteContext -> QuoteContext -> Bool
    $c/= :: QuoteContext -> QuoteContext -> Bool
    == :: QuoteContext -> QuoteContext -> Bool
    $c== :: QuoteContext -> QuoteContext -> Bool
    Eq, Int -> QuoteContext -> String -> String
    [QuoteContext] -> String -> String
    QuoteContext -> String
    (Int -> QuoteContext -> String -> String)
    -> (QuoteContext -> String)
    -> ([QuoteContext] -> String -> String)
    -> Show QuoteContext
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [QuoteContext] -> String -> String
    $cshowList :: [QuoteContext] -> String -> String
    show :: QuoteContext -> String
    $cshow :: QuoteContext -> String
    showsPrec :: Int -> QuoteContext -> String -> String
    $cshowsPrec :: Int -> QuoteContext -> String -> String
    Show)

    type NoteTable = [(Text, Text)]

    type NoteTable' = M.Map Text (SourcePos, F Blocks)
    -- used in markdown reader

    newtype Key = Key Text deriving (Int -> Key -> String -> String
    [Key] -> String -> String
    Key -> String
    (Int -> Key -> String -> String)
    -> (Key -> String) -> ([Key] -> String -> String) -> Show Key
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    showList :: [Key] -> String -> String
    $cshowList :: [Key] -> String -> String
    show :: Key -> String
    $cshow :: Key -> String
    showsPrec :: Int -> Key -> String -> String
    $cshowsPrec :: Int -> Key -> String -> String
    Show, ReadPrec [Key]
    ReadPrec Key
    Int -> ReadS Key
    ReadS [Key]
    (Int -> ReadS Key)
    -> ReadS [Key] -> ReadPrec Key -> ReadPrec [Key] -> Read Key
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    readListPrec :: ReadPrec [Key]
    $creadListPrec :: ReadPrec [Key]
    readPrec :: ReadPrec Key
    $creadPrec :: ReadPrec Key
    readList :: ReadS [Key]
    $creadList :: ReadS [Key]
    readsPrec :: Int -> ReadS Key
    $creadsPrec :: Int -> ReadS Key
    Read, Key -> Key -> Bool
    (Key -> Key -> Bool) -> (Key -> Key -> Bool) -> Eq Key
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Key -> Key -> Bool
    $c/= :: Key -> Key -> Bool
    == :: Key -> Key -> Bool
    $c== :: Key -> Key -> Bool
    Eq, Eq Key
    Eq Key =>
    (Key -> Key -> Ordering)
    -> (Key -> Key -> Bool)
    -> (Key -> Key -> Bool)
    -> (Key -> Key -> Bool)
    -> (Key -> Key -> Bool)
    -> (Key -> Key -> Key)
    -> (Key -> Key -> Key)
    -> Ord Key
    Key -> Key -> Bool
    Key -> Key -> Ordering
    Key -> Key -> Key
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    min :: Key -> Key -> Key
    $cmin :: Key -> Key -> Key
    max :: Key -> Key -> Key
    $cmax :: Key -> Key -> Key
    >= :: Key -> Key -> Bool
    $c>= :: Key -> Key -> Bool
    > :: Key -> Key -> Bool
    $c> :: Key -> Key -> Bool
    <= :: Key -> Key -> Bool
    $c<= :: Key -> Key -> Bool
    < :: Key -> Key -> Bool
    $c< :: Key -> Key -> Bool
    compare :: Key -> Key -> Ordering
    $ccompare :: Key -> Key -> Ordering
    $cp1Ord :: Eq Key
    Ord)

    toKey :: Text -> Key
    toKey :: Text -> Key
    toKey = Text -> Key
    Key (Text -> Key) -> (Text -> Text) -> Text -> Key
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Text
    T.toLower (Text -> Text) -> (Text -> Text) -> Text -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [Text] -> Text
    T.unwords ([Text] -> Text) -> (Text -> [Text]) -> Text -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> [Text]
    T.words (Text -> [Text]) -> (Text -> Text) -> Text -> [Text]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Text
    unbracket
      where unbracket :: Text -> Text
    unbracket t :: Text
    t
              | Just ('[', t' :: Text
    t') <- Text -> Maybe (Char, Text)
    T.uncons Text
    t
              , Just (t'' :: Text
    t'', ']') <- Text -> Maybe (Text, Char)
    T.unsnoc Text
    t'
              = Text
    t''
              | Bool
    otherwise
              = Text
    t

    type KeyTable = M.Map Key (Target, Attr)

    type SubstTable = M.Map Key Inlines

    --  | Add header to the list of headers in state, together
    --  with its associated identifier.  If the identifier is null
    --  and the auto_identifiers extension is set, generate a new
    --  unique identifier, and update the list of identifiers
    --  in state.  Issue a warning if an explicit identifier
    --  is encountered that duplicates an earlier identifier
    --  (explicit or automatically generated).
    registerHeader :: (Stream s m a, HasReaderOptions st,
                       HasLogMessages st, HasIdentifierList st)
                   => Attr -> Inlines -> ParserT s st m Attr
    registerHeader :: Attr -> Inlines -> ParserT s st m Attr
    registerHeader (ident :: Text
    ident,classes :: [Text]
    classes,kvs :: NoteTable
    kvs) header' :: Inlines
    header' = do
      Set Text
    ids <- st -> Set Text
    forall st. HasIdentifierList st => st -> Set Text
    extractIdentifierList (st -> Set Text) -> ParsecT s st m st -> ParsecT s st m (Set Text)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT s st m st
    forall (m :: * -> *) s u. Monad m => ParsecT s u m u
    getState
      Extensions
    exts <- (ReaderOptions -> Extensions) -> ParserT s st m Extensions
    forall st s (m :: * -> *) t b.
    (HasReaderOptions st, Stream s m t) =>
    (ReaderOptions -> b) -> ParserT s st m b
    getOption ReaderOptions -> Extensions
    readerExtensions
      if Text -> Bool
    T.null Text
    ident Bool -> Bool -> Bool
    && Extension
    Ext_auto_identifiers Extension -> Extensions -> Bool
    `extensionEnabled` Extensions
    exts
         then do
           let id' :: Text
    id' = Extensions -> [Inline] -> Set Text -> Text
    uniqueIdent Extensions
    exts (Inlines -> [Inline]
    forall a. Many a -> [a]
    B.toList Inlines
    header') Set Text
    ids
           let id'' :: Text
    id'' = if Extension
    Ext_ascii_identifiers Extension -> Extensions -> Bool
    `extensionEnabled` Extensions
    exts
                         then String -> Text
    T.pack (String -> Text) -> String -> Text
    forall a b. (a -> b) -> a -> b
    $ (Char -> Maybe Char) -> String -> String
    forall a b. (a -> Maybe b) -> [a] -> [b]
    mapMaybe Char -> Maybe Char
    toAsciiChar (String -> String) -> String -> String
    forall a b. (a -> b) -> a -> b
    $ Text -> String
    T.unpack Text
    id'
                         else Text
    id'
           (st -> st) -> ParsecT s st m ()
    forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
    updateState ((st -> st) -> ParsecT s st m ())
    -> (st -> st) -> ParsecT s st m ()
    forall a b. (a -> b) -> a -> b
    $ (Set Text -> Set Text) -> st -> st
    forall st.
    HasIdentifierList st =>
    (Set Text -> Set Text) -> st -> st
    updateIdentifierList ((Set Text -> Set Text) -> st -> st)
    -> (Set Text -> Set Text) -> st -> st
    forall a b. (a -> b) -> a -> b
    $ Text -> Set Text -> Set Text
    forall a. Ord a => a -> Set a -> Set a
    Set.insert Text
    id'
           (st -> st) -> ParsecT s st m ()
    forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
    updateState ((st -> st) -> ParsecT s st m ())
    -> (st -> st) -> ParsecT s st m ()
    forall a b. (a -> b) -> a -> b
    $ (Set Text -> Set Text) -> st -> st
    forall st.
    HasIdentifierList st =>
    (Set Text -> Set Text) -> st -> st
    updateIdentifierList ((Set Text -> Set Text) -> st -> st)
    -> (Set Text -> Set Text) -> st -> st
    forall a b. (a -> b) -> a -> b
    $ Text -> Set Text -> Set Text
    forall a. Ord a => a -> Set a -> Set a
    Set.insert Text
    id''
           Attr -> ParserT s st m Attr
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Text
    id'',[Text]
    classes,NoteTable
    kvs)
         else do
            Bool -> ParsecT s st m () -> ParsecT s st m ()
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    unless (Text -> Bool
    T.null Text
    ident) (ParsecT s st m () -> ParsecT s st m ())
    -> ParsecT s st m () -> ParsecT s st m ()
    forall a b. (a -> b) -> a -> b
    $ do
              Bool -> ParsecT s st m () -> ParsecT s st m ()
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    when (Text
    ident Text -> Set Text -> Bool
    forall a. Ord a => a -> Set a -> Bool
    `Set.member` Set Text
    ids) (ParsecT s st m () -> ParsecT s st m ())
    -> ParsecT s st m () -> ParsecT s st m ()
    forall a b. (a -> b) -> a -> b
    $ do
                SourcePos
    pos <- ParsecT s st m SourcePos
    forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
    getPosition
                LogMessage -> ParsecT s st m ()
    forall s (m :: * -> *) a st.
    (Stream s m a, HasLogMessages st) =>
    LogMessage -> ParserT s st m ()
    logMessage (LogMessage -> ParsecT s st m ())
    -> LogMessage -> ParsecT s st m ()
    forall a b. (a -> b) -> a -> b
    $ Text -> SourcePos -> LogMessage
    DuplicateIdentifier Text
    ident SourcePos
    pos
              (st -> st) -> ParsecT s st m ()
    forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
    updateState ((st -> st) -> ParsecT s st m ())
    -> (st -> st) -> ParsecT s st m ()
    forall a b. (a -> b) -> a -> b
    $ (Set Text -> Set Text) -> st -> st
    forall st.
    HasIdentifierList st =>
    (Set Text -> Set Text) -> st -> st
    updateIdentifierList ((Set Text -> Set Text) -> st -> st)
    -> (Set Text -> Set Text) -> st -> st
    forall a b. (a -> b) -> a -> b
    $ Text -> Set Text -> Set Text
    forall a. Ord a => a -> Set a -> Set a
    Set.insert Text
    ident
            Attr -> ParserT s st m Attr
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Text
    ident,[Text]
    classes,NoteTable
    kvs)

    smartPunctuation :: (HasReaderOptions st, HasLastStrPosition st, HasQuoteContext st m, Stream s m Char)
                     => ParserT s st m Inlines
                     -> ParserT s st m Inlines
    smartPunctuation :: ParserT s st m Inlines -> ParserT s st m Inlines
    smartPunctuation inlineParser :: ParserT s st m Inlines
    inlineParser = do
      Extension -> ParserT s st m ()
    forall s (m :: * -> *) a st.
    (Stream s m a, HasReaderOptions st) =>
    Extension -> ParserT s st m ()
    guardEnabled Extension
    Ext_smart
      [ParserT s st m Inlines] -> ParserT s st m Inlines
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    [ParsecT s u m a] -> ParsecT s u m a
    choice [ ParserT s st m Inlines -> ParserT s st m Inlines
    forall st (m :: * -> *) s.
    (HasLastStrPosition st, HasQuoteContext st m, Stream s m Char) =>
    ParserT s st m Inlines -> ParserT s st m Inlines
    quoted ParserT s st m Inlines
    inlineParser, ParserT s st m Inlines
    forall s (m :: * -> *) st.
    Stream s m Char =>
    ParserT s st m Inlines
    apostrophe, ParserT s st m Inlines
    forall st s (m :: * -> *).
    (HasReaderOptions st, Stream s m Char) =>
    ParserT s st m Inlines
    dash, ParserT s st m Inlines
    forall s (m :: * -> *) st.
    Stream s m Char =>
    ParserT s st m Inlines
    ellipses ]

    apostrophe :: Stream s m Char => ParserT s st m Inlines
    apostrophe :: ParserT s st m Inlines
    apostrophe = (Char -> ParsecT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '\'' ParsecT s st m Char -> ParsecT s st m Char -> ParsecT s 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 s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '\8217') ParsecT s st m Char
    -> ParserT s st m Inlines -> ParserT s st m Inlines
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> Inlines -> ParserT s st m Inlines
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Text -> Inlines
    B.str "\x2019")

    quoted :: (HasLastStrPosition st, HasQuoteContext st m, Stream s m Char)
           => ParserT s st m Inlines
           -> ParserT s st m Inlines
    quoted :: ParserT s st m Inlines -> ParserT s st m Inlines
    quoted inlineParser :: ParserT s st m Inlines
    inlineParser = ParserT s st m Inlines -> ParserT s st m Inlines
    forall st (m :: * -> *) s.
    (HasQuoteContext st m, Stream s m Char) =>
    ParserT s st m Inlines -> ParserT s st m Inlines
    doubleQuoted ParserT s st m Inlines
    inlineParser ParserT s st m Inlines
    -> ParserT s st m Inlines -> ParserT s st m Inlines
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParserT s st m Inlines -> ParserT s st m Inlines
    forall st (m :: * -> *) s.
    (HasLastStrPosition st, HasQuoteContext st m, Stream s m Char) =>
    ParserT s st m Inlines -> ParserT s st m Inlines
    singleQuoted ParserT s st m Inlines
    inlineParser

    singleQuoted :: (HasLastStrPosition st, HasQuoteContext st m, Stream s m Char)
                 => ParserT s st m Inlines
                 -> ParserT s st m Inlines
    singleQuoted :: ParserT s st m Inlines -> ParserT s st m Inlines
    singleQuoted inlineParser :: ParserT s st m Inlines
    inlineParser = ParserT s st m Inlines -> ParserT s st m Inlines
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT s st m Inlines -> ParserT s st m Inlines)
    -> ParserT s st m Inlines -> ParserT s st m Inlines
    forall a b. (a -> b) -> a -> b
    $ Inlines -> Inlines
    B.singleQuoted (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 s st m () -> ParsecT s st m ([Inlines] -> Inlines)
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$  ParsecT s st m ()
    forall st (m :: * -> *) s.
    (HasLastStrPosition st, HasQuoteContext st m, Stream s m Char) =>
    ParserT s st m ()
    singleQuoteStart
      ParsecT s st m ([Inlines] -> Inlines)
    -> ParsecT s st m [Inlines] -> ParserT s st m Inlines
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> QuoteContext
    -> ParsecT s st m [Inlines] -> ParsecT s st 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 s st m Inlines
    -> ParsecT s st m () -> ParsecT s st 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 s st m Inlines
    inlineParser ParsecT s st m ()
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m ()
    singleQuoteEnd)

    doubleQuoted :: (HasQuoteContext st m, Stream s m Char)
                 => ParserT s st m Inlines
                 -> ParserT s st m Inlines
    doubleQuoted :: ParserT s st m Inlines -> ParserT s st m Inlines
    doubleQuoted inlineParser :: ParserT s st m Inlines
    inlineParser = ParserT s st m Inlines -> ParserT s st m Inlines
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT s st m Inlines -> ParserT s st m Inlines)
    -> ParserT s st m Inlines -> ParserT s st m Inlines
    forall a b. (a -> b) -> a -> b
    $ Inlines -> Inlines
    B.doubleQuoted (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 s st m () -> ParsecT s st m ([Inlines] -> Inlines)
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$  ParsecT s st m ()
    forall st (m :: * -> *) s.
    (HasQuoteContext st m, Stream s m Char) =>
    ParserT s st m ()
    doubleQuoteStart
      ParsecT s st m ([Inlines] -> Inlines)
    -> ParsecT s st m [Inlines] -> ParserT s st m Inlines
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> QuoteContext
    -> ParsecT s st m [Inlines] -> ParsecT s st 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 s st m Inlines
    -> ParsecT s st m () -> ParsecT s st 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 ParserT s st m Inlines
    inlineParser ParsecT s st m ()
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m ()
    doubleQuoteEnd)

    failIfInQuoteContext :: (HasQuoteContext st m, Stream s m t)
                         => QuoteContext
                         -> ParserT s st m ()
    failIfInQuoteContext :: QuoteContext -> ParserT s st m ()
    failIfInQuoteContext context :: QuoteContext
    context = do
      QuoteContext
    context' <- ParsecT s st m QuoteContext
    forall st (m :: * -> *) s t.
    (HasQuoteContext st m, Stream s m t) =>
    ParsecT s st m QuoteContext
    getQuoteContext
      Bool -> ParserT s st m () -> ParserT s st m ()
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    when (QuoteContext
    context' QuoteContext -> QuoteContext -> Bool
    forall a. Eq a => a -> a -> Bool
    == QuoteContext
    context) (ParserT s st m () -> ParserT s st m ())
    -> ParserT s st m () -> ParserT s st m ()
    forall a b. (a -> b) -> a -> b
    $ String -> ParserT s st m ()
    forall (m :: * -> *) a. MonadFail m => String -> m a
    Prelude.fail "already inside quotes"

    charOrRef :: Stream s m Char => [Char] -> ParserT s st m Char
    charOrRef :: String -> ParserT s st m Char
    charOrRef cs :: String
    cs =
      String -> ParserT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    String -> ParsecT s u m Char
    oneOf String
    cs ParserT s st m Char -> ParserT s st m Char -> ParserT s st m Char
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParserT s st m Char -> ParserT s st m Char
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (do Char
    c <- ParserT s st m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    characterReference
                           Bool -> ParsecT s st m ()
    forall (f :: * -> *). Alternative f => Bool -> f ()
    guard (Char
    c Char -> String -> Bool
    forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
    `elem` String
    cs)
                           Char -> ParserT s st m Char
    forall (m :: * -> *) a. Monad m => a -> m a
    return Char
    c)

    singleQuoteStart :: (HasLastStrPosition st, HasQuoteContext st m, Stream s m Char)
                     => ParserT s st m ()
    singleQuoteStart :: ParserT s st m ()
    singleQuoteStart = do
      QuoteContext -> ParserT s st m ()
    forall st (m :: * -> *) s t.
    (HasQuoteContext st m, Stream s m t) =>
    QuoteContext -> ParserT s st m ()
    failIfInQuoteContext QuoteContext
    InSingleQuote
      -- single quote start can't be right after str
      Bool -> ParserT s st m ()
    forall (f :: * -> *). Alternative f => Bool -> f ()
    guard (Bool -> ParserT s st m ())
    -> ParsecT s st m Bool -> ParserT s st m ()
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< ParsecT s st m Bool
    forall s (m :: * -> *) a st.
    (Stream s m a, HasLastStrPosition st) =>
    ParserT s st m Bool
    notAfterString
      ParserT s st m () -> ParserT s st m ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT s st m () -> ParserT s st m ())
    -> ParserT s st m () -> ParserT s st m ()
    forall a b. (a -> b) -> a -> b
    $ do
        String -> ParserT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    String -> ParsecT s u m Char
    charOrRef "'\8216\145"
        ParserT s st m Char -> ParserT s st m ()
    forall s (m :: * -> *) t a u.
    (Stream s m t, Show a) =>
    ParsecT s u m a -> ParsecT s u m ()
    notFollowedBy (String -> ParserT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    String -> ParsecT s u m Char
    oneOf [' ', '\t', '\n'])

    singleQuoteEnd :: Stream s m Char
                   => ParserT s st m ()
    singleQuoteEnd :: ParserT s st m ()
    singleQuoteEnd = ParserT s st m () -> ParserT s st m ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT s st m () -> ParserT s st m ())
    -> ParserT s st m () -> ParserT s st m ()
    forall a b. (a -> b) -> a -> b
    $ do
      String -> ParserT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    String -> ParsecT s u m Char
    charOrRef "'\8217\146"
      ParserT s st m Char -> ParserT s st m ()
    forall s (m :: * -> *) t a u.
    (Stream s m t, Show a) =>
    ParsecT s u m a -> ParsecT s u m ()
    notFollowedBy ParserT s st m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    alphaNum

    doubleQuoteStart :: (HasQuoteContext st m, Stream s m Char)
                     => ParserT s st m ()
    doubleQuoteStart :: ParserT s st m ()
    doubleQuoteStart = do
      QuoteContext -> ParserT s st m ()
    forall st (m :: * -> *) s t.
    (HasQuoteContext st m, Stream s m t) =>
    QuoteContext -> ParserT s st m ()
    failIfInQuoteContext QuoteContext
    InDoubleQuote
      ParserT s st m () -> ParserT s st m ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT s st m () -> ParserT s st m ())
    -> ParserT s st m () -> ParserT s st m ()
    forall a b. (a -> b) -> a -> b
    $ do String -> ParserT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    String -> ParsecT s u m Char
    charOrRef "\"\8220\147"
               ParserT s st m Char -> ParserT s st m ()
    forall s (m :: * -> *) t a u.
    (Stream s m t, Show a) =>
    ParsecT s u m a -> ParsecT s u m ()
    notFollowedBy (String -> ParserT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    String -> ParsecT s u m Char
    oneOf [' ', '\t', '\n'])

    doubleQuoteEnd :: Stream s m Char
                   => ParserT s st m ()
    doubleQuoteEnd :: ParserT s st m ()
    doubleQuoteEnd = ParsecT s st m Char -> ParserT s st m ()
    forall (f :: * -> *) a. Functor f => f a -> f ()
    void (String -> ParsecT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    String -> ParsecT s u m Char
    charOrRef "\"\8221\148")

    ellipses :: Stream s m Char
             => ParserT s st m Inlines
    ellipses :: ParserT s st m Inlines
    ellipses = ParserT s st m Inlines -> ParserT s st m Inlines
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (String -> ParsecT s st m String
    forall s (m :: * -> *) u.
    Stream s m Char =>
    String -> ParsecT s u m String
    string "..." ParsecT s st m String
    -> ParserT s st m Inlines -> ParserT s st m Inlines
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> Inlines -> ParserT s st m Inlines
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Text -> Inlines
    B.str "\8230"))

    dash :: (HasReaderOptions st, Stream s m Char)
         => ParserT s st m Inlines
    dash :: ParserT s st m Inlines
    dash = ParserT s st m Inlines -> ParserT s st m Inlines
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT s st m Inlines -> ParserT s st m Inlines)
    -> ParserT s st m Inlines -> ParserT s st m Inlines
    forall a b. (a -> b) -> a -> b
    $ do
      Bool
    oldDashes <- Extension -> Extensions -> Bool
    extensionEnabled Extension
    Ext_old_dashes (Extensions -> Bool)
    -> ParsecT s st m Extensions -> ParsecT s st m Bool
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (ReaderOptions -> Extensions) -> ParsecT s st m Extensions
    forall st s (m :: * -> *) t b.
    (HasReaderOptions st, Stream s m t) =>
    (ReaderOptions -> b) -> ParserT s st m b
    getOption ReaderOptions -> Extensions
    readerExtensions
      if Bool
    oldDashes
         then do
           Char -> ParsecT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '-'
           (Char -> ParsecT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '-' ParsecT s st m Char
    -> ParserT s st m Inlines -> ParserT s st m Inlines
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> Inlines -> ParserT s st m Inlines
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Text -> Inlines
    B.str "\8212"))
             ParserT s st m Inlines
    -> ParserT s st m Inlines -> ParserT s st m Inlines
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> (ParsecT s st m Char -> ParsecT s st m Char
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m a
    lookAhead ParsecT s st m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    digit ParsecT s st m Char
    -> ParserT s st m Inlines -> ParserT s st m Inlines
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> Inlines -> ParserT s st m Inlines
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Text -> Inlines
    B.str "\8211"))
         else do
           String -> ParsecT s st m String
    forall s (m :: * -> *) u.
    Stream s m Char =>
    String -> ParsecT s u m String
    string "--"
           (Char -> ParsecT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '-' ParsecT s st m Char
    -> ParserT s st m Inlines -> ParserT s st m Inlines
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> Inlines -> ParserT s st m Inlines
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Text -> Inlines
    B.str "\8212"))
             ParserT s st m Inlines
    -> ParserT s st m Inlines -> ParserT s st m Inlines
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> Inlines -> ParserT s st m Inlines
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Text -> Inlines
    B.str "\8211")

    -- This is used to prevent exponential blowups for things like:
    -- a**a*a**a*a**a*a**a*a**a*a**a*a**
    nested :: Stream s m a
           => ParserT s ParserState m a
           -> ParserT s ParserState m a
    nested :: ParserT s ParserState m a -> ParserT s ParserState m a
    nested p :: ParserT s ParserState m a
    p = do
      Int
    nestlevel <- ParserState -> Int
    stateMaxNestingLevel (ParserState -> Int)
    -> ParsecT s ParserState m ParserState
    -> ParsecT s ParserState m Int
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$>  ParsecT s ParserState m ParserState
    forall (m :: * -> *) s u. Monad m => ParsecT s u m u
    getState
      Bool -> ParsecT s ParserState m ()
    forall (f :: * -> *). Alternative f => Bool -> f ()
    guard (Bool -> ParsecT s ParserState m ())
    -> Bool -> ParsecT s ParserState m ()
    forall a b. (a -> b) -> a -> b
    $ Int
    nestlevel Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    > 0
      (ParserState -> ParserState) -> ParsecT s ParserState m ()
    forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
    updateState ((ParserState -> ParserState) -> ParsecT s ParserState m ())
    -> (ParserState -> ParserState) -> ParsecT s ParserState m ()
    forall a b. (a -> b) -> a -> b
    $ \st :: ParserState
    st -> ParserState
    st{ stateMaxNestingLevel :: Int
    stateMaxNestingLevel = ParserState -> Int
    stateMaxNestingLevel ParserState
    st Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - 1 }
      a
    res <- ParserT s ParserState m a
    p
      (ParserState -> ParserState) -> ParsecT s ParserState m ()
    forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
    updateState ((ParserState -> ParserState) -> ParsecT s ParserState m ())
    -> (ParserState -> ParserState) -> ParsecT s ParserState m ()
    forall a b. (a -> b) -> a -> b
    $ \st :: ParserState
    st -> ParserState
    st{ stateMaxNestingLevel :: Int
    stateMaxNestingLevel = Int
    nestlevel }
      a -> ParserT s ParserState m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return a
    res

    citeKey :: (Stream s m Char, HasLastStrPosition st)
            => ParserT s st m (Bool, Text)
    citeKey :: ParserT s st m (Bool, Text)
    citeKey = ParserT s st m (Bool, Text) -> ParserT s st m (Bool, Text)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT s st m (Bool, Text) -> ParserT s st m (Bool, Text))
    -> ParserT s st m (Bool, Text) -> ParserT s st m (Bool, Text)
    forall a b. (a -> b) -> a -> b
    $ do
      Bool -> ParsecT s st m ()
    forall (f :: * -> *). Alternative f => Bool -> f ()
    guard (Bool -> ParsecT s st m ())
    -> ParsecT s st m Bool -> ParsecT s st m ()
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< ParsecT s st m Bool
    forall s (m :: * -> *) a st.
    (Stream s m a, HasLastStrPosition st) =>
    ParserT s st m Bool
    notAfterString
      Bool
    suppress_author <- Bool -> ParsecT s st m Bool -> ParsecT s st 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 s st m Char -> ParsecT s st m Bool
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ Char -> ParsecT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '-')
      Char -> ParsecT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '@'
      Char
    firstChar <- ParsecT s st m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    alphaNum ParsecT s st m Char -> ParsecT s st m Char -> ParsecT s 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 s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '_' ParsecT s st m Char -> ParsecT s st m Char -> ParsecT s 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 s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '*' -- @* for wildcard in nocite
      let regchar :: ParsecT s u m Char
    regchar = (Char -> Bool) -> ParsecT s u m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    (Char -> Bool) -> ParsecT s u m Char
    satisfy (\c :: Char
    c -> Char -> Bool
    isAlphaNum Char
    c Bool -> Bool -> Bool
    || Char
    c Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    == '_')
      let internal :: ParsecT s u m a -> ParsecT s u m a
    internal p :: ParsecT s u m a
    p = ParsecT s u m a -> ParsecT s u m a
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT s u m a -> ParsecT s u m a)
    -> ParsecT s u m a -> ParsecT s u m a
    forall a b. (a -> b) -> a -> b
    $ ParsecT s u m a
    p ParsecT s u m a -> ParsecT s u m Char -> ParsecT s u m a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT s u m Char -> ParsecT s 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 s u m Char
    forall u. ParsecT s u m Char
    regchar
      String
    rest <- ParsecT s st m Char -> ParsecT s st m String
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many (ParsecT s st m Char -> ParsecT s st m String)
    -> ParsecT s st m Char -> ParsecT s st m String
    forall a b. (a -> b) -> a -> b
    $ ParsecT s st m Char
    forall u. ParsecT s u m Char
    regchar ParsecT s st m Char -> ParsecT s st m Char -> ParsecT s st m Char
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT s st m Char -> ParsecT s st m Char
    forall t u a. Stream s m t => ParsecT s u m a -> ParsecT s u m a
    internal (String -> ParsecT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    String -> ParsecT s u m Char
    oneOf ":.#$%&-+?<>~/") ParsecT s st m Char -> ParsecT s st m Char -> ParsecT s st m Char
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|>
                     ParsecT s st m Char -> ParsecT s st m Char
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (String -> ParsecT s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    String -> ParsecT s u m Char
    oneOf ":/" ParsecT s st m Char -> ParsecT s st m Char -> ParsecT s st m Char
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT s st m Char -> ParsecT s st 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 s st m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char '/'))
      let key :: String
    key = Char
    firstCharChar -> String -> String
    forall a. a -> [a] -> [a]
    :String
    rest
      (Bool, Text) -> ParserT s st m (Bool, Text)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Bool
    suppress_author, String -> Text
    T.pack String
    key)

    token :: (Stream s m t)
          => (t -> Text)
          -> (t -> SourcePos)
          -> (t -> Maybe a)
          -> ParsecT s st m a
    token :: (t -> Text)
    -> (t -> SourcePos) -> (t -> Maybe a) -> ParsecT s st m a
    token pp :: t -> Text
    pp pos :: t -> SourcePos
    pos match :: t -> Maybe a
    match = (t -> String)
    -> (SourcePos -> t -> s -> SourcePos)
    -> (t -> Maybe a)
    -> ParsecT s st m a
    forall s (m :: * -> *) t a u.
    Stream s m t =>
    (t -> String)
    -> (SourcePos -> t -> s -> SourcePos)
    -> (t -> Maybe a)
    -> ParsecT s u m a
    tokenPrim (Text -> String
    T.unpack (Text -> String) -> (t -> Text) -> t -> String
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . t -> Text
    pp) (\_ t :: t
    t _ -> t -> SourcePos
    pos t
    t) t -> Maybe a
    match

    infixr 5 <+?>
    (<+?>) :: (Monoid a) => ParserT s st m a -> ParserT s st m a -> ParserT s st m a
    a :: ParserT s st m a
    a <+?> :: ParserT s st m a -> ParserT s st m a -> ParserT s st m a
    <+?> b :: ParserT s st m a
    b = ParserT s st m a
    a ParserT s st m a -> (a -> ParserT s st m a) -> ParserT s st m a
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= ((a -> a) -> ParserT s st m a -> ParserT s st m a)
    -> ParserT s st m a -> (a -> a) -> ParserT s st m a
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip (a -> a) -> ParserT s st m a -> ParserT s st m a
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (ParserT s st m a -> ParserT s st m a
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try ParserT s st m a
    b ParserT s st m a -> ParserT s st m a -> ParserT s st m a
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> a -> ParserT s st m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return a
    forall a. Monoid a => a
    mempty) ((a -> a) -> ParserT s st m a)
    -> (a -> a -> a) -> a -> ParserT s st m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> a -> a
    forall a. Monoid a => a -> a -> a
    mappend

    extractIdClass :: Attr -> Attr
    extractIdClass :: Attr -> Attr
    extractIdClass (ident :: Text
    ident, cls :: [Text]
    cls, kvs :: NoteTable
    kvs) = (Text
    ident', [Text]
    cls', NoteTable
    kvs')
      where
        ident' :: Text
    ident' = Text -> Maybe Text -> Text
    forall a. a -> Maybe a -> a
    fromMaybe Text
    ident (Text -> NoteTable -> Maybe Text
    forall a b. Eq a => a -> [(a, b)] -> Maybe b
    lookup "id" NoteTable
    kvs)
        cls' :: [Text]
    cls'   = case Text -> NoteTable -> Maybe Text
    forall a b. Eq a => a -> [(a, b)] -> Maybe b
    lookup "class" NoteTable
    kvs of
                   Just cl :: Text
    cl -> Text -> [Text]
    T.words Text
    cl
                   Nothing -> [Text]
    cls
        kvs' :: NoteTable
    kvs'  = ((Text, Text) -> Bool) -> NoteTable -> NoteTable
    forall a. (a -> Bool) -> [a] -> [a]
    filter (\(k :: Text
    k,_) -> 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") NoteTable
    kvs

    insertIncludedFile' :: (PandocMonad m, HasIncludeFiles st)
                        => ParserT a st m (mf Blocks)
                        -> (Text -> a)
                        -> [FilePath] -> FilePath
                        -> ParserT a st m (mf Blocks)
    insertIncludedFile' :: ParserT a st m (mf Blocks)
    -> (Text -> a) -> [String] -> String -> ParserT a st m (mf Blocks)
    insertIncludedFile' blocks :: ParserT a st m (mf Blocks)
    blocks totoks :: Text -> a
    totoks dirs :: [String]
    dirs f :: String
    f = do
      SourcePos
    oldPos <- ParsecT a st m SourcePos
    forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
    getPosition
      a
    oldInput <- ParsecT a st m a
    forall (m :: * -> *) s u. Monad m => ParsecT s u m s
    getInput
      [Text]
    containers <- st -> [Text]
    forall st. HasIncludeFiles st => st -> [Text]
    getIncludeFiles (st -> [Text]) -> ParsecT a st m st -> ParsecT a st m [Text]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT a st m st
    forall (m :: * -> *) s u. Monad m => ParsecT s u m u
    getState
      Bool -> ParsecT a st m () -> ParsecT a st m ()
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    when (String -> Text
    T.pack String
    f Text -> [Text] -> Bool
    forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
    `elem` [Text]
    containers) (ParsecT a st m () -> ParsecT a st m ())
    -> ParsecT a st m () -> ParsecT a st m ()
    forall a b. (a -> b) -> a -> b
    $
        PandocError -> ParsecT a st m ()
    forall e (m :: * -> *) a. MonadError e m => e -> m a
    throwError (PandocError -> ParsecT a st m ())
    -> PandocError -> ParsecT a st m ()
    forall a b. (a -> b) -> a -> b
    $ Text -> PandocError
    PandocParseError (Text -> PandocError) -> Text -> PandocError
    forall a b. (a -> b) -> a -> b
    $ String -> Text
    T.pack (String -> Text) -> String -> Text
    forall a b. (a -> b) -> a -> b
    $ "Include file loop at " String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ SourcePos -> String
    forall a. Show a => a -> String
    show SourcePos
    oldPos
      (st -> st) -> ParsecT a st m ()
    forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
    updateState ((st -> st) -> ParsecT a st m ())
    -> (st -> st) -> ParsecT a st m ()
    forall a b. (a -> b) -> a -> b
    $ Text -> st -> st
    forall st. HasIncludeFiles st => Text -> st -> st
    addIncludeFile (Text -> st -> st) -> Text -> st -> st
    forall a b. (a -> b) -> a -> b
    $ String -> Text
    T.pack String
    f
      Maybe Text
    mbcontents <- [String] -> String -> ParsecT a st m (Maybe Text)
    forall (m :: * -> *).
    PandocMonad m =>
    [String] -> String -> m (Maybe Text)
    readFileFromDirs [String]
    dirs String
    f
      Text
    contents <- case Maybe Text
    mbcontents of
                       Just s :: Text
    s -> Text -> ParsecT a st m Text
    forall (m :: * -> *) a. Monad m => a -> m a
    return Text
    s
                       Nothing -> do
                         LogMessage -> ParsecT a st m ()
    forall (m :: * -> *). PandocMonad m => LogMessage -> m ()
    report (LogMessage -> ParsecT a st m ())
    -> LogMessage -> ParsecT a st m ()
    forall a b. (a -> b) -> a -> b
    $ Text -> SourcePos -> LogMessage
    CouldNotLoadIncludeFile (String -> Text
    T.pack String
    f) SourcePos
    oldPos
                         Text -> ParsecT a st m Text
    forall (m :: * -> *) a. Monad m => a -> m a
    return ""
      SourcePos -> ParsecT a st m ()
    forall (m :: * -> *) s u. Monad m => SourcePos -> ParsecT s u m ()
    setPosition (SourcePos -> ParsecT a st m ()) -> SourcePos -> ParsecT a st m ()
    forall a b. (a -> b) -> a -> b
    $ String -> Int -> Int -> SourcePos
    newPos String
    f 1 1
      a -> ParsecT a st m ()
    forall (m :: * -> *) s u. Monad m => s -> ParsecT s u m ()
    setInput (a -> ParsecT a st m ()) -> a -> ParsecT a st m ()
    forall a b. (a -> b) -> a -> b
    $ Text -> a
    totoks Text
    contents
      mf Blocks
    bs <- ParserT a st m (mf Blocks)
    blocks
      a -> ParsecT a st m ()
    forall (m :: * -> *) s u. Monad m => s -> ParsecT s u m ()
    setInput a
    oldInput
      SourcePos -> ParsecT a st m ()
    forall (m :: * -> *) s u. Monad m => SourcePos -> ParsecT s u m ()
    setPosition SourcePos
    oldPos
      (st -> st) -> ParsecT a st m ()
    forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
    updateState st -> st
    forall st. HasIncludeFiles st => st -> st
    dropLatestIncludeFile
      mf Blocks -> ParserT a st m (mf Blocks)
    forall (m :: * -> *) a. Monad m => a -> m a
    return mf Blocks
    bs

    -- | Parse content of include file as blocks. Circular includes result in an
    -- @PandocParseError@.
    insertIncludedFile :: (PandocMonad m, HasIncludeFiles st)
                       => ParserT [a] st m Blocks
                       -> (Text -> [a])
                       -> [FilePath] -> FilePath
                       -> ParserT [a] st m Blocks
    insertIncludedFile :: ParserT [a] st m Blocks
    -> (Text -> [a]) -> [String] -> String -> ParserT [a] st m Blocks
    insertIncludedFile blocks :: ParserT [a] st m Blocks
    blocks totoks :: Text -> [a]
    totoks dirs :: [String]
    dirs f :: String
    f =
      Identity Blocks -> Blocks
    forall a. Identity a -> a
    runIdentity (Identity Blocks -> Blocks)
    -> ParsecT [a] st m (Identity Blocks) -> ParserT [a] st m Blocks
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT [a] st m (Identity Blocks)
    -> (Text -> [a])
    -> [String]
    -> String
    -> ParsecT [a] st m (Identity Blocks)
    forall (m :: * -> *) st a (mf :: * -> *).
    (PandocMonad m, HasIncludeFiles st) =>
    ParserT a st m (mf Blocks)
    -> (Text -> a) -> [String] -> String -> ParserT a st m (mf Blocks)
    insertIncludedFile' (Blocks -> Identity Blocks
    forall a. a -> Identity a
    Identity (Blocks -> Identity Blocks)
    -> ParserT [a] st m Blocks -> ParsecT [a] st m (Identity Blocks)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParserT [a] st m Blocks
    blocks) Text -> [a]
    totoks [String]
    dirs String
    f

    -- | Parse content of include file as future blocks. Circular includes result in
    -- an @PandocParseError@.
    insertIncludedFileF :: (PandocMonad m, HasIncludeFiles st)
                        => ParserT Text st m (Future st Blocks)
                        -> [FilePath] -> FilePath
                        -> ParserT Text st m (Future st Blocks)
    insertIncludedFileF :: ParserT Text st m (Future st Blocks)
    -> [String] -> String -> ParserT Text st m (Future st Blocks)
    insertIncludedFileF p :: ParserT Text st m (Future st Blocks)
    p = ParserT Text st m (Future st Blocks)
    -> (Text -> Text)
    -> [String]
    -> String
    -> ParserT Text st m (Future st Blocks)
    forall (m :: * -> *) st a (mf :: * -> *).
    (PandocMonad m, HasIncludeFiles st) =>
    ParserT a st m (mf Blocks)
    -> (Text -> a) -> [String] -> String -> ParserT a st m (mf Blocks)
    insertIncludedFile' ParserT Text st m (Future st Blocks)
    p Text -> Text
    forall a. a -> a
    id