    {-# LANGUAGE FlexibleContexts  #-}
    {-# LANGUAGE TupleSections     #-}
    {-# LANGUAGE OverloadedStrings #-}
    {- |
       Module      : Text.Pandoc.Readers.Muse
       Copyright   : Copyright (C) 2017-2020 Alexander Krotov
       License     : GNU GPL, version 2 or above

       Maintainer  : Alexander Krotov <ilabdsf@gmail.com>
       Stability   : alpha
       Portability : portable

    Conversion of Muse text to 'Pandoc' document.
    -}
    {-
    TODO:
    - <cite> tag
    -}
    module Text.Pandoc.Readers.Muse (readMuse) where

    import Control.Monad
    import Control.Monad.Reader
    import Control.Monad.Except (throwError)
    import Data.Bifunctor
    import Data.Default
    import Data.List (transpose)
    import qualified Data.Map as M
    import qualified Data.Set as Set
    import Data.Maybe (fromMaybe, isNothing, maybeToList)
    import Data.Text (Text)
    import qualified Data.Text as T
    import Text.Pandoc.Builder (Blocks, Inlines, underline)
    import qualified Text.Pandoc.Builder as B
    import Text.Pandoc.Class.PandocMonad (PandocMonad (..))
    import Text.Pandoc.Definition
    import Text.Pandoc.Logging
    import Text.Pandoc.Options
    import Text.Pandoc.Parsing
    import Text.Pandoc.Shared (trimr, tshow)

    -- | Read Muse from an input string and return a Pandoc document.
    readMuse :: (PandocMonad m, ToSources a)
             => ReaderOptions
             -> a
             -> m Pandoc
    readMuse :: forall (m :: * -> *) a.
    (PandocMonad m, ToSources a) =>
    ReaderOptions -> a -> m Pandoc
    readMuse ReaderOptions
    opts a
    s = do
      let sources :: Sources
    sources = a -> Sources
    forall a. ToSources a => a -> Sources
    toSources a
    s
      res <- (ReaderT MuseEnv m (Either ParseError Pandoc)
     -> MuseEnv -> m (Either ParseError Pandoc))
    -> MuseEnv
    -> ReaderT MuseEnv m (Either ParseError Pandoc)
    -> m (Either ParseError Pandoc)
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip ReaderT MuseEnv m (Either ParseError Pandoc)
    -> MuseEnv -> m (Either ParseError Pandoc)
    forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
    runReaderT MuseEnv
    forall a. Default a => a
    def (ReaderT MuseEnv m (Either ParseError Pandoc)
     -> m (Either ParseError Pandoc))
    -> ReaderT MuseEnv m (Either ParseError Pandoc)
    -> m (Either ParseError Pandoc)
    forall a b. (a -> b) -> a -> b
    $ ParsecT Sources MuseState (ReaderT MuseEnv m) Pandoc
    -> MuseState
    -> SourceName
    -> Sources
    -> ReaderT MuseEnv m (Either ParseError Pandoc)
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> u -> SourceName -> s -> m (Either ParseError a)
    runParserT ParsecT Sources MuseState (ReaderT MuseEnv m) Pandoc
    forall (m :: * -> *). PandocMonad m => MuseParser m Pandoc
    parseMuse MuseState
    forall a. Default a => a
    def{ museOptions = opts }
                  (Sources -> SourceName
    initialSourceName Sources
    sources) Sources
    sources
      case res of
           Left ParseError
    e  -> PandocError -> m Pandoc
    forall a. PandocError -> m a
    forall e (m :: * -> *) a. MonadError e m => e -> m a
    throwError (PandocError -> m Pandoc) -> PandocError -> m Pandoc
    forall a b. (a -> b) -> a -> b
    $ Sources -> ParseError -> PandocError
    fromParsecError Sources
    sources ParseError
    e
           Right Pandoc
    d -> Pandoc -> m Pandoc
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Pandoc
    d

    type F = Future MuseState

    data MuseState = MuseState { MuseState -> F Meta
    museMeta :: F Meta -- ^ Document metadata
                               , MuseState -> ReaderOptions
    museOptions :: ReaderOptions
                               , MuseState -> Set Text
    museIdentifierList :: Set.Set Text
                               , MuseState -> Maybe SourcePos
    museLastSpacePos :: Maybe SourcePos -- ^ Position after last space or newline parsed
                               , MuseState -> Maybe SourcePos
    museLastStrPos :: Maybe SourcePos -- ^ Position after last str parsed
                               , MuseState -> [LogMessage]
    museLogMessages :: [LogMessage]
                               , MuseState -> Map Text (SourcePos, F Blocks)
    museNotes :: M.Map Text (SourcePos, F Blocks)
                               }

    instance Default MuseState where
      def :: MuseState
    def = MuseState { museMeta :: F Meta
    museMeta = Meta -> F Meta
    forall a. a -> Future MuseState a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Meta
    nullMeta
                      , museOptions :: ReaderOptions
    museOptions = ReaderOptions
    forall a. Default a => a
    def
                      , museIdentifierList :: Set Text
    museIdentifierList = Set Text
    forall a. Set a
    Set.empty
                      , museLastStrPos :: Maybe SourcePos
    museLastStrPos = Maybe SourcePos
    forall a. Maybe a
    Nothing
                      , museLastSpacePos :: Maybe SourcePos
    museLastSpacePos = Maybe SourcePos
    forall a. Maybe a
    Nothing
                      , museLogMessages :: [LogMessage]
    museLogMessages = []
                      , museNotes :: Map Text (SourcePos, F Blocks)
    museNotes = Map Text (SourcePos, F Blocks)
    forall k a. Map k a
    M.empty
                      }

    data MuseEnv =
      MuseEnv { MuseEnv -> Bool
    museInLink :: Bool -- ^ True when parsing a link description to avoid nested links
              , MuseEnv -> Bool
    museInPara :: Bool -- ^ True when parsing paragraph is not allowed
              }

    instance Default MuseEnv where
      def :: MuseEnv
    def = MuseEnv { museInLink :: Bool
    museInLink = Bool
    False
                    , museInPara :: Bool
    museInPara = Bool
    False
                    }

    type MuseParser m = ParsecT Sources MuseState (ReaderT MuseEnv m)

    instance HasReaderOptions MuseState where
      extractReaderOptions :: MuseState -> ReaderOptions
    extractReaderOptions = MuseState -> ReaderOptions
    museOptions

    instance HasIdentifierList MuseState where
      extractIdentifierList :: MuseState -> Set Text
    extractIdentifierList     = MuseState -> Set Text
    museIdentifierList
      updateIdentifierList :: (Set Text -> Set Text) -> MuseState -> MuseState
    updateIdentifierList Set Text -> Set Text
    f MuseState
    st = MuseState
    st{ museIdentifierList = f $ museIdentifierList st }

    instance HasLastStrPosition MuseState where
      setLastStrPos :: Maybe SourcePos -> MuseState -> MuseState
    setLastStrPos Maybe SourcePos
    pos MuseState
    st = MuseState
    st{ museLastStrPos = pos }
      getLastStrPos :: MuseState -> Maybe SourcePos
    getLastStrPos MuseState
    st     = MuseState -> Maybe SourcePos
    museLastStrPos MuseState
    st

    instance HasLogMessages MuseState where
      addLogMessage :: LogMessage -> MuseState -> MuseState
    addLogMessage LogMessage
    m MuseState
    s = MuseState
    s{ museLogMessages = m : museLogMessages s }
      getLogMessages :: MuseState -> [LogMessage]
    getLogMessages = [LogMessage] -> [LogMessage]
    forall a. [a] -> [a]
    reverse ([LogMessage] -> [LogMessage])
    -> (MuseState -> [LogMessage]) -> MuseState -> [LogMessage]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . MuseState -> [LogMessage]
    museLogMessages

    updateLastSpacePos :: Monad m => MuseParser m ()
    updateLastSpacePos :: forall (m :: * -> *). Monad m => MuseParser m ()
    updateLastSpacePos = ParsecT Sources MuseState (ReaderT MuseEnv m) SourcePos
    forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
    getPosition ParsecT Sources MuseState (ReaderT MuseEnv m) SourcePos
    -> (SourcePos -> ParsecT Sources MuseState (ReaderT MuseEnv m) ())
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> (a -> ParsecT Sources MuseState (ReaderT MuseEnv m) b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \SourcePos
    pos ->
      (MuseState -> MuseState)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
    updateState ((MuseState -> MuseState)
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) ())
    -> (MuseState -> MuseState)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall a b. (a -> b) -> a -> b
    $ \MuseState
    s -> MuseState
    s { museLastSpacePos = Just pos }

    -- | Parse Muse document
    parseMuse :: PandocMonad m => MuseParser m Pandoc
    parseMuse :: forall (m :: * -> *). PandocMonad m => MuseParser m Pandoc
    parseMuse = do
      ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [()]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall (m :: * -> *). PandocMonad m => MuseParser m ()
    directive
      blocks <- (:) (F Blocks -> [F Blocks] -> [F Blocks])
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) ([F Blocks] -> [F Blocks])
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    parseBlocks ParsecT
      Sources MuseState (ReaderT MuseEnv m) ([F Blocks] -> [F Blocks])
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [F Blocks]
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [F Blocks]
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [F Blocks]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    parseSection
      eof
      st <- getState
      runF (Pandoc <$> museMeta st <*> fmap B.toList (mconcat blocks)) st <$ reportLogMessages

    -- * Utility functions

    -- | Trim up to one newline from the beginning of the string.
    lchop :: Text -> Text
    lchop :: Text -> Text
    lchop Text
    s = case Text -> Maybe (Char, Text)
    T.uncons Text
    s of
      Just (Char
    '\n', Text
    xs) -> Text
    xs
      Maybe (Char, Text)
    _               -> Text
    s

    -- | Trim up to one newline from the end of the string.
    rchop :: Text -> Text
    rchop :: Text -> Text
    rchop Text
    s = case Text -> Maybe (Text, Char)
    T.unsnoc Text
    s of
      Just (Text
    xs, Char
    '\n') -> Text
    xs
      Maybe (Text, Char)
    _               -> Text
    s

    unindent :: Text -> Text
    unindent :: Text -> Text
    unindent = Text -> Text
    rchop (Text -> Text) -> (Text -> Text) -> Text -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> [Text] -> Text
    T.intercalate Text
    "\n" ([Text] -> Text) -> (Text -> [Text]) -> Text -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [Text] -> [Text]
    dropSpacePrefix ([Text] -> [Text]) -> (Text -> [Text]) -> Text -> [Text]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . HasCallStack => Text -> Text -> [Text]
    Text -> Text -> [Text]
    T.splitOn Text
    "\n" (Text -> [Text]) -> (Text -> Text) -> Text -> [Text]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Text
    lchop

    dropSpacePrefix :: [Text] -> [Text]
    dropSpacePrefix :: [Text] -> [Text]
    dropSpacePrefix [Text]
    lns = Int -> Text -> Text
    T.drop Int
    maxIndent (Text -> Text) -> [Text] -> [Text]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> [Text]
    lns
      where isSpaceChar :: Char -> Bool
    isSpaceChar Char
    c = Char
    c Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    == Char
    ' ' Bool -> Bool -> Bool
    || Char
    c Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    == Char
    '\t'
            maxIndent :: Int
    maxIndent = [Text] -> Int
    forall a. [a] -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    length ([Text] -> Int) -> [Text] -> Int
    forall a b. (a -> b) -> a -> b
    $ (Text -> Bool) -> [Text] -> [Text]
    forall a. (a -> Bool) -> [a] -> [a]
    takeWhile (Char -> Bool
    isSpaceChar (Char -> Bool) -> (Text -> Char) -> Text -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . HasCallStack => Text -> Char
    Text -> Char
    T.head) ([Text] -> [Text]) -> [Text] -> [Text]
    forall a b. (a -> b) -> a -> b
    $ (Text -> Bool) -> [Text] -> [Text]
    forall a. (a -> Bool) -> [a] -> [a]
    takeWhile Text -> Bool
    same ([Text] -> [Text]) -> [Text] -> [Text]
    forall a b. (a -> b) -> a -> b
    $ [Text] -> [Text]
    T.transpose [Text]
    lns
            same :: Text -> Bool
    same Text
    t = case Text -> Maybe (Char, Text)
    T.uncons Text
    t of
              Just (Char
    c, Text
    cs) -> (Char -> Bool) -> Text -> Bool
    T.all (Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    == Char
    c) Text
    cs
              Maybe (Char, Text)
    Nothing      -> Bool
    True

    atStart :: PandocMonad m => MuseParser m ()
    atStart :: forall (m :: * -> *). PandocMonad m => MuseParser m ()
    atStart = do
      pos <- ParsecT Sources MuseState (ReaderT MuseEnv m) SourcePos
    forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
    getPosition
      st <- getState
      guard $ museLastStrPos st /= Just pos

    noSpaceBefore :: PandocMonad m => MuseParser m ()
    noSpaceBefore :: forall (m :: * -> *). PandocMonad m => MuseParser m ()
    noSpaceBefore = do
      pos <- ParsecT Sources MuseState (ReaderT MuseEnv m) SourcePos
    forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
    getPosition
      st <- getState
      guard $ museLastSpacePos st /= Just pos

    firstColumn :: PandocMonad m => MuseParser m ()
    firstColumn :: forall (m :: * -> *). PandocMonad m => MuseParser m ()
    firstColumn = ParsecT Sources MuseState (ReaderT MuseEnv m) SourcePos
    forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
    getPosition ParsecT Sources MuseState (ReaderT MuseEnv m) SourcePos
    -> (SourcePos -> ParsecT Sources MuseState (ReaderT MuseEnv m) ())
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> (a -> ParsecT Sources MuseState (ReaderT MuseEnv m) b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \SourcePos
    pos -> Bool -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall (f :: * -> *). Alternative f => Bool -> f ()
    guard (SourcePos -> Int
    sourceColumn SourcePos
    pos Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    1)

    -- * Parsers

    -- | Parse end-of-line, which can be either a newline or end-of-file.
    eol :: (Stream s m Char, UpdateSourcePos s Char) => ParsecT s st m ()
    eol :: forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m ()
    eol = ParsecT s st m Char -> ParsecT s st m ()
    forall (f :: * -> *) a. Functor f => f a -> f ()
    void ParsecT s st m Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s u m Char
    newline ParsecT s st m () -> ParsecT s st m () -> ParsecT s st m ()
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT s st m ()
    forall s (m :: * -> *) t u.
    (Stream s m t, Show t) =>
    ParsecT s u m ()
    eof

    getIndent :: PandocMonad m
              => MuseParser m Int
    getIndent :: forall (m :: * -> *). PandocMonad m => MuseParser m Int
    getIndent = Int -> Int -> Int
    forall a. Num a => a -> a -> a
    subtract Int
    1 (Int -> Int) -> (SourcePos -> Int) -> SourcePos -> Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . SourcePos -> Int
    sourceColumn (SourcePos -> Int)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (SourcePos -> Int)
    forall a b.
    a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    spaceChar ParsecT Sources MuseState (ReaderT MuseEnv m) (SourcePos -> Int)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourcePos
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Int
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ParsecT Sources MuseState (ReaderT MuseEnv m) SourcePos
    forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
    getPosition

    -- ** HTML parsers

    openTag :: PandocMonad m => Text -> MuseParser m [(Text, Text)]
    openTag :: forall (m :: * -> *).
    PandocMonad m =>
    Text -> MuseParser m [(Text, Text)]
    openTag Text
    tag = ParsecT Sources MuseState (ReaderT MuseEnv m) [(Text, Text)]
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [(Text, Text)]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) [(Text, Text)]
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) [(Text, Text)])
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [(Text, Text)]
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [(Text, Text)]
    forall a b. (a -> b) -> a -> b
    $
      Char -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    Char -> ParsecT s u m Char
    char Char
    '<' ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> Text -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall s (m :: * -> *) u.
    (Stream s m Char, UpdateSourcePos s Char) =>
    Text -> ParsecT s u m Text
    textStr Text
    tag ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [(Text, Text)]
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [(Text, Text)]
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> ParsecT Sources MuseState (ReaderT MuseEnv m) (Text, Text)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [(Text, Text)]
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    manyTill ParsecT Sources MuseState (ReaderT MuseEnv m) (Text, Text)
    forall {u}. ParsecT Sources u (ReaderT MuseEnv m) (Text, Text)
    attr (Char -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    Char -> ParsecT s u m Char
    char Char
    '>')
      where
        attr :: ParsecT Sources u (ReaderT MuseEnv m) (Text, Text)
    attr = ParsecT Sources u (ReaderT MuseEnv m) (Text, Text)
    -> ParsecT Sources u (ReaderT MuseEnv m) (Text, Text)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources u (ReaderT MuseEnv m) (Text, Text)
     -> ParsecT Sources u (ReaderT MuseEnv m) (Text, Text))
    -> ParsecT Sources u (ReaderT MuseEnv m) (Text, Text)
    -> ParsecT Sources u (ReaderT MuseEnv m) (Text, Text)
    forall a b. (a -> b) -> a -> b
    $ (,)
          (Text -> Text -> (Text, Text))
    -> ParsecT Sources u (ReaderT MuseEnv m) SourceName
    -> ParsecT
         Sources u (ReaderT MuseEnv m) (Text -> Text -> (Text, Text))
    forall a b.
    a
    -> ParsecT Sources u (ReaderT MuseEnv m) b
    -> ParsecT Sources u (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$  ParsecT Sources u (ReaderT MuseEnv m) Char
    -> ParsecT Sources u (ReaderT MuseEnv m) SourceName
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many1 ParsecT Sources u (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    spaceChar
          ParsecT
      Sources u (ReaderT MuseEnv m) (Text -> Text -> (Text, Text))
    -> ParsecT Sources u (ReaderT MuseEnv m) Text
    -> ParsecT Sources u (ReaderT MuseEnv m) (Text -> (Text, Text))
    forall a b.
    ParsecT Sources u (ReaderT MuseEnv m) (a -> b)
    -> ParsecT Sources u (ReaderT MuseEnv m) a
    -> ParsecT Sources u (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ParsecT Sources u (ReaderT MuseEnv m) Char
    -> ParsecT Sources u (ReaderT MuseEnv m) Text
    forall s (m :: * -> *) t st.
    Stream s m t =>
    ParsecT s st m Char -> ParsecT s st m Text
    many1Char (SourceName -> ParsecT Sources u (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    SourceName -> ParsecT s u m Char
    noneOf SourceName
    "=\n")
          ParsecT Sources u (ReaderT MuseEnv m) (Text -> (Text, Text))
    -> ParsecT Sources u (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources u (ReaderT MuseEnv m) (Text -> (Text, Text))
    forall a b.
    ParsecT Sources u (ReaderT MuseEnv m) a
    -> ParsecT Sources u (ReaderT MuseEnv m) b
    -> ParsecT Sources u (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <*  SourceName -> ParsecT Sources u (ReaderT MuseEnv m) SourceName
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    SourceName -> ParsecT s u m SourceName
    string SourceName
    "=\""
          ParsecT Sources u (ReaderT MuseEnv m) (Text -> (Text, Text))
    -> ParsecT Sources u (ReaderT MuseEnv m) Text
    -> ParsecT Sources u (ReaderT MuseEnv m) (Text, Text)
    forall a b.
    ParsecT Sources u (ReaderT MuseEnv m) (a -> b)
    -> ParsecT Sources u (ReaderT MuseEnv m) a
    -> ParsecT Sources u (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ParsecT Sources u (ReaderT MuseEnv m) Char
    -> ParsecT Sources u (ReaderT MuseEnv m) Char
    -> ParsecT Sources u (ReaderT MuseEnv m) Text
    forall s (m :: * -> *) t st a.
    Stream s m t =>
    ParsecT s st m Char -> ParsecT s st m a -> ParsecT s st m Text
    manyTillChar (SourceName -> ParsecT Sources u (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    SourceName -> ParsecT s u m Char
    noneOf SourceName
    "\"") (Char -> ParsecT Sources u (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    Char -> ParsecT s u m Char
    char Char
    '"')

    closeTag :: PandocMonad m => Text -> MuseParser m ()
    closeTag :: forall (m :: * -> *). PandocMonad m => Text -> MuseParser m ()
    closeTag Text
    tag = ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) ()
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) ())
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall a b. (a -> b) -> a -> b
    $ SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    SourceName -> ParsecT s u m SourceName
    string SourceName
    "</" ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> Text -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall s (m :: * -> *) u.
    (Stream s m Char, UpdateSourcePos s Char) =>
    Text -> ParsecT s u m Text
    textStr Text
    tag ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall (f :: * -> *) a. Functor f => f a -> f ()
    void (Char -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    Char -> ParsecT s u m Char
    char Char
    '>')

    -- | Convert HTML attributes to Pandoc 'Attr'
    htmlAttrToPandoc :: [(Text, Text)] -> Attr
    htmlAttrToPandoc :: [(Text, Text)] -> Attr
    htmlAttrToPandoc [(Text, Text)]
    attrs = (Text
    ident, [Text]
    classes, [(Text, Text)]
    keyvals)
      where
        ident :: Text
    ident   = Text -> Maybe Text -> Text
    forall a. a -> Maybe a -> a
    fromMaybe Text
    "" (Maybe Text -> Text) -> Maybe Text -> Text
    forall a b. (a -> b) -> a -> b
    $ Text -> [(Text, Text)] -> Maybe Text
    forall a b. Eq a => a -> [(a, b)] -> Maybe b
    lookup Text
    "id" [(Text, Text)]
    attrs
        classes :: [Text]
    classes = [Text] -> (Text -> [Text]) -> Maybe Text -> [Text]
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe [] Text -> [Text]
    T.words (Maybe Text -> [Text]) -> Maybe Text -> [Text]
    forall a b. (a -> b) -> a -> b
    $ Text -> [(Text, Text)] -> Maybe Text
    forall a b. Eq a => a -> [(a, b)] -> Maybe b
    lookup Text
    "class" [(Text, Text)]
    attrs
        keyvals :: [(Text, Text)]
    keyvals = [(Text
    k,Text
    v) | (Text
    k,Text
    v) <- [(Text, Text)]
    attrs, Text
    k Text -> Text -> Bool
    forall a. Eq a => a -> a -> Bool
    /= Text
    "id", Text
    k Text -> Text -> Bool
    forall a. Eq a => a -> a -> Bool
    /= Text
    "class"]

    parseHtmlContent :: PandocMonad m
                     => Text -- ^ Tag name
                     -> MuseParser m (Attr, F Blocks)
    parseHtmlContent :: forall (m :: * -> *).
    PandocMonad m =>
    Text -> MuseParser m (Attr, F Blocks)
    parseHtmlContent Text
    tag = ParsecT Sources MuseState (ReaderT MuseEnv m) (Attr, F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (Attr, F Blocks)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) (Attr, F Blocks)
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (Attr, F Blocks))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (Attr, F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (Attr, F Blocks)
    forall a b. (a -> b) -> a -> b
    $ MuseParser m Int
    forall (m :: * -> *). PandocMonad m => MuseParser m Int
    getIndent MuseParser m Int
    -> (Int
        -> ParsecT Sources MuseState (ReaderT MuseEnv m) (Attr, F Blocks))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (Attr, F Blocks)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> (a -> ParsecT Sources MuseState (ReaderT MuseEnv m) b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \Int
    indent -> (,)
      (Attr -> F Blocks -> (Attr, F Blocks))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Attr
    -> ParsecT
         Sources
         MuseState
         (ReaderT MuseEnv m)
         (F Blocks -> (Attr, F Blocks))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ([(Text, Text)] -> Attr)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [(Text, Text)]
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Attr
    forall a b.
    (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap [(Text, Text)] -> Attr
    htmlAttrToPandoc (Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [(Text, Text)]
    forall (m :: * -> *).
    PandocMonad m =>
    Text -> MuseParser m [(Text, Text)]
    openTag Text
    tag)
      ParsecT
      Sources
      MuseState
      (ReaderT MuseEnv m)
      (F Blocks -> (Attr, F Blocks))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT
         Sources
         MuseState
         (ReaderT MuseEnv m)
         (F Blocks -> (Attr, F Blocks))
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <*  ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    manyTill ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    spaceChar ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m ()
    eol
      ParsecT
      Sources
      MuseState
      (ReaderT MuseEnv m)
      (F Blocks -> (Attr, F Blocks))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (Attr, F Blocks)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (m :: * -> *) a. MonadReader MuseEnv m => m a -> m a
    allowPara (ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (m :: * -> *) a.
    PandocMonad m =>
    MuseParser m a -> MuseParser m (F Blocks)
    parseBlocksTill (ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) ()
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) ())
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall a b. (a -> b) -> a -> b
    $ Int -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char, HasReaderOptions st) =>
    Int -> ParsecT s st m Text
    indentWith Int
    indent ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> Text -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall (m :: * -> *). PandocMonad m => Text -> MuseParser m ()
    closeTag Text
    tag))
      ParsecT Sources MuseState (ReaderT MuseEnv m) (Attr, F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (Attr, F Blocks)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <*  ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    manyTill ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    spaceChar ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m ()
    eol -- closing tag must be followed by optional whitespace and newline

    -- ** Directive parsers

    -- While not documented, Emacs Muse allows "-" in directive name
    parseDirectiveKey :: PandocMonad m => MuseParser m Text
    parseDirectiveKey :: forall (m :: * -> *). PandocMonad m => MuseParser m Text
    parseDirectiveKey = Char -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    Char -> ParsecT s u m Char
    char Char
    '#' ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall s (m :: * -> *) t st.
    Stream s m t =>
    ParsecT s st m Char -> ParsecT s st m Text
    manyChar (ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s u m Char
    letter ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> Char -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    Char -> ParsecT s u m Char
    char Char
    '-')

    parseEmacsDirective :: PandocMonad m => MuseParser m (Text, F Inlines)
    parseEmacsDirective :: forall (m :: * -> *).
    PandocMonad m =>
    MuseParser m (Text, F Inlines)
    parseEmacsDirective = (,)
      (Text -> F Inlines -> (Text, F Inlines))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT
         Sources
         MuseState
         (ReaderT MuseEnv m)
         (F Inlines -> (Text, F Inlines))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall (m :: * -> *). PandocMonad m => MuseParser m Text
    parseDirectiveKey
      ParsecT
      Sources
      MuseState
      (ReaderT MuseEnv m)
      (F Inlines -> (Text, F Inlines))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT
         Sources
         MuseState
         (ReaderT MuseEnv m)
         (F Inlines -> (Text, F Inlines))
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <*  ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    spaceChar
      ParsecT
      Sources
      MuseState
      (ReaderT MuseEnv m)
      (F Inlines -> (Text, F Inlines))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (Text, F Inlines)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (F Inlines -> F Inlines
    forall s. Future s Inlines -> Future s Inlines
    trimInlinesF (F Inlines -> F Inlines)
    -> ([F Inlines] -> F Inlines) -> [F Inlines] -> F Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [F Inlines] -> F Inlines
    forall a. Monoid a => [a] -> a
    mconcat ([F Inlines] -> F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [F Inlines]
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [F Inlines]
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    manyTill ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    inline' ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m ()
    eol)

    parseAmuseDirective :: PandocMonad m => MuseParser m (Text, F Inlines)
    parseAmuseDirective :: forall (m :: * -> *).
    PandocMonad m =>
    MuseParser m (Text, F Inlines)
    parseAmuseDirective = (,)
      (Text -> F Inlines -> (Text, F Inlines))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT
         Sources
         MuseState
         (ReaderT MuseEnv m)
         (F Inlines -> (Text, F Inlines))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall (m :: * -> *). PandocMonad m => MuseParser m Text
    parseDirectiveKey
      ParsecT
      Sources
      MuseState
      (ReaderT MuseEnv m)
      (F Inlines -> (Text, F Inlines))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT
         Sources
         MuseState
         (ReaderT MuseEnv m)
         (F Inlines -> (Text, F Inlines))
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <*  ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many1 ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    spaceChar
      ParsecT
      Sources
      MuseState
      (ReaderT MuseEnv m)
      (F Inlines -> (Text, F Inlines))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (Text, F Inlines)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (F Inlines -> F Inlines
    forall s. Future s Inlines -> Future s Inlines
    trimInlinesF (F Inlines -> F Inlines)
    -> ([F Inlines] -> F Inlines) -> [F Inlines] -> F Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [F Inlines] -> F Inlines
    forall a. Monoid a => [a] -> a
    mconcat ([F Inlines] -> F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [F Inlines]
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [F Inlines]
    forall end s (m :: * -> *) t st a.
    (Show end, Stream s m t) =>
    ParsecT s st m a -> ParsecT s st m end -> ParsecT s st m [a]
    many1Till ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    inline ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    endOfDirective)
      ParsecT Sources MuseState (ReaderT MuseEnv m) (Text, F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (Text, F Inlines)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <*  ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    blankline
      where
        endOfDirective :: ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    endOfDirective = ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m a
    lookAhead (ParsecT Sources MuseState (ReaderT MuseEnv m) ()
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) ())
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall a b. (a -> b) -> a -> b
    $ ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) t u.
    (Stream s m t, Show t) =>
    ParsecT s u m ()
    eof ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s u m Char
    newline ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> (ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall (f :: * -> *) a. Functor f => f a -> f ()
    void ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    blankline ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall (f :: * -> *) a. Functor f => f a -> f ()
    void ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall (m :: * -> *). PandocMonad m => MuseParser m Text
    parseDirectiveKey))

    directive :: PandocMonad m => MuseParser m ()
    directive :: forall (m :: * -> *). PandocMonad m => MuseParser m ()
    directive = do
      ext <- (ReaderOptions -> Extensions)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Extensions
    forall st s (m :: * -> *) t b.
    (HasReaderOptions st, Stream s m t) =>
    (ReaderOptions -> b) -> ParsecT s st m b
    forall s (m :: * -> *) t b.
    Stream s m t =>
    (ReaderOptions -> b) -> ParsecT s MuseState m b
    getOption ReaderOptions -> Extensions
    readerExtensions
      (key, value) <- if extensionEnabled Ext_amuse ext then parseAmuseDirective else parseEmacsDirective
      updateState $ \MuseState
    st -> MuseState
    st { museMeta = B.setMeta (translateKey key) <$> value <*> museMeta st }
      where translateKey :: a -> a
    translateKey a
    "cover" = a
    "cover-image"
            translateKey a
    x = a
    x

    -- ** Block parsers

    allowPara :: MonadReader MuseEnv m => m a -> m a
    allowPara :: forall (m :: * -> *) a. MonadReader MuseEnv m => m a -> m a
    allowPara m a
    p = (MuseEnv -> MuseEnv) -> m a -> m a
    forall a. (MuseEnv -> MuseEnv) -> m a -> m a
    forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
    local (\MuseEnv
    s -> MuseEnv
    s { museInPara = False }) m a
    p

    -- | Parse section contents until EOF or next header
    parseBlocks :: PandocMonad m
                => MuseParser m (F Blocks)
    parseBlocks :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    parseBlocks =
      ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall {u}. ParsecT Sources u (ReaderT MuseEnv m) (F Blocks)
    parseEnd ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|>
           ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    nextSection ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|>
           ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    listStart ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|>
           ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    blockStart ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|>
           ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    paraStart)
      where
        nextSection :: ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    nextSection = F Blocks
    forall a. Monoid a => a
    mempty F Blocks
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (Text, Int)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b.
    a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ ParsecT Sources MuseState (ReaderT MuseEnv m) (Text, Int)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (Text, Int)
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m a
    lookAhead ParsecT Sources MuseState (ReaderT MuseEnv m) (Text, Int)
    forall (m :: * -> *). PandocMonad m => MuseParser m (Text, Int)
    headingStart
        parseEnd :: ParsecT Sources u (ReaderT MuseEnv m) (F Blocks)
    parseEnd = F Blocks
    forall a. Monoid a => a
    mempty F Blocks
    -> ParsecT Sources u (ReaderT MuseEnv m) ()
    -> ParsecT Sources u (ReaderT MuseEnv m) (F Blocks)
    forall a b.
    a
    -> ParsecT Sources u (ReaderT MuseEnv m) b
    -> ParsecT Sources u (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ ParsecT Sources u (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) t u.
    (Stream s m t, Show t) =>
    ParsecT s u m ()
    eof
        blockStart :: ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    blockStart = F Blocks -> F Blocks -> F Blocks
    forall a. Semigroup a => a -> a -> a
    (B.<>) (F Blocks -> F Blocks -> F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (F Blocks -> F Blocks)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    blockElements ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    emacsNoteBlock)
                            ParsecT
      Sources MuseState (ReaderT MuseEnv m) (F Blocks -> F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (m :: * -> *) a. MonadReader MuseEnv m => m a -> m a
    allowPara ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    parseBlocks
        listStart :: ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    listStart =
          (F Blocks -> F Blocks -> F Blocks)
    -> (F Blocks, F Blocks) -> F Blocks
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry F Blocks -> F Blocks -> F Blocks
    forall a. Semigroup a => a -> a -> a
    (B.<>) ((F Blocks, F Blocks) -> F Blocks)
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (F Blocks, F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, F Blocks)
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (F Blocks, F Blocks)
    forall (m :: * -> *) a. MonadReader MuseEnv m => m a -> m a
    allowPara (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (F Blocks, F Blocks)
    forall (m :: * -> *) a.
    PandocMonad m =>
    MuseParser m a -> MuseParser m (F Blocks, a)
    anyListUntil ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    parseBlocks ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, F Blocks)
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (F Blocks, F Blocks)
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (F Blocks, F Blocks)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (F Blocks, F Blocks)
    forall (m :: * -> *) a.
    PandocMonad m =>
    MuseParser m a -> MuseParser m (F Blocks, a)
    amuseNoteBlockUntil ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    parseBlocks)
        paraStart :: ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    paraStart = do
          indent <- SourceName -> Int
    forall a. [a] -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    length (SourceName -> Int)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Int
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    spaceChar
          uncurry (B.<>) . first (p indent) <$> paraUntil parseBlocks
          where p :: a -> f Blocks -> f Blocks
    p a
    indent = if a
    indent a -> a -> Bool
    forall a. Ord a => a -> a -> Bool
    >= a
    2 Bool -> Bool -> Bool
    && a
    indent a -> a -> Bool
    forall a. Ord a => a -> a -> Bool
    < a
    6 then (Blocks -> Blocks) -> f Blocks -> f Blocks
    forall a b. (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Blocks -> Blocks
    B.blockQuote else f Blocks -> f Blocks
    forall a. a -> a
    id

    -- | Parse section that starts with a header
    parseSection :: PandocMonad m
                 => MuseParser m (F Blocks)
    parseSection :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    parseSection =
      (F Blocks -> F Blocks -> F Blocks
    forall a. Semigroup a => a -> a -> a
    (B.<>) (F Blocks -> F Blocks -> F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (F Blocks -> F Blocks)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    emacsHeading ParsecT
      Sources MuseState (ReaderT MuseEnv m) (F Blocks -> F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    parseBlocks) ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|>
      ((F Blocks -> F Blocks -> F Blocks)
    -> (F Blocks, F Blocks) -> F Blocks
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry F Blocks -> F Blocks -> F Blocks
    forall a. Semigroup a => a -> a -> a
    (B.<>) ((F Blocks, F Blocks) -> F Blocks)
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (F Blocks, F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (F Blocks, F Blocks)
    forall (m :: * -> *) a.
    PandocMonad m =>
    MuseParser m a -> MuseParser m (F Blocks, a)
    amuseHeadingUntil ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    parseBlocks)

    parseBlocksTill :: PandocMonad m
                    => MuseParser m a
                    -> MuseParser m (F Blocks)
    parseBlocksTill :: forall (m :: * -> *) a.
    PandocMonad m =>
    MuseParser m a -> MuseParser m (F Blocks)
    parseBlocksTill MuseParser m a
    end = ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    continuation
      where
        parseEnd :: ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    parseEnd = F Blocks
    forall a. Monoid a => a
    mempty F Blocks
    -> MuseParser m a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b.
    a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ MuseParser m a
    end
        blockStart :: ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    blockStart = F Blocks -> F Blocks -> F Blocks
    forall a. Semigroup a => a -> a -> a
    (B.<>) (F Blocks -> F Blocks -> F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (F Blocks -> F Blocks)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    blockElements ParsecT
      Sources MuseState (ReaderT MuseEnv m) (F Blocks -> F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (m :: * -> *) a. MonadReader MuseEnv m => m a -> m a
    allowPara ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    continuation
        listStart :: ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    listStart = (F Blocks -> F Blocks -> F Blocks)
    -> (F Blocks, F Blocks) -> F Blocks
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry F Blocks -> F Blocks -> F Blocks
    forall a. Semigroup a => a -> a -> a
    (B.<>) ((F Blocks, F Blocks) -> F Blocks)
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (F Blocks, F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, F Blocks)
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (F Blocks, F Blocks)
    forall (m :: * -> *) a. MonadReader MuseEnv m => m a -> m a
    allowPara (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (F Blocks, F Blocks)
    forall (m :: * -> *) a.
    PandocMonad m =>
    MuseParser m a -> MuseParser m (F Blocks, a)
    anyListUntil (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    parseEnd ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    continuation))
        paraStart :: ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    paraStart = (F Blocks -> F Blocks -> F Blocks)
    -> (F Blocks, F Blocks) -> F Blocks
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry F Blocks -> F Blocks -> F Blocks
    forall a. Semigroup a => a -> a -> a
    (B.<>) ((F Blocks, F Blocks) -> F Blocks)
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (F Blocks, F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (F Blocks, F Blocks)
    forall (m :: * -> *) a.
    PandocMonad m =>
    MuseParser m a -> MuseParser m (F Blocks, a)
    paraUntil (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    parseEnd ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    continuation)
        continuation :: ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    continuation = ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b. (a -> b) -> a -> b
    $ ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    parseEnd ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    listStart ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    blockStart ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    paraStart

    listItemContentsUntil :: PandocMonad m
                          => Int
                          -> MuseParser m a
                          -> MuseParser m a
                          -> MuseParser m (F Blocks, a)
    listItemContentsUntil :: forall (m :: * -> *) a.
    PandocMonad m =>
    Int
    -> MuseParser m a -> MuseParser m a -> MuseParser m (F Blocks, a)
    listItemContentsUntil Int
    col MuseParser m a
    pre MuseParser m a
    end = ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    p
      where
        p :: ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    p = ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    listStart ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    blockStart ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    paraStart
        parsePre :: ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    parsePre = (F Blocks
    forall a. Monoid a => a
    mempty,) (a -> (F Blocks, a))
    -> MuseParser m a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> MuseParser m a
    pre
        parseEnd :: ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    parseEnd = (F Blocks
    forall a. Monoid a => a
    mempty,) (a -> (F Blocks, a))
    -> MuseParser m a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> MuseParser m a
    end
        paraStart :: ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    paraStart = do
          (f, (r, e)) <- ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    -> MuseParser m (F Blocks, (F Blocks, a))
    forall (m :: * -> *) a.
    PandocMonad m =>
    MuseParser m a -> MuseParser m (F Blocks, a)
    paraUntil (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    parsePre ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    continuation ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    parseEnd)
          return (f B.<> r, e)
        blockStart :: ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    blockStart = (F Blocks -> F Blocks) -> (F Blocks, a) -> (F Blocks, a)
    forall a b c. (a -> b) -> (a, c) -> (b, c)
    forall (p :: * -> * -> *) a b c.
    Bifunctor p =>
    (a -> b) -> p a c -> p b c
    first ((F Blocks -> F Blocks) -> (F Blocks, a) -> (F Blocks, a))
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (F Blocks -> F Blocks)
    -> ParsecT
         Sources
         MuseState
         (ReaderT MuseEnv m)
         ((F Blocks, a) -> (F Blocks, a))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (F Blocks -> F Blocks -> F Blocks
    forall a. Semigroup a => a -> a -> a
    (B.<>) (F Blocks -> F Blocks -> F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (F Blocks -> F Blocks)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    blockElements)
                           ParsecT
      Sources
      MuseState
      (ReaderT MuseEnv m)
      ((F Blocks, a) -> (F Blocks, a))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    forall (m :: * -> *) a. MonadReader MuseEnv m => m a -> m a
    allowPara (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    parsePre ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    continuation ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    parseEnd)
        listStart :: ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    listStart = do
          (f, (r, e)) <- MuseParser m (F Blocks, (F Blocks, a))
    -> MuseParser m (F Blocks, (F Blocks, a))
    forall (m :: * -> *) a. MonadReader MuseEnv m => m a -> m a
    allowPara (MuseParser m (F Blocks, (F Blocks, a))
     -> MuseParser m (F Blocks, (F Blocks, a)))
    -> MuseParser m (F Blocks, (F Blocks, a))
    -> MuseParser m (F Blocks, (F Blocks, a))
    forall a b. (a -> b) -> a -> b
    $ ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    -> MuseParser m (F Blocks, (F Blocks, a))
    forall (m :: * -> *) a.
    PandocMonad m =>
    MuseParser m a -> MuseParser m (F Blocks, a)
    anyListUntil (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    parsePre ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    continuation ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    parseEnd)
          return (f B.<> r, e)
        continuation :: ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    continuation = ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    forall a b. (a -> b) -> a -> b
    $ do blank <- ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (Maybe Char)
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m (Maybe a)
    optionMaybe ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    blankline
                                skipMany blankline
                                indentWith col
                                local (\MuseEnv
    s -> MuseEnv
    s { museInPara = museInPara s && isNothing blank }) p

    parseBlock :: PandocMonad m => MuseParser m (F Blocks)
    parseBlock :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    parseBlock = do
      res <- MuseParser m (F Blocks)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    blockElements MuseParser m (F Blocks)
    -> MuseParser m (F Blocks) -> MuseParser m (F Blocks)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> MuseParser m (F Blocks)
    para
      trace (T.take 60 $ tshow $ B.toList $ runF res def)
      return res
      where para :: MuseParser m (F Blocks)
    para = (F Blocks, ()) -> F Blocks
    forall a b. (a, b) -> a
    fst ((F Blocks, ()) -> F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, ())
    -> MuseParser m (F Blocks)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, ())
    forall (m :: * -> *) a.
    PandocMonad m =>
    MuseParser m a -> MuseParser m (F Blocks, a)
    paraUntil (ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) t u.
    (Stream s m t, Show t) =>
    ParsecT s u m ()
    eof ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> MuseParser m (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall (f :: * -> *) a. Functor f => f a -> f ()
    void (MuseParser m (F Blocks) -> MuseParser m (F Blocks)
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m a
    lookAhead MuseParser m (F Blocks)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    blockElements)))

    blockElements :: PandocMonad m => MuseParser m (F Blocks)
    blockElements :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    blockElements = (F Blocks
    forall a. Monoid a => a
    mempty F Blocks
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b.
    a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    blankline)
                ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    comment
                ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    separator
                ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    pagebreak
                ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    example
                ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    exampleTag
                ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    literalTag
                ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    centerTag
                ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    rightTag
                ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    quoteTag
                ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    divTag
                ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    biblioTag
                ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    playTag
                ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    verseTag
                ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    lineBlock
                ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    museGridTable
                ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    table
                ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    commentTag

    -- | Parse a line comment, starting with @;@ in the first column.
    comment :: PandocMonad m => MuseParser m (F Blocks)
    comment :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    comment = ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b. (a -> b) -> a -> b
    $ F Blocks
    forall a. Monoid a => a
    mempty
      F Blocks
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b.
    a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall (m :: * -> *). PandocMonad m => MuseParser m ()
    firstColumn
      ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* Char -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    Char -> ParsecT s u m Char
    char Char
    ';'
      ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m ()
    optional (ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    spaceChar ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many (SourceName -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    SourceName -> ParsecT s u m Char
    noneOf SourceName
    "\n"))
      ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m ()
    eol

    -- | Parse a horizontal rule, consisting of 4 or more @\'-\'@ characters.
    separator :: PandocMonad m => MuseParser m (F Blocks)
    separator :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    separator = ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b. (a -> b) -> a -> b
    $ Blocks -> F Blocks
    forall a. a -> Future MuseState a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Blocks
    B.horizontalRule
      F Blocks
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b.
    a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    SourceName -> ParsecT s u m SourceName
    string SourceName
    "----"
      ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many (Char -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    Char -> ParsecT s u m Char
    char Char
    '-')
      ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    spaceChar
      ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m ()
    eol

    -- | Parse a page break
    pagebreak :: PandocMonad m => MuseParser m (F Blocks)
    pagebreak :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    pagebreak = ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b. (a -> b) -> a -> b
    $ Blocks -> F Blocks
    forall a. a -> Future MuseState a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Attr -> Blocks -> Blocks
    B.divWith (Text
    "", [], [(Text
    "style", Text
    "page-break-before: always;")]) Blocks
    forall a. Monoid a => a
    mempty)
      F Blocks
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b.
    a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ Int
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    Int -> ParsecT s u m a -> ParsecT s u m [a]
    count Int
    6 ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    spaceChar
      ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    spaceChar
      ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    SourceName -> ParsecT s u m SourceName
    string SourceName
    "* * * * *"
      ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    manyTill ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    spaceChar ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m ()
    eol

    headingStart :: PandocMonad m => MuseParser m (Text, Int)
    headingStart :: forall (m :: * -> *). PandocMonad m => MuseParser m (Text, Int)
    headingStart = ParsecT Sources MuseState (ReaderT MuseEnv m) (Text, Int)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (Text, Int)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) (Text, Int)
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (Text, Int))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (Text, Int)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (Text, Int)
    forall a b. (a -> b) -> a -> b
    $ (,)
      (Text -> Int -> (Text, Int))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (Int -> (Text, Int))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv 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
    "" (ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall (m :: * -> *). PandocMonad m => MuseParser m Text
    parseAnchor ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    manyTill ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    spaceChar ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m ()
    eol))
      ParsecT Sources MuseState (ReaderT MuseEnv m) (Int -> (Text, Int))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (Int -> (Text, Int))
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <*  ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall (m :: * -> *). PandocMonad m => MuseParser m ()
    firstColumn
      ParsecT Sources MuseState (ReaderT MuseEnv m) (Int -> (Text, Int))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Int
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (Text, Int)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (SourceName -> Int)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Int
    forall a b.
    (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap SourceName -> Int
    forall a. [a] -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    length (ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many1 (ParsecT Sources MuseState (ReaderT MuseEnv m) Char
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall a b. (a -> b) -> a -> b
    $ Char -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    Char -> ParsecT s u m Char
    char Char
    '*')
      ParsecT Sources MuseState (ReaderT MuseEnv m) (Text, Int)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (Text, Int)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <*  ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    spaceChar

    -- | Parse a single-line heading.
    emacsHeading :: PandocMonad m => MuseParser m (F Blocks)
    emacsHeading :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    emacsHeading = ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b. (a -> b) -> a -> b
    $ do
      Extension -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) a st.
    (Stream s m a, HasReaderOptions st) =>
    Extension -> ParsecT s st m ()
    guardDisabled Extension
    Ext_amuse
      (anchorId, level) <- MuseParser m (Text, Int)
    forall (m :: * -> *). PandocMonad m => MuseParser m (Text, Int)
    headingStart
      content <- trimInlinesF . mconcat <$> manyTill inline eol
      attr <- registerHeader (anchorId, [], []) (runF content def)
      return $ B.headerWith attr level <$> content

    -- | Parse a multi-line heading.
    -- It is a Text::Amuse extension, Emacs Muse does not allow heading to span multiple lines.
    amuseHeadingUntil :: PandocMonad m
                      => MuseParser m a -- ^ Terminator parser
                      -> MuseParser m (F Blocks, a)
    amuseHeadingUntil :: forall (m :: * -> *) a.
    PandocMonad m =>
    MuseParser m a -> MuseParser m (F Blocks, a)
    amuseHeadingUntil MuseParser m a
    end = ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    forall a b. (a -> b) -> a -> b
    $ do
      Extension -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) a st.
    (Stream s m a, HasReaderOptions st) =>
    Extension -> ParsecT s st m ()
    guardEnabled Extension
    Ext_amuse
      (anchorId, level) <- MuseParser m (Text, Int)
    forall (m :: * -> *). PandocMonad m => MuseParser m (Text, Int)
    headingStart
      (content, e) <- paraContentsUntil end
      attr <- registerHeader (anchorId, [], []) (runF content def)
      return (B.headerWith attr level <$> content, e)

    -- | Parse an example between @{{{@ and @}}}@.
    -- It is an Amusewiki extension influenced by Creole wiki, as described in @Text::Amuse@ documentation.
    example :: PandocMonad m => MuseParser m (F Blocks)
    example :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    example = ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b. (a -> b) -> a -> b
    $ Blocks -> F Blocks
    forall a. a -> Future MuseState a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Blocks -> F Blocks) -> (Text -> Blocks) -> Text -> F Blocks
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Blocks
    B.codeBlock
      (Text -> F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (Text -> F Blocks)
    forall a b.
    a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$  SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    SourceName -> ParsecT s u m SourceName
    string SourceName
    "{{{"
      ParsecT Sources MuseState (ReaderT MuseEnv m) (Text -> F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (Text -> F Blocks)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <*  ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    spaceChar
      ParsecT Sources MuseState (ReaderT MuseEnv m) (Text -> F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Text -> Text
    unindent (Text -> Text)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall s (m :: * -> *) t st a.
    Stream s m t =>
    ParsecT s st m Char -> ParsecT s st m a -> ParsecT s st m Text
    manyTillChar ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s u m Char
    anyChar (SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    SourceName -> ParsecT s u m SourceName
    string SourceName
    "}}}"))

    -- | Parse an @\<example>@ tag.
    exampleTag :: PandocMonad m => MuseParser m (F Blocks)
    exampleTag :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    exampleTag = ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b. (a -> b) -> a -> b
    $ (Blocks -> F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Blocks
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b.
    (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Blocks -> F Blocks
    forall a. a -> Future MuseState a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (ParsecT Sources MuseState (ReaderT MuseEnv m) Blocks
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Blocks
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b. (a -> b) -> a -> b
    $ Attr -> Text -> Blocks
    B.codeBlockWith
      (Attr -> Text -> Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (Attr -> Text -> Blocks)
    forall a b.
    a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$  ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    spaceChar
      ParsecT
      Sources MuseState (ReaderT MuseEnv m) (Attr -> Text -> Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Attr
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (Text -> Blocks)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ([(Text, Text)] -> Attr
    htmlAttrToPandoc ([(Text, Text)] -> Attr)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [(Text, Text)]
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Attr
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [(Text, Text)]
    forall (m :: * -> *).
    PandocMonad m =>
    Text -> MuseParser m [(Text, Text)]
    openTag Text
    "example")
      ParsecT Sources MuseState (ReaderT MuseEnv m) (Text -> Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Blocks
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Text -> Text
    unindent (Text -> Text)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall s (m :: * -> *) t st a.
    Stream s m t =>
    ParsecT s st m Char -> ParsecT s st m a -> ParsecT s st m Text
    manyTillChar ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s u m Char
    anyChar (Text -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall (m :: * -> *). PandocMonad m => Text -> MuseParser m ()
    closeTag Text
    "example"))
      ParsecT Sources MuseState (ReaderT MuseEnv m) Blocks
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Blocks
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <*  ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    manyTill ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    spaceChar ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m ()
    eol

    -- | Parse a @\<literal>@ tag as a raw block.
    -- For 'RawInline' @\<literal>@ parser, see 'inlineLiteralTag'.
    literalTag :: PandocMonad m => MuseParser m (F Blocks)
    literalTag :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    literalTag = ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b. (a -> b) -> a -> b
    $ (Blocks -> F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Blocks
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b.
    (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Blocks -> F Blocks
    forall a. a -> Future MuseState a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (ParsecT Sources MuseState (ReaderT MuseEnv m) Blocks
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Blocks
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b. (a -> b) -> a -> b
    $ Text -> Text -> Blocks
    B.rawBlock
      (Text -> Text -> Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (Text -> Text -> Blocks)
    forall a b.
    a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$  ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    spaceChar
      ParsecT
      Sources MuseState (ReaderT MuseEnv m) (Text -> Text -> Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (Text -> Blocks)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Text -> Maybe Text -> Text
    forall a. a -> Maybe a -> a
    fromMaybe Text
    "html" (Maybe Text -> Text)
    -> ([(Text, Text)] -> Maybe Text) -> [(Text, Text)] -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> [(Text, Text)] -> Maybe Text
    forall a b. Eq a => a -> [(a, b)] -> Maybe b
    lookup Text
    "style" ([(Text, Text)] -> Text)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [(Text, Text)]
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [(Text, Text)]
    forall (m :: * -> *).
    PandocMonad m =>
    Text -> MuseParser m [(Text, Text)]
    openTag Text
    "literal") -- FIXME: Emacs Muse inserts <literal> without style into all output formats, but we assume HTML
      ParsecT Sources MuseState (ReaderT MuseEnv m) (Text -> Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (Text -> Blocks)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <*  ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    manyTill ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    spaceChar ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m ()
    eol
      ParsecT Sources MuseState (ReaderT MuseEnv m) (Text -> Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Blocks
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Text -> Text
    unindent (Text -> Text)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall s (m :: * -> *) t st a.
    Stream s m t =>
    ParsecT s st m Char -> ParsecT s st m a -> ParsecT s st m Text
    manyTillChar ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s u m Char
    anyChar (Text -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall (m :: * -> *). PandocMonad m => Text -> MuseParser m ()
    closeTag Text
    "literal"))
      ParsecT Sources MuseState (ReaderT MuseEnv m) Blocks
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Blocks
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <*  ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    manyTill ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    spaceChar ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m ()
    eol

    -- | Parse @\<center>@ tag.
    -- Currently it is ignored as Pandoc cannot represent centered blocks.
    centerTag :: PandocMonad m => MuseParser m (F Blocks)
    centerTag :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    centerTag = (Attr, F Blocks) -> F Blocks
    forall a b. (a, b) -> b
    snd ((Attr, F Blocks) -> F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (Attr, F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (Attr, F Blocks)
    forall (m :: * -> *).
    PandocMonad m =>
    Text -> MuseParser m (Attr, F Blocks)
    parseHtmlContent Text
    "center"

    -- | Parse @\<right>@ tag.
    -- Currently it is ignored as Pandoc cannot represent centered blocks.
    rightTag :: PandocMonad m => MuseParser m (F Blocks)
    rightTag :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    rightTag = (Attr, F Blocks) -> F Blocks
    forall a b. (a, b) -> b
    snd ((Attr, F Blocks) -> F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (Attr, F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (Attr, F Blocks)
    forall (m :: * -> *).
    PandocMonad m =>
    Text -> MuseParser m (Attr, F Blocks)
    parseHtmlContent Text
    "right"

    -- | Parse @\<quote>@ tag.
    quoteTag :: PandocMonad m => MuseParser m (F Blocks)
    quoteTag :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    quoteTag = (Blocks -> Blocks) -> F Blocks -> F Blocks
    forall a b. (a -> b) -> Future MuseState a -> Future MuseState b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Blocks -> Blocks
    B.blockQuote (F Blocks -> F Blocks)
    -> ((Attr, F Blocks) -> F Blocks) -> (Attr, F Blocks) -> F Blocks
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Attr, F Blocks) -> F Blocks
    forall a b. (a, b) -> b
    snd ((Attr, F Blocks) -> F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (Attr, F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (Attr, F Blocks)
    forall (m :: * -> *).
    PandocMonad m =>
    Text -> MuseParser m (Attr, F Blocks)
    parseHtmlContent Text
    "quote"

    -- | Parse @\<div>@ tag.
    -- @\<div>@ tag is supported by Emacs Muse, but not Amusewiki 2.025.
    divTag :: PandocMonad m => MuseParser m (F Blocks)
    divTag :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    divTag = do
      (attrs, content) <- Text -> MuseParser m (Attr, F Blocks)
    forall (m :: * -> *).
    PandocMonad m =>
    Text -> MuseParser m (Attr, F Blocks)
    parseHtmlContent Text
    "div"
      return $ B.divWith attrs <$> content

    -- | Parse @\<biblio>@ tag, the result is the same as @\<div class="biblio">@.
    -- @\<biblio>@ tag is supported only in Text::Amuse mode.
    biblioTag :: PandocMonad m => MuseParser m (F Blocks)
    biblioTag :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    biblioTag = (Blocks -> Blocks) -> F Blocks -> F Blocks
    forall a b. (a -> b) -> Future MuseState a -> Future MuseState b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (Attr -> Blocks -> Blocks
    B.divWith (Text
    "", [Text
    "biblio"], [])) (F Blocks -> F Blocks)
    -> ((Attr, F Blocks) -> F Blocks) -> (Attr, F Blocks) -> F Blocks
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Attr, F Blocks) -> F Blocks
    forall a b. (a, b) -> b
    snd
      ((Attr, F Blocks) -> F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT
         Sources
         MuseState
         (ReaderT MuseEnv m)
         ((Attr, F Blocks) -> F Blocks)
    forall a b.
    a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$  Extension -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) a st.
    (Stream s m a, HasReaderOptions st) =>
    Extension -> ParsecT s st m ()
    guardEnabled Extension
    Ext_amuse
      ParsecT
      Sources
      MuseState
      (ReaderT MuseEnv m)
      ((Attr, F Blocks) -> F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (Attr, F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (Attr, F Blocks)
    forall (m :: * -> *).
    PandocMonad m =>
    Text -> MuseParser m (Attr, F Blocks)
    parseHtmlContent Text
    "biblio"

    -- | Parse @\<play>@ tag, the result is the same as @\<div class="play">@.
    -- @\<play>@ tag is supported only in Text::Amuse mode.
    playTag :: PandocMonad m => MuseParser m (F Blocks)
    playTag :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    playTag = do
      Extension -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) a st.
    (Stream s m a, HasReaderOptions st) =>
    Extension -> ParsecT s st m ()
    guardEnabled Extension
    Ext_amuse
      (Blocks -> Blocks) -> F Blocks -> F Blocks
    forall a b. (a -> b) -> Future MuseState a -> Future MuseState b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (Attr -> Blocks -> Blocks
    B.divWith (Text
    "", [Text
    "play"], [])) (F Blocks -> F Blocks)
    -> ((Attr, F Blocks) -> F Blocks) -> (Attr, F Blocks) -> F Blocks
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Attr, F Blocks) -> F Blocks
    forall a b. (a, b) -> b
    snd ((Attr, F Blocks) -> F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (Attr, F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (Attr, F Blocks)
    forall (m :: * -> *).
    PandocMonad m =>
    Text -> MuseParser m (Attr, F Blocks)
    parseHtmlContent Text
    "play"

    verseLine :: PandocMonad m => MuseParser m (F Inlines)
    verseLine :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    verseLine = F Inlines -> F Inlines -> F Inlines
    forall a. Semigroup a => a -> a -> a
    (<>)
      (F Inlines -> F Inlines -> F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (F Inlines -> F Inlines)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Inlines -> F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Inlines
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b.
    (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Inlines -> F Inlines
    forall a. a -> Future MuseState a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Inlines
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Inlines
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Inlines
    forall s (m :: * -> *) t a u.
    Stream s m t =>
    a -> ParsecT s u m a -> ParsecT s u m a
    option Inlines
    forall a. Monoid a => a
    mempty (Text -> Inlines
    B.str (Text -> Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Inlines
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall s (m :: * -> *) t st.
    Stream s m t =>
    ParsecT s st m Char -> ParsecT s st m Text
    many1Char (Char
    '\160' Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall a b.
    a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ Char -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    Char -> ParsecT s u m Char
    char Char
    ' ')))
      ParsecT
      Sources MuseState (ReaderT MuseEnv m) (F Inlines -> F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ([F Inlines] -> F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [F Inlines]
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b.
    (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (F Inlines -> F Inlines
    forall s. Future s Inlines -> Future s Inlines
    trimInlinesF (F Inlines -> F Inlines)
    -> ([F Inlines] -> F Inlines) -> [F Inlines] -> F Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [F Inlines] -> F Inlines
    forall a. Monoid a => [a] -> a
    mconcat) (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [F Inlines]
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    manyTill ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    inline' ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m ()
    eol)

    -- | Parse @\<verse>@ tag.
    verseTag :: PandocMonad m => MuseParser m (F Blocks)
    verseTag :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    verseTag = ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b. (a -> b) -> a -> b
    $ MuseParser m Int
    forall (m :: * -> *). PandocMonad m => MuseParser m Int
    getIndent MuseParser m Int
    -> (Int
        -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> (a -> ParsecT Sources MuseState (ReaderT MuseEnv m) b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \Int
    indent -> ([Inlines] -> Blocks) -> Future MuseState [Inlines] -> F Blocks
    forall a b. (a -> b) -> Future MuseState a -> Future MuseState b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap [Inlines] -> Blocks
    B.lineBlock (Future MuseState [Inlines] -> F Blocks)
    -> ([F Inlines] -> Future MuseState [Inlines])
    -> [F Inlines]
    -> F Blocks
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [F Inlines] -> Future MuseState [Inlines]
    forall (t :: * -> *) (m :: * -> *) a.
    (Traversable t, Monad m) =>
    t (m a) -> m (t a)
    forall (m :: * -> *) a. Monad m => [m a] -> m [a]
    sequence
      ([F Inlines] -> F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [(Text, Text)]
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) ([F Inlines] -> F Blocks)
    forall a b.
    a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$  Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [(Text, Text)]
    forall (m :: * -> *).
    PandocMonad m =>
    Text -> MuseParser m [(Text, Text)]
    openTag Text
    "verse"
      ParsecT
      Sources MuseState (ReaderT MuseEnv m) ([F Inlines] -> F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) ([F Inlines] -> F Blocks)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <*  ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    manyTill ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    spaceChar ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m ()
    eol
      ParsecT
      Sources MuseState (ReaderT MuseEnv m) ([F Inlines] -> F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [F Inlines]
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [F 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 (Int -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char, HasReaderOptions st) =>
    Int -> ParsecT s st m Text
    indentWith Int
    indent ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    verseLine) (ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) ()
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) ())
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall a b. (a -> b) -> a -> b
    $ Int -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char, HasReaderOptions st) =>
    Int -> ParsecT s st m Text
    indentWith Int
    indent ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> Text -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall (m :: * -> *). PandocMonad m => Text -> MuseParser m ()
    closeTag Text
    "verse")
      ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <*  ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    manyTill ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    spaceChar ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m ()
    eol

    -- | Parse @\<comment>@ tag.
    commentTag :: PandocMonad m => MuseParser m (F Blocks)
    commentTag :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    commentTag = ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b. (a -> b) -> a -> b
    $ F Blocks
    forall a. Monoid a => a
    mempty
      F Blocks
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b.
    a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    spaceChar
      ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [(Text, Text)]
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [(Text, Text)]
    forall (m :: * -> *).
    PandocMonad m =>
    Text -> MuseParser m [(Text, Text)]
    openTag Text
    "comment"
      ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    manyTill ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s u m Char
    anyChar (Text -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall (m :: * -> *). PandocMonad m => Text -> MuseParser m ()
    closeTag Text
    "comment")
      ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    manyTill ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    spaceChar ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m ()
    eol

    -- | Parse paragraph contents.
    paraContentsUntil :: PandocMonad m
                      => MuseParser m a -- ^ Terminator parser
                      -> MuseParser m (F Inlines, a)
    paraContentsUntil :: forall (m :: * -> *) a.
    PandocMonad m =>
    MuseParser m a -> MuseParser m (F Inlines, a)
    paraContentsUntil MuseParser m a
    end = ([F Inlines] -> F Inlines) -> ([F Inlines], a) -> (F Inlines, a)
    forall a b c. (a -> b) -> (a, c) -> (b, c)
    forall (p :: * -> * -> *) a b c.
    Bifunctor p =>
    (a -> b) -> p a c -> p b c
    first (F Inlines -> F Inlines
    forall s. Future s Inlines -> Future s Inlines
    trimInlinesF (F Inlines -> F Inlines)
    -> ([F Inlines] -> F Inlines) -> [F Inlines] -> F Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [F Inlines] -> F Inlines
    forall a. Monoid a => [a] -> a
    mconcat)
      (([F Inlines], a) -> (F Inlines, a))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ([F Inlines], a)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines, a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> MuseParser m a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ([F Inlines], a)
    forall s u (m :: * -> *) a b.
    ParsecT s u m a -> ParsecT s u m b -> ParsecT s u m ([a], b)
    manyUntil ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    inline (MuseParser m a -> MuseParser m a
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    manyTill ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    spaceChar ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m ()
    eol ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> MuseParser m a -> MuseParser m a
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> (MuseEnv -> MuseEnv) -> MuseParser m a -> MuseParser m a
    forall a.
    (MuseEnv -> MuseEnv)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
    local (\MuseEnv
    s -> MuseEnv
    s { museInPara = True}) MuseParser m a
    end))

    -- | Parse a paragraph.
    paraUntil :: PandocMonad m
              => MuseParser m a -- ^ Terminator parser
              -> MuseParser m (F Blocks, a)
    paraUntil :: forall (m :: * -> *) a.
    PandocMonad m =>
    MuseParser m a -> MuseParser m (F Blocks, a)
    paraUntil MuseParser m a
    end = do
      inPara <- (MuseEnv -> Bool)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Bool
    forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
    asks MuseEnv -> Bool
    museInPara
      guard $ not inPara
      first (fmap B.para) <$> paraContentsUntil end

    noteMarker' :: PandocMonad m
                => Char
                -> Char
                -> MuseParser m Text
    noteMarker' :: forall (m :: * -> *).
    PandocMonad m =>
    Char -> Char -> MuseParser m Text
    noteMarker' Char
    l Char
    r = ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) Text
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall a b. (a -> b) -> a -> b
    $ (\Char
    x SourceName
    y -> SourceName -> Text
    T.pack (SourceName -> Text) -> SourceName -> Text
    forall a b. (a -> b) -> a -> b
    $ Char
    lChar -> SourceName -> SourceName
    forall a. a -> [a] -> [a]
    :Char
    xChar -> SourceName -> SourceName
    forall a. a -> [a] -> [a]
    :SourceName
    y SourceName -> SourceName -> SourceName
    forall a. [a] -> [a] -> [a]
    ++ [Char
    r])
      (Char -> SourceName -> Text)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (Char -> SourceName -> Text)
    forall a b.
    a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ Char -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    Char -> ParsecT s u m Char
    char Char
    l
      ParsecT
      Sources MuseState (ReaderT MuseEnv m) (Char -> SourceName -> Text)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (SourceName -> Text)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> SourceName -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    SourceName -> ParsecT s u m Char
    oneOf SourceName
    "123456789"
      ParsecT Sources MuseState (ReaderT MuseEnv m) (SourceName -> Text)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    manyTill ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s u m Char
    digit (Char -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    Char -> ParsecT s u m Char
    char Char
    r)

    noteMarker :: PandocMonad m => MuseParser m Text
    noteMarker :: forall (m :: * -> *). PandocMonad m => MuseParser m Text
    noteMarker = Char -> Char -> MuseParser m Text
    forall (m :: * -> *).
    PandocMonad m =>
    Char -> Char -> MuseParser m Text
    noteMarker' Char
    '[' Char
    ']' MuseParser m Text -> MuseParser m Text -> MuseParser m Text
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> Char -> Char -> MuseParser m Text
    forall (m :: * -> *).
    PandocMonad m =>
    Char -> Char -> MuseParser m Text
    noteMarker' Char
    '{' Char
    '}'

    addNote :: PandocMonad m
            => Text
            -> SourcePos
            -> F Blocks
            -> MuseParser m ()
    addNote :: forall (m :: * -> *).
    PandocMonad m =>
    Text -> SourcePos -> F Blocks -> MuseParser m ()
    addNote Text
    ref SourcePos
    pos F Blocks
    content = do
      oldnotes <- MuseState -> Map Text (SourcePos, F Blocks)
    museNotes (MuseState -> Map Text (SourcePos, F Blocks))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) MuseState
    -> ParsecT
         Sources
         MuseState
         (ReaderT MuseEnv m)
         (Map Text (SourcePos, F Blocks))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Sources MuseState (ReaderT MuseEnv m) MuseState
    forall (m :: * -> *) s u. Monad m => ParsecT s u m u
    getState
      when (M.member ref oldnotes)
        (logMessage $ DuplicateNoteReference ref pos)
      updateState $ \MuseState
    s -> MuseState
    s{ museNotes = M.insert ref (pos, content) oldnotes }

    -- Amusewiki version of note
    -- Parsing is similar to list item, except that note marker is used instead of list marker
    amuseNoteBlockUntil :: PandocMonad m
                        => MuseParser m a
                        -> MuseParser m (F Blocks, a)
    amuseNoteBlockUntil :: forall (m :: * -> *) a.
    PandocMonad m =>
    MuseParser m a -> MuseParser m (F Blocks, a)
    amuseNoteBlockUntil MuseParser m a
    end = ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    forall a b. (a -> b) -> a -> b
    $ do
      Extension -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) a st.
    (Stream s m a, HasReaderOptions st) =>
    Extension -> ParsecT s st m ()
    guardEnabled Extension
    Ext_amuse
      ref <- MuseParser m Text
    forall (m :: * -> *). PandocMonad m => MuseParser m Text
    noteMarker
      pos <- getPosition
      void spaceChar <|> lookAhead eol
      (content, e) <- allowPara $ listItemContentsUntil (sourceColumn pos) (Prelude.fail "x") end
      addNote ref pos content
      return (mempty, e)

    -- Emacs version of note
    -- Notes are allowed only at the end of text, no indentation is required.
    emacsNoteBlock :: PandocMonad m => MuseParser m (F Blocks)
    emacsNoteBlock :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    emacsNoteBlock = ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b. (a -> b) -> a -> b
    $ do
      Extension -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) a st.
    (Stream s m a, HasReaderOptions st) =>
    Extension -> ParsecT s st m ()
    guardDisabled Extension
    Ext_amuse
      ref <- MuseParser m Text
    forall (m :: * -> *). PandocMonad m => MuseParser m Text
    noteMarker
      pos <- getPosition
      content <- fmap mconcat blocksTillNote
      addNote ref pos content
      return mempty
      where
        blocksTillNote :: ParsecT Sources MuseState (ReaderT MuseEnv m) [F Blocks]
    blocksTillNote =
          ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [F Blocks]
    forall end s (m :: * -> *) t st a.
    (Show end, Stream s m t) =>
    ParsecT s st m a -> ParsecT s st m end -> ParsecT s st m [a]
    many1Till ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    parseBlock (ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) t u.
    (Stream s m t, Show t) =>
    ParsecT s u m ()
    eof ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> () ()
    -> MuseParser m Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall a b.
    a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ MuseParser m Text -> MuseParser m Text
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m a
    lookAhead MuseParser m Text
    forall (m :: * -> *). PandocMonad m => MuseParser m Text
    noteMarker)

    --
    -- Verse markup
    --

    -- | Parse a line block indicated by @\'>\'@ characters.
    lineBlock :: PandocMonad m => MuseParser m (F Blocks)
    lineBlock :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    lineBlock = ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b. (a -> b) -> a -> b
    $ MuseParser m Int
    forall (m :: * -> *). PandocMonad m => MuseParser m Int
    getIndent MuseParser m Int
    -> (Int
        -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> (a -> ParsecT Sources MuseState (ReaderT MuseEnv m) b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \Int
    indent -> ([Inlines] -> Blocks) -> Future MuseState [Inlines] -> F Blocks
    forall a b. (a -> b) -> Future MuseState a -> Future MuseState b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap [Inlines] -> Blocks
    B.lineBlock (Future MuseState [Inlines] -> F Blocks)
    -> ([F Inlines] -> Future MuseState [Inlines])
    -> [F Inlines]
    -> F Blocks
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [F Inlines] -> Future MuseState [Inlines]
    forall (t :: * -> *) (m :: * -> *) a.
    (Traversable t, Monad m) =>
    t (m a) -> m (t a)
    forall (m :: * -> *) a. Monad m => [m a] -> m [a]
    sequence
      ([F Inlines] -> F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [F Inlines]
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall {u}. ParsecT Sources u (ReaderT MuseEnv m) (F Inlines)
    blankVerseLine ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    nonblankVerseLine) ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [F Inlines]
    forall s u (m :: * -> *) a sep.
    ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
    `sepBy1'` ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (Int -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char, HasReaderOptions st) =>
    Int -> ParsecT s st m Text
    indentWith Int
    indent)
      where
        blankVerseLine :: ParsecT Sources u (ReaderT MuseEnv m) (F Inlines)
    blankVerseLine = ParsecT Sources u (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources u (ReaderT MuseEnv m) (F Inlines)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources u (ReaderT MuseEnv m) (F Inlines)
     -> ParsecT Sources u (ReaderT MuseEnv m) (F Inlines))
    -> ParsecT Sources u (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources u (ReaderT MuseEnv m) (F Inlines)
    forall a b. (a -> b) -> a -> b
    $ F Inlines
    forall a. Monoid a => a
    mempty F Inlines
    -> ParsecT Sources u (ReaderT MuseEnv m) Char
    -> ParsecT Sources u (ReaderT MuseEnv m) (F Inlines)
    forall a b.
    a
    -> ParsecT Sources u (ReaderT MuseEnv m) b
    -> ParsecT Sources u (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ Char -> ParsecT Sources u (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    Char -> ParsecT s u m Char
    char Char
    '>' ParsecT Sources u (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources u (ReaderT MuseEnv m) Char
    -> ParsecT Sources u (ReaderT MuseEnv m) (F Inlines)
    forall a b.
    ParsecT Sources u (ReaderT MuseEnv m) a
    -> ParsecT Sources u (ReaderT MuseEnv m) b
    -> ParsecT Sources u (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT Sources u (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    blankline
        nonblankVerseLine :: ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    nonblankVerseLine = ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    SourceName -> ParsecT s u m SourceName
    string SourceName
    "> ") ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    verseLine

    -- *** List parsers

    bulletListItemsUntil :: PandocMonad m
                         => Int -- ^ Indentation
                         -> MuseParser m a -- ^ Terminator parser
                         -> MuseParser m ([F Blocks], a)
    bulletListItemsUntil :: forall (m :: * -> *) a.
    PandocMonad m =>
    Int -> MuseParser m a -> MuseParser m ([F Blocks], a)
    bulletListItemsUntil Int
    indent MuseParser m a
    end = ParsecT Sources MuseState (ReaderT MuseEnv m) ([F Blocks], a)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ([F Blocks], a)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) ([F Blocks], a)
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) ([F Blocks], a))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ([F Blocks], a)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ([F Blocks], a)
    forall a b. (a -> b) -> a -> b
    $ do
      Char -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    Char -> ParsecT s u m Char
    char Char
    '-'
      ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall (f :: * -> *) a. Functor f => f a -> f ()
    void ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    spaceChar ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m a
    lookAhead ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m ()
    eol
      (x, (xs, e)) <- ParsecT
      Sources MuseState (ReaderT MuseEnv m) (F Blocks, ([F Blocks], a))
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (F Blocks, ([F Blocks], a))
    forall (m :: * -> *) a. MonadReader MuseEnv m => m a -> m a
    allowPara (ParsecT
       Sources MuseState (ReaderT MuseEnv m) (F Blocks, ([F Blocks], a))
     -> ParsecT
          Sources MuseState (ReaderT MuseEnv m) (F Blocks, ([F Blocks], a)))
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (F Blocks, ([F Blocks], a))
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (F Blocks, ([F Blocks], a))
    forall a b. (a -> b) -> a -> b
    $ Int
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ([F Blocks], a)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ([F Blocks], a)
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (F Blocks, ([F Blocks], a))
    forall (m :: * -> *) a.
    PandocMonad m =>
    Int
    -> MuseParser m a -> MuseParser m a -> MuseParser m (F Blocks, a)
    listItemContentsUntil (Int
    indent Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    2) (ParsecT Sources MuseState (ReaderT MuseEnv m) ([F Blocks], a)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ([F Blocks], a)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m ()
    optional ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    blankline ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> Int -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char, HasReaderOptions st) =>
    Int -> ParsecT s st m Text
    indentWith Int
    indent ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ([F Blocks], a)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ([F Blocks], a)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> Int
    -> MuseParser m a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ([F Blocks], a)
    forall (m :: * -> *) a.
    PandocMonad m =>
    Int -> MuseParser m a -> MuseParser m ([F Blocks], a)
    bulletListItemsUntil Int
    indent MuseParser m a
    end)) (([],) (a -> ([F Blocks], a))
    -> MuseParser m a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ([F Blocks], a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> MuseParser m a
    end)
      return (x:xs, e)

    -- | Parse a bullet list.
    bulletListUntil :: PandocMonad m
                    => MuseParser m a
                    -> MuseParser m (F Blocks, a)
    bulletListUntil :: forall (m :: * -> *) a.
    PandocMonad m =>
    MuseParser m a -> MuseParser m (F Blocks, a)
    bulletListUntil MuseParser m a
    end = ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    forall a b. (a -> b) -> a -> b
    $ do
      indent <- MuseParser m Int
    forall (m :: * -> *). PandocMonad m => MuseParser m Int
    getIndent
      guard $ indent /= 0
      first (fmap B.bulletList . sequence) <$> bulletListItemsUntil indent end

    museOrderedListMarker :: PandocMonad m
                          => ListNumberStyle
                          -> MuseParser m Int
    museOrderedListMarker :: forall (m :: * -> *).
    PandocMonad m =>
    ListNumberStyle -> MuseParser m Int
    museOrderedListMarker ListNumberStyle
    style =
      (ListNumberStyle, Int) -> Int
    forall a b. (a, b) -> b
    snd ((ListNumberStyle, Int) -> Int)
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (ListNumberStyle, Int)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Int
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT
      Sources MuseState (ReaderT MuseEnv m) (ListNumberStyle, Int)
    forall {st}.
    ParsecT Sources st (ReaderT MuseEnv m) (ListNumberStyle, Int)
    p ParsecT Sources MuseState (ReaderT MuseEnv m) Int
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Int
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* Char -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    Char -> ParsecT s u m Char
    char Char
    '.'
      where p :: ParsecT Sources st (ReaderT MuseEnv m) (ListNumberStyle, Int)
    p = case ListNumberStyle
    style of
                  ListNumberStyle
    Decimal    -> ParsecT Sources st (ReaderT MuseEnv m) (ListNumberStyle, Int)
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m (ListNumberStyle, Int)
    decimal
                  ListNumberStyle
    UpperRoman -> ParsecT Sources st (ReaderT MuseEnv m) (ListNumberStyle, Int)
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m (ListNumberStyle, Int)
    upperRoman
                  ListNumberStyle
    LowerRoman -> ParsecT Sources st (ReaderT MuseEnv m) (ListNumberStyle, Int)
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m (ListNumberStyle, Int)
    lowerRoman
                  ListNumberStyle
    UpperAlpha -> ParsecT Sources st (ReaderT MuseEnv m) (ListNumberStyle, Int)
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m (ListNumberStyle, Int)
    upperAlpha
                  ListNumberStyle
    LowerAlpha -> ParsecT Sources st (ReaderT MuseEnv m) (ListNumberStyle, Int)
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m (ListNumberStyle, Int)
    lowerAlpha
                  ListNumberStyle
    _          -> SourceName
    -> ParsecT Sources st (ReaderT MuseEnv m) (ListNumberStyle, Int)
    forall a. SourceName -> ParsecT Sources st (ReaderT MuseEnv m) a
    forall (m :: * -> *) a. MonadFail m => SourceName -> m a
    Prelude.fail SourceName
    "Unhandled case"

    orderedListItemsUntil :: PandocMonad m
                          => Int
                          -> ListNumberStyle
                          -> MuseParser m a
                          -> MuseParser m ([F Blocks], a)
    orderedListItemsUntil :: forall (m :: * -> *) a.
    PandocMonad m =>
    Int
    -> ListNumberStyle
    -> MuseParser m a
    -> MuseParser m ([F Blocks], a)
    orderedListItemsUntil Int
    indent ListNumberStyle
    style MuseParser m a
    end =
      ParsecT Sources MuseState (ReaderT MuseEnv m) ([F Blocks], a)
    continuation
      where
        continuation :: ParsecT Sources MuseState (ReaderT MuseEnv m) ([F Blocks], a)
    continuation = ParsecT Sources MuseState (ReaderT MuseEnv m) ([F Blocks], a)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ([F Blocks], a)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) ([F Blocks], a)
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) ([F Blocks], a))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ([F Blocks], a)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ([F Blocks], a)
    forall a b. (a -> b) -> a -> b
    $ do
          pos <- ParsecT Sources MuseState (ReaderT MuseEnv m) SourcePos
    forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
    getPosition
          void spaceChar <|> lookAhead eol
          (x, (xs, e)) <- allowPara $ listItemContentsUntil (sourceColumn pos) (try (optional blankline *> indentWith indent *> museOrderedListMarker style *> continuation)) (([],) <$> end)
          return (x:xs, e)

    -- | Parse an ordered list.
    orderedListUntil :: PandocMonad m
                     => MuseParser m a
                     -> MuseParser m (F Blocks, a)
    orderedListUntil :: forall (m :: * -> *) a.
    PandocMonad m =>
    MuseParser m a -> MuseParser m (F Blocks, a)
    orderedListUntil MuseParser m a
    end = ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    forall a b. (a -> b) -> a -> b
    $ do
      indent <- MuseParser m Int
    forall (m :: * -> *). PandocMonad m => MuseParser m Int
    getIndent
      guard $ indent /= 0
      (style, start) <- decimal <|> lowerRoman <|> upperRoman <|> lowerAlpha <|> upperAlpha
      char '.'
      first (fmap (B.orderedListWith (start, style, Period)) . sequence)
        <$> orderedListItemsUntil indent style end

    descriptionsUntil :: PandocMonad m
                      => Int
                      -> MuseParser m a
                      -> MuseParser m ([F Blocks], a)
    descriptionsUntil :: forall (m :: * -> *) a.
    PandocMonad m =>
    Int -> MuseParser m a -> MuseParser m ([F Blocks], a)
    descriptionsUntil Int
    indent MuseParser m a
    end = do
      ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall (f :: * -> *) a. Functor f => f a -> f ()
    void ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    spaceChar ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m a
    lookAhead ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m ()
    eol
      (x, (xs, e)) <- ParsecT
      Sources MuseState (ReaderT MuseEnv m) (F Blocks, ([F Blocks], a))
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (F Blocks, ([F Blocks], a))
    forall (m :: * -> *) a. MonadReader MuseEnv m => m a -> m a
    allowPara (ParsecT
       Sources MuseState (ReaderT MuseEnv m) (F Blocks, ([F Blocks], a))
     -> ParsecT
          Sources MuseState (ReaderT MuseEnv m) (F Blocks, ([F Blocks], a)))
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (F Blocks, ([F Blocks], a))
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (F Blocks, ([F Blocks], a))
    forall a b. (a -> b) -> a -> b
    $ Int
    -> MuseParser m ([F Blocks], a)
    -> MuseParser m ([F Blocks], a)
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (F Blocks, ([F Blocks], a))
    forall (m :: * -> *) a.
    PandocMonad m =>
    Int
    -> MuseParser m a -> MuseParser m a -> MuseParser m (F Blocks, a)
    listItemContentsUntil Int
    indent (MuseParser m ([F Blocks], a) -> MuseParser m ([F Blocks], a)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m ()
    optional ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    blankline ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> Int -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char, HasReaderOptions st) =>
    Int -> ParsecT s st m Text
    indentWith Int
    indent ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    manyTill ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    spaceChar (SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    SourceName -> ParsecT s u m SourceName
    string SourceName
    "::") ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> MuseParser m ([F Blocks], a) -> MuseParser m ([F Blocks], a)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> Int -> MuseParser m a -> MuseParser m ([F Blocks], a)
    forall (m :: * -> *) a.
    PandocMonad m =>
    Int -> MuseParser m a -> MuseParser m ([F Blocks], a)
    descriptionsUntil Int
    indent MuseParser m a
    end)) (([],) (a -> ([F Blocks], a))
    -> MuseParser m a -> MuseParser m ([F Blocks], a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> MuseParser m a
    end)
      return (x:xs, e)

    definitionListItemsUntil :: PandocMonad m
                             => Int
                             -> MuseParser m a
                             -> MuseParser m ([F (Inlines, [Blocks])], a)
    definitionListItemsUntil :: forall (m :: * -> *) a.
    PandocMonad m =>
    Int -> MuseParser m a -> MuseParser m ([F (Inlines, [Blocks])], a)
    definitionListItemsUntil Int
    indent MuseParser m a
    end =
      ParsecT
      Sources MuseState (ReaderT MuseEnv m) ([F (Inlines, [Blocks])], a)
    continuation
      where
        continuation :: ParsecT
      Sources MuseState (ReaderT MuseEnv m) ([F (Inlines, [Blocks])], a)
    continuation = ParsecT
      Sources MuseState (ReaderT MuseEnv m) ([F (Inlines, [Blocks])], a)
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) ([F (Inlines, [Blocks])], a)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT
       Sources MuseState (ReaderT MuseEnv m) ([F (Inlines, [Blocks])], a)
     -> ParsecT
          Sources MuseState (ReaderT MuseEnv m) ([F (Inlines, [Blocks])], a))
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) ([F (Inlines, [Blocks])], a)
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) ([F (Inlines, [Blocks])], a)
    forall a b. (a -> b) -> a -> b
    $ do
          pos <- ParsecT Sources MuseState (ReaderT MuseEnv m) SourcePos
    forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
    getPosition
          term <- trimInlinesF . mconcat <$> manyTill inline' (try $ string "::")
          (x, (xs, e)) <- descriptionsUntil (sourceColumn pos) (try (optional blankline *> indentWith indent *> continuation) <|> (([],) <$> end))
          let xx = (,) (Inlines -> [Blocks] -> (Inlines, [Blocks]))
    -> F Inlines -> Future MuseState ([Blocks] -> (Inlines, [Blocks]))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> F Inlines
    term Future MuseState ([Blocks] -> (Inlines, [Blocks]))
    -> Future MuseState [Blocks] -> F (Inlines, [Blocks])
    forall a b.
    Future MuseState (a -> b)
    -> Future MuseState a -> Future MuseState b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> [F Blocks] -> Future MuseState [Blocks]
    forall (t :: * -> *) (m :: * -> *) a.
    (Traversable t, Monad m) =>
    t (m a) -> m (t a)
    forall (m :: * -> *) a. Monad m => [m a] -> m [a]
    sequence [F Blocks]
    x
          return (xx:xs, e)

    -- | Parse a definition list.
    definitionListUntil :: PandocMonad m
                        => MuseParser m a -- ^ Terminator parser
                        -> MuseParser m (F Blocks, a)
    definitionListUntil :: forall (m :: * -> *) a.
    PandocMonad m =>
    MuseParser m a -> MuseParser m (F Blocks, a)
    definitionListUntil MuseParser m a
    end = ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks, a)
    forall a b. (a -> b) -> a -> b
    $ do
      indent <- MuseParser m Int
    forall (m :: * -> *). PandocMonad m => MuseParser m Int
    getIndent
      guardDisabled Ext_amuse <|> guard (indent /= 0) -- Initial space is required by Amusewiki, but not Emacs Muse
      first (fmap B.definitionList . sequence) <$> definitionListItemsUntil indent end

    anyListUntil :: PandocMonad m
                 => MuseParser m a -- ^ Terminator parser
                 -> MuseParser m (F Blocks, a)
    anyListUntil :: forall (m :: * -> *) a.
    PandocMonad m =>
    MuseParser m a -> MuseParser m (F Blocks, a)
    anyListUntil MuseParser m a
    end =
      MuseParser m a -> MuseParser m (F Blocks, a)
    forall (m :: * -> *) a.
    PandocMonad m =>
    MuseParser m a -> MuseParser m (F Blocks, a)
    bulletListUntil MuseParser m a
    end MuseParser m (F Blocks, a)
    -> MuseParser m (F Blocks, a) -> MuseParser m (F Blocks, a)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> MuseParser m a -> MuseParser m (F Blocks, a)
    forall (m :: * -> *) a.
    PandocMonad m =>
    MuseParser m a -> MuseParser m (F Blocks, a)
    orderedListUntil MuseParser m a
    end MuseParser m (F Blocks, a)
    -> MuseParser m (F Blocks, a) -> MuseParser m (F Blocks, a)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> MuseParser m a -> MuseParser m (F Blocks, a)
    forall (m :: * -> *) a.
    PandocMonad m =>
    MuseParser m a -> MuseParser m (F Blocks, a)
    definitionListUntil MuseParser m a
    end

    -- *** Table parsers

    -- | Internal Muse table representation.
    data MuseTable = MuseTable
      { MuseTable -> Inlines
    museTableCaption :: Inlines
      , MuseTable -> [[Blocks]]
    museTableHeaders :: [[Blocks]]
      , MuseTable -> [[Blocks]]
    museTableRows    :: [[Blocks]]
      , MuseTable -> [[Blocks]]
    museTableFooters :: [[Blocks]]
      }

    data MuseTableElement = MuseHeaderRow [Blocks]
                          | MuseBodyRow [Blocks]
                          | MuseFooterRow [Blocks]
                          | MuseCaption Inlines

    museToPandocTable :: MuseTable -> Blocks
    museToPandocTable :: MuseTable -> Blocks
    museToPandocTable (MuseTable Inlines
    caption [[Blocks]]
    headers [[Blocks]]
    body [[Blocks]]
    footers) =
      Caption
    -> [ColSpec] -> TableHead -> [TableBody] -> TableFoot -> Blocks
    B.table (Blocks -> Caption
    B.simpleCaption (Blocks -> Caption) -> Blocks -> Caption
    forall a b. (a -> b) -> a -> b
    $ Inlines -> Blocks
    B.plain Inlines
    caption)
              [ColSpec]
    attrs
              (Attr -> [Row] -> TableHead
    TableHead Attr
    nullAttr ([Row] -> TableHead) -> [Row] -> TableHead
    forall a b. (a -> b) -> a -> b
    $ [Blocks] -> [Row]
    toHeaderRow [Blocks]
    headRow)
              [Attr -> RowHeadColumns -> [Row] -> [Row] -> TableBody
    TableBody Attr
    nullAttr RowHeadColumns
    0 [] ([Row] -> TableBody) -> [Row] -> TableBody
    forall a b. (a -> b) -> a -> b
    $ ([Blocks] -> Row) -> [[Blocks]] -> [Row]
    forall a b. (a -> b) -> [a] -> [b]
    map [Blocks] -> Row
    toRow ([[Blocks]] -> [Row]) -> [[Blocks]] -> [Row]
    forall a b. (a -> b) -> a -> b
    $ [[Blocks]]
    rows [[Blocks]] -> [[Blocks]] -> [[Blocks]]
    forall a. [a] -> [a] -> [a]
    ++ [[Blocks]]
    body [[Blocks]] -> [[Blocks]] -> [[Blocks]]
    forall a. [a] -> [a] -> [a]
    ++ [[Blocks]]
    footers]
              (Attr -> [Row] -> TableFoot
    TableFoot Attr
    nullAttr [])
      where attrs :: [ColSpec]
    attrs = (Alignment
    AlignDefault, ColWidth
    ColWidthDefault) ColSpec -> [[Blocks]] -> [ColSpec]
    forall a b. a -> [b] -> [a]
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ [[Blocks]] -> [[Blocks]]
    forall a. [[a]] -> [[a]]
    transpose ([[Blocks]]
    headers [[Blocks]] -> [[Blocks]] -> [[Blocks]]
    forall a. [a] -> [a] -> [a]
    ++ [[Blocks]]
    body [[Blocks]] -> [[Blocks]] -> [[Blocks]]
    forall a. [a] -> [a] -> [a]
    ++ [[Blocks]]
    footers)
            ([Blocks]
    headRow, [[Blocks]]
    rows) =
              case [[Blocks]]
    headers of
                ([Blocks]
    r:[[Blocks]]
    rs) -> ([Blocks]
    r, [[Blocks]]
    rs)
                []     -> ([], [])
            toRow :: [Blocks] -> Row
    toRow = Attr -> [Cell] -> Row
    Row Attr
    nullAttr ([Cell] -> Row) -> ([Blocks] -> [Cell]) -> [Blocks] -> Row
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Blocks -> Cell) -> [Blocks] -> [Cell]
    forall a b. (a -> b) -> [a] -> [b]
    map Blocks -> Cell
    B.simpleCell
            toHeaderRow :: [Blocks] -> [Row]
    toHeaderRow [Blocks]
    l = [[Blocks] -> Row
    toRow [Blocks]
    l | Bool -> Bool
    not ([Blocks] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [Blocks]
    l)]

    museAppendElement :: MuseTableElement
                      -> MuseTable
                      -> MuseTable
    museAppendElement :: MuseTableElement -> MuseTable -> MuseTable
    museAppendElement MuseTableElement
    element MuseTable
    tbl =
      case MuseTableElement
    element of
        MuseHeaderRow [Blocks]
    row -> MuseTable
    tbl{ museTableHeaders = row : museTableHeaders tbl }
        MuseBodyRow [Blocks]
    row -> MuseTable
    tbl{ museTableRows = row : museTableRows tbl }
        MuseFooterRow [Blocks]
    row -> MuseTable
    tbl{ museTableFooters = row : museTableFooters tbl }
        MuseCaption Inlines
    inlines -> MuseTable
    tbl{ museTableCaption = inlines }

    tableElements :: PandocMonad m => MuseParser m (F [MuseTableElement])
    tableElements :: forall (m :: * -> *).
    PandocMonad m =>
    MuseParser m (F [MuseTableElement])
    tableElements = [Future MuseState MuseTableElement] -> F [MuseTableElement]
    forall (t :: * -> *) (m :: * -> *) a.
    (Traversable t, Monad m) =>
    t (m a) -> m (t a)
    forall (m :: * -> *) a. Monad m => [m a] -> m [a]
    sequence ([Future MuseState MuseTableElement] -> F [MuseTableElement])
    -> ParsecT
         Sources
         MuseState
         (ReaderT MuseEnv m)
         [Future MuseState MuseTableElement]
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (F [MuseTableElement])
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT
      Sources
      MuseState
      (ReaderT MuseEnv m)
      (Future MuseState MuseTableElement)
    -> ParsecT
         Sources
         MuseState
         (ReaderT MuseEnv m)
         [Future MuseState MuseTableElement]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many1 ParsecT
      Sources
      MuseState
      (ReaderT MuseEnv m)
      (Future MuseState MuseTableElement)
    forall (m :: * -> *).
    PandocMonad m =>
    MuseParser m (Future MuseState MuseTableElement)
    tableParseElement

    elementsToTable :: [MuseTableElement] -> MuseTable
    elementsToTable :: [MuseTableElement] -> MuseTable
    elementsToTable = (MuseTableElement -> MuseTable -> MuseTable)
    -> MuseTable -> [MuseTableElement] -> MuseTable
    forall a b. (a -> b -> b) -> b -> [a] -> b
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    foldr MuseTableElement -> MuseTable -> MuseTable
    museAppendElement MuseTable
    emptyTable
      where emptyTable :: MuseTable
    emptyTable = Inlines -> [[Blocks]] -> [[Blocks]] -> [[Blocks]] -> MuseTable
    MuseTable Inlines
    forall a. Monoid a => a
    mempty [[Blocks]]
    forall a. Monoid a => a
    mempty [[Blocks]]
    forall a. Monoid a => a
    mempty [[Blocks]]
    forall a. Monoid a => a
    mempty

    museGridPart :: PandocMonad m => MuseParser m Int
    museGridPart :: forall (m :: * -> *). PandocMonad m => MuseParser m Int
    museGridPart = ParsecT Sources MuseState (ReaderT MuseEnv m) Int
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Int
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) Int
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) Int)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Int
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Int
    forall a b. (a -> b) -> a -> b
    $ SourceName -> Int
    forall a. [a] -> Int
    forall (t :: * -> *) a. Foldable t => t a -> Int
    length (SourceName -> Int)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Int
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many1 (Char -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    Char -> ParsecT s u m Char
    char Char
    '-') ParsecT Sources MuseState (ReaderT MuseEnv m) Int
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Int
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* Char -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    Char -> ParsecT s u m Char
    char Char
    '+'

    museGridTableHeader :: PandocMonad m => MuseParser m [Int]
    museGridTableHeader :: forall (m :: * -> *). PandocMonad m => MuseParser m [Int]
    museGridTableHeader = ParsecT Sources MuseState (ReaderT MuseEnv m) [Int]
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [Int]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) [Int]
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) [Int])
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [Int]
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [Int]
    forall a b. (a -> b) -> a -> b
    $ Char -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    Char -> ParsecT s u m Char
    char Char
    '+' ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [Int]
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [Int]
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> ParsecT Sources MuseState (ReaderT MuseEnv m) Int
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [Int]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many1 ParsecT Sources MuseState (ReaderT MuseEnv m) Int
    forall (m :: * -> *). PandocMonad m => MuseParser m Int
    museGridPart ParsecT Sources MuseState (ReaderT MuseEnv m) [Int]
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [Int]
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    manyTill ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    spaceChar ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m ()
    eol

    museGridTableRow :: PandocMonad m
                     => Int
                     -> [Int]
                     -> MuseParser m (F [Blocks])
    museGridTableRow :: forall (m :: * -> *).
    PandocMonad m =>
    Int -> [Int] -> MuseParser m (Future MuseState [Blocks])
    museGridTableRow Int
    indent [Int]
    indices = ParsecT
      Sources MuseState (ReaderT MuseEnv m) (Future MuseState [Blocks])
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (Future MuseState [Blocks])
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT
       Sources MuseState (ReaderT MuseEnv m) (Future MuseState [Blocks])
     -> ParsecT
          Sources MuseState (ReaderT MuseEnv m) (Future MuseState [Blocks]))
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (Future MuseState [Blocks])
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (Future MuseState [Blocks])
    forall a b. (a -> b) -> a -> b
    $ do
      lns <- ParsecT Sources MuseState (ReaderT MuseEnv m) [Text]
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [[Text]]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many1 (ParsecT Sources MuseState (ReaderT MuseEnv m) [Text]
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) [[Text]])
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [Text]
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [[Text]]
    forall a b. (a -> b) -> a -> b
    $ ParsecT Sources MuseState (ReaderT MuseEnv m) [Text]
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [Text]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (Int -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char, HasReaderOptions st) =>
    Int -> ParsecT s st m Text
    indentWith Int
    indent ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [Text]
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [Text]
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> [Int] -> ParsecT Sources MuseState (ReaderT MuseEnv m) [Text]
    forall (m :: * -> *). PandocMonad m => [Int] -> MuseParser m [Text]
    museGridTableRawLine [Int]
    indices)
      let cols = ([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
    trimr) ([[Text]] -> [Text]) -> [[Text]] -> [Text]
    forall a b. (a -> b) -> a -> b
    $ [[Text]] -> [[Text]]
    forall a. [[a]] -> [[a]]
    transpose [[Text]]
    lns
      indentWith indent *> museGridTableHeader
      sequence <$> mapM (parseFromString' parseBlocks) cols

    museGridTableRawLine :: PandocMonad m
                         => [Int]
                         -> MuseParser m [Text]
    museGridTableRawLine :: forall (m :: * -> *). PandocMonad m => [Int] -> MuseParser m [Text]
    museGridTableRawLine [Int]
    indices =
      Char -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    Char -> ParsecT s u m Char
    char Char
    '|' ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [Text]
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [Text]
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> [Int]
    -> (Int -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [Text]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    t a -> (a -> m b) -> m (t b)
    forM [Int]
    indices (\Int
    n -> Int
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char, Monad m) =>
    Int -> ParsecT s st m Char -> ParsecT s st m Text
    countChar Int
    n ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s u m Char
    anyChar ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* Char -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    Char -> ParsecT s u m Char
    char Char
    '|') ParsecT Sources MuseState (ReaderT MuseEnv m) [Text]
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [Text]
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    manyTill ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    spaceChar ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m ()
    eol

    museGridTable :: PandocMonad m => MuseParser m (F Blocks)
    museGridTable :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    museGridTable = ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b. (a -> b) -> a -> b
    $ do
      indent <- MuseParser m Int
    forall (m :: * -> *). PandocMonad m => MuseParser m Int
    getIndent
      indices <- museGridTableHeader
      fmap rowsToTable . sequence <$> many1 (museGridTableRow indent indices)
      where rowsToTable :: [[Blocks]] -> Blocks
    rowsToTable [[Blocks]]
    rows = Caption
    -> [ColSpec] -> TableHead -> [TableBody] -> TableFoot -> Blocks
    B.table Caption
    B.emptyCaption
                                       [ColSpec]
    attrs
                                       (Attr -> [Row] -> TableHead
    TableHead Attr
    nullAttr [])
                                       [Attr -> RowHeadColumns -> [Row] -> [Row] -> TableBody
    TableBody Attr
    nullAttr RowHeadColumns
    0 [] ([Row] -> TableBody) -> [Row] -> TableBody
    forall a b. (a -> b) -> a -> b
    $ ([Blocks] -> Row) -> [[Blocks]] -> [Row]
    forall a b. (a -> b) -> [a] -> [b]
    map [Blocks] -> Row
    toRow [[Blocks]]
    rows]
                                       (Attr -> [Row] -> TableFoot
    TableFoot Attr
    nullAttr [])
                               where attrs :: [ColSpec]
    attrs = (Alignment
    AlignDefault, ColWidth
    ColWidthDefault) ColSpec -> [[Blocks]] -> [ColSpec]
    forall a b. a -> [b] -> [a]
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ [[Blocks]] -> [[Blocks]]
    forall a. [[a]] -> [[a]]
    transpose [[Blocks]]
    rows
                                     toRow :: [Blocks] -> Row
    toRow = Attr -> [Cell] -> Row
    Row Attr
    nullAttr ([Cell] -> Row) -> ([Blocks] -> [Cell]) -> [Blocks] -> Row
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Blocks -> Cell) -> [Blocks] -> [Cell]
    forall a b. (a -> b) -> [a] -> [b]
    map Blocks -> Cell
    B.simpleCell

    -- | Parse a table.
    table :: PandocMonad m => MuseParser m (F Blocks)
    table :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Blocks)
    table = ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b. (a -> b) -> a -> b
    $ ([MuseTableElement] -> Blocks) -> F [MuseTableElement] -> F Blocks
    forall a b. (a -> b) -> Future MuseState a -> Future MuseState b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (MuseTable -> Blocks
    museToPandocTable (MuseTable -> Blocks)
    -> ([MuseTableElement] -> MuseTable)
    -> [MuseTableElement]
    -> Blocks
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [MuseTableElement] -> MuseTable
    elementsToTable) (F [MuseTableElement] -> F Blocks)
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (F [MuseTableElement])
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT
      Sources MuseState (ReaderT MuseEnv m) (F [MuseTableElement])
    forall (m :: * -> *).
    PandocMonad m =>
    MuseParser m (F [MuseTableElement])
    tableElements

    tableParseElement :: PandocMonad m => MuseParser m (F MuseTableElement)
    tableParseElement :: forall (m :: * -> *).
    PandocMonad m =>
    MuseParser m (Future MuseState MuseTableElement)
    tableParseElement = MuseParser m (Future MuseState MuseTableElement)
    forall (m :: * -> *).
    PandocMonad m =>
    MuseParser m (Future MuseState MuseTableElement)
    tableParseHeader
                    MuseParser m (Future MuseState MuseTableElement)
    -> MuseParser m (Future MuseState MuseTableElement)
    -> MuseParser m (Future MuseState MuseTableElement)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> MuseParser m (Future MuseState MuseTableElement)
    forall (m :: * -> *).
    PandocMonad m =>
    MuseParser m (Future MuseState MuseTableElement)
    tableParseBody
                    MuseParser m (Future MuseState MuseTableElement)
    -> MuseParser m (Future MuseState MuseTableElement)
    -> MuseParser m (Future MuseState MuseTableElement)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> MuseParser m (Future MuseState MuseTableElement)
    forall (m :: * -> *).
    PandocMonad m =>
    MuseParser m (Future MuseState MuseTableElement)
    tableParseFooter
                    MuseParser m (Future MuseState MuseTableElement)
    -> MuseParser m (Future MuseState MuseTableElement)
    -> MuseParser m (Future MuseState MuseTableElement)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> MuseParser m (Future MuseState MuseTableElement)
    forall (m :: * -> *).
    PandocMonad m =>
    MuseParser m (Future MuseState MuseTableElement)
    tableParseCaption

    tableParseRow :: PandocMonad m
                  => Int -- ^ Number of separator characters
                  -> MuseParser m (F [Blocks])
    tableParseRow :: forall (m :: * -> *).
    PandocMonad m =>
    Int -> MuseParser m (Future MuseState [Blocks])
    tableParseRow Int
    n = ParsecT
      Sources MuseState (ReaderT MuseEnv m) (Future MuseState [Blocks])
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (Future MuseState [Blocks])
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT
       Sources MuseState (ReaderT MuseEnv m) (Future MuseState [Blocks])
     -> ParsecT
          Sources MuseState (ReaderT MuseEnv m) (Future MuseState [Blocks]))
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (Future MuseState [Blocks])
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (Future MuseState [Blocks])
    forall a b. (a -> b) -> a -> b
    $ [F Blocks] -> Future MuseState [Blocks]
    forall (t :: * -> *) (m :: * -> *) a.
    (Traversable t, Monad m) =>
    t (m a) -> m (t a)
    forall (m :: * -> *) a. Monad m => [m a] -> m [a]
    sequence ([F Blocks] -> Future MuseState [Blocks])
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [F Blocks]
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (Future MuseState [Blocks])
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Sources MuseState (ReaderT MuseEnv m) [F Blocks]
    tableCells
      where tableCells :: ParsecT Sources MuseState (ReaderT MuseEnv m) [F Blocks]
    tableCells = (:) (F Blocks -> [F Blocks] -> [F Blocks])
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) ([F Blocks] -> [F Blocks])
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (m :: * -> *) a.
    PandocMonad m =>
    MuseParser m a -> MuseParser m (F Blocks)
    tableCell ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall {u}. ParsecT Sources u (ReaderT MuseEnv m) ()
    sep ParsecT
      Sources MuseState (ReaderT MuseEnv m) ([F Blocks] -> [F Blocks])
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [F Blocks]
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [F Blocks]
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (ParsecT Sources MuseState (ReaderT MuseEnv m) [F Blocks]
    tableCells ParsecT Sources MuseState (ReaderT MuseEnv m) [F Blocks]
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [F Blocks]
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [F Blocks]
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> (F Blocks -> [F Blocks])
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [F Blocks]
    forall a b.
    (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap F Blocks -> [F Blocks]
    forall a. a -> [a]
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (m :: * -> *) a.
    PandocMonad m =>
    MuseParser m a -> MuseParser m (F Blocks)
    tableCell ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m ()
    eol))
            tableCell :: ParsecT Sources MuseState (ReaderT MuseEnv m) end
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    tableCell ParsecT Sources MuseState (ReaderT MuseEnv m) end
    p = ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall a b. (a -> b) -> a -> b
    $ (Inlines -> Blocks) -> F Inlines -> F Blocks
    forall a b. (a -> b) -> Future MuseState a -> Future MuseState b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Inlines -> Blocks
    B.plain (F Inlines -> F Blocks)
    -> ([F Inlines] -> F Inlines) -> [F Inlines] -> F Blocks
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . F Inlines -> F Inlines
    forall s. Future s Inlines -> Future s Inlines
    trimInlinesF (F Inlines -> F Inlines)
    -> ([F Inlines] -> F Inlines) -> [F Inlines] -> F Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [F Inlines] -> F Inlines
    forall a. Monoid a => [a] -> a
    mconcat ([F Inlines] -> F Blocks)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [F Inlines]
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Blocks)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) end
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [F Inlines]
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    manyTill ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    inline' ParsecT Sources MuseState (ReaderT MuseEnv m) end
    p
            sep :: ParsecT Sources u (ReaderT MuseEnv m) ()
    sep = ParsecT Sources u (ReaderT MuseEnv m) ()
    -> ParsecT Sources u (ReaderT MuseEnv m) ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources u (ReaderT MuseEnv m) ()
     -> ParsecT Sources u (ReaderT MuseEnv m) ())
    -> ParsecT Sources u (ReaderT MuseEnv m) ()
    -> ParsecT Sources u (ReaderT MuseEnv m) ()
    forall a b. (a -> b) -> a -> b
    $ ParsecT Sources u (ReaderT MuseEnv m) Char
    -> ParsecT Sources u (ReaderT MuseEnv m) SourceName
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many1 ParsecT Sources u (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    spaceChar ParsecT Sources u (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources u (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources u (ReaderT MuseEnv m) SourceName
    forall a b.
    ParsecT Sources u (ReaderT MuseEnv m) a
    -> ParsecT Sources u (ReaderT MuseEnv m) b
    -> ParsecT Sources u (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> Int
    -> ParsecT Sources u (ReaderT MuseEnv m) Char
    -> ParsecT Sources u (ReaderT MuseEnv m) SourceName
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    Int -> ParsecT s u m a -> ParsecT s u m [a]
    count Int
    n (Char -> ParsecT Sources u (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    Char -> ParsecT s u m Char
    char Char
    '|') ParsecT Sources u (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources u (ReaderT MuseEnv m) ()
    -> ParsecT Sources u (ReaderT MuseEnv m) ()
    forall a b.
    ParsecT Sources u (ReaderT MuseEnv m) a
    -> ParsecT Sources u (ReaderT MuseEnv m) b
    -> ParsecT Sources u (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> ParsecT Sources u (ReaderT MuseEnv m) ()
    -> ParsecT Sources u (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m a
    lookAhead (ParsecT Sources u (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources u (ReaderT MuseEnv m) ()
    forall (f :: * -> *) a. Functor f => f a -> f ()
    void (ParsecT Sources u (ReaderT MuseEnv m) Char
    -> ParsecT Sources u (ReaderT MuseEnv m) SourceName
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many1 ParsecT Sources u (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    spaceChar) ParsecT Sources u (ReaderT MuseEnv m) ()
    -> ParsecT Sources u (ReaderT MuseEnv m) ()
    -> ParsecT Sources u (ReaderT MuseEnv m) ()
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Sources u (ReaderT MuseEnv m) ()
    -> ParsecT Sources u (ReaderT MuseEnv m) ()
    forall (f :: * -> *) a. Functor f => f a -> f ()
    void ParsecT Sources u (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m ()
    eol)

    -- | Parse a table header row.
    tableParseHeader :: PandocMonad m => MuseParser m (F MuseTableElement)
    tableParseHeader :: forall (m :: * -> *).
    PandocMonad m =>
    MuseParser m (Future MuseState MuseTableElement)
    tableParseHeader = ([Blocks] -> MuseTableElement)
    -> Future MuseState [Blocks] -> Future MuseState MuseTableElement
    forall a b. (a -> b) -> Future MuseState a -> Future MuseState b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap [Blocks] -> MuseTableElement
    MuseHeaderRow (Future MuseState [Blocks] -> Future MuseState MuseTableElement)
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (Future MuseState [Blocks])
    -> ParsecT
         Sources
         MuseState
         (ReaderT MuseEnv m)
         (Future MuseState MuseTableElement)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Int
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (Future MuseState [Blocks])
    forall (m :: * -> *).
    PandocMonad m =>
    Int -> MuseParser m (Future MuseState [Blocks])
    tableParseRow Int
    2

    -- | Parse a table body row.
    tableParseBody :: PandocMonad m => MuseParser m (F MuseTableElement)
    tableParseBody :: forall (m :: * -> *).
    PandocMonad m =>
    MuseParser m (Future MuseState MuseTableElement)
    tableParseBody = ([Blocks] -> MuseTableElement)
    -> Future MuseState [Blocks] -> Future MuseState MuseTableElement
    forall a b. (a -> b) -> Future MuseState a -> Future MuseState b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap [Blocks] -> MuseTableElement
    MuseBodyRow (Future MuseState [Blocks] -> Future MuseState MuseTableElement)
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (Future MuseState [Blocks])
    -> ParsecT
         Sources
         MuseState
         (ReaderT MuseEnv m)
         (Future MuseState MuseTableElement)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Int
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (Future MuseState [Blocks])
    forall (m :: * -> *).
    PandocMonad m =>
    Int -> MuseParser m (Future MuseState [Blocks])
    tableParseRow Int
    1

    -- | Parse a table footer row.
    tableParseFooter :: PandocMonad m => MuseParser m (F MuseTableElement)
    tableParseFooter :: forall (m :: * -> *).
    PandocMonad m =>
    MuseParser m (Future MuseState MuseTableElement)
    tableParseFooter = ([Blocks] -> MuseTableElement)
    -> Future MuseState [Blocks] -> Future MuseState MuseTableElement
    forall a b. (a -> b) -> Future MuseState a -> Future MuseState b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap [Blocks] -> MuseTableElement
    MuseFooterRow (Future MuseState [Blocks] -> Future MuseState MuseTableElement)
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (Future MuseState [Blocks])
    -> ParsecT
         Sources
         MuseState
         (ReaderT MuseEnv m)
         (Future MuseState MuseTableElement)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Int
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (Future MuseState [Blocks])
    forall (m :: * -> *).
    PandocMonad m =>
    Int -> MuseParser m (Future MuseState [Blocks])
    tableParseRow Int
    3

    -- | Parse table caption.
    tableParseCaption :: PandocMonad m => MuseParser m (F MuseTableElement)
    tableParseCaption :: forall (m :: * -> *).
    PandocMonad m =>
    MuseParser m (Future MuseState MuseTableElement)
    tableParseCaption = ParsecT
      Sources
      MuseState
      (ReaderT MuseEnv m)
      (Future MuseState MuseTableElement)
    -> ParsecT
         Sources
         MuseState
         (ReaderT MuseEnv m)
         (Future MuseState MuseTableElement)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT
       Sources
       MuseState
       (ReaderT MuseEnv m)
       (Future MuseState MuseTableElement)
     -> ParsecT
          Sources
          MuseState
          (ReaderT MuseEnv m)
          (Future MuseState MuseTableElement))
    -> ParsecT
         Sources
         MuseState
         (ReaderT MuseEnv m)
         (Future MuseState MuseTableElement)
    -> ParsecT
         Sources
         MuseState
         (ReaderT MuseEnv m)
         (Future MuseState MuseTableElement)
    forall a b. (a -> b) -> a -> b
    $ (Inlines -> MuseTableElement)
    -> F Inlines -> Future MuseState MuseTableElement
    forall a b. (a -> b) -> Future MuseState a -> Future MuseState b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Inlines -> MuseTableElement
    MuseCaption (F Inlines -> Future MuseState MuseTableElement)
    -> ([F Inlines] -> F Inlines)
    -> [F Inlines]
    -> Future MuseState MuseTableElement
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . F Inlines -> F Inlines
    forall s. Future s Inlines -> Future s Inlines
    trimInlinesF (F Inlines -> F Inlines)
    -> ([F Inlines] -> F Inlines) -> [F Inlines] -> F Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [F Inlines] -> F Inlines
    forall a. Monoid a => [a] -> a
    mconcat
      ([F Inlines] -> Future MuseState MuseTableElement)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT
         Sources
         MuseState
         (ReaderT MuseEnv m)
         ([F Inlines] -> Future MuseState MuseTableElement)
    forall a b.
    a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$  ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    spaceChar
      ParsecT
      Sources
      MuseState
      (ReaderT MuseEnv m)
      ([F Inlines] -> Future MuseState MuseTableElement)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT
         Sources
         MuseState
         (ReaderT MuseEnv m)
         ([F Inlines] -> Future MuseState MuseTableElement)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <*  SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    SourceName -> ParsecT s u m SourceName
    string SourceName
    "|+"
      ParsecT
      Sources
      MuseState
      (ReaderT MuseEnv m)
      ([F Inlines] -> Future MuseState MuseTableElement)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [F Inlines]
    -> ParsecT
         Sources
         MuseState
         (ReaderT MuseEnv m)
         (Future MuseState MuseTableElement)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [F Inlines]
    forall end s (m :: * -> *) t st a.
    (Show end, Stream s m t) =>
    ParsecT s st m a -> ParsecT s st m end -> ParsecT s st m [a]
    many1Till ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    inline (ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) ()
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) ())
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall a b. (a -> b) -> a -> b
    $ SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    SourceName -> ParsecT s u m SourceName
    string SourceName
    "+|" ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m ()
    eol)

    -- ** Inline parsers

    inline' :: PandocMonad m => MuseParser m (F Inlines)
    inline' :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    inline' = MuseParser m (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    whitespace
          MuseParser m (F Inlines)
    -> MuseParser m (F Inlines) -> MuseParser m (F Inlines)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> MuseParser m (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    br
          MuseParser m (F Inlines)
    -> MuseParser m (F Inlines) -> MuseParser m (F Inlines)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> MuseParser m (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    anchor
          MuseParser m (F Inlines)
    -> MuseParser m (F Inlines) -> MuseParser m (F Inlines)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> MuseParser m (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    footnote
          MuseParser m (F Inlines)
    -> MuseParser m (F Inlines) -> MuseParser m (F Inlines)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> MuseParser m (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    strongEmph
          MuseParser m (F Inlines)
    -> MuseParser m (F Inlines) -> MuseParser m (F Inlines)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> MuseParser m (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    strong
          MuseParser m (F Inlines)
    -> MuseParser m (F Inlines) -> MuseParser m (F Inlines)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> MuseParser m (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    strongTag
          MuseParser m (F Inlines)
    -> MuseParser m (F Inlines) -> MuseParser m (F Inlines)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> MuseParser m (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    emph
          MuseParser m (F Inlines)
    -> MuseParser m (F Inlines) -> MuseParser m (F Inlines)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> MuseParser m (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    emphTag
          MuseParser m (F Inlines)
    -> MuseParser m (F Inlines) -> MuseParser m (F Inlines)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> MuseParser m (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    underlined
          MuseParser m (F Inlines)
    -> MuseParser m (F Inlines) -> MuseParser m (F Inlines)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> MuseParser m (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    superscriptTag
          MuseParser m (F Inlines)
    -> MuseParser m (F Inlines) -> MuseParser m (F Inlines)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> MuseParser m (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    subscriptTag
          MuseParser m (F Inlines)
    -> MuseParser m (F Inlines) -> MuseParser m (F Inlines)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> MuseParser m (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    strikeoutTag
          MuseParser m (F Inlines)
    -> MuseParser m (F Inlines) -> MuseParser m (F Inlines)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> MuseParser m (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    verbatimTag
          MuseParser m (F Inlines)
    -> MuseParser m (F Inlines) -> MuseParser m (F Inlines)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> MuseParser m (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    classTag
          MuseParser m (F Inlines)
    -> MuseParser m (F Inlines) -> MuseParser m (F Inlines)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> MuseParser m (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    inlineRtl
          MuseParser m (F Inlines)
    -> MuseParser m (F Inlines) -> MuseParser m (F Inlines)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> MuseParser m (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    inlineLtr
          MuseParser m (F Inlines)
    -> MuseParser m (F Inlines) -> MuseParser m (F Inlines)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> MuseParser m (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    nbsp
          MuseParser m (F Inlines)
    -> MuseParser m (F Inlines) -> MuseParser m (F Inlines)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> MuseParser m (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    linkOrImage
          MuseParser m (F Inlines)
    -> MuseParser m (F Inlines) -> MuseParser m (F Inlines)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> MuseParser m (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    code
          MuseParser m (F Inlines)
    -> MuseParser m (F Inlines) -> MuseParser m (F Inlines)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> MuseParser m (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    codeTag
          MuseParser m (F Inlines)
    -> MuseParser m (F Inlines) -> MuseParser m (F Inlines)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> MuseParser m (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    mathTag
          MuseParser m (F Inlines)
    -> MuseParser m (F Inlines) -> MuseParser m (F Inlines)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> MuseParser m (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    inlineLiteralTag
          MuseParser m (F Inlines)
    -> MuseParser m (F Inlines) -> MuseParser m (F Inlines)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> MuseParser m (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    str
          MuseParser m (F Inlines)
    -> MuseParser m (F Inlines) -> MuseParser m (F Inlines)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> MuseParser m (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    asterisks
          MuseParser m (F Inlines)
    -> MuseParser m (F Inlines) -> MuseParser m (F Inlines)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> MuseParser m (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    symbol
          MuseParser m (F Inlines) -> SourceName -> MuseParser m (F Inlines)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> SourceName -> ParsecT s u m a
    <?> SourceName
    "inline"

    inline :: PandocMonad m => MuseParser m (F Inlines)
    inline :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    inline = MuseParser m (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    endline MuseParser m (F Inlines)
    -> MuseParser m (F Inlines) -> MuseParser m (F Inlines)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> MuseParser m (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    inline'

    -- | Parse a soft break.
    endline :: PandocMonad m => MuseParser m (F Inlines)
    endline :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    endline = ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b. (a -> b) -> a -> b
    $ Inlines -> F Inlines
    forall a. a -> Future MuseState a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Inlines
    B.softbreak F Inlines
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b.
    a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s u m Char
    newline ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) t a u.
    (Stream s m t, Show a) =>
    ParsecT s u m a -> ParsecT s u m ()
    notFollowedBy ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    blankline ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall (m :: * -> *). Monad m => MuseParser m ()
    updateLastSpacePos

    parseAnchor :: PandocMonad m => MuseParser m Text
    parseAnchor :: forall (m :: * -> *). PandocMonad m => MuseParser m Text
    parseAnchor = ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) Text
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall a b. (a -> b) -> a -> b
    $ Char -> Text -> Text
    T.cons
      (Char -> Text -> Text)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (Char -> Text -> Text)
    forall a b.
    a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$  ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall (m :: * -> *). PandocMonad m => MuseParser m ()
    firstColumn
      ParsecT
      Sources MuseState (ReaderT MuseEnv m) (Char -> Text -> Text)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (Char -> Text -> Text)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <*  Char -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    Char -> ParsecT s u m Char
    char Char
    '#'
      ParsecT
      Sources MuseState (ReaderT MuseEnv m) (Char -> Text -> Text)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (Text -> Text)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s u m Char
    letter
      ParsecT Sources MuseState (ReaderT MuseEnv m) (Text -> Text)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall s (m :: * -> *) t st.
    Stream s m t =>
    ParsecT s st m Char -> ParsecT s st m Text
    manyChar (ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s u m Char
    letter ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s u m Char
    digit ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> Char -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    Char -> ParsecT s u m Char
    char Char
    '-')

    anchor :: PandocMonad m => MuseParser m (F Inlines)
    anchor :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    anchor = ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b. (a -> b) -> a -> b
    $ do
      anchorId <- MuseParser m Text
    forall (m :: * -> *). PandocMonad m => MuseParser m Text
    parseAnchor
      skipMany spaceChar <|> void newline
      return $ return $ B.spanWith (anchorId, [], []) mempty

    -- | Parse a footnote reference.
    footnote :: PandocMonad m => MuseParser m (F Inlines)
    footnote :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    footnote = ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b. (a -> b) -> a -> b
    $ do
      inLink <- (MuseEnv -> Bool)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Bool
    forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
    asks MuseEnv -> Bool
    museInLink
      guard $ not inLink
      ref <- noteMarker
      return $ do
        notes <- asksF museNotes
        case M.lookup ref notes of
          Maybe (SourcePos, F Blocks)
    Nothing -> Inlines -> F Inlines
    forall a. a -> Future MuseState a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Inlines -> F Inlines) -> Inlines -> F Inlines
    forall a b. (a -> b) -> a -> b
    $ Text -> Inlines
    B.str Text
    ref
          Just (SourcePos
    _pos, F Blocks
    contents) -> do
            st <- Future MuseState MuseState
    forall s. Future s s
    askF
            let contents' = F Blocks -> MuseState -> Blocks
    forall s a. Future s a -> s -> a
    runF F Blocks
    contents MuseState
    st { museNotes = M.delete ref (museNotes st) }
            return $ B.note contents'

    whitespace :: PandocMonad m => MuseParser m (F Inlines)
    whitespace :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    whitespace = ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b. (a -> b) -> a -> b
    $ Inlines -> F Inlines
    forall a. a -> Future MuseState a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Inlines
    B.space F Inlines
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b.
    a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m ()
    skipMany1 ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    spaceChar ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall (m :: * -> *). Monad m => MuseParser m ()
    updateLastSpacePos

    -- | Parse @\<br>@ tag.
    br :: PandocMonad m => MuseParser m (F Inlines)
    br :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    br = ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b. (a -> b) -> a -> b
    $ Inlines -> F Inlines
    forall a. a -> Future MuseState a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Inlines
    B.linebreak F Inlines
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b.
    a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    SourceName -> ParsecT s u m SourceName
    string SourceName
    "<br>"

    emphasisBetween :: (PandocMonad m, Show a)
                    => MuseParser m a
                    -> MuseParser m (F Inlines)
    emphasisBetween :: forall (m :: * -> *) a.
    (PandocMonad m, Show a) =>
    MuseParser m a -> MuseParser m (F Inlines)
    emphasisBetween MuseParser m a
    p = ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b. (a -> b) -> a -> b
    $ F Inlines -> F Inlines
    forall s. Future s Inlines -> Future s Inlines
    trimInlinesF (F Inlines -> F Inlines)
    -> ([F Inlines] -> F Inlines) -> [F Inlines] -> F Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [F Inlines] -> F Inlines
    forall a. Monoid a => [a] -> a
    mconcat
      ([F Inlines] -> F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) ([F Inlines] -> F Inlines)
    forall a b.
    a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$  ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall (m :: * -> *). PandocMonad m => MuseParser m ()
    atStart
      ParsecT
      Sources MuseState (ReaderT MuseEnv m) ([F Inlines] -> F Inlines)
    -> MuseParser m a
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) ([F Inlines] -> F Inlines)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <*  MuseParser m a
    p
      ParsecT
      Sources MuseState (ReaderT MuseEnv m) ([F Inlines] -> F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) ([F Inlines] -> F Inlines)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <*  ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) t a u.
    (Stream s m t, Show a) =>
    ParsecT s u m a -> ParsecT s u m ()
    notFollowedBy ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s u m Char
    space
      ParsecT
      Sources MuseState (ReaderT MuseEnv m) ([F Inlines] -> F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [F Inlines]
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> MuseParser m a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [F Inlines]
    forall end s (m :: * -> *) t st a.
    (Show end, Stream s m t) =>
    ParsecT s st m a -> ParsecT s st m end -> ParsecT s st m [a]
    many1Till ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    inline (MuseParser m a -> MuseParser m a
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (MuseParser m a -> MuseParser m a)
    -> MuseParser m a -> MuseParser m a
    forall a b. (a -> b) -> a -> b
    $ ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall (m :: * -> *). PandocMonad m => MuseParser m ()
    noSpaceBefore ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> MuseParser m a -> MuseParser m a
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> MuseParser m a
    p MuseParser m a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> MuseParser m a
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) t a u.
    (Stream s m t, Show a) =>
    ParsecT s u m a -> ParsecT s u m ()
    notFollowedBy ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s u m Char
    alphaNum)

    -- | Parse an inline tag, such as @\<em>@ and @\<strong>@.
    inlineTag :: PandocMonad m
              => Text -- ^ Tag name
              -> MuseParser m (F Inlines)
    inlineTag :: forall (m :: * -> *).
    PandocMonad m =>
    Text -> MuseParser m (F Inlines)
    inlineTag Text
    tag = ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b. (a -> b) -> a -> b
    $ [F Inlines] -> F Inlines
    forall a. Monoid a => [a] -> a
    mconcat
      ([F Inlines] -> F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [(Text, Text)]
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) ([F Inlines] -> F Inlines)
    forall a b.
    a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$  Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [(Text, Text)]
    forall (m :: * -> *).
    PandocMonad m =>
    Text -> MuseParser m [(Text, Text)]
    openTag Text
    tag
      ParsecT
      Sources MuseState (ReaderT MuseEnv m) ([F Inlines] -> F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [F Inlines]
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [F Inlines]
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    manyTill ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    inline (Text -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall (m :: * -> *). PandocMonad m => Text -> MuseParser m ()
    closeTag Text
    tag)

    -- | Parse strong emphasis inline markup, indicated by @***@.
    strongEmph :: PandocMonad m => MuseParser m (F Inlines)
    strongEmph :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    strongEmph = (Inlines -> Inlines) -> F Inlines -> F Inlines
    forall a b. (a -> b) -> Future MuseState a -> Future MuseState b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (Inlines -> Inlines
    B.strong (Inlines -> Inlines) -> (Inlines -> Inlines) -> Inlines -> Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Inlines -> Inlines
    B.emph) (F Inlines -> F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> MuseParser m SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall (m :: * -> *) a.
    (PandocMonad m, Show a) =>
    MuseParser m a -> MuseParser m (F Inlines)
    emphasisBetween (SourceName -> MuseParser m SourceName
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    SourceName -> ParsecT s u m SourceName
    string SourceName
    "***" MuseParser m SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> MuseParser m SourceName
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv 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 Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    Char -> ParsecT s u m Char
    char Char
    '*'))

    -- | Parse strong inline markup, indicated by @**@.
    strong :: PandocMonad m => MuseParser m (F Inlines)
    strong :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    strong = (Inlines -> Inlines) -> F Inlines -> F Inlines
    forall a b. (a -> b) -> Future MuseState a -> Future MuseState b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Inlines -> Inlines
    B.strong (F Inlines -> F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> MuseParser m SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall (m :: * -> *) a.
    (PandocMonad m, Show a) =>
    MuseParser m a -> MuseParser m (F Inlines)
    emphasisBetween (SourceName -> MuseParser m SourceName
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    SourceName -> ParsecT s u m SourceName
    string SourceName
    "**" MuseParser m SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> MuseParser m SourceName
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv 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 Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    Char -> ParsecT s u m Char
    char Char
    '*'))

    -- | Parse emphasis inline markup, indicated by @*@.
    emph :: PandocMonad m => MuseParser m (F Inlines)
    emph :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    emph = (Inlines -> Inlines) -> F Inlines -> F Inlines
    forall a b. (a -> b) -> Future MuseState a -> Future MuseState b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Inlines -> Inlines
    B.emph (F Inlines -> F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> MuseParser m Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall (m :: * -> *) a.
    (PandocMonad m, Show a) =>
    MuseParser m a -> MuseParser m (F Inlines)
    emphasisBetween (Char -> MuseParser m Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    Char -> ParsecT s u m Char
    char Char
    '*' MuseParser m Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> MuseParser m Char
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* MuseParser m Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) t a u.
    (Stream s m t, Show a) =>
    ParsecT s u m a -> ParsecT s u m ()
    notFollowedBy (Char -> MuseParser m Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    Char -> ParsecT s u m Char
    char Char
    '*'))

    -- | Parse underline inline markup, indicated by @_@.
    -- Supported only in Emacs Muse mode, not Text::Amuse.
    underlined :: PandocMonad m => MuseParser m (F Inlines)
    underlined :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    underlined = (Inlines -> Inlines) -> F Inlines -> F Inlines
    forall a b. (a -> b) -> Future MuseState a -> Future MuseState b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Inlines -> Inlines
    underline
      (F Inlines -> F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (F Inlines -> F Inlines)
    forall a b.
    a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$  Extension -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) a st.
    (Stream s m a, HasReaderOptions st) =>
    Extension -> ParsecT s st m ()
    guardDisabled Extension
    Ext_amuse -- Supported only by Emacs Muse
      ParsecT
      Sources MuseState (ReaderT MuseEnv m) (F Inlines -> F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> MuseParser m Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall (m :: * -> *) a.
    (PandocMonad m, Show a) =>
    MuseParser m a -> MuseParser m (F Inlines)
    emphasisBetween (Char -> MuseParser m Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    Char -> ParsecT s u m Char
    char Char
    '_')

    -- | Parse @\<strong>@ tag.
    strongTag :: PandocMonad m => MuseParser m (F Inlines)
    strongTag :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    strongTag = (Inlines -> Inlines) -> F Inlines -> F Inlines
    forall a b. (a -> b) -> Future MuseState a -> Future MuseState b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Inlines -> Inlines
    B.strong (F Inlines -> F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Text -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall (m :: * -> *).
    PandocMonad m =>
    Text -> MuseParser m (F Inlines)
    inlineTag Text
    "strong"

    -- | Parse @\<em>@ tag.
    emphTag :: PandocMonad m => MuseParser m (F Inlines)
    emphTag :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    emphTag = (Inlines -> Inlines) -> F Inlines -> F Inlines
    forall a b. (a -> b) -> Future MuseState a -> Future MuseState b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Inlines -> Inlines
    B.emph (F Inlines -> F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Text -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall (m :: * -> *).
    PandocMonad m =>
    Text -> MuseParser m (F Inlines)
    inlineTag Text
    "em"

    -- | Parse @\<sup>@ tag.
    superscriptTag :: PandocMonad m => MuseParser m (F Inlines)
    superscriptTag :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    superscriptTag = (Inlines -> Inlines) -> F Inlines -> F Inlines
    forall a b. (a -> b) -> Future MuseState a -> Future MuseState b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Inlines -> Inlines
    B.superscript (F Inlines -> F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Text -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall (m :: * -> *).
    PandocMonad m =>
    Text -> MuseParser m (F Inlines)
    inlineTag Text
    "sup"

    -- | Parse @\<sub>@ tag.
    subscriptTag :: PandocMonad m => MuseParser m (F Inlines)
    subscriptTag :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    subscriptTag = (Inlines -> Inlines) -> F Inlines -> F Inlines
    forall a b. (a -> b) -> Future MuseState a -> Future MuseState b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Inlines -> Inlines
    B.subscript (F Inlines -> F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Text -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall (m :: * -> *).
    PandocMonad m =>
    Text -> MuseParser m (F Inlines)
    inlineTag Text
    "sub"

    -- | Parse @\<del>@ tag.
    strikeoutTag :: PandocMonad m => MuseParser m (F Inlines)
    strikeoutTag :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    strikeoutTag = (Inlines -> Inlines) -> F Inlines -> F Inlines
    forall a b. (a -> b) -> Future MuseState a -> Future MuseState b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Inlines -> Inlines
    B.strikeout (F Inlines -> F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Text -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall (m :: * -> *).
    PandocMonad m =>
    Text -> MuseParser m (F Inlines)
    inlineTag Text
    "del"

    -- | Parse @\<verbatim>@ tag.
    verbatimTag :: PandocMonad m => MuseParser m (F Inlines)
    verbatimTag :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    verbatimTag = Inlines -> F Inlines
    forall a. a -> Future MuseState a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Inlines -> F Inlines) -> (Text -> Inlines) -> Text -> F Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Inlines
    B.text
      (Text -> F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [(Text, Text)]
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (Text -> F Inlines)
    forall a b.
    a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$  Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [(Text, Text)]
    forall (m :: * -> *).
    PandocMonad m =>
    Text -> MuseParser m [(Text, Text)]
    openTag Text
    "verbatim"
      ParsecT Sources MuseState (ReaderT MuseEnv m) (Text -> F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall s (m :: * -> *) t st a.
    Stream s m t =>
    ParsecT s st m Char -> ParsecT s st m a -> ParsecT s st m Text
    manyTillChar ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s u m Char
    anyChar (Text -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall (m :: * -> *). PandocMonad m => Text -> MuseParser m ()
    closeTag Text
    "verbatim")

    -- | Parse @\<class>@ tag.
    classTag :: PandocMonad m => MuseParser m (F Inlines)
    classTag :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    classTag = do
      classes <- [Text] -> (Text -> [Text]) -> Maybe Text -> [Text]
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe [] Text -> [Text]
    T.words (Maybe Text -> [Text])
    -> ([(Text, Text)] -> Maybe Text) -> [(Text, Text)] -> [Text]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> [(Text, Text)] -> Maybe Text
    forall a b. Eq a => a -> [(a, b)] -> Maybe b
    lookup Text
    "name" ([(Text, Text)] -> [Text])
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [(Text, Text)]
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [Text]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [(Text, Text)]
    forall (m :: * -> *).
    PandocMonad m =>
    Text -> MuseParser m [(Text, Text)]
    openTag Text
    "class"
      fmap (B.spanWith ("", classes, [])) . mconcat <$> manyTill inline (closeTag "class")

    -- | Parse @\<\<\<RTL>>>@ text.
    inlineRtl :: PandocMonad m => MuseParser m (F Inlines)
    inlineRtl :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    inlineRtl = ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b. (a -> b) -> a -> b
    $
      (Inlines -> Inlines) -> F Inlines -> F Inlines
    forall a b. (a -> b) -> Future MuseState a -> Future MuseState b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (Attr -> Inlines -> Inlines
    B.spanWith (Text
    "", [], [(Text
    "dir", Text
    "rtl")])) (F Inlines -> F Inlines)
    -> ([F Inlines] -> F Inlines) -> [F Inlines] -> F Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [F Inlines] -> F Inlines
    forall a. Monoid a => [a] -> a
    mconcat ([F Inlines] -> F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) ([F Inlines] -> F Inlines)
    forall a b.
    a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    SourceName -> ParsecT s u m SourceName
    string SourceName
    "<<<" ParsecT
      Sources MuseState (ReaderT MuseEnv m) ([F Inlines] -> F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [F Inlines]
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [F Inlines]
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    manyTill ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    inline (SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    SourceName -> ParsecT s u m SourceName
    string SourceName
    ">>>")

    -- | Parse @\<\<\<LTR>>>@ text.
    inlineLtr :: PandocMonad m => MuseParser m (F Inlines)
    inlineLtr :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    inlineLtr = ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b. (a -> b) -> a -> b
    $
      (Inlines -> Inlines) -> F Inlines -> F Inlines
    forall a b. (a -> b) -> Future MuseState a -> Future MuseState b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (Attr -> Inlines -> Inlines
    B.spanWith (Text
    "", [], [(Text
    "dir", Text
    "ltr")])) (F Inlines -> F Inlines)
    -> ([F Inlines] -> F Inlines) -> [F Inlines] -> F Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [F Inlines] -> F Inlines
    forall a. Monoid a => [a] -> a
    mconcat ([F Inlines] -> F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) ([F Inlines] -> F Inlines)
    forall a b.
    a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    SourceName -> ParsecT s u m SourceName
    string SourceName
    ">>>" ParsecT
      Sources MuseState (ReaderT MuseEnv m) ([F Inlines] -> F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [F Inlines]
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [F Inlines]
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    manyTill ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    inline (SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    SourceName -> ParsecT s u m SourceName
    string SourceName
    "<<<")

    -- | Parse "~~" as nonbreaking space.
    nbsp :: PandocMonad m => MuseParser m (F Inlines)
    nbsp :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    nbsp = ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b. (a -> b) -> a -> b
    $ Inlines -> F Inlines
    forall a. a -> Future MuseState a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Text -> Inlines
    B.str Text
    "\160") F Inlines
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b.
    a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    SourceName -> ParsecT s u m SourceName
    string SourceName
    "~~"

    -- | Parse code markup, indicated by @\'=\'@ characters.
    code :: PandocMonad m => MuseParser m (F Inlines)
    code :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    code = ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b. (a -> b) -> a -> b
    $ (Inlines -> F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Inlines
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b.
    (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Inlines -> F Inlines
    forall a. a -> Future MuseState a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (ParsecT Sources MuseState (ReaderT MuseEnv m) Inlines
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Inlines
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b. (a -> b) -> a -> b
    $ Text -> Inlines
    B.code (Text -> Inlines)
    -> ((Text, Text) -> Text) -> (Text, Text) -> Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Text -> Text -> Text) -> (Text, Text) -> Text
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    (<>)
      ((Text, Text) -> Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) ((Text, Text) -> Inlines)
    forall a b.
    a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$  ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall (m :: * -> *). PandocMonad m => MuseParser m ()
    atStart
      ParsecT
      Sources MuseState (ReaderT MuseEnv m) ((Text, Text) -> Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) ((Text, Text) -> Inlines)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <*  Char -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    Char -> ParsecT s u m Char
    char Char
    '='
      ParsecT
      Sources MuseState (ReaderT MuseEnv m) ((Text, Text) -> Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) ((Text, Text) -> Inlines)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <*  ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) t a u.
    (Stream s m t, Show a) =>
    ParsecT s u m a -> ParsecT s u m ()
    notFollowedBy (ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    spaceChar ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s u m Char
    newline)
      ParsecT
      Sources MuseState (ReaderT MuseEnv m) ((Text, Text) -> Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (Text, Text)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Inlines
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (Text, Text)
    forall s u (m :: * -> *) b.
    ParsecT s u m Char -> ParsecT s u m b -> ParsecT s u m (Text, b)
    manyUntilChar (SourceName -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    SourceName -> ParsecT s u m Char
    noneOf SourceName
    "\n\r" ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> (ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s u m Char
    newline ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) t a u.
    (Stream s m t, Show a) =>
    ParsecT s u m a -> ParsecT s u m ()
    notFollowedBy ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s u m Char
    newline)) (ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) Text
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall a b. (a -> b) -> a -> b
    $ (Char -> Text)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall a b.
    (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Char -> Text
    T.singleton (ParsecT Sources MuseState (ReaderT MuseEnv m) Char
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall a b. (a -> b) -> a -> b
    $ SourceName -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    SourceName -> ParsecT s u m Char
    noneOf SourceName
    " \t\n\r=" ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* Char -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    Char -> ParsecT s u m Char
    char Char
    '=')
      ParsecT Sources MuseState (ReaderT MuseEnv m) Inlines
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Inlines
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <*  ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) t a u.
    (Stream s m t, Show a) =>
    ParsecT s u m a -> ParsecT s u m ()
    notFollowedBy ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s u m Char
    alphaNum

    -- | Parse @\<code>@ tag.
    codeTag :: PandocMonad m => MuseParser m (F Inlines)
    codeTag :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    codeTag = (Inlines -> F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Inlines
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b.
    (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Inlines -> F Inlines
    forall a. a -> Future MuseState a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (ParsecT Sources MuseState (ReaderT MuseEnv m) Inlines
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Inlines
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b. (a -> b) -> a -> b
    $ Attr -> Text -> Inlines
    B.codeWith
      (Attr -> Text -> Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Attr
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (Text -> Inlines)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ([(Text, Text)] -> Attr
    htmlAttrToPandoc ([(Text, Text)] -> Attr)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [(Text, Text)]
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Attr
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [(Text, Text)]
    forall (m :: * -> *).
    PandocMonad m =>
    Text -> MuseParser m [(Text, Text)]
    openTag Text
    "code")
      ParsecT Sources MuseState (ReaderT MuseEnv m) (Text -> Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Inlines
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall s (m :: * -> *) t st a.
    Stream s m t =>
    ParsecT s st m Char -> ParsecT s st m a -> ParsecT s st m Text
    manyTillChar ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s u m Char
    anyChar (Text -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall (m :: * -> *). PandocMonad m => Text -> MuseParser m ()
    closeTag Text
    "code")

    -- | Parse @\<math>@ tag.
    -- @\<math>@ tag is an Emacs Muse extension enabled by @(require 'muse-latex2png)@
    mathTag :: PandocMonad m => MuseParser m (F Inlines)
    mathTag :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    mathTag = Inlines -> F Inlines
    forall a. a -> Future MuseState a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Inlines -> F Inlines) -> (Text -> Inlines) -> Text -> F Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Inlines
    B.math
      (Text -> F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [(Text, Text)]
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) (Text -> F Inlines)
    forall a b.
    a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$  Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [(Text, Text)]
    forall (m :: * -> *).
    PandocMonad m =>
    Text -> MuseParser m [(Text, Text)]
    openTag Text
    "math"
      ParsecT Sources MuseState (ReaderT MuseEnv m) (Text -> F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall s (m :: * -> *) t st a.
    Stream s m t =>
    ParsecT s st m Char -> ParsecT s st m a -> ParsecT s st m Text
    manyTillChar ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s u m Char
    anyChar (Text -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall (m :: * -> *). PandocMonad m => Text -> MuseParser m ()
    closeTag Text
    "math")

    -- | Parse inline @\<literal>@ tag as a raw inline.
    inlineLiteralTag :: PandocMonad m => MuseParser m (F Inlines)
    inlineLiteralTag :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    inlineLiteralTag = ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b. (a -> b) -> a -> b
    $ (Inlines -> F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Inlines
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b.
    (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Inlines -> F Inlines
    forall a. a -> Future MuseState a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (ParsecT Sources MuseState (ReaderT MuseEnv m) Inlines
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Inlines
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b. (a -> b) -> a -> b
    $ Text -> Text -> Inlines
    B.rawInline
      (Text -> Text -> Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (Text -> Inlines)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Text -> Maybe Text -> Text
    forall a. a -> Maybe a -> a
    fromMaybe Text
    "html" (Maybe Text -> Text)
    -> ([(Text, Text)] -> Maybe Text) -> [(Text, Text)] -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> [(Text, Text)] -> Maybe Text
    forall a b. Eq a => a -> [(a, b)] -> Maybe b
    lookup Text
    "style" ([(Text, Text)] -> Text)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [(Text, Text)]
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [(Text, Text)]
    forall (m :: * -> *).
    PandocMonad m =>
    Text -> MuseParser m [(Text, Text)]
    openTag Text
    "literal") -- FIXME: Emacs Muse inserts <literal> without style into all output formats, but we assume HTML
      ParsecT Sources MuseState (ReaderT MuseEnv m) (Text -> Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Inlines
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall s (m :: * -> *) t st a.
    Stream s m t =>
    ParsecT s st m Char -> ParsecT s st m a -> ParsecT s st m Text
    manyTillChar ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s u m Char
    anyChar (Text -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall (m :: * -> *). PandocMonad m => Text -> MuseParser m ()
    closeTag Text
    "literal")

    str :: PandocMonad m => MuseParser m (F Inlines)
    str :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    str = Inlines -> F Inlines
    forall a. a -> Future MuseState a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Inlines -> F Inlines) -> (Text -> Inlines) -> Text -> F Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Inlines
    B.str (Text -> F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall s (m :: * -> *) t st.
    Stream s m t =>
    ParsecT s st m Char -> ParsecT s st m Text
    many1Char ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s u m Char
    alphaNum ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT Sources MuseState (ReaderT MuseEnv m) ()
    forall s (m :: * -> *) a st.
    (Stream s m a, HasLastStrPosition st) =>
    ParsecT s st m ()
    updateLastStrPos

    -- | Consume asterisks that were not used as emphasis opening.
    -- This prevents series of asterisks from being split into
    -- literal asterisk and emphasis opening.
    asterisks :: PandocMonad m => MuseParser m (F Inlines)
    asterisks :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    asterisks = Inlines -> F Inlines
    forall a. a -> Future MuseState a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Inlines -> F Inlines) -> (Text -> Inlines) -> Text -> F Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Inlines
    B.str (Text -> F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Text
    forall s (m :: * -> *) t st.
    Stream s m t =>
    ParsecT s st m Char -> ParsecT s st m Text
    many1Char (Char -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    Char -> ParsecT s u m Char
    char Char
    '*')

    symbol :: PandocMonad m => MuseParser m (F Inlines)
    symbol :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    symbol = Inlines -> F Inlines
    forall a. a -> Future MuseState a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Inlines -> F Inlines) -> (Char -> Inlines) -> Char -> F Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Inlines
    B.str (Text -> Inlines) -> (Char -> Text) -> Char -> Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Char -> Text
    T.singleton (Char -> F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    nonspaceChar

    -- | Parse a link or image.
    linkOrImage :: PandocMonad m => MuseParser m (F Inlines)
    linkOrImage :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    linkOrImage = ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b. (a -> b) -> a -> b
    $ Text -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall (m :: * -> *).
    PandocMonad m =>
    Text -> MuseParser m (F Inlines)
    link Text
    "URL:" ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    image ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> Text -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall (m :: * -> *).
    PandocMonad m =>
    Text -> MuseParser m (F Inlines)
    link Text
    ""

    linkContent :: PandocMonad m => MuseParser m (F Inlines)
    linkContent :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    linkContent = F Inlines -> F Inlines
    forall s. Future s Inlines -> Future s Inlines
    trimInlinesF (F Inlines -> F Inlines)
    -> ([F Inlines] -> F Inlines) -> [F Inlines] -> F Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [F Inlines] -> F Inlines
    forall a. Monoid a => [a] -> a
    mconcat
      ([F Inlines] -> F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT
         Sources MuseState (ReaderT MuseEnv m) ([F Inlines] -> F Inlines)
    forall a b.
    a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$  Char -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    Char -> ParsecT s u m Char
    char Char
    '['
      ParsecT
      Sources MuseState (ReaderT MuseEnv m) ([F Inlines] -> F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [F Inlines]
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) (a -> b)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) [F Inlines]
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    manyTill ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    inline (Char -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    Char -> ParsecT s u m Char
    char Char
    ']')

    -- | Parse a link starting with (possibly null) prefix
    link :: PandocMonad m => Text -> MuseParser m (F Inlines)
    link :: forall (m :: * -> *).
    PandocMonad m =>
    Text -> MuseParser m (F Inlines)
    link Text
    prefix = ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b. (a -> b) -> a -> b
    $ do
      inLink <- (MuseEnv -> Bool)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Bool
    forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
    asks MuseEnv -> Bool
    museInLink
      guard $ not inLink
      textStr $ "[[" <> prefix
      url <- manyTillChar anyChar $ char ']'
      content <- option (pure $ B.str url) (local (\MuseEnv
    s -> MuseEnv
    s { museInLink = True }) linkContent)
      char ']'
      return $ B.link url "" <$> content

    image :: PandocMonad m => MuseParser m (F Inlines)
    image :: forall (m :: * -> *). PandocMonad m => MuseParser m (F Inlines)
    image = ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
     -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines))
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) (F Inlines)
    forall a b. (a -> b) -> a -> b
    $ do
      SourceName
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) SourceName
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    SourceName -> ParsecT s u m SourceName
    string SourceName
    "[["
      (url, (ext, width, align)) <- ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT
         Sources
         MuseState
         (ReaderT MuseEnv m)
         (Text, Maybe Text, Maybe Char)
    -> ParsecT
         Sources
         MuseState
         (ReaderT MuseEnv m)
         (Text, (Text, Maybe Text, Maybe Char))
    forall s u (m :: * -> *) b.
    ParsecT s u m Char -> ParsecT s u m b -> ParsecT s u m (Text, b)
    manyUntilChar (SourceName -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    SourceName -> ParsecT s u m Char
    noneOf SourceName
    "]") (ParsecT
      Sources
      MuseState
      (ReaderT MuseEnv m)
      (Text, Maybe Text, Maybe Char)
    forall {u}.
    ParsecT
      Sources u (ReaderT MuseEnv m) (Text, Maybe Text, Maybe Char)
    imageExtensionAndOptions ParsecT
      Sources
      MuseState
      (ReaderT MuseEnv m)
      (Text, Maybe Text, Maybe Char)
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    -> ParsecT
         Sources
         MuseState
         (ReaderT MuseEnv m)
         (Text, Maybe Text, Maybe Char)
    forall a b.
    ParsecT Sources MuseState (ReaderT MuseEnv m) a
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) b
    -> ParsecT Sources MuseState (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* Char -> ParsecT Sources MuseState (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    Char -> ParsecT s u m Char
    char Char
    ']')
      content <- option mempty linkContent
      char ']'
      let widthAttr = case Maybe Char
    align of
                        Just Char
    'f' -> [(Text
    "width", Text -> Maybe Text -> Text
    forall a. a -> Maybe a -> a
    fromMaybe Text
    "100" Maybe Text
    width Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Text
    "%"), (Text
    "height", Text
    "75%")]
                        Maybe Char
    _ -> Maybe (Text, Text) -> [(Text, Text)]
    forall a. Maybe a -> [a]
    maybeToList ((Text
    "width",) (Text -> (Text, Text)) -> (Text -> Text) -> Text -> (Text, Text)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Text
    "%") (Text -> (Text, Text)) -> Maybe Text -> Maybe (Text, Text)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe Text
    width)
      let alignClass = case Maybe Char
    align of
                         Just Char
    'r' -> [Text
    "align-right"]
                         Just Char
    'l' -> [Text
    "align-left"]
                         Just Char
    'f' -> []
                         Maybe Char
    _        -> []
      return $ B.imageWith ("", alignClass, widthAttr) (url <> ext) mempty <$> content
      where -- Taken from muse-image-regexp defined in Emacs Muse file lisp/muse-regexps.el
            imageExtensions :: [Text]
    imageExtensions = [Text
    ".eps", Text
    ".gif", Text
    ".jpg", Text
    ".jpeg", Text
    ".pbm", Text
    ".png", Text
    ".tiff", Text
    ".xbm", Text
    ".xpm"]
            imageExtension :: ParsecT Sources u (ReaderT MuseEnv m) Text
    imageExtension = [ParsecT Sources u (ReaderT MuseEnv m) Text]
    -> ParsecT Sources u (ReaderT MuseEnv m) Text
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    [ParsecT s u m a] -> ParsecT s u m a
    choice (ParsecT Sources u (ReaderT MuseEnv m) Text
    -> ParsecT Sources u (ReaderT MuseEnv m) Text
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Sources u (ReaderT MuseEnv m) Text
     -> ParsecT Sources u (ReaderT MuseEnv m) Text)
    -> (Text -> ParsecT Sources u (ReaderT MuseEnv m) Text)
    -> Text
    -> ParsecT Sources u (ReaderT MuseEnv m) Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> ParsecT Sources u (ReaderT MuseEnv m) Text
    forall s (m :: * -> *) u.
    (Stream s m Char, UpdateSourcePos s Char) =>
    Text -> ParsecT s u m Text
    textStr (Text -> ParsecT Sources u (ReaderT MuseEnv m) Text)
    -> [Text] -> [ParsecT Sources u (ReaderT MuseEnv m) Text]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> [Text]
    imageExtensions)
            imageExtensionAndOptions :: ParsecT
      Sources u (ReaderT MuseEnv m) (Text, Maybe Text, Maybe Char)
    imageExtensionAndOptions = do
              ext <- ParsecT Sources u (ReaderT MuseEnv m) Text
    forall {u}. ParsecT Sources u (ReaderT MuseEnv m) Text
    imageExtension
              (width, align) <- option (Nothing, Nothing) imageAttrs
              return (ext, width, align)
            imageAttrs :: ParsecT Sources u (ReaderT MuseEnv m) (Maybe Text, Maybe Char)
    imageAttrs = (,)
              (Maybe Text -> Maybe Char -> (Maybe Text, Maybe Char))
    -> ParsecT Sources u (ReaderT MuseEnv m) SourceName
    -> ParsecT
         Sources
         u
         (ReaderT MuseEnv m)
         (Maybe Text -> Maybe Char -> (Maybe Text, Maybe Char))
    forall a b.
    a
    -> ParsecT Sources u (ReaderT MuseEnv m) b
    -> ParsecT Sources u (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$  ParsecT Sources u (ReaderT MuseEnv m) Char
    -> ParsecT Sources u (ReaderT MuseEnv m) SourceName
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many1 ParsecT Sources u (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    spaceChar
              ParsecT
      Sources
      u
      (ReaderT MuseEnv m)
      (Maybe Text -> Maybe Char -> (Maybe Text, Maybe Char))
    -> ParsecT Sources u (ReaderT MuseEnv m) (Maybe Text)
    -> ParsecT
         Sources
         u
         (ReaderT MuseEnv m)
         (Maybe Char -> (Maybe Text, Maybe Char))
    forall a b.
    ParsecT Sources u (ReaderT MuseEnv m) (a -> b)
    -> ParsecT Sources u (ReaderT MuseEnv m) a
    -> ParsecT Sources u (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ParsecT Sources u (ReaderT MuseEnv m) Text
    -> ParsecT Sources u (ReaderT MuseEnv m) (Maybe Text)
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m (Maybe a)
    optionMaybe (ParsecT Sources u (ReaderT MuseEnv m) Char
    -> ParsecT Sources u (ReaderT MuseEnv m) Text
    forall s (m :: * -> *) t st.
    Stream s m t =>
    ParsecT s st m Char -> ParsecT s st m Text
    many1Char ParsecT Sources u (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s u m Char
    digit)
              ParsecT
      Sources
      u
      (ReaderT MuseEnv m)
      (Maybe Char -> (Maybe Text, Maybe Char))
    -> ParsecT Sources u (ReaderT MuseEnv m) SourceName
    -> ParsecT
         Sources
         u
         (ReaderT MuseEnv m)
         (Maybe Char -> (Maybe Text, Maybe Char))
    forall a b.
    ParsecT Sources u (ReaderT MuseEnv m) a
    -> ParsecT Sources u (ReaderT MuseEnv m) b
    -> ParsecT Sources u (ReaderT MuseEnv m) a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <*  ParsecT Sources u (ReaderT MuseEnv m) Char
    -> ParsecT Sources u (ReaderT MuseEnv m) SourceName
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many ParsecT Sources u (ReaderT MuseEnv m) Char
    forall s (m :: * -> *) st.
    (Stream s m Char, UpdateSourcePos s Char) =>
    ParsecT s st m Char
    spaceChar
              ParsecT
      Sources
      u
      (ReaderT MuseEnv m)
      (Maybe Char -> (Maybe Text, Maybe Char))
    -> ParsecT Sources u (ReaderT MuseEnv m) (Maybe Char)
    -> ParsecT Sources u (ReaderT MuseEnv m) (Maybe Text, Maybe Char)
    forall a b.
    ParsecT Sources u (ReaderT MuseEnv m) (a -> b)
    -> ParsecT Sources u (ReaderT MuseEnv m) a
    -> ParsecT Sources u (ReaderT MuseEnv m) b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ParsecT Sources u (ReaderT MuseEnv m) Char
    -> ParsecT Sources u (ReaderT MuseEnv m) (Maybe Char)
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m (Maybe a)
    optionMaybe (SourceName -> ParsecT Sources u (ReaderT MuseEnv m) Char
    forall (m :: * -> *) s u.
    (Monad m, Stream s m Char, UpdateSourcePos s Char) =>
    SourceName -> ParsecT s u m Char
    oneOf SourceName
    "rlf")