    {-# LANGUAGE FlexibleInstances     #-}
    {-# LANGUAGE FlexibleContexts      #-}
    {-# LANGUAGE LambdaCase            #-}
    {-# LANGUAGE BangPatterns          #-}
    {-# LANGUAGE MultiParamTypeClasses #-}
    {-# LANGUAGE OverloadedStrings     #-}
    {-# LANGUAGE ScopedTypeVariables   #-}
    {- |
       Module      : Text.Pandoc.Readers.LaTeX.Parsing
       Copyright   : Copyright (C) 2006-2024 John MacFarlane
       License     : GNU GPL, version 2 or above

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

    General parsing types and functions for LaTeX.
    -}
    module Text.Pandoc.Readers.LaTeX.Parsing
      ( DottedNum(..)
      , renderDottedNum
      , incrementDottedNum
      , TheoremSpec(..)
      , TheoremStyle(..)
      , LaTeXState(..)
      , defaultLaTeXState
      , LP
      , TokStream(..)
      , withVerbatimMode
      , rawLaTeXParser
      , applyMacros
      , tokenize
      , tokenizeSources
      , getInputTokens
      , untokenize
      , untoken
      , satisfyTok
      , peekTok
      , parseFromToks
      , disablingWithRaw
      , doMacros
      , doMacros'
      , setpos
      , anyControlSeq
      , anySymbol
      , isNewlineTok
      , isWordTok
      , isArgTok
      , infile
      , spaces
      , spaces1
      , tokTypeIn
      , controlSeq
      , symbol
      , symbolIn
      , sp
      , whitespace
      , newlineTok
      , comment
      , anyTok
      , singleChar
      , tokWith
      , specialChars
      , endline
      , blankline
      , primEscape
      , bgroup
      , egroup
      , grouped
      , braced
      , braced'
      , bracedUrl
      , bracedOrToken
      , bracketed
      , bracketedToks
      , parenWrapped
      , dimenarg
      , ignore
      , withRaw
      , keyvals
      , verbEnv
      , begin_
      , end_
      , getRawCommand
      , skipopts
      , rawopt
      , overlaySpecification
      , getNextNumber
      , label
      , setCaption
      , resetCaption
      , env
      , addMeta
      , removeLabel
      ) where

    import Control.Applicative (many, (<|>))
    import Control.Monad
    import Control.Monad.Except (throwError)
    import Control.Monad.Trans (lift)
    import Data.Char (chr, isAlphaNum, isDigit, isLetter, ord)
    import Data.Default
    import Data.List (intercalate)
    import qualified Data.IntMap as IntMap
    import qualified Data.Map as M
    import qualified Data.Set as Set
    import Data.Text (Text)
    import Data.Maybe (fromMaybe)
    import Data.List.NonEmpty (NonEmpty(..))
    import qualified Data.List.NonEmpty as NonEmpty
    import qualified Data.Text as T
    import Text.Pandoc.Builder
    import Text.Pandoc.Class.PandocMonad (PandocMonad, report)
    import Text.Pandoc.Error
             (PandocError (PandocMacroLoop,PandocShouldNeverHappenError))
    import Text.Pandoc.Logging
    import Text.Pandoc.Options
    import Text.Pandoc.Parsing hiding (blankline, many, mathDisplay, mathInline,
                                space, spaces, withRaw, (<|>))
    import Text.Pandoc.TeX (ExpansionPoint (..), Macro (..),
                                            ArgSpec (..), Tok (..), TokType (..))
    import Text.Pandoc.Shared
    import Text.Pandoc.Walk

    newtype DottedNum = DottedNum [Int]
      deriving (Int -> DottedNum -> ShowS
    [DottedNum] -> ShowS
    DottedNum -> [Char]
    (Int -> DottedNum -> ShowS)
    -> (DottedNum -> [Char])
    -> ([DottedNum] -> ShowS)
    -> Show DottedNum
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DottedNum -> ShowS
    showsPrec :: Int -> DottedNum -> ShowS
    $cshow :: DottedNum -> [Char]
    show :: DottedNum -> [Char]
    $cshowList :: [DottedNum] -> ShowS
    showList :: [DottedNum] -> ShowS
    Show, DottedNum -> DottedNum -> Bool
    (DottedNum -> DottedNum -> Bool)
    -> (DottedNum -> DottedNum -> Bool) -> Eq DottedNum
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DottedNum -> DottedNum -> Bool
    == :: DottedNum -> DottedNum -> Bool
    $c/= :: DottedNum -> DottedNum -> Bool
    /= :: DottedNum -> DottedNum -> Bool
    Eq)

    renderDottedNum :: DottedNum -> T.Text
    renderDottedNum :: DottedNum -> Text
    renderDottedNum (DottedNum [Int]
    xs) = [Char] -> Text
    T.pack ([Char] -> Text) -> [Char] -> Text
    forall a b. (a -> b) -> a -> b
    $
      [Char] -> [[Char]] -> [Char]
    forall a. [a] -> [[a]] -> [a]
    intercalate [Char]
    "." ((Int -> [Char]) -> [Int] -> [[Char]]
    forall a b. (a -> b) -> [a] -> [b]
    map Int -> [Char]
    forall a. Show a => a -> [Char]
    show [Int]
    xs)

    incrementDottedNum :: Int -> DottedNum -> DottedNum
    incrementDottedNum :: Int -> DottedNum -> DottedNum
    incrementDottedNum Int
    level (DottedNum [Int]
    ns) = [Int] -> DottedNum
    DottedNum ([Int] -> DottedNum) -> [Int] -> DottedNum
    forall a b. (a -> b) -> a -> b
    $
      case [Int] -> [Int]
    forall a. [a] -> [a]
    reverse (Int -> [Int] -> [Int]
    forall a. Int -> [a] -> [a]
    take Int
    level ([Int]
    ns [Int] -> [Int] -> [Int]
    forall a. [a] -> [a] -> [a]
    ++ Int -> [Int]
    forall a. a -> [a]
    repeat Int
    0)) of
           (Int
    x:[Int]
    xs) -> [Int] -> [Int]
    forall a. [a] -> [a]
    reverse (Int
    xInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    1 Int -> [Int] -> [Int]
    forall a. a -> [a] -> [a]
    : [Int]
    xs)
           []     -> []  -- shouldn't happen

    data TheoremStyle =
      PlainStyle | DefinitionStyle | RemarkStyle
      deriving (Int -> TheoremStyle -> ShowS
    [TheoremStyle] -> ShowS
    TheoremStyle -> [Char]
    (Int -> TheoremStyle -> ShowS)
    -> (TheoremStyle -> [Char])
    -> ([TheoremStyle] -> ShowS)
    -> Show TheoremStyle
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> TheoremStyle -> ShowS
    showsPrec :: Int -> TheoremStyle -> ShowS
    $cshow :: TheoremStyle -> [Char]
    show :: TheoremStyle -> [Char]
    $cshowList :: [TheoremStyle] -> ShowS
    showList :: [TheoremStyle] -> ShowS
    Show, TheoremStyle -> TheoremStyle -> Bool
    (TheoremStyle -> TheoremStyle -> Bool)
    -> (TheoremStyle -> TheoremStyle -> Bool) -> Eq TheoremStyle
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: TheoremStyle -> TheoremStyle -> Bool
    == :: TheoremStyle -> TheoremStyle -> Bool
    $c/= :: TheoremStyle -> TheoremStyle -> Bool
    /= :: TheoremStyle -> TheoremStyle -> Bool
    Eq)

    data TheoremSpec =
      TheoremSpec
        { TheoremSpec -> [Tok]
    theoremName    :: [Tok]
        , TheoremSpec -> TheoremStyle
    theoremStyle   :: TheoremStyle
        , TheoremSpec -> Maybe Text
    theoremSeries  :: Maybe Text
        , TheoremSpec -> Maybe Text
    theoremSyncTo  :: Maybe Text
        , TheoremSpec -> Bool
    theoremNumber  :: Bool
        , TheoremSpec -> DottedNum
    theoremLastNum :: DottedNum }
        deriving (Int -> TheoremSpec -> ShowS
    [TheoremSpec] -> ShowS
    TheoremSpec -> [Char]
    (Int -> TheoremSpec -> ShowS)
    -> (TheoremSpec -> [Char])
    -> ([TheoremSpec] -> ShowS)
    -> Show TheoremSpec
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> TheoremSpec -> ShowS
    showsPrec :: Int -> TheoremSpec -> ShowS
    $cshow :: TheoremSpec -> [Char]
    show :: TheoremSpec -> [Char]
    $cshowList :: [TheoremSpec] -> ShowS
    showList :: [TheoremSpec] -> ShowS
    Show, TheoremSpec -> TheoremSpec -> Bool
    (TheoremSpec -> TheoremSpec -> Bool)
    -> (TheoremSpec -> TheoremSpec -> Bool) -> Eq TheoremSpec
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: TheoremSpec -> TheoremSpec -> Bool
    == :: TheoremSpec -> TheoremSpec -> Bool
    $c/= :: TheoremSpec -> TheoremSpec -> Bool
    /= :: TheoremSpec -> TheoremSpec -> Bool
    Eq)

    data LaTeXState = LaTeXState{ LaTeXState -> ReaderOptions
    sOptions       :: ReaderOptions
                                , LaTeXState -> Meta
    sMeta          :: Meta
                                , LaTeXState -> QuoteContext
    sQuoteContext  :: QuoteContext
                                , LaTeXState -> NonEmpty (Map Text Macro)
    sMacros        :: NonEmpty (M.Map Text Macro)
                                , LaTeXState -> [Text]
    sContainers    :: [Text]
                                , LaTeXState -> [LogMessage]
    sLogMessages   :: [LogMessage]
                                , LaTeXState -> Set Text
    sIdentifiers   :: Set.Set Text
                                , LaTeXState -> Bool
    sVerbatimMode  :: Bool
                                , LaTeXState -> Bool
    sMathMode      :: Bool
                                , LaTeXState -> Maybe Caption
    sCaption       :: Maybe Caption
                                , LaTeXState -> Bool
    sInListItem    :: Bool
                                , LaTeXState -> Bool
    sInTableCell   :: Bool
                                , LaTeXState -> DottedNum
    sLastHeaderNum :: DottedNum
                                , LaTeXState -> DottedNum
    sLastFigureNum :: DottedNum
                                , LaTeXState -> DottedNum
    sLastTableNum  :: DottedNum
                                , LaTeXState -> Int
    sLastNoteNum   :: Int
                                , LaTeXState -> Map Int Blocks
    sFootnoteTexts :: M.Map Int Blocks
                                , LaTeXState -> Map Text TheoremSpec
    sTheoremMap    :: M.Map Text TheoremSpec
                                , LaTeXState -> TheoremStyle
    sLastTheoremStyle :: TheoremStyle
                                , LaTeXState -> Maybe Text
    sLastLabel     :: Maybe Text
                                , LaTeXState -> Map Text [Inline]
    sLabels        :: M.Map Text [Inline]
                                , LaTeXState -> Bool
    sHasChapters   :: Bool
                                , LaTeXState -> Map Text Bool
    sToggles       :: M.Map Text Bool
                                , LaTeXState -> Map Text Text
    sFileContents  :: M.Map Text Text
                                , LaTeXState -> Bool
    sEnableWithRaw :: Bool
                                , LaTeXState -> IntMap [Tok]
    sRawTokens     :: IntMap.IntMap [Tok]
                                , LaTeXState -> Bool
    sLigatures     :: Bool
                                }
         deriving Int -> LaTeXState -> ShowS
    [LaTeXState] -> ShowS
    LaTeXState -> [Char]
    (Int -> LaTeXState -> ShowS)
    -> (LaTeXState -> [Char])
    -> ([LaTeXState] -> ShowS)
    -> Show LaTeXState
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> LaTeXState -> ShowS
    showsPrec :: Int -> LaTeXState -> ShowS
    $cshow :: LaTeXState -> [Char]
    show :: LaTeXState -> [Char]
    $cshowList :: [LaTeXState] -> ShowS
    showList :: [LaTeXState] -> ShowS
    Show

    defaultLaTeXState :: LaTeXState
    defaultLaTeXState :: LaTeXState
    defaultLaTeXState = LaTeXState{ sOptions :: ReaderOptions
    sOptions       = ReaderOptions
    forall a. Default a => a
    def
                                  , sMeta :: Meta
    sMeta          = Meta
    nullMeta
                                  , sQuoteContext :: QuoteContext
    sQuoteContext  = QuoteContext
    NoQuote
                                  , sMacros :: NonEmpty (Map Text Macro)
    sMacros        = Map Text Macro
    forall k a. Map k a
    M.empty Map Text Macro -> [Map Text Macro] -> NonEmpty (Map Text Macro)
    forall a. a -> [a] -> NonEmpty a
    :| []
                                  , sContainers :: [Text]
    sContainers    = []
                                  , sLogMessages :: [LogMessage]
    sLogMessages   = []
                                  , sIdentifiers :: Set Text
    sIdentifiers   = Set Text
    forall a. Set a
    Set.empty
                                  , sVerbatimMode :: Bool
    sVerbatimMode  = Bool
    False
                                  , sMathMode :: Bool
    sMathMode      = Bool
    False
                                  , sCaption :: Maybe Caption
    sCaption       = Maybe Caption
    forall a. Maybe a
    Nothing
                                  , sInListItem :: Bool
    sInListItem    = Bool
    False
                                  , sInTableCell :: Bool
    sInTableCell   = Bool
    False
                                  , sLastHeaderNum :: DottedNum
    sLastHeaderNum = [Int] -> DottedNum
    DottedNum []
                                  , sLastFigureNum :: DottedNum
    sLastFigureNum = [Int] -> DottedNum
    DottedNum []
                                  , sLastTableNum :: DottedNum
    sLastTableNum  = [Int] -> DottedNum
    DottedNum []
                                  , sLastNoteNum :: Int
    sLastNoteNum   = Int
    0
                                  , sFootnoteTexts :: Map Int Blocks
    sFootnoteTexts = Map Int Blocks
    forall k a. Map k a
    M.empty
                                  , sTheoremMap :: Map Text TheoremSpec
    sTheoremMap    = Map Text TheoremSpec
    forall k a. Map k a
    M.empty
                                  , sLastTheoremStyle :: TheoremStyle
    sLastTheoremStyle = TheoremStyle
    PlainStyle
                                  , sLastLabel :: Maybe Text
    sLastLabel     = Maybe Text
    forall a. Maybe a
    Nothing
                                  , sLabels :: Map Text [Inline]
    sLabels        = Map Text [Inline]
    forall k a. Map k a
    M.empty
                                  , sHasChapters :: Bool
    sHasChapters   = Bool
    False
                                  , sToggles :: Map Text Bool
    sToggles       = Map Text Bool
    forall k a. Map k a
    M.empty
                                  , sFileContents :: Map Text Text
    sFileContents  = Map Text Text
    forall k a. Map k a
    M.empty
                                  , sEnableWithRaw :: Bool
    sEnableWithRaw = Bool
    True
                                  , sRawTokens :: IntMap [Tok]
    sRawTokens     = IntMap [Tok]
    forall a. IntMap a
    IntMap.empty
                                  , sLigatures :: Bool
    sLigatures     = Bool
    True
                                  }

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

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

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

    instance HasIncludeFiles LaTeXState where
      getIncludeFiles :: LaTeXState -> [Text]
    getIncludeFiles = LaTeXState -> [Text]
    sContainers
      addIncludeFile :: Text -> LaTeXState -> LaTeXState
    addIncludeFile Text
    f LaTeXState
    s = LaTeXState
    s{ sContainers = f : sContainers s }
      dropLatestIncludeFile :: LaTeXState -> LaTeXState
    dropLatestIncludeFile LaTeXState
    s = LaTeXState
    s { sContainers = drop 1 $ sContainers s }

    instance HasMacros LaTeXState where
      extractMacros :: LaTeXState -> Map Text Macro
    extractMacros  LaTeXState
    st  = NonEmpty (Map Text Macro) -> Map Text Macro
    forall a. NonEmpty a -> a
    NonEmpty.head (NonEmpty (Map Text Macro) -> Map Text Macro)
    -> NonEmpty (Map Text Macro) -> Map Text Macro
    forall a b. (a -> b) -> a -> b
    $ LaTeXState -> NonEmpty (Map Text Macro)
    sMacros LaTeXState
    st
      updateMacros :: (Map Text Macro -> Map Text Macro) -> LaTeXState -> LaTeXState
    updateMacros Map Text Macro -> Map Text Macro
    f LaTeXState
    st  = LaTeXState
    st{ sMacros = f (NonEmpty.head (sMacros st))
                                         :| NonEmpty.tail (sMacros st) }

    instance HasReaderOptions LaTeXState where
      extractReaderOptions :: LaTeXState -> ReaderOptions
    extractReaderOptions = LaTeXState -> ReaderOptions
    sOptions

    instance HasMeta LaTeXState where
      setMeta :: forall b. ToMetaValue b => Text -> b -> LaTeXState -> LaTeXState
    setMeta Text
    field b
    val LaTeXState
    st =
        LaTeXState
    st{ sMeta = setMeta field val $ sMeta st }
      deleteMeta :: Text -> LaTeXState -> LaTeXState
    deleteMeta Text
    field LaTeXState
    st =
        LaTeXState
    st{ sMeta = deleteMeta field $ sMeta st }

    instance Default LaTeXState where
      def :: LaTeXState
    def = LaTeXState
    defaultLaTeXState

    -- The Boolean is True if macros have already been expanded,
    -- False if they need expanding.
    data TokStream = TokStream !Bool [Tok]
      deriving (Int -> TokStream -> ShowS
    [TokStream] -> ShowS
    TokStream -> [Char]
    (Int -> TokStream -> ShowS)
    -> (TokStream -> [Char])
    -> ([TokStream] -> ShowS)
    -> Show TokStream
    forall a.
    (Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> TokStream -> ShowS
    showsPrec :: Int -> TokStream -> ShowS
    $cshow :: TokStream -> [Char]
    show :: TokStream -> [Char]
    $cshowList :: [TokStream] -> ShowS
    showList :: [TokStream] -> ShowS
    Show)

    instance Semigroup TokStream where
      (TokStream Bool
    exp1 [Tok]
    ts1) <> :: TokStream -> TokStream -> TokStream
    <> (TokStream Bool
    exp2 [Tok]
    ts2) =
        Bool -> [Tok] -> TokStream
    TokStream (if [Tok] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [Tok]
    ts1 then Bool
    exp2 else Bool
    exp1) ([Tok]
    ts1 [Tok] -> [Tok] -> [Tok]
    forall a. Semigroup a => a -> a -> a
    <> [Tok]
    ts2)

    instance Monoid TokStream where
      mempty :: TokStream
    mempty = Bool -> [Tok] -> TokStream
    TokStream Bool
    False [Tok]
    forall a. Monoid a => a
    mempty
      mappend :: TokStream -> TokStream -> TokStream
    mappend = TokStream -> TokStream -> TokStream
    forall a. Semigroup a => a -> a -> a
    (<>)

    instance Monad m => Stream TokStream m Tok where
      uncons :: TokStream -> m (Maybe (Tok, TokStream))
    uncons (TokStream Bool
    _ []) = Maybe (Tok, TokStream) -> m (Maybe (Tok, TokStream))
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe (Tok, TokStream)
    forall a. Maybe a
    Nothing
      uncons (TokStream Bool
    _ (Tok
    t:[Tok]
    ts)) = Maybe (Tok, TokStream) -> m (Maybe (Tok, TokStream))
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe (Tok, TokStream) -> m (Maybe (Tok, TokStream)))
    -> Maybe (Tok, TokStream) -> m (Maybe (Tok, TokStream))
    forall a b. (a -> b) -> a -> b
    $ (Tok, TokStream) -> Maybe (Tok, TokStream)
    forall a. a -> Maybe a
    Just (Tok
    t, Bool -> [Tok] -> TokStream
    TokStream Bool
    False [Tok]
    ts)

    type LP m = ParsecT TokStream LaTeXState m

    withVerbatimMode :: PandocMonad m => LP m a -> LP m a
    withVerbatimMode :: forall (m :: * -> *) a. PandocMonad m => LP m a -> LP m a
    withVerbatimMode LP m a
    parser = do
      alreadyVerbatimMode <- LaTeXState -> Bool
    sVerbatimMode (LaTeXState -> Bool)
    -> ParsecT TokStream LaTeXState m LaTeXState
    -> ParsecT TokStream LaTeXState m Bool
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT TokStream LaTeXState m LaTeXState
    forall (m :: * -> *) s u. Monad m => ParsecT s u m u
    getState
      if alreadyVerbatimMode
         then parser
         else do
           updateState $ \LaTeXState
    st -> LaTeXState
    st{ sVerbatimMode = True }
           result <- parser
           updateState $ \LaTeXState
    st -> LaTeXState
    st{ sVerbatimMode = False }
           return result

    rawLaTeXParser :: (PandocMonad m, HasMacros s, HasReaderOptions s, Show a)
                   => [Tok] -> LP m () -> LP m a
                   -> ParsecT Sources s m (a, Text)
    rawLaTeXParser :: forall (m :: * -> *) s a.
    (PandocMonad m, HasMacros s, HasReaderOptions s, Show a) =>
    [Tok] -> LP m () -> LP m a -> ParsecT Sources s m (a, Text)
    rawLaTeXParser [Tok]
    toks LP m ()
    parser LP m a
    valParser = do
      pstate <- ParsecT Sources s m s
    forall (m :: * -> *) s u. Monad m => ParsecT s u m u
    getState
      let lstate = LaTeXState
    forall a. Default a => a
    def{ sOptions = extractReaderOptions pstate }
      let lstate' = LaTeXState
    lstate { sMacros = extractMacros pstate :| [] }
      let setStartPos = case [Tok]
    toks of
                          Tok SourcePos
    pos TokType
    _ Text
    _ : [Tok]
    _ -> SourcePos -> ParsecT s u m ()
    forall (m :: * -> *) s u. Monad m => SourcePos -> ParsecT s u m ()
    setPosition SourcePos
    pos
                          [Tok]
    _ -> () -> ParsecT s u m ()
    forall a. a -> ParsecT s u m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()
      let preparser = LP m ()
    forall {s} {u}. ParsecT s u m ()
    setStartPos LP m () -> LP m () -> LP m ()
    forall a b.
    ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m b
    -> ParsecT TokStream LaTeXState m b
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> LP m ()
    parser
      let rawparser = (,) ((a, [Tok]) -> LaTeXState -> ((a, [Tok]), LaTeXState))
    -> ParsecT TokStream LaTeXState m (a, [Tok])
    -> ParsecT
         TokStream LaTeXState m (LaTeXState -> ((a, [Tok]), LaTeXState))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> LP m a -> ParsecT TokStream LaTeXState m (a, [Tok])
    forall (m :: * -> *) a. PandocMonad m => LP m a -> LP m (a, [Tok])
    withRaw LP m a
    valParser ParsecT
      TokStream LaTeXState m (LaTeXState -> ((a, [Tok]), LaTeXState))
    -> ParsecT TokStream LaTeXState m LaTeXState
    -> ParsecT TokStream LaTeXState m ((a, [Tok]), LaTeXState)
    forall a b.
    ParsecT TokStream LaTeXState m (a -> b)
    -> ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ParsecT TokStream LaTeXState m LaTeXState
    forall (m :: * -> *) s u. Monad m => ParsecT s u m u
    getState
      res' <- lift $ runParserT (withRaw (preparser >> getPosition))
                                lstate "chunk" $ TokStream False toks
      case res' of
           Left ParseError
    _    -> ParsecT Sources s m (a, Text)
    forall a. ParsecT Sources s m a
    forall (m :: * -> *) a. MonadPlus m => m a
    mzero
           Right (SourcePos
    endpos, [Tok]
    toks') -> do
             res <- m (Either ParseError ((a, [Tok]), LaTeXState))
    -> ParsecT Sources s m (Either ParseError ((a, [Tok]), LaTeXState))
    forall (m :: * -> *) a. Monad m => m a -> ParsecT Sources s m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (m (Either ParseError ((a, [Tok]), LaTeXState))
     -> ParsecT
          Sources s m (Either ParseError ((a, [Tok]), LaTeXState)))
    -> m (Either ParseError ((a, [Tok]), LaTeXState))
    -> ParsecT Sources s m (Either ParseError ((a, [Tok]), LaTeXState))
    forall a b. (a -> b) -> a -> b
    $ ParsecT TokStream LaTeXState m ((a, [Tok]), LaTeXState)
    -> LaTeXState
    -> [Char]
    -> TokStream
    -> m (Either ParseError ((a, [Tok]), LaTeXState))
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> u -> [Char] -> s -> m (Either ParseError a)
    runParserT ParsecT TokStream LaTeXState m ((a, [Tok]), LaTeXState)
    rawparser LaTeXState
    lstate' [Char]
    "chunk"
                         (TokStream -> m (Either ParseError ((a, [Tok]), LaTeXState)))
    -> TokStream -> m (Either ParseError ((a, [Tok]), LaTeXState))
    forall a b. (a -> b) -> a -> b
    $ Bool -> [Tok] -> TokStream
    TokStream Bool
    False [Tok]
    toks'
             case res of
                  Left ParseError
    _    -> ParsecT Sources s m (a, Text)
    forall a. ParsecT Sources s m a
    forall (m :: * -> *) a. MonadPlus m => m a
    mzero
                  Right ((a
    val, [Tok]
    raw), LaTeXState
    st) -> do
                    (s -> s) -> ParsecT Sources s m ()
    forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
    updateState ((Map Text Macro -> Map Text Macro) -> s -> s
    forall st.
    HasMacros st =>
    (Map Text Macro -> Map Text Macro) -> st -> st
    updateMacros ((NonEmpty (Map Text Macro) -> Map Text Macro
    forall a. NonEmpty a -> a
    NonEmpty.head (LaTeXState -> NonEmpty (Map Text Macro)
    sMacros LaTeXState
    st)) Map Text Macro -> Map Text Macro -> Map Text Macro
    forall a. Semigroup a => a -> a -> a
    <>))
                    let rawChar :: ParsecT Sources u m Char
    rawChar = do
                          pos <- ParsecT Sources u m SourcePos
    forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
    getPosition
                          if pos >= endpos
                             then mzero
                             else anyChar
                    result <- (Extension -> ParsecT Sources s m ()
    forall s (m :: * -> *) a st.
    (Stream s m a, HasReaderOptions st) =>
    Extension -> ParsecT s st m ()
    guardEnabled Extension
    Ext_latex_macros
                                 ParsecT Sources s m ()
    -> ParsecT Sources s m Text -> ParsecT Sources s m Text
    forall a b.
    ParsecT Sources s m a
    -> ParsecT Sources s m b -> ParsecT Sources s m b
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> ([Tok] -> Text
    untokenize [Tok]
    raw Text -> ParsecT Sources s m () -> ParsecT Sources s m Text
    forall a b. a -> ParsecT Sources s m b -> ParsecT Sources s m a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ ParsecT Sources s m Char -> ParsecT Sources s m ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m ()
    skipMany ParsecT Sources s m Char
    forall {u}. ParsecT Sources u m Char
    rawChar))
                              ParsecT Sources s m Text
    -> ParsecT Sources s m Text -> ParsecT Sources s m Text
    forall a.
    ParsecT Sources s m a
    -> ParsecT Sources s m a -> ParsecT Sources s m a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> [Char] -> Text
    T.pack ([Char] -> Text)
    -> ParsecT Sources s m [Char] -> ParsecT Sources s m Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Sources s m Char -> ParsecT Sources s m [Char]
    forall a. ParsecT Sources s m a -> ParsecT Sources s m [a]
    forall (f :: * -> *) a. Alternative f => f a -> f [a]
    many ParsecT Sources s m Char
    forall {u}. ParsecT Sources u m Char
    rawChar
                    -- ensure we end with space if input did, see #4442
                    let result' =
                          case [Tok] -> [Tok]
    forall a. [a] -> [a]
    reverse [Tok]
    toks' of
                            (Tok SourcePos
    _ (CtrlSeq Text
    _) Text
    t : [Tok]
    _)
                             | Text
    " " Text -> Text -> Bool
    `T.isSuffixOf` Text
    t
                             , Bool -> Bool
    not (Text
    " " Text -> Text -> Bool
    `T.isSuffixOf` Text
    result)
                              -> Text
    result Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Text
    " "
                            [Tok]
    _ -> Text
    result
                    return (val, result')

    applyMacros :: (PandocMonad m, HasMacros s, HasReaderOptions s)
                => Text -> ParsecT Sources s m Text
    applyMacros :: forall (m :: * -> *) s.
    (PandocMonad m, HasMacros s, HasReaderOptions s) =>
    Text -> ParsecT Sources s m Text
    applyMacros Text
    s = (Extension -> ParsecT Sources s m ()
    forall s (m :: * -> *) a st.
    (Stream s m a, HasReaderOptions st) =>
    Extension -> ParsecT s st m ()
    guardDisabled Extension
    Ext_latex_macros ParsecT Sources s m ()
    -> ParsecT Sources s m Text -> ParsecT Sources s m Text
    forall a b.
    ParsecT Sources s m a
    -> ParsecT Sources s m b -> ParsecT Sources s m b
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> Text -> ParsecT Sources s m Text
    forall a. a -> ParsecT Sources s m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Text
    s) ParsecT Sources s m Text
    -> ParsecT Sources s m Text -> ParsecT Sources s m Text
    forall a.
    ParsecT Sources s m a
    -> ParsecT Sources s m a -> ParsecT Sources s m a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|>
       do let retokenize :: ParsecT TokStream LaTeXState (ParsecT Sources s m) Text
    retokenize = [Tok] -> Text
    untokenize ([Tok] -> Text)
    -> ParsecT TokStream LaTeXState (ParsecT Sources s m) [Tok]
    -> ParsecT TokStream LaTeXState (ParsecT Sources s m) Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT TokStream LaTeXState (ParsecT Sources s m) Tok
    -> ParsecT TokStream LaTeXState (ParsecT Sources s m) [Tok]
    forall a.
    ParsecT TokStream LaTeXState (ParsecT Sources s m) a
    -> ParsecT TokStream LaTeXState (ParsecT Sources s m) [a]
    forall (f :: * -> *) a. Alternative f => f a -> f [a]
    many ParsecT TokStream LaTeXState (ParsecT Sources s m) Tok
    forall (m :: * -> *). PandocMonad m => LP m Tok
    anyTok
          pstate <- ParsecT Sources s m s
    forall (m :: * -> *) s u. Monad m => ParsecT s u m u
    getState
          let lstate = LaTeXState
    forall a. Default a => a
    def{ sOptions = extractReaderOptions pstate
                          , sMacros  = extractMacros pstate :| [] }
          res <- runParserT retokenize lstate "math" $
                     TokStream False (tokenize (initialPos "math") s)
          case res of
               Left ParseError
    e   -> [Char] -> ParsecT Sources s m Text
    forall a. [Char] -> ParsecT Sources s m a
    forall (m :: * -> *) a. MonadFail m => [Char] -> m a
    Prelude.fail (ParseError -> [Char]
    forall a. Show a => a -> [Char]
    show ParseError
    e)
               Right Text
    s' -> Text -> ParsecT Sources s m Text
    forall a. a -> ParsecT Sources s m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Text
    s'

    {-
    When tokenize or untokenize change, test with this
    QuickCheck property:

    > tokUntokRoundtrip :: String -> Bool
    > tokUntokRoundtrip s =
    >   let t = T.pack s in untokenize (tokenize "random" t) == t
    -}

    tokenizeSources :: Sources -> [Tok]
    tokenizeSources :: Sources -> [Tok]
    tokenizeSources = ((SourcePos, Text) -> [Tok]) -> [(SourcePos, Text)] -> [Tok]
    forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
    concatMap (SourcePos, Text) -> [Tok]
    tokenizeSource ([(SourcePos, Text)] -> [Tok])
    -> (Sources -> [(SourcePos, Text)]) -> Sources -> [Tok]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Sources -> [(SourcePos, Text)]
    unSources
     where
       tokenizeSource :: (SourcePos, Text) -> [Tok]
    tokenizeSource (SourcePos
    pos, Text
    t) = SourcePos -> Text -> [Tok]
    tokenize SourcePos
    pos Text
    t

    -- Return tokens from input sources. Ensure that starting position is
    -- correct.
    getInputTokens :: PandocMonad m => ParsecT Sources s m [Tok]
    getInputTokens :: forall (m :: * -> *) s. PandocMonad m => ParsecT Sources s m [Tok]
    getInputTokens = do
      pos <- ParsecT Sources s m SourcePos
    forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
    getPosition
      ss <- getInput
      return $
        case ss of
          Sources [] -> []
          Sources ((SourcePos
    _,Text
    t):[(SourcePos, Text)]
    rest) -> Sources -> [Tok]
    tokenizeSources (Sources -> [Tok]) -> Sources -> [Tok]
    forall a b. (a -> b) -> a -> b
    $ [(SourcePos, Text)] -> Sources
    Sources ((SourcePos
    pos,Text
    t)(SourcePos, Text) -> [(SourcePos, Text)] -> [(SourcePos, Text)]
    forall a. a -> [a] -> [a]
    :[(SourcePos, Text)]
    rest)

    tokenize :: SourcePos -> Text -> [Tok]
    tokenize :: SourcePos -> Text -> [Tok]
    tokenize = Bool -> SourcePos -> Text -> [Tok]
    totoks Bool
    False
     where
      totoks :: Bool -> SourcePos -> Text -> [Tok]
    totoks Bool
    atIsLetter SourcePos
    pos Text
    t =
        case Text -> Maybe (Char, Text)
    T.uncons Text
    t of
           Maybe (Char, Text)
    Nothing        -> []
           Just (Char
    c, Text
    rest)
             | Char
    c Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    == Char
    '\n' ->
               SourcePos -> TokType -> Text -> Tok
    Tok SourcePos
    pos TokType
    Newline Text
    "\n"
               Tok -> [Tok] -> [Tok]
    forall a. a -> [a] -> [a]
    : Bool -> SourcePos -> Text -> [Tok]
    totoks Bool
    atIsLetter (SourcePos -> Int -> SourcePos
    setSourceColumn (SourcePos -> Int -> SourcePos
    incSourceLine SourcePos
    pos Int
    1) Int
    1) Text
    rest
             | Char -> Bool
    isSpaceOrTab Char
    c ->
               let (Text
    sps, Text
    rest') = (Char -> Bool) -> Text -> (Text, Text)
    T.span Char -> Bool
    isSpaceOrTab Text
    t
               in  SourcePos -> TokType -> Text -> Tok
    Tok SourcePos
    pos TokType
    Spaces Text
    sps
                   Tok -> [Tok] -> [Tok]
    forall a. a -> [a] -> [a]
    : Bool -> SourcePos -> Text -> [Tok]
    totoks Bool
    atIsLetter (SourcePos -> Int -> SourcePos
    incSourceColumn SourcePos
    pos (Text -> Int
    T.length Text
    sps))
                     Text
    rest'
             | Char -> Bool
    isAlphaNum Char
    c ->
               let (Text
    ws, Text
    rest') = (Char -> Bool) -> Text -> (Text, Text)
    T.span Char -> Bool
    isAlphaNum Text
    t
               in  SourcePos -> TokType -> Text -> Tok
    Tok SourcePos
    pos TokType
    Word Text
    ws
                   Tok -> [Tok] -> [Tok]
    forall a. a -> [a] -> [a]
    : Bool -> SourcePos -> Text -> [Tok]
    totoks Bool
    atIsLetter (SourcePos -> Int -> SourcePos
    incSourceColumn SourcePos
    pos (Text -> Int
    T.length Text
    ws)) Text
    rest'
             | Char
    c Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    == Char
    '%' ->
               let (Text
    cs, Text
    rest') = (Char -> Bool) -> Text -> (Text, Text)
    T.break (Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    == Char
    '\n') Text
    rest
               in  SourcePos -> TokType -> Text -> Tok
    Tok SourcePos
    pos TokType
    Comment (Text
    "%" Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Text
    cs)
                   Tok -> [Tok] -> [Tok]
    forall a. a -> [a] -> [a]
    : Bool -> SourcePos -> Text -> [Tok]
    totoks Bool
    atIsLetter (SourcePos -> Int -> SourcePos
    incSourceColumn SourcePos
    pos (Int
    1 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Text -> Int
    T.length Text
    cs)) Text
    rest'
             | Char
    c Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    == Char
    '\\' ->
               case Text -> Maybe (Char, Text)
    T.uncons Text
    rest of
                    Maybe (Char, Text)
    Nothing -> [SourcePos -> TokType -> Text -> Tok
    Tok SourcePos
    pos (Text -> TokType
    CtrlSeq Text
    " ") Text
    "\\"]
                    Just (Char
    d, Text
    rest')
                      | Bool -> Char -> Bool
    isLetter' Bool
    atIsLetter Char
    d ->
                          let (Text
    ws, Text
    rest'') = (Char -> Bool) -> Text -> (Text, Text)
    T.span (Bool -> Char -> Bool
    isLetter' Bool
    atIsLetter) Text
    rest
                              (Text
    ss, Text
    rest''') = (Char -> Bool) -> Text -> (Text, Text)
    T.span Char -> Bool
    isSpaceOrTab Text
    rest''
                              atIsLetter' :: Bool
    atIsLetter' = case Text
    ws of
                                              Text
    "makeatletter" -> Bool
    True
                                              Text
    "makeatother" -> Bool
    False
                                              Text
    _ -> Bool
    atIsLetter
                          in  SourcePos -> TokType -> Text -> Tok
    Tok SourcePos
    pos (Text -> TokType
    CtrlSeq Text
    ws) (Text
    "\\" Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Text
    ws Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Text
    ss)
                              Tok -> [Tok] -> [Tok]
    forall a. a -> [a] -> [a]
    : Bool -> SourcePos -> Text -> [Tok]
    totoks Bool
    atIsLetter' (SourcePos -> Int -> SourcePos
    incSourceColumn SourcePos
    pos
                                   (Int
    1 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Text -> Int
    T.length Text
    ws Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Text -> Int
    T.length Text
    ss)) Text
    rest'''
                      | Char -> Bool
    isSpaceOrTab Char
    d Bool -> Bool -> Bool
    || Char
    d Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    == Char
    '\n' ->
                          let (Text
    w1, Text
    r1) = (Char -> Bool) -> Text -> (Text, Text)
    T.span Char -> Bool
    isSpaceOrTab Text
    rest
                              (Text
    w2, (Text
    w3, Text
    r3)) = case Text -> Maybe (Char, Text)
    T.uncons Text
    r1 of
                                              Just (Char
    '\n', Text
    r2)
                                                      -> ([Char] -> Text
    T.pack [Char]
    "\n",
                                                            (Char -> Bool) -> Text -> (Text, Text)
    T.span Char -> Bool
    isSpaceOrTab Text
    r2)
                                              Maybe (Char, Text)
    _ -> (Text
    forall a. Monoid a => a
    mempty, (Text
    forall a. Monoid a => a
    mempty, Text
    r1))
                              ws :: Text
    ws = Text
    "\\" Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Text
    w1 Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Text
    w2 Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Text
    w3
                          in  case Text -> Maybe (Char, Text)
    T.uncons Text
    r3 of
                                   Just (Char
    '\n', Text
    _) ->
                                     SourcePos -> TokType -> Text -> Tok
    Tok SourcePos
    pos (Text -> TokType
    CtrlSeq Text
    " ") (Text
    "\\" Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Text
    w1)
                                     Tok -> [Tok] -> [Tok]
    forall a. a -> [a] -> [a]
    : Bool -> SourcePos -> Text -> [Tok]
    totoks Bool
    atIsLetter
                                        (SourcePos -> Int -> SourcePos
    incSourceColumn SourcePos
    pos (Text -> Int
    T.length Text
    ws)) Text
    r1
                                   Maybe (Char, Text)
    _ ->
                                     SourcePos -> TokType -> Text -> Tok
    Tok SourcePos
    pos (Text -> TokType
    CtrlSeq Text
    " ") Text
    ws
                                     Tok -> [Tok] -> [Tok]
    forall a. a -> [a] -> [a]
    : Bool -> SourcePos -> Text -> [Tok]
    totoks Bool
    atIsLetter
                                        (SourcePos -> Int -> SourcePos
    incSourceColumn SourcePos
    pos (Text -> Int
    T.length Text
    ws)) Text
    r3
                      | Bool
    otherwise  ->
                          SourcePos -> TokType -> Text -> Tok
    Tok SourcePos
    pos (Text -> TokType
    CtrlSeq (Char -> Text
    T.singleton Char
    d)) ([Char] -> Text
    T.pack [Char
    c,Char
    d])
                          Tok -> [Tok] -> [Tok]
    forall a. a -> [a] -> [a]
    : Bool -> SourcePos -> Text -> [Tok]
    totoks Bool
    atIsLetter (SourcePos -> Int -> SourcePos
    incSourceColumn SourcePos
    pos Int
    2) Text
    rest'
             | Char
    c Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    == Char
    '#' ->
               case Text -> Maybe (Char, Text)
    T.uncons Text
    rest of
                 Just (Char
    '#', Text
    t3) ->
                   let (Text
    t1, Text
    t2) = (Char -> Bool) -> Text -> (Text, Text)
    T.span (\Char
    d -> Char
    d Char -> Char -> Bool
    forall a. Ord a => a -> a -> Bool
    >= Char
    '0' Bool -> Bool -> Bool
    && Char
    d Char -> Char -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Char
    '9') Text
    t3
                   in  case Text -> Maybe Int
    forall (m :: * -> *) a. (MonadPlus m, Read a) => Text -> m a
    safeRead Text
    t1 of
                            Just Int
    i ->
                               SourcePos -> TokType -> Text -> Tok
    Tok SourcePos
    pos (Int -> TokType
    DeferredArg Int
    i) (Text
    "##" Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Text
    t1)
                               Tok -> [Tok] -> [Tok]
    forall a. a -> [a] -> [a]
    : Bool -> SourcePos -> Text -> [Tok]
    totoks Bool
    atIsLetter
                                  (SourcePos -> Int -> SourcePos
    incSourceColumn SourcePos
    pos (Int
    2 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Text -> Int
    T.length Text
    t1)) Text
    t2
                            Maybe Int
    Nothing -> SourcePos -> TokType -> Text -> Tok
    Tok SourcePos
    pos TokType
    Symbol Text
    "#"
                                      Tok -> [Tok] -> [Tok]
    forall a. a -> [a] -> [a]
    : SourcePos -> TokType -> Text -> Tok
    Tok (SourcePos -> Int -> SourcePos
    incSourceColumn SourcePos
    pos Int
    1) TokType
    Symbol Text
    "#"
                                      Tok -> [Tok] -> [Tok]
    forall a. a -> [a] -> [a]
    : Bool -> SourcePos -> Text -> [Tok]
    totoks Bool
    atIsLetter (SourcePos -> Int -> SourcePos
    incSourceColumn SourcePos
    pos Int
    1) Text
    t3
                 Maybe (Char, Text)
    _ ->
                   let (Text
    t1, Text
    t2) = (Char -> Bool) -> Text -> (Text, Text)
    T.span (\Char
    d -> Char
    d Char -> Char -> Bool
    forall a. Ord a => a -> a -> Bool
    >= Char
    '0' Bool -> Bool -> Bool
    && Char
    d Char -> Char -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Char
    '9') Text
    rest
                   in  case Text -> Maybe Int
    forall (m :: * -> *) a. (MonadPlus m, Read a) => Text -> m a
    safeRead Text
    t1 of
                            Just Int
    i ->
                               SourcePos -> TokType -> Text -> Tok
    Tok SourcePos
    pos (Int -> TokType
    Arg Int
    i) (Text
    "#" Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Text
    t1)
                               Tok -> [Tok] -> [Tok]
    forall a. a -> [a] -> [a]
    : Bool -> SourcePos -> Text -> [Tok]
    totoks Bool
    atIsLetter
                                   (SourcePos -> Int -> SourcePos
    incSourceColumn SourcePos
    pos (Int
    1 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Text -> Int
    T.length Text
    t1)) Text
    t2
                            Maybe Int
    Nothing -> SourcePos -> TokType -> Text -> Tok
    Tok SourcePos
    pos TokType
    Symbol Text
    "#"
                                      Tok -> [Tok] -> [Tok]
    forall a. a -> [a] -> [a]
    : Bool -> SourcePos -> Text -> [Tok]
    totoks Bool
    atIsLetter (SourcePos -> Int -> SourcePos
    incSourceColumn SourcePos
    pos Int
    1) Text
    rest
             | Char
    c Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    == Char
    '^' ->
               case Text -> Maybe (Char, Text)
    T.uncons Text
    rest of
                    Just (Char
    '^', Text
    rest') ->
                      case Text -> Maybe (Char, Text)
    T.uncons Text
    rest' of
                           Just (Char
    d, Text
    rest'')
                             | Char -> Bool
    isLowerHex Char
    d ->
                               case Text -> Maybe (Char, Text)
    T.uncons Text
    rest'' of
                                    Just (Char
    e, Text
    rest''') | Char -> Bool
    isLowerHex Char
    e ->
                                      SourcePos -> TokType -> Text -> Tok
    Tok SourcePos
    pos TokType
    Esc2 ([Char] -> Text
    T.pack [Char
    '^',Char
    '^',Char
    d,Char
    e])
                                      Tok -> [Tok] -> [Tok]
    forall a. a -> [a] -> [a]
    : Bool -> SourcePos -> Text -> [Tok]
    totoks Bool
    atIsLetter
                                         (SourcePos -> Int -> SourcePos
    incSourceColumn SourcePos
    pos Int
    4) Text
    rest'''
                                    Maybe (Char, Text)
    _ ->
                                      SourcePos -> TokType -> Text -> Tok
    Tok SourcePos
    pos TokType
    Esc1 ([Char] -> Text
    T.pack [Char
    '^',Char
    '^',Char
    d])
                                      Tok -> [Tok] -> [Tok]
    forall a. a -> [a] -> [a]
    : Bool -> SourcePos -> Text -> [Tok]
    totoks Bool
    atIsLetter
                                          (SourcePos -> Int -> SourcePos
    incSourceColumn SourcePos
    pos Int
    3) Text
    rest''
                             | Char
    d Char -> Char -> Bool
    forall a. Ord a => a -> a -> Bool
    < Char
    '\128' ->
                                      SourcePos -> TokType -> Text -> Tok
    Tok SourcePos
    pos TokType
    Esc1 ([Char] -> Text
    T.pack [Char
    '^',Char
    '^',Char
    d])
                                      Tok -> [Tok] -> [Tok]
    forall a. a -> [a] -> [a]
    : Bool -> SourcePos -> Text -> [Tok]
    totoks Bool
    atIsLetter
                                         (SourcePos -> Int -> SourcePos
    incSourceColumn SourcePos
    pos Int
    3) Text
    rest''
                           Maybe (Char, Text)
    _ -> SourcePos -> TokType -> Text -> Tok
    Tok SourcePos
    pos TokType
    Symbol Text
    "^" Tok -> [Tok] -> [Tok]
    forall a. a -> [a] -> [a]
    :
                                SourcePos -> TokType -> Text -> Tok
    Tok (SourcePos -> Int -> SourcePos
    incSourceColumn SourcePos
    pos Int
    1) TokType
    Symbol Text
    "^" Tok -> [Tok] -> [Tok]
    forall a. a -> [a] -> [a]
    :
                                Bool -> SourcePos -> Text -> [Tok]
    totoks Bool
    atIsLetter (SourcePos -> Int -> SourcePos
    incSourceColumn SourcePos
    pos Int
    2) Text
    rest'
                    Maybe (Char, Text)
    _ -> SourcePos -> TokType -> Text -> Tok
    Tok SourcePos
    pos TokType
    Symbol Text
    "^"
                         Tok -> [Tok] -> [Tok]
    forall a. a -> [a] -> [a]
    : Bool -> SourcePos -> Text -> [Tok]
    totoks Bool
    atIsLetter (SourcePos -> Int -> SourcePos
    incSourceColumn SourcePos
    pos Int
    1) Text
    rest
             | Bool
    otherwise ->
               SourcePos -> TokType -> Text -> Tok
    Tok SourcePos
    pos TokType
    Symbol (Char -> Text
    T.singleton Char
    c) Tok -> [Tok] -> [Tok]
    forall a. a -> [a] -> [a]
    :
                 Bool -> SourcePos -> Text -> [Tok]
    totoks Bool
    atIsLetter (SourcePos -> Int -> SourcePos
    incSourceColumn SourcePos
    pos Int
    1) Text
    rest

    isSpaceOrTab :: Char -> Bool
    isSpaceOrTab :: Char -> Bool
    isSpaceOrTab Char
    ' '  = Bool
    True
    isSpaceOrTab Char
    '\t' = Bool
    True
    isSpaceOrTab Char
    _    = Bool
    False

    -- First parameter is True if @ is letter
    isLetter' :: Bool -> Char -> Bool
    isLetter' :: Bool -> Char -> Bool
    isLetter' Bool
    True Char
    '@' = Bool
    True
    isLetter' Bool
    _ Char
    c = Char -> Bool
    isLetter Char
    c

    isLetterOrAt :: Char -> Bool
    isLetterOrAt :: Char -> Bool
    isLetterOrAt Char
    '@' = Bool
    True
    isLetterOrAt Char
    c   = Char -> Bool
    isLetter Char
    c

    isLowerHex :: Char -> Bool
    isLowerHex :: Char -> Bool
    isLowerHex Char
    x = Char
    x Char -> Char -> Bool
    forall a. Ord a => a -> a -> Bool
    >= Char
    '0' Bool -> Bool -> Bool
    && Char
    x Char -> Char -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Char
    '9' Bool -> Bool -> Bool
    || Char
    x Char -> Char -> Bool
    forall a. Ord a => a -> a -> Bool
    >= Char
    'a' Bool -> Bool -> Bool
    && Char
    x Char -> Char -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Char
    'f'

    untokenize :: [Tok] -> Text
    untokenize :: [Tok] -> Text
    untokenize = (Tok -> Text -> Text) -> Text -> [Tok] -> Text
    forall a b. (a -> b -> b) -> b -> [a] -> b
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    foldr Tok -> Text -> Text
    untokenAccum Text
    forall a. Monoid a => a
    mempty

    untokenAccum :: Tok -> Text -> Text
    untokenAccum :: Tok -> Text -> Text
    untokenAccum (Tok SourcePos
    _ (CtrlSeq Text
    _) Text
    t) Text
    accum =
      -- insert space to prevent breaking a control sequence; see #5836
      case (Text -> Maybe (Text, Char)
    T.unsnoc Text
    t, Text -> Maybe (Char, Text)
    T.uncons Text
    accum) of
        (Just (Text
    _,Char
    c), Just (Char
    d,Text
    _))
          | Char -> Bool
    isLetter Char
    c
          , Char -> Bool
    isLetter Char
    d
          -> Text
    t Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Text
    " " Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Text
    accum
        (Maybe (Text, Char), Maybe (Char, Text))
    _ -> Text
    t Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Text
    accum
    untokenAccum (Tok SourcePos
    _ TokType
    _ Text
    t) Text
    accum = Text
    t Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Text
    accum

    untoken :: Tok -> Text
    untoken :: Tok -> Text
    untoken Tok
    t = Tok -> Text -> Text
    untokenAccum Tok
    t Text
    forall a. Monoid a => a
    mempty

    parseFromToks :: PandocMonad m => LP m a -> [Tok] -> LP m a
    parseFromToks :: forall (m :: * -> *) a. PandocMonad m => LP m a -> [Tok] -> LP m a
    parseFromToks LP m a
    parser [Tok]
    toks = do
      oldInput <- ParsecT TokStream LaTeXState m TokStream
    forall (m :: * -> *) s u. Monad m => ParsecT s u m s
    getInput
      setInput $ TokStream False toks
      oldpos <- getPosition
      case toks of
         Tok SourcePos
    pos TokType
    _ Text
    _ : [Tok]
    _ -> SourcePos -> ParsecT TokStream LaTeXState m ()
    forall (m :: * -> *) s u. Monad m => SourcePos -> ParsecT s u m ()
    setPosition SourcePos
    pos
         [Tok]
    _ -> () -> ParsecT TokStream LaTeXState m ()
    forall a. a -> ParsecT TokStream LaTeXState m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()
      -- we ignore existing raw tokens maps (see #9517)
      oldRawTokens <- sRawTokens <$> getState
      updateState $ \LaTeXState
    st -> LaTeXState
    st{ sRawTokens = mempty }
      result <- parser
      updateState $ \LaTeXState
    st -> LaTeXState
    st{ sRawTokens = oldRawTokens }
      setInput oldInput
      setPosition oldpos
      return result

    disablingWithRaw :: PandocMonad m => LP m a -> LP m a
    disablingWithRaw :: forall (m :: * -> *) a. PandocMonad m => LP m a -> LP m a
    disablingWithRaw LP m a
    parser = do
      oldEnableWithRaw <- LaTeXState -> Bool
    sEnableWithRaw (LaTeXState -> Bool)
    -> ParsecT TokStream LaTeXState m LaTeXState
    -> ParsecT TokStream LaTeXState m Bool
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT TokStream LaTeXState m LaTeXState
    forall (m :: * -> *) s u. Monad m => ParsecT s u m u
    getState
      updateState $ \LaTeXState
    st -> LaTeXState
    st{ sEnableWithRaw = False }
      result <- parser
      updateState $ \LaTeXState
    st -> LaTeXState
    st{ sEnableWithRaw = oldEnableWithRaw }
      return result

    satisfyTok :: PandocMonad m => (Tok -> Bool) -> LP m Tok
    satisfyTok :: forall (m :: * -> *). PandocMonad m => (Tok -> Bool) -> LP m Tok
    satisfyTok Tok -> Bool
    f = do
        LP m ()
    forall (m :: * -> *). PandocMonad m => LP m ()
    doMacros -- apply macros on remaining input stream
        res <- (Tok -> [Char])
    -> (SourcePos -> Tok -> TokStream -> SourcePos)
    -> (Tok -> Maybe Tok)
    -> ParsecT TokStream LaTeXState m Tok
    forall s (m :: * -> *) t a u.
    Stream s m t =>
    (t -> [Char])
    -> (SourcePos -> t -> s -> SourcePos)
    -> (t -> Maybe a)
    -> ParsecT s u m a
    tokenPrim (Text -> [Char]
    T.unpack (Text -> [Char]) -> (Tok -> Text) -> Tok -> [Char]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Tok -> Text
    untoken) SourcePos -> Tok -> TokStream -> SourcePos
    updatePos Tok -> Maybe Tok
    matcher
        updateState $ \LaTeXState
    st ->
          if LaTeXState -> Bool
    sEnableWithRaw LaTeXState
    st
             then
               let !newraws :: IntMap [Tok]
    newraws = ([Tok] -> [Tok]) -> IntMap [Tok] -> IntMap [Tok]
    forall a b. (a -> b) -> IntMap a -> IntMap b
    IntMap.map (Tok
    resTok -> [Tok] -> [Tok]
    forall a. a -> [a] -> [a]
    :) (IntMap [Tok] -> IntMap [Tok]) -> IntMap [Tok] -> IntMap [Tok]
    forall a b. (a -> b) -> a -> b
    $! LaTeXState -> IntMap [Tok]
    sRawTokens LaTeXState
    st
                in  LaTeXState
    st{ sRawTokens = newraws }
             else LaTeXState
    st
        return $! res
      where matcher :: Tok -> Maybe Tok
    matcher Tok
    t | Tok -> Bool
    f Tok
    t       = Tok -> Maybe Tok
    forall a. a -> Maybe a
    Just Tok
    t
                      | Bool
    otherwise = Maybe Tok
    forall a. Maybe a
    Nothing
            updatePos :: SourcePos -> Tok -> TokStream -> SourcePos
            updatePos :: SourcePos -> Tok -> TokStream -> SourcePos
    updatePos SourcePos
    _spos Tok
    _ (TokStream Bool
    _ (Tok SourcePos
    pos TokType
    _ Text
    _ : [Tok]
    _)) = SourcePos
    pos
            updatePos SourcePos
    spos (Tok SourcePos
    _ TokType
    _ Text
    t) TokStream
    _ = SourcePos -> Int -> SourcePos
    incSourceColumn SourcePos
    spos (Text -> Int
    T.length Text
    t)

    peekTok :: PandocMonad m => LP m Tok
    peekTok :: forall (m :: * -> *). PandocMonad m => LP m Tok
    peekTok = do
      LP m ()
    forall (m :: * -> *). PandocMonad m => LP m ()
    doMacros
      ParsecT TokStream LaTeXState m Tok
    -> ParsecT TokStream LaTeXState m Tok
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m a
    lookAhead ((Tok -> Bool) -> ParsecT TokStream LaTeXState m Tok
    forall (m :: * -> *). PandocMonad m => (Tok -> Bool) -> LP m Tok
    satisfyTok (Bool -> Tok -> Bool
    forall a b. a -> b -> a
    const Bool
    True))

    doMacros :: PandocMonad m => LP m ()
    doMacros :: forall (m :: * -> *). PandocMonad m => LP m ()
    doMacros = do
      TokStream macrosExpanded toks <- ParsecT TokStream LaTeXState m TokStream
    forall (m :: * -> *) s u. Monad m => ParsecT s u m s
    getInput
      unless macrosExpanded $ do
        st <- getState
        unless (sVerbatimMode st) $
          doMacros' 1 toks >>= setInput . TokStream True

    doMacros' :: PandocMonad m => Int -> [Tok] -> LP m [Tok]
    doMacros' :: forall (m :: * -> *). PandocMonad m => Int -> [Tok] -> LP m [Tok]
    doMacros' Int
    n [Tok]
    inp =
      case [Tok]
    inp of
         Tok SourcePos
    spos (CtrlSeq Text
    "begin") Text
    _ : Tok SourcePos
    _ TokType
    Symbol Text
    "{" :
          Tok SourcePos
    _ TokType
    Word Text
    name : Tok SourcePos
    _ TokType
    Symbol Text
    "}" : [Tok]
    ts
            -> Int -> SourcePos -> Text -> [Tok] -> LP m [Tok]
    forall {m :: * -> *}.
    PandocMonad m =>
    Int
    -> SourcePos
    -> Text
    -> [Tok]
    -> ParsecT TokStream LaTeXState m [Tok]
    handleMacros Int
    n SourcePos
    spos Text
    name [Tok]
    ts LP m [Tok] -> LP m [Tok] -> LP m [Tok]
    forall a.
    ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> [Tok] -> LP m [Tok]
    forall a. a -> ParsecT TokStream LaTeXState m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return [Tok]
    inp
         Tok SourcePos
    spos (CtrlSeq Text
    "end") Text
    _ : Tok SourcePos
    _ TokType
    Symbol Text
    "{" :
          Tok SourcePos
    _ TokType
    Word Text
    name : Tok SourcePos
    _ TokType
    Symbol Text
    "}" : [Tok]
    ts
            -> Int -> SourcePos -> Text -> [Tok] -> LP m [Tok]
    forall {m :: * -> *}.
    PandocMonad m =>
    Int
    -> SourcePos
    -> Text
    -> [Tok]
    -> ParsecT TokStream LaTeXState m [Tok]
    handleMacros Int
    n SourcePos
    spos (Text
    "end" Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Text
    name) [Tok]
    ts LP m [Tok] -> LP m [Tok] -> LP m [Tok]
    forall a.
    ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> [Tok] -> LP m [Tok]
    forall a. a -> ParsecT TokStream LaTeXState m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return [Tok]
    inp
         Tok SourcePos
    _ (CtrlSeq Text
    "expandafter") Text
    _ : Tok
    t : [Tok]
    ts
            -> Tok -> [Tok] -> [Tok]
    combineTok Tok
    t ([Tok] -> [Tok]) -> LP m [Tok] -> LP m [Tok]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Int -> [Tok] -> LP m [Tok]
    forall (m :: * -> *). PandocMonad m => Int -> [Tok] -> LP m [Tok]
    doMacros' Int
    n [Tok]
    ts
         Tok SourcePos
    spos (CtrlSeq Text
    name) Text
    _ : [Tok]
    ts
            -> Int -> SourcePos -> Text -> [Tok] -> LP m [Tok]
    forall {m :: * -> *}.
    PandocMonad m =>
    Int
    -> SourcePos
    -> Text
    -> [Tok]
    -> ParsecT TokStream LaTeXState m [Tok]
    handleMacros Int
    n SourcePos
    spos Text
    name [Tok]
    ts LP m [Tok] -> LP m [Tok] -> LP m [Tok]
    forall a.
    ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> [Tok] -> LP m [Tok]
    forall a. a -> ParsecT TokStream LaTeXState m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return [Tok]
    inp
         [Tok]
    _ -> [Tok] -> LP m [Tok]
    forall a. a -> ParsecT TokStream LaTeXState m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return [Tok]
    inp

      where
        combineTok :: Tok -> [Tok] -> [Tok]
    combineTok (Tok SourcePos
    spos (CtrlSeq Text
    name) Text
    x) (Tok SourcePos
    _ TokType
    Word Text
    w : [Tok]
    ts)
          | (Char -> Bool) -> Text -> Bool
    T.all Char -> Bool
    isLetterOrAt Text
    w =
            SourcePos -> TokType -> Text -> Tok
    Tok SourcePos
    spos (Text -> TokType
    CtrlSeq (Text
    name Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Text
    w)) (Text
    x1 Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Text
    w Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Text
    x2) Tok -> [Tok] -> [Tok]
    forall a. a -> [a] -> [a]
    : [Tok]
    ts
              where (Text
    x1, Text
    x2) = (Char -> Bool) -> Text -> (Text, Text)
    T.break Char -> Bool
    isSpaceOrTab Text
    x
        combineTok Tok
    t [Tok]
    ts = Tok
    tTok -> [Tok] -> [Tok]
    forall a. a -> [a] -> [a]
    :[Tok]
    ts

        matchTok :: Tok -> LP m Tok
    matchTok (Tok SourcePos
    _ TokType
    toktype Text
    txt) =
          (Tok -> Bool) -> LP m Tok
    forall (m :: * -> *). PandocMonad m => (Tok -> Bool) -> LP m Tok
    satisfyTok (\(Tok SourcePos
    _ TokType
    toktype' Text
    txt') ->
                        TokType
    toktype TokType -> TokType -> Bool
    forall a. Eq a => a -> a -> Bool
    == TokType
    toktype' Bool -> Bool -> Bool
    &&
                        Text
    txt Text -> Text -> Bool
    forall a. Eq a => a -> a -> Bool
    == Text
    txt')

        matchPattern :: t Tok -> ParsecT TokStream LaTeXState m ()
    matchPattern t Tok
    toks = ParsecT TokStream LaTeXState m ()
    -> ParsecT TokStream LaTeXState m ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT TokStream LaTeXState m ()
     -> ParsecT TokStream LaTeXState m ())
    -> ParsecT TokStream LaTeXState m ()
    -> ParsecT TokStream LaTeXState m ()
    forall a b. (a -> b) -> a -> b
    $ (Tok -> ParsecT TokStream LaTeXState m Tok)
    -> t Tok -> ParsecT TokStream LaTeXState m ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    (a -> m b) -> t a -> m ()
    mapM_ Tok -> ParsecT TokStream LaTeXState m Tok
    forall {m :: * -> *}. PandocMonad m => Tok -> LP m Tok
    matchTok t Tok
    toks

        getargs :: Map Int [Tok]
    -> [ArgSpec] -> ParsecT TokStream LaTeXState m (Map Int [Tok])
    getargs Map Int [Tok]
    argmap [] = Map Int [Tok] -> ParsecT TokStream LaTeXState m (Map Int [Tok])
    forall a. a -> ParsecT TokStream LaTeXState m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Map Int [Tok]
    argmap
        getargs Map Int [Tok]
    argmap (Pattern [Tok]
    toks : [ArgSpec]
    rest) = ParsecT TokStream LaTeXState m (Map Int [Tok])
    -> ParsecT TokStream LaTeXState m (Map Int [Tok])
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT TokStream LaTeXState m (Map Int [Tok])
     -> ParsecT TokStream LaTeXState m (Map Int [Tok]))
    -> ParsecT TokStream LaTeXState m (Map Int [Tok])
    -> ParsecT TokStream LaTeXState m (Map Int [Tok])
    forall a b. (a -> b) -> a -> b
    $ do
           [Tok] -> ParsecT TokStream LaTeXState m ()
    forall {t :: * -> *} {m :: * -> *}.
    (Foldable t, PandocMonad m) =>
    t Tok -> ParsecT TokStream LaTeXState m ()
    matchPattern [Tok]
    toks
           Map Int [Tok]
    -> [ArgSpec] -> ParsecT TokStream LaTeXState m (Map Int [Tok])
    getargs Map Int [Tok]
    argmap [ArgSpec]
    rest
        getargs Map Int [Tok]
    argmap (ArgNum Int
    i : Pattern [Tok]
    toks : [ArgSpec]
    rest) =
          ParsecT TokStream LaTeXState m (Map Int [Tok])
    -> ParsecT TokStream LaTeXState m (Map Int [Tok])
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT TokStream LaTeXState m (Map Int [Tok])
     -> ParsecT TokStream LaTeXState m (Map Int [Tok]))
    -> ParsecT TokStream LaTeXState m (Map Int [Tok])
    -> ParsecT TokStream LaTeXState m (Map Int [Tok])
    forall a b. (a -> b) -> a -> b
    $ do
            x <- [[Tok]] -> [Tok]
    forall a. Monoid a => [a] -> a
    mconcat ([[Tok]] -> [Tok])
    -> ParsecT TokStream LaTeXState m [[Tok]]
    -> ParsecT TokStream LaTeXState m [Tok]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT TokStream LaTeXState m [Tok]
    -> ParsecT TokStream LaTeXState m ()
    -> ParsecT TokStream LaTeXState m [[Tok]]
    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 TokStream LaTeXState m [Tok]
    forall (m :: * -> *). PandocMonad m => LP m [Tok]
    braced ParsecT TokStream LaTeXState m [Tok]
    -> ParsecT TokStream LaTeXState m [Tok]
    -> ParsecT TokStream LaTeXState m [Tok]
    forall a.
    ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> ((Tok -> [Tok] -> [Tok]
    forall a. a -> [a] -> [a]
    :[]) (Tok -> [Tok])
    -> ParsecT TokStream LaTeXState m Tok
    -> ParsecT TokStream LaTeXState m [Tok]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT TokStream LaTeXState m Tok
    forall (m :: * -> *). PandocMonad m => LP m Tok
    anyTok))
                      ([Tok] -> ParsecT TokStream LaTeXState m ()
    forall {t :: * -> *} {m :: * -> *}.
    (Foldable t, PandocMonad m) =>
    t Tok -> ParsecT TokStream LaTeXState m ()
    matchPattern [Tok]
    toks)
            getargs (M.insert i x argmap) rest
        getargs Map Int [Tok]
    argmap (ArgNum Int
    i : [ArgSpec]
    rest) = do
          x <- ParsecT TokStream LaTeXState m [Tok]
    -> ParsecT TokStream LaTeXState m [Tok]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT TokStream LaTeXState m [Tok]
     -> ParsecT TokStream LaTeXState m [Tok])
    -> ParsecT TokStream LaTeXState m [Tok]
    -> ParsecT TokStream LaTeXState m [Tok]
    forall a b. (a -> b) -> a -> b
    $ ParsecT TokStream LaTeXState m ()
    forall (m :: * -> *). PandocMonad m => LP m ()
    spaces ParsecT TokStream LaTeXState m ()
    -> ParsecT TokStream LaTeXState m [Tok]
    -> ParsecT TokStream LaTeXState m [Tok]
    forall a b.
    ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m b
    -> ParsecT TokStream LaTeXState m b
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> ParsecT TokStream LaTeXState m [Tok]
    forall (m :: * -> *). PandocMonad m => LP m [Tok]
    bracedOrToken
          getargs (M.insert i x argmap) rest

        addTok :: Bool -> Map Int (t Tok) -> SourcePos -> Tok -> [Tok] -> [Tok]
    addTok Bool
    False Map Int (t Tok)
    _args SourcePos
    spos (Tok SourcePos
    _ (DeferredArg Int
    i) Text
    txt) [Tok]
    acc =
          SourcePos -> TokType -> Text -> Tok
    Tok SourcePos
    spos (Int -> TokType
    Arg Int
    i) Text
    txt Tok -> [Tok] -> [Tok]
    forall a. a -> [a] -> [a]
    : [Tok]
    acc
        addTok Bool
    False Map Int (t Tok)
    args SourcePos
    spos (Tok SourcePos
    _ (Arg Int
    i) Text
    _) [Tok]
    acc =
           case Int -> Map Int (t Tok) -> Maybe (t Tok)
    forall k a. Ord k => k -> Map k a -> Maybe a
    M.lookup Int
    i Map Int (t Tok)
    args of
                Maybe (t Tok)
    Nothing -> [Tok]
    forall a. [a]
    forall (m :: * -> *) a. MonadPlus m => m a
    mzero
                Just t Tok
    xs -> (Tok -> [Tok] -> [Tok]) -> [Tok] -> t Tok -> [Tok]
    forall a b. (a -> b -> b) -> b -> t a -> b
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    foldr (Bool -> Map Int (t Tok) -> SourcePos -> Tok -> [Tok] -> [Tok]
    addTok Bool
    True Map Int (t Tok)
    args SourcePos
    spos) [Tok]
    acc t Tok
    xs
        -- see #4007
        addTok Bool
    _ Map Int (t Tok)
    _ SourcePos
    spos (Tok SourcePos
    _ (CtrlSeq Text
    x) Text
    txt)
               acc :: [Tok]
    acc@(Tok SourcePos
    _ TokType
    Word Text
    _ : [Tok]
    _)
          | Bool -> Bool
    not (Text -> Bool
    T.null Text
    txt)
          , Char -> Bool
    isLetter (HasCallStack => Text -> Char
    Text -> Char
    T.last Text
    txt) =
            SourcePos -> TokType -> Text -> Tok
    Tok SourcePos
    spos (Text -> TokType
    CtrlSeq Text
    x) (Text
    txt Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Text
    " ") Tok -> [Tok] -> [Tok]
    forall a. a -> [a] -> [a]
    : [Tok]
    acc
        addTok Bool
    _ Map Int (t Tok)
    _ SourcePos
    spos Tok
    t [Tok]
    acc = SourcePos -> Tok -> Tok
    setpos SourcePos
    spos Tok
    t Tok -> [Tok] -> [Tok]
    forall a. a -> [a] -> [a]
    : [Tok]
    acc

        handleMacros :: Int
    -> SourcePos
    -> Text
    -> [Tok]
    -> ParsecT TokStream LaTeXState m [Tok]
    handleMacros Int
    n' SourcePos
    spos Text
    name [Tok]
    ts = do
          Bool
    -> ParsecT TokStream LaTeXState m ()
    -> ParsecT TokStream LaTeXState m ()
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    when (Int
    n' Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    > Int
    20)  -- detect macro expansion loops
            (ParsecT TokStream LaTeXState m ()
     -> ParsecT TokStream LaTeXState m ())
    -> ParsecT TokStream LaTeXState m ()
    -> ParsecT TokStream LaTeXState m ()
    forall a b. (a -> b) -> a -> b
    $ PandocError -> ParsecT TokStream LaTeXState m ()
    forall a. PandocError -> ParsecT TokStream LaTeXState m a
    forall e (m :: * -> *) a. MonadError e m => e -> m a
    throwError (PandocError -> ParsecT TokStream LaTeXState m ())
    -> PandocError -> ParsecT TokStream LaTeXState m ()
    forall a b. (a -> b) -> a -> b
    $ Text -> PandocError
    PandocMacroLoop Text
    name
          (macros :| _ ) <- LaTeXState -> NonEmpty (Map Text Macro)
    sMacros (LaTeXState -> NonEmpty (Map Text Macro))
    -> ParsecT TokStream LaTeXState m LaTeXState
    -> ParsecT TokStream LaTeXState m (NonEmpty (Map Text Macro))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT TokStream LaTeXState m LaTeXState
    forall (m :: * -> *) s u. Monad m => ParsecT s u m u
    getState
          case M.lookup name macros of
               Maybe Macro
    Nothing -> Text -> [Tok] -> ParsecT TokStream LaTeXState m [Tok]
    forall (m :: * -> *). PandocMonad m => Text -> [Tok] -> LP m [Tok]
    trySpecialMacro Text
    name [Tok]
    ts
               Just (Macro MacroScope
    _scope ExpansionPoint
    expansionPoint [ArgSpec]
    argspecs Maybe [Tok]
    optarg [Tok]
    newtoks) -> do
                 let getargs' :: ParsecT TokStream LaTeXState m (Map Int [Tok], [Tok])
    getargs' = do
                       args <-
                         (case ExpansionPoint
    expansionPoint of
                            ExpansionPoint
    ExpandWhenUsed    -> LP m (Map Int [Tok]) -> LP m (Map Int [Tok])
    forall (m :: * -> *) a. PandocMonad m => LP m a -> LP m a
    withVerbatimMode
                            ExpansionPoint
    ExpandWhenDefined -> LP m (Map Int [Tok]) -> LP m (Map Int [Tok])
    forall a. a -> a
    id)
                         (LP m (Map Int [Tok]) -> LP m (Map Int [Tok]))
    -> LP m (Map Int [Tok]) -> LP m (Map Int [Tok])
    forall a b. (a -> b) -> a -> b
    $ case Maybe [Tok]
    optarg of
                                 Maybe [Tok]
    Nothing -> Map Int [Tok] -> [ArgSpec] -> LP m (Map Int [Tok])
    forall {m :: * -> *}.
    PandocMonad m =>
    Map Int [Tok]
    -> [ArgSpec] -> ParsecT TokStream LaTeXState m (Map Int [Tok])
    getargs Map Int [Tok]
    forall k a. Map k a
    M.empty [ArgSpec]
    argspecs
                                 Just [Tok]
    o  -> do
                                    x <- [Tok]
    -> ParsecT TokStream LaTeXState m [Tok]
    -> ParsecT TokStream LaTeXState m [Tok]
    forall s (m :: * -> *) t a u.
    Stream s m t =>
    a -> ParsecT s u m a -> ParsecT s u m a
    option [Tok]
    o ParsecT TokStream LaTeXState m [Tok]
    forall (m :: * -> *). PandocMonad m => LP m [Tok]
    bracketedToks
                                    getargs (M.singleton 1 x) $ drop 1 argspecs
                       TokStream _ rest <- getInput
                       return (args, rest)
                 lstate <- ParsecT TokStream LaTeXState m LaTeXState
    forall (m :: * -> *) s u. Monad m => ParsecT s u m u
    getState
                 res <- lift $ runParserT getargs' lstate "args" $ TokStream False ts
                 case res of
                   Left ParseError
    _ -> [Char] -> ParsecT TokStream LaTeXState m [Tok]
    forall a. [Char] -> ParsecT TokStream LaTeXState m a
    forall (m :: * -> *) a. MonadFail m => [Char] -> m a
    Prelude.fail ([Char] -> ParsecT TokStream LaTeXState m [Tok])
    -> [Char] -> ParsecT TokStream LaTeXState m [Tok]
    forall a b. (a -> b) -> a -> b
    $ [Char]
    "Could not parse arguments for " [Char] -> ShowS
    forall a. [a] -> [a] -> [a]
    ++
                                    Text -> [Char]
    T.unpack Text
    name
                   Right (Map Int [Tok]
    args, [Tok]
    rest) -> do
                     -- first boolean param is true if we're tokenizing
                     -- an argument (in which case we don't want to
                     -- expand #1 etc.)
                     let result :: [Tok]
    result = (Tok -> [Tok] -> [Tok]) -> [Tok] -> [Tok] -> [Tok]
    forall a b. (a -> b -> b) -> b -> [a] -> b
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    foldr (Bool -> Map Int [Tok] -> SourcePos -> Tok -> [Tok] -> [Tok]
    forall {t :: * -> *}.
    Foldable t =>
    Bool -> Map Int (t Tok) -> SourcePos -> Tok -> [Tok] -> [Tok]
    addTok Bool
    False Map Int [Tok]
    args SourcePos
    spos) [Tok]
    rest [Tok]
    newtoks
                     case ExpansionPoint
    expansionPoint of
                       ExpansionPoint
    ExpandWhenUsed    -> Int -> [Tok] -> ParsecT TokStream LaTeXState m [Tok]
    forall (m :: * -> *). PandocMonad m => Int -> [Tok] -> LP m [Tok]
    doMacros' (Int
    n' Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1) [Tok]
    result
                       ExpansionPoint
    ExpandWhenDefined -> [Tok] -> ParsecT TokStream LaTeXState m [Tok]
    forall a. a -> ParsecT TokStream LaTeXState m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return [Tok]
    result

    -- | Certain macros do low-level tex manipulations that can't
    -- be represented in our Macro type, so we handle them here.
    trySpecialMacro :: PandocMonad m => Text -> [Tok] -> LP m [Tok]
    trySpecialMacro :: forall (m :: * -> *). PandocMonad m => Text -> [Tok] -> LP m [Tok]
    trySpecialMacro Text
    "xspace" [Tok]
    ts = do
      ts' <- Int -> [Tok] -> LP m [Tok]
    forall (m :: * -> *). PandocMonad m => Int -> [Tok] -> LP m [Tok]
    doMacros' Int
    1 [Tok]
    ts
      case ts' of
        Tok SourcePos
    pos TokType
    Word Text
    t : [Tok]
    _
          | Text -> Bool
    startsWithAlphaNum Text
    t -> [Tok] -> LP m [Tok]
    forall a. a -> ParsecT TokStream LaTeXState m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ([Tok] -> LP m [Tok]) -> [Tok] -> LP m [Tok]
    forall a b. (a -> b) -> a -> b
    $ SourcePos -> TokType -> Text -> Tok
    Tok SourcePos
    pos TokType
    Spaces Text
    " " Tok -> [Tok] -> [Tok]
    forall a. a -> [a] -> [a]
    : [Tok]
    ts'
        [Tok]
    _ -> [Tok] -> LP m [Tok]
    forall a. a -> ParsecT TokStream LaTeXState m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return [Tok]
    ts'
    trySpecialMacro Text
    "iftrue" [Tok]
    ts = LP m [Tok] -> [Tok] -> LP m [Tok]
    forall (m :: * -> *).
    PandocMonad m =>
    LP m [Tok] -> [Tok] -> LP m [Tok]
    handleIf (Bool -> LP m [Tok]
    forall (m :: * -> *). PandocMonad m => Bool -> LP m [Tok]
    ifParser Bool
    True) [Tok]
    ts
    trySpecialMacro Text
    "iffalse" [Tok]
    ts = LP m [Tok] -> [Tok] -> LP m [Tok]
    forall (m :: * -> *).
    PandocMonad m =>
    LP m [Tok] -> [Tok] -> LP m [Tok]
    handleIf (Bool -> LP m [Tok]
    forall (m :: * -> *). PandocMonad m => Bool -> LP m [Tok]
    ifParser Bool
    False) [Tok]
    ts
    trySpecialMacro Text
    "ifmmode" [Tok]
    ts = do
      mathMode <- LaTeXState -> Bool
    sMathMode (LaTeXState -> Bool)
    -> ParsecT TokStream LaTeXState m LaTeXState
    -> ParsecT TokStream LaTeXState m Bool
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT TokStream LaTeXState m LaTeXState
    forall (m :: * -> *) s u. Monad m => ParsecT s u m u
    getState
      handleIf (ifParser mathMode) ts
    trySpecialMacro Text
    "ifstrequal" [Tok]
    ts = do
      LP m [Tok] -> [Tok] -> LP m [Tok]
    forall (m :: * -> *).
    PandocMonad m =>
    LP m [Tok] -> [Tok] -> LP m [Tok]
    handleIf LP m [Tok]
    forall (m :: * -> *). PandocMonad m => LP m [Tok]
    ifStrequalParser [Tok]
    ts
    trySpecialMacro Text
    _ [Tok]
    _ = LP m [Tok]
    forall a. ParsecT TokStream LaTeXState m a
    forall (m :: * -> *) a. MonadPlus m => m a
    mzero

    ifStrequalParser :: PandocMonad m => LP m [Tok]
    ifStrequalParser :: forall (m :: * -> *). PandocMonad m => LP m [Tok]
    ifStrequalParser = do
      str1 <- LP m [Tok]
    forall (m :: * -> *). PandocMonad m => LP m [Tok]
    braced LP m [Tok] -> LP m [Tok] -> LP m [Tok]
    forall a.
    ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> Int -> ParsecT TokStream LaTeXState m Tok -> LP m [Tok]
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    Int -> ParsecT s u m a -> ParsecT s u m [a]
    count Int
    1 ParsecT TokStream LaTeXState m Tok
    forall (m :: * -> *). PandocMonad m => LP m Tok
    anyTok
      str2 <- braced <|> count 1 anyTok
      ifequal <- withVerbatimMode (braced <|> count 1 anyTok)
      ifnotequal <- withVerbatimMode (braced <|> count 1 anyTok)
      TokStream _ ts <- getInput
      return $
        if untokenize str1 == untokenize str2
           then ifequal ++ ts
           else ifnotequal ++ ts

    handleIf :: PandocMonad m => LP m [Tok] -> [Tok] -> LP m [Tok]
    handleIf :: forall (m :: * -> *).
    PandocMonad m =>
    LP m [Tok] -> [Tok] -> LP m [Tok]
    handleIf LP m [Tok]
    parser [Tok]
    ts = do
      res' <- m (Either ParseError [Tok])
    -> ParsecT TokStream LaTeXState m (Either ParseError [Tok])
    forall (m :: * -> *) a.
    Monad m =>
    m a -> ParsecT TokStream LaTeXState m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (m (Either ParseError [Tok])
     -> ParsecT TokStream LaTeXState m (Either ParseError [Tok]))
    -> m (Either ParseError [Tok])
    -> ParsecT TokStream LaTeXState m (Either ParseError [Tok])
    forall a b. (a -> b) -> a -> b
    $ LP m [Tok]
    -> LaTeXState -> [Char] -> TokStream -> m (Either ParseError [Tok])
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> u -> [Char] -> s -> m (Either ParseError a)
    runParserT LP m [Tok]
    parser LaTeXState
    defaultLaTeXState [Char]
    "tokens"
                   (TokStream -> m (Either ParseError [Tok]))
    -> TokStream -> m (Either ParseError [Tok])
    forall a b. (a -> b) -> a -> b
    $ Bool -> [Tok] -> TokStream
    TokStream Bool
    False [Tok]
    ts
      case res' of
        Left ParseError
    _ -> [Char] -> LP m [Tok]
    forall a. [Char] -> ParsecT TokStream LaTeXState m a
    forall (m :: * -> *) a. MonadFail m => [Char] -> m a
    Prelude.fail [Char]
    "Could not parse conditional"
        Right [Tok]
    ts' -> [Tok] -> LP m [Tok]
    forall a. a -> ParsecT TokStream LaTeXState m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return [Tok]
    ts'

    ifParser :: PandocMonad m => Bool -> LP m [Tok]
    ifParser :: forall (m :: * -> *). PandocMonad m => Bool -> LP m [Tok]
    ifParser Bool
    b = do
      ifToks <- ParsecT TokStream LaTeXState m Tok
    -> ParsecT TokStream LaTeXState m [Tok]
    forall a.
    ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m [a]
    forall (f :: * -> *) a. Alternative f => f a -> f [a]
    many (ParsecT TokStream LaTeXState m Tok
    -> ParsecT TokStream LaTeXState m ()
    forall s (m :: * -> *) t a u.
    (Stream s m t, Show a) =>
    ParsecT s u m a -> ParsecT s u m ()
    notFollowedBy (Text -> ParsecT TokStream LaTeXState m Tok
    forall (m :: * -> *). PandocMonad m => Text -> LP m Tok
    controlSeq Text
    "else" ParsecT TokStream LaTeXState m Tok
    -> ParsecT TokStream LaTeXState m Tok
    -> ParsecT TokStream LaTeXState m Tok
    forall a.
    ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> Text -> ParsecT TokStream LaTeXState m Tok
    forall (m :: * -> *). PandocMonad m => Text -> LP m Tok
    controlSeq Text
    "fi")
                        ParsecT TokStream LaTeXState m ()
    -> ParsecT TokStream LaTeXState m Tok
    -> ParsecT TokStream LaTeXState m Tok
    forall a b.
    ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m b
    -> ParsecT TokStream LaTeXState m b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> ParsecT TokStream LaTeXState m Tok
    forall (m :: * -> *). PandocMonad m => LP m Tok
    anyTok)
      elseToks <- (controlSeq "else" >> manyTill anyTok (controlSeq "fi"))
                     <|> ([] <$ controlSeq "fi")
      TokStream _ rest <- getInput
      return $ (if b then ifToks else elseToks) ++ rest

    startsWithAlphaNum :: Text -> Bool
    startsWithAlphaNum :: Text -> Bool
    startsWithAlphaNum Text
    t =
      case Text -> Maybe (Char, Text)
    T.uncons Text
    t of
           Just (Char
    c, Text
    _) | Char -> Bool
    isAlphaNum Char
    c -> Bool
    True
           Maybe (Char, Text)
    _           -> Bool
    False

    setpos :: SourcePos -> Tok -> Tok
    setpos :: SourcePos -> Tok -> Tok
    setpos SourcePos
    spos (Tok SourcePos
    _ TokType
    tt Text
    txt) = SourcePos -> TokType -> Text -> Tok
    Tok SourcePos
    spos TokType
    tt Text
    txt

    anyControlSeq :: PandocMonad m => LP m Tok
    anyControlSeq :: forall (m :: * -> *). PandocMonad m => LP m Tok
    anyControlSeq = (Tok -> Bool) -> LP m Tok
    forall (m :: * -> *). PandocMonad m => (Tok -> Bool) -> LP m Tok
    satisfyTok Tok -> Bool
    isCtrlSeq

    isCtrlSeq :: Tok -> Bool
    isCtrlSeq :: Tok -> Bool
    isCtrlSeq (Tok SourcePos
    _ (CtrlSeq Text
    _) Text
    _) = Bool
    True
    isCtrlSeq Tok
    _                     = Bool
    False

    anySymbol :: PandocMonad m => LP m Tok
    anySymbol :: forall (m :: * -> *). PandocMonad m => LP m Tok
    anySymbol = (Tok -> Bool) -> LP m Tok
    forall (m :: * -> *). PandocMonad m => (Tok -> Bool) -> LP m Tok
    satisfyTok Tok -> Bool
    isSymbolTok

    isSymbolTok :: Tok -> Bool
    isSymbolTok :: Tok -> Bool
    isSymbolTok (Tok SourcePos
    _ TokType
    Symbol Text
    _) = Bool
    True
    isSymbolTok Tok
    _                = Bool
    False

    isWordTok :: Tok -> Bool
    isWordTok :: Tok -> Bool
    isWordTok (Tok SourcePos
    _ TokType
    Word Text
    _) = Bool
    True
    isWordTok Tok
    _              = Bool
    False

    isArgTok :: Tok -> Bool
    isArgTok :: Tok -> Bool
    isArgTok (Tok SourcePos
    _ (Arg Int
    _) Text
    _) = Bool
    True
    isArgTok Tok
    _                 = Bool
    False

    infile :: PandocMonad m => SourceName -> LP m Tok
    infile :: forall (m :: * -> *). PandocMonad m => [Char] -> LP m Tok
    infile [Char]
    reference = (Tok -> Bool) -> LP m Tok
    forall (m :: * -> *). PandocMonad m => (Tok -> Bool) -> LP m Tok
    satisfyTok (\(Tok SourcePos
    source TokType
    _ Text
    _) -> (SourcePos -> [Char]
    sourceName SourcePos
    source) [Char] -> [Char] -> Bool
    forall a. Eq a => a -> a -> Bool
    == [Char]
    reference)

    spaces :: PandocMonad m => LP m ()
    spaces :: forall (m :: * -> *). PandocMonad m => LP m ()
    spaces = ParsecT TokStream LaTeXState m Tok
    -> ParsecT TokStream LaTeXState m ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m ()
    skipMany ((Tok -> Bool) -> ParsecT TokStream LaTeXState m Tok
    forall (m :: * -> *). PandocMonad m => (Tok -> Bool) -> LP m Tok
    satisfyTok ([TokType] -> Tok -> Bool
    tokTypeIn [TokType
    Comment, TokType
    Spaces, TokType
    Newline]))

    spaces1 :: PandocMonad m => LP m ()
    spaces1 :: forall (m :: * -> *). PandocMonad m => LP m ()
    spaces1 = ParsecT TokStream LaTeXState m Tok
    -> ParsecT TokStream LaTeXState m ()
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m ()
    skipMany1 ((Tok -> Bool) -> ParsecT TokStream LaTeXState m Tok
    forall (m :: * -> *). PandocMonad m => (Tok -> Bool) -> LP m Tok
    satisfyTok ([TokType] -> Tok -> Bool
    tokTypeIn [TokType
    Comment, TokType
    Spaces, TokType
    Newline]))

    tokTypeIn :: [TokType] -> Tok -> Bool
    tokTypeIn :: [TokType] -> Tok -> Bool
    tokTypeIn [TokType]
    toktypes (Tok SourcePos
    _ TokType
    tt Text
    _) = TokType
    tt TokType -> [TokType] -> Bool
    forall a. Eq a => a -> [a] -> Bool
    forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
    `elem` [TokType]
    toktypes

    controlSeq :: PandocMonad m => Text -> LP m Tok
    controlSeq :: forall (m :: * -> *). PandocMonad m => Text -> LP m Tok
    controlSeq Text
    name = (Tok -> Bool) -> LP m Tok
    forall (m :: * -> *). PandocMonad m => (Tok -> Bool) -> LP m Tok
    satisfyTok Tok -> Bool
    isNamed
      where isNamed :: Tok -> Bool
    isNamed (Tok SourcePos
    _ (CtrlSeq Text
    n) Text
    _) = Text
    n Text -> Text -> Bool
    forall a. Eq a => a -> a -> Bool
    == Text
    name
            isNamed Tok
    _                     = Bool
    False

    symbol :: PandocMonad m => Char -> LP m Tok
    symbol :: forall (m :: * -> *). PandocMonad m => Char -> LP m Tok
    symbol Char
    c = (Tok -> Bool) -> LP m Tok
    forall (m :: * -> *). PandocMonad m => (Tok -> Bool) -> LP m Tok
    satisfyTok Tok -> Bool
    isc
      where isc :: Tok -> Bool
    isc (Tok SourcePos
    _ TokType
    Symbol Text
    d) = case Text -> Maybe (Char, Text)
    T.uncons Text
    d of
                                        Just (Char
    c',Text
    _) -> Char
    c Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    == Char
    c'
                                        Maybe (Char, Text)
    _           -> Bool
    False
            isc Tok
    _ = Bool
    False

    symbolIn :: PandocMonad m => [Char] -> LP m Tok
    symbolIn :: forall (m :: * -> *). PandocMonad m => [Char] -> LP m Tok
    symbolIn [Char]
    cs = (Tok -> Bool) -> LP m Tok
    forall (m :: * -> *). PandocMonad m => (Tok -> Bool) -> LP m Tok
    satisfyTok Tok -> Bool
    isInCs
      where isInCs :: Tok -> Bool
    isInCs (Tok SourcePos
    _ TokType
    Symbol Text
    d) = case Text -> Maybe (Char, Text)
    T.uncons Text
    d of
                                           Just (Char
    c,Text
    _) -> Char
    c Char -> [Char] -> Bool
    forall a. Eq a => a -> [a] -> Bool
    forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
    `elem` [Char]
    cs
                                           Maybe (Char, Text)
    _          -> Bool
    False
            isInCs Tok
    _ = Bool
    False

    sp :: PandocMonad m => LP m ()
    sp :: forall (m :: * -> *). PandocMonad m => LP m ()
    sp = do
      ParsecT TokStream LaTeXState m ()
    -> ParsecT TokStream LaTeXState m ()
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m ()
    optional (ParsecT TokStream LaTeXState m ()
     -> ParsecT TokStream LaTeXState m ())
    -> ParsecT TokStream LaTeXState m ()
    -> ParsecT TokStream LaTeXState m ()
    forall a b. (a -> b) -> a -> b
    $ ParsecT TokStream LaTeXState m ()
    -> ParsecT TokStream LaTeXState m ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m ()
    skipMany (ParsecT TokStream LaTeXState m ()
    forall (m :: * -> *). PandocMonad m => LP m ()
    whitespace ParsecT TokStream LaTeXState m ()
    -> ParsecT TokStream LaTeXState m ()
    -> ParsecT TokStream LaTeXState m ()
    forall a.
    ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> ParsecT TokStream LaTeXState m ()
    forall (m :: * -> *). PandocMonad m => LP m ()
    comment)
      ParsecT TokStream LaTeXState m ()
    -> ParsecT TokStream LaTeXState m ()
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m ()
    optional (ParsecT TokStream LaTeXState m ()
     -> ParsecT TokStream LaTeXState m ())
    -> ParsecT TokStream LaTeXState m ()
    -> ParsecT TokStream LaTeXState m ()
    forall a b. (a -> b) -> a -> b
    $ ParsecT TokStream LaTeXState m ()
    forall (m :: * -> *). PandocMonad m => LP m ()
    endline  ParsecT TokStream LaTeXState m ()
    -> ParsecT TokStream LaTeXState m ()
    -> ParsecT TokStream LaTeXState m ()
    forall a b.
    ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m b
    -> ParsecT TokStream LaTeXState m b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> ParsecT TokStream LaTeXState m ()
    -> ParsecT TokStream LaTeXState m ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m ()
    skipMany (ParsecT TokStream LaTeXState m ()
    forall (m :: * -> *). PandocMonad m => LP m ()
    whitespace ParsecT TokStream LaTeXState m ()
    -> ParsecT TokStream LaTeXState m ()
    -> ParsecT TokStream LaTeXState m ()
    forall a.
    ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> ParsecT TokStream LaTeXState m ()
    forall (m :: * -> *). PandocMonad m => LP m ()
    comment)

    whitespace :: PandocMonad m => LP m ()
    whitespace :: forall (m :: * -> *). PandocMonad m => LP m ()
    whitespace = () ()
    -> ParsecT TokStream LaTeXState m Tok
    -> ParsecT TokStream LaTeXState m ()
    forall a b.
    a
    -> ParsecT TokStream LaTeXState m b
    -> ParsecT TokStream LaTeXState m a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ (Tok -> Bool) -> ParsecT TokStream LaTeXState m Tok
    forall (m :: * -> *). PandocMonad m => (Tok -> Bool) -> LP m Tok
    satisfyTok Tok -> Bool
    isSpaceTok

    isSpaceTok :: Tok -> Bool
    isSpaceTok :: Tok -> Bool
    isSpaceTok (Tok SourcePos
    _ TokType
    Spaces Text
    _) = Bool
    True
    isSpaceTok Tok
    _                = Bool
    False

    newlineTok :: PandocMonad m => LP m ()
    newlineTok :: forall (m :: * -> *). PandocMonad m => LP m ()
    newlineTok = () ()
    -> ParsecT TokStream LaTeXState m Tok
    -> ParsecT TokStream LaTeXState m ()
    forall a b.
    a
    -> ParsecT TokStream LaTeXState m b
    -> ParsecT TokStream LaTeXState m a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ (Tok -> Bool) -> ParsecT TokStream LaTeXState m Tok
    forall (m :: * -> *). PandocMonad m => (Tok -> Bool) -> LP m Tok
    satisfyTok Tok -> Bool
    isNewlineTok

    isNewlineTok :: Tok -> Bool
    isNewlineTok :: Tok -> Bool
    isNewlineTok (Tok SourcePos
    _ TokType
    Newline Text
    _) = Bool
    True
    isNewlineTok Tok
    _                 = Bool
    False

    comment :: PandocMonad m => LP m ()
    comment :: forall (m :: * -> *). PandocMonad m => LP m ()
    comment = () ()
    -> ParsecT TokStream LaTeXState m Tok
    -> ParsecT TokStream LaTeXState m ()
    forall a b.
    a
    -> ParsecT TokStream LaTeXState m b
    -> ParsecT TokStream LaTeXState m a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ (Tok -> Bool) -> ParsecT TokStream LaTeXState m Tok
    forall (m :: * -> *). PandocMonad m => (Tok -> Bool) -> LP m Tok
    satisfyTok Tok -> Bool
    isCommentTok

    isCommentTok :: Tok -> Bool
    isCommentTok :: Tok -> Bool
    isCommentTok (Tok SourcePos
    _ TokType
    Comment Text
    _) = Bool
    True
    isCommentTok Tok
    _                 = Bool
    False

    anyTok :: PandocMonad m => LP m Tok
    anyTok :: forall (m :: * -> *). PandocMonad m => LP m Tok
    anyTok = (Tok -> Bool) -> LP m Tok
    forall (m :: * -> *). PandocMonad m => (Tok -> Bool) -> LP m Tok
    satisfyTok (Bool -> Tok -> Bool
    forall a b. a -> b -> a
    const Bool
    True)

    singleCharTok :: PandocMonad m => LP m Tok
    singleCharTok :: forall (m :: * -> *). PandocMonad m => LP m Tok
    singleCharTok =
      (Tok -> Bool) -> LP m Tok
    forall (m :: * -> *). PandocMonad m => (Tok -> Bool) -> LP m Tok
    satisfyTok ((Tok -> Bool) -> LP m Tok) -> (Tok -> Bool) -> LP m Tok
    forall a b. (a -> b) -> a -> b
    $ \case
         Tok SourcePos
    _ TokType
    Word  Text
    t   -> Text -> Int
    T.length Text
    t Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    1
         Tok SourcePos
    _ TokType
    Symbol Text
    t  -> Bool -> Bool
    not ((Char -> Bool) -> Text -> Bool
    T.any (Char -> Set Char -> Bool
    forall a. Ord a => a -> Set a -> Bool
    `Set.member` Set Char
    specialChars) Text
    t)
         Tok
    _               -> Bool
    False

    singleChar :: PandocMonad m => LP m Tok
    singleChar :: forall (m :: * -> *). PandocMonad m => LP m Tok
    singleChar = LP m Tok
    forall (m :: * -> *). PandocMonad m => LP m Tok
    singleCharTok LP m Tok -> LP m Tok -> LP m Tok
    forall a.
    ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> LP m Tok
    singleCharFromWord
     where
      singleCharFromWord :: LP m Tok
    singleCharFromWord = do
        Tok pos toktype t <- LP m Tok -> LP m Tok
    forall (m :: * -> *) a. PandocMonad m => LP m a -> LP m a
    disablingWithRaw (LP m Tok -> LP m Tok) -> LP m Tok -> LP m Tok
    forall a b. (a -> b) -> a -> b
    $ (Tok -> Bool) -> LP m Tok
    forall (m :: * -> *). PandocMonad m => (Tok -> Bool) -> LP m Tok
    satisfyTok Tok -> Bool
    isWordTok
        let (t1, t2) = (T.take 1 t, T.drop 1 t)
        TokStream macrosExpanded inp <- getInput
        setInput $ TokStream macrosExpanded
                 $ Tok pos toktype t1 : Tok (incSourceColumn pos 1) toktype t2 : inp
        anyTok

    specialChars :: Set.Set Char
    specialChars :: Set Char
    specialChars = [Char] -> Set Char
    forall a. Ord a => [a] -> Set a
    Set.fromList [Char]
    "#$%&~_^\\{}"

    endline :: PandocMonad m => LP m ()
    endline :: forall (m :: * -> *). PandocMonad m => LP m ()
    endline = ParsecT TokStream LaTeXState m ()
    -> ParsecT TokStream LaTeXState m ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT TokStream LaTeXState m ()
     -> ParsecT TokStream LaTeXState m ())
    -> ParsecT TokStream LaTeXState m ()
    -> ParsecT TokStream LaTeXState m ()
    forall a b. (a -> b) -> a -> b
    $ do
      ParsecT TokStream LaTeXState m ()
    forall (m :: * -> *). PandocMonad m => LP m ()
    newlineTok
      ParsecT TokStream LaTeXState m Tok
    -> ParsecT TokStream LaTeXState m Tok
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m a
    lookAhead ParsecT TokStream LaTeXState m Tok
    forall (m :: * -> *). PandocMonad m => LP m Tok
    anyTok
      ParsecT TokStream LaTeXState m ()
    -> ParsecT TokStream LaTeXState m ()
    forall s (m :: * -> *) t a u.
    (Stream s m t, Show a) =>
    ParsecT s u m a -> ParsecT s u m ()
    notFollowedBy ParsecT TokStream LaTeXState m ()
    forall (m :: * -> *). PandocMonad m => LP m ()
    blankline

    blankline :: PandocMonad m => LP m ()
    blankline :: forall (m :: * -> *). PandocMonad m => LP m ()
    blankline = ParsecT TokStream LaTeXState m ()
    -> ParsecT TokStream LaTeXState m ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT TokStream LaTeXState m ()
     -> ParsecT TokStream LaTeXState m ())
    -> ParsecT TokStream LaTeXState m ()
    -> ParsecT TokStream LaTeXState m ()
    forall a b. (a -> b) -> a -> b
    $ ParsecT TokStream LaTeXState m ()
    -> ParsecT TokStream LaTeXState m ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m ()
    skipMany ParsecT TokStream LaTeXState m ()
    forall (m :: * -> *). PandocMonad m => LP m ()
    whitespace ParsecT TokStream LaTeXState m ()
    -> ParsecT TokStream LaTeXState m ()
    -> ParsecT TokStream LaTeXState m ()
    forall a b.
    ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m b
    -> ParsecT TokStream LaTeXState m b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> ParsecT TokStream LaTeXState m ()
    forall (m :: * -> *). PandocMonad m => LP m ()
    newlineTok

    primEscape :: PandocMonad m => LP m Char
    primEscape :: forall (m :: * -> *). PandocMonad m => LP m Char
    primEscape = do
      Tok _ toktype t <- (Tok -> Bool) -> LP m Tok
    forall (m :: * -> *). PandocMonad m => (Tok -> Bool) -> LP m Tok
    satisfyTok ([TokType] -> Tok -> Bool
    tokTypeIn [TokType
    Esc1, TokType
    Esc2])
      case toktype of
           TokType
    Esc1 -> case Text -> Maybe (Char, Text)
    T.uncons (Int -> Text -> Text
    T.drop Int
    2 Text
    t) of
                        Just (Char
    c, Text
    _)
                          | Char
    c Char -> Char -> Bool
    forall a. Ord a => a -> a -> Bool
    >= Char
    '\64' Bool -> Bool -> Bool
    && Char
    c Char -> Char -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Char
    '\127' -> Char -> ParsecT TokStream LaTeXState m Char
    forall a. a -> ParsecT TokStream LaTeXState m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int -> Char
    chr (Char -> Int
    ord Char
    c Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    64))
                          | Bool
    otherwise                 -> Char -> ParsecT TokStream LaTeXState m Char
    forall a. a -> ParsecT TokStream LaTeXState m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int -> Char
    chr (Char -> Int
    ord Char
    c Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    64))
                        Maybe (Char, Text)
    Nothing -> [Char] -> ParsecT TokStream LaTeXState m Char
    forall a. [Char] -> ParsecT TokStream LaTeXState m a
    forall (m :: * -> *) a. MonadFail m => [Char] -> m a
    Prelude.fail [Char]
    "Empty content of Esc1"
           TokType
    Esc2 -> case Text -> Maybe Int
    forall (m :: * -> *) a. (MonadPlus m, Read a) => Text -> m a
    safeRead (Text
    "0x" Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Int -> Text -> Text
    T.drop Int
    2 Text
    t) of
                        Just Int
    x  -> Char -> ParsecT TokStream LaTeXState m Char
    forall a. a -> ParsecT TokStream LaTeXState m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int -> Char
    chr Int
    x)
                        Maybe Int
    Nothing -> [Char] -> ParsecT TokStream LaTeXState m Char
    forall a. [Char] -> ParsecT TokStream LaTeXState m a
    forall (m :: * -> *) a. MonadFail m => [Char] -> m a
    Prelude.fail ([Char] -> ParsecT TokStream LaTeXState m Char)
    -> [Char] -> ParsecT TokStream LaTeXState m Char
    forall a b. (a -> b) -> a -> b
    $ [Char]
    "Could not read: " [Char] -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ Text -> [Char]
    T.unpack Text
    t
           TokType
    _    -> [Char] -> ParsecT TokStream LaTeXState m Char
    forall a. [Char] -> ParsecT TokStream LaTeXState m a
    forall (m :: * -> *) a. MonadFail m => [Char] -> m a
    Prelude.fail [Char]
    "Expected an Esc1 or Esc2 token" -- should not happen

    bgroup :: PandocMonad m => LP m Tok
    bgroup :: forall (m :: * -> *). PandocMonad m => LP m Tok
    bgroup = ParsecT TokStream LaTeXState m Tok
    -> ParsecT TokStream LaTeXState m Tok
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT TokStream LaTeXState m Tok
     -> ParsecT TokStream LaTeXState m Tok)
    -> ParsecT TokStream LaTeXState m Tok
    -> ParsecT TokStream LaTeXState m Tok
    forall a b. (a -> b) -> a -> b
    $ do
      ParsecT TokStream LaTeXState m ()
    -> ParsecT TokStream LaTeXState m ()
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m ()
    optional ParsecT TokStream LaTeXState m ()
    forall (m :: * -> *). PandocMonad m => LP m ()
    sp
      t <- Char -> ParsecT TokStream LaTeXState m Tok
    forall (m :: * -> *). PandocMonad m => Char -> LP m Tok
    symbol Char
    '{' ParsecT TokStream LaTeXState m Tok
    -> ParsecT TokStream LaTeXState m Tok
    -> ParsecT TokStream LaTeXState m Tok
    forall a.
    ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> Text -> ParsecT TokStream LaTeXState m Tok
    forall (m :: * -> *). PandocMonad m => Text -> LP m Tok
    controlSeq Text
    "bgroup" ParsecT TokStream LaTeXState m Tok
    -> ParsecT TokStream LaTeXState m Tok
    -> ParsecT TokStream LaTeXState m Tok
    forall a.
    ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> Text -> ParsecT TokStream LaTeXState m Tok
    forall (m :: * -> *). PandocMonad m => Text -> LP m Tok
    controlSeq Text
    "begingroup"
      -- Add a copy of the macro table to the top of the macro stack,
      -- private for this group. We inherit all the macros defined in
      -- the parent group.
      updateState $ \LaTeXState
    s -> LaTeXState
    s{ sMacros = NonEmpty.cons (NonEmpty.head (sMacros s))
                                                     (sMacros s) }
      return t

    egroup :: PandocMonad m => LP m Tok
    egroup :: forall (m :: * -> *). PandocMonad m => LP m Tok
    egroup = do
      t <- Char -> LP m Tok
    forall (m :: * -> *). PandocMonad m => Char -> LP m Tok
    symbol Char
    '}' LP m Tok -> LP m Tok -> LP m Tok
    forall a.
    ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> Text -> LP m Tok
    forall (m :: * -> *). PandocMonad m => Text -> LP m Tok
    controlSeq Text
    "egroup" LP m Tok -> LP m Tok -> LP m Tok
    forall a.
    ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> Text -> LP m Tok
    forall (m :: * -> *). PandocMonad m => Text -> LP m Tok
    controlSeq Text
    "endgroup"
      -- remove the group's macro table from the stack
      updateState $ \LaTeXState
    s -> LaTeXState
    s{ sMacros = fromMaybe (sMacros s) $
          NonEmpty.nonEmpty (NonEmpty.tail (sMacros s)) }
      return t

    grouped :: (PandocMonad m,  Monoid a) => LP m a -> LP m a
    grouped :: forall (m :: * -> *) a.
    (PandocMonad m, Monoid a) =>
    LP m a -> LP m a
    grouped LP m a
    parser = LP m a -> LP m a
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (LP m a -> LP m a) -> LP m a -> LP m a
    forall a b. (a -> b) -> a -> b
    $ do
      LP m Tok
    forall (m :: * -> *). PandocMonad m => LP m Tok
    bgroup
      -- first we check for an inner 'grouped', because
      -- {{a,b}} should be parsed the same as {a,b}
      LP m a -> LP m a
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (LP m a -> LP m a
    forall (m :: * -> *) a.
    (PandocMonad m, Monoid a) =>
    LP m a -> LP m a
    grouped LP m a
    parser LP m a -> LP m Tok -> LP m a
    forall a b.
    ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m b
    -> ParsecT TokStream LaTeXState m a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* LP m Tok
    forall (m :: * -> *). PandocMonad m => LP m Tok
    egroup) LP m a -> LP m a -> LP m a
    forall a.
    ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> ([a] -> a
    forall a. Monoid a => [a] -> a
    mconcat ([a] -> a) -> ParsecT TokStream LaTeXState m [a] -> LP m a
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> LP m a -> LP m Tok -> ParsecT TokStream LaTeXState m [a]
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    manyTill LP m a
    parser LP m Tok
    forall (m :: * -> *). PandocMonad m => LP m Tok
    egroup)

    braced' :: PandocMonad m => LP m Tok -> LP m [Tok]
    braced' :: forall (m :: * -> *). PandocMonad m => LP m Tok -> LP m [Tok]
    braced' LP m Tok
    getTok = Char -> LP m Tok
    forall (m :: * -> *). PandocMonad m => Char -> LP m Tok
    symbol Char
    '{' LP m Tok
    -> ParsecT TokStream LaTeXState m [Tok]
    -> ParsecT TokStream LaTeXState m [Tok]
    forall a b.
    ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m b
    -> ParsecT TokStream LaTeXState m b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> Int -> ParsecT TokStream LaTeXState m [Tok]
    forall {t}.
    (Ord t, Num t) =>
    t -> ParsecT TokStream LaTeXState m [Tok]
    go (Int
    1 :: Int)
     where
      go :: t -> ParsecT TokStream LaTeXState m [Tok]
    go t
    n = do
        t <- LP m Tok
    getTok
        case t of
          Tok SourcePos
    _ TokType
    Symbol Text
    "}"
            | t
    n t -> t -> Bool
    forall a. Ord a => a -> a -> Bool
    > t
    1     -> (Tok
    tTok -> [Tok] -> [Tok]
    forall a. a -> [a] -> [a]
    :) ([Tok] -> [Tok])
    -> ParsecT TokStream LaTeXState m [Tok]
    -> ParsecT TokStream LaTeXState m [Tok]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> t -> ParsecT TokStream LaTeXState m [Tok]
    go (t
    n t -> t -> t
    forall a. Num a => a -> a -> a
    - t
    1)
            | Bool
    otherwise -> [Tok] -> ParsecT TokStream LaTeXState m [Tok]
    forall a. a -> ParsecT TokStream LaTeXState m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return []
          Tok SourcePos
    _ TokType
    Symbol Text
    "{" -> (Tok
    tTok -> [Tok] -> [Tok]
    forall a. a -> [a] -> [a]
    :) ([Tok] -> [Tok])
    -> ParsecT TokStream LaTeXState m [Tok]
    -> ParsecT TokStream LaTeXState m [Tok]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> t -> ParsecT TokStream LaTeXState m [Tok]
    go (t
    n t -> t -> t
    forall a. Num a => a -> a -> a
    + t
    1)
          Tok
    _ -> (Tok
    tTok -> [Tok] -> [Tok]
    forall a. a -> [a] -> [a]
    :) ([Tok] -> [Tok])
    -> ParsecT TokStream LaTeXState m [Tok]
    -> ParsecT TokStream LaTeXState m [Tok]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> t -> ParsecT TokStream LaTeXState m [Tok]
    go t
    n

    braced :: PandocMonad m => LP m [Tok]
    braced :: forall (m :: * -> *). PandocMonad m => LP m [Tok]
    braced = LP m Tok -> LP m [Tok]
    forall (m :: * -> *). PandocMonad m => LP m Tok -> LP m [Tok]
    braced' LP m Tok
    forall (m :: * -> *). PandocMonad m => LP m Tok
    anyTok

    -- URLs require special handling, because they can contain %
    -- characters.  So we retonenize comments as we go...
    bracedUrl :: PandocMonad m => LP m [Tok]
    bracedUrl :: forall (m :: * -> *). PandocMonad m => LP m [Tok]
    bracedUrl = LP m Tok -> LP m [Tok]
    forall (m :: * -> *). PandocMonad m => LP m Tok -> LP m [Tok]
    braced' (LP m ()
    forall (m :: * -> *). PandocMonad m => LP m ()
    retokenizeComment LP m () -> LP m Tok -> LP m Tok
    forall a b.
    ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m b
    -> ParsecT TokStream LaTeXState m b
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> LP m Tok
    forall (m :: * -> *). PandocMonad m => LP m Tok
    anyTok)

    -- For handling URLs, which allow literal % characters...
    retokenizeComment :: PandocMonad m => LP m ()
    retokenizeComment :: forall (m :: * -> *). PandocMonad m => LP m ()
    retokenizeComment = (do
      Tok pos Comment txt <- (Tok -> Bool) -> LP m Tok
    forall (m :: * -> *). PandocMonad m => (Tok -> Bool) -> LP m Tok
    satisfyTok Tok -> Bool
    isCommentTok
      let updPos (Tok SourcePos
    pos' TokType
    toktype' Text
    txt') =
            SourcePos -> TokType -> Text -> Tok
    Tok (SourcePos -> Int -> SourcePos
    incSourceColumn (SourcePos -> Int -> SourcePos
    incSourceLine SourcePos
    pos' (SourcePos -> Int
    sourceLine SourcePos
    pos Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    1))
                 (SourcePos -> Int
    sourceColumn SourcePos
    pos)) TokType
    toktype' Text
    txt'
      let newtoks = (Tok -> Tok) -> [Tok] -> [Tok]
    forall a b. (a -> b) -> [a] -> [b]
    map Tok -> Tok
    updPos ([Tok] -> [Tok]) -> [Tok] -> [Tok]
    forall a b. (a -> b) -> a -> b
    $ SourcePos -> Text -> [Tok]
    tokenize SourcePos
    pos (Text -> [Tok]) -> Text -> [Tok]
    forall a b. (a -> b) -> a -> b
    $ HasCallStack => Text -> Text
    Text -> Text
    T.tail Text
    txt
      TokStream macrosExpanded ts <- getInput
      setInput $ TokStream macrosExpanded ((Tok pos Symbol "%" : newtoks) ++ ts))
        ParsecT TokStream LaTeXState m ()
    -> ParsecT TokStream LaTeXState m ()
    -> ParsecT TokStream LaTeXState m ()
    forall a.
    ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> () -> ParsecT TokStream LaTeXState m ()
    forall a. a -> ParsecT TokStream LaTeXState m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    bracedOrToken :: PandocMonad m => LP m [Tok]
    bracedOrToken :: forall (m :: * -> *). PandocMonad m => LP m [Tok]
    bracedOrToken = LP m [Tok]
    forall (m :: * -> *). PandocMonad m => LP m [Tok]
    braced LP m [Tok] -> LP m [Tok] -> LP m [Tok]
    forall a.
    ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> ((Tok -> [Tok] -> [Tok]
    forall a. a -> [a] -> [a]
    :[]) (Tok -> [Tok]) -> ParsecT TokStream LaTeXState m Tok -> LP m [Tok]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (ParsecT TokStream LaTeXState m Tok
    forall (m :: * -> *). PandocMonad m => LP m Tok
    anyControlSeq ParsecT TokStream LaTeXState m Tok
    -> ParsecT TokStream LaTeXState m Tok
    -> ParsecT TokStream LaTeXState m Tok
    forall a.
    ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> ParsecT TokStream LaTeXState m Tok
    forall (m :: * -> *). PandocMonad m => LP m Tok
    singleChar))

    bracketed :: PandocMonad m => Monoid a => LP m a -> LP m a
    bracketed :: forall (m :: * -> *) a.
    (PandocMonad m, Monoid a) =>
    LP m a -> LP m a
    bracketed LP m a
    parser = LP m a -> LP m a
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (LP m a -> LP m a) -> LP m a -> LP m a
    forall a b. (a -> b) -> a -> b
    $ do
      Char -> LP m Tok
    forall (m :: * -> *). PandocMonad m => Char -> LP m Tok
    symbol Char
    '['
      [a] -> a
    forall a. Monoid a => [a] -> a
    mconcat ([a] -> a) -> ParsecT TokStream LaTeXState m [a] -> LP m a
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> LP m a -> LP m Tok -> ParsecT TokStream LaTeXState m [a]
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    manyTill LP m a
    parser (Char -> LP m Tok
    forall (m :: * -> *). PandocMonad m => Char -> LP m Tok
    symbol Char
    ']')

    bracketedToks :: PandocMonad m => LP m [Tok]
    bracketedToks :: forall (m :: * -> *). PandocMonad m => LP m [Tok]
    bracketedToks = do
      Char -> LP m Tok
    forall (m :: * -> *). PandocMonad m => Char -> LP m Tok
    symbol Char
    '['
      [[Tok]] -> [Tok]
    forall (t :: * -> *) a. Foldable t => t [a] -> [a]
    concat ([[Tok]] -> [Tok])
    -> ParsecT TokStream LaTeXState m [[Tok]]
    -> ParsecT TokStream LaTeXState m [Tok]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT TokStream LaTeXState m [Tok]
    -> LP m Tok -> ParsecT TokStream LaTeXState m [[Tok]]
    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 ((([Tok], [Tok]) -> [Tok]
    forall a b. (a, b) -> b
    snd (([Tok], [Tok]) -> [Tok])
    -> ParsecT TokStream LaTeXState m ([Tok], [Tok])
    -> ParsecT TokStream LaTeXState m [Tok]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT TokStream LaTeXState m [Tok]
    -> ParsecT TokStream LaTeXState m ([Tok], [Tok])
    forall (m :: * -> *) a. PandocMonad m => LP m a -> LP m (a, [Tok])
    withRaw (ParsecT TokStream LaTeXState m [Tok]
    -> ParsecT TokStream LaTeXState m [Tok]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try ParsecT TokStream LaTeXState m [Tok]
    forall (m :: * -> *). PandocMonad m => LP m [Tok]
    braced)) ParsecT TokStream LaTeXState m [Tok]
    -> ParsecT TokStream LaTeXState m [Tok]
    -> ParsecT TokStream LaTeXState m [Tok]
    forall a.
    ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> Int -> LP m Tok -> ParsecT TokStream LaTeXState m [Tok]
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    Int -> ParsecT s u m a -> ParsecT s u m [a]
    count Int
    1 LP m Tok
    forall (m :: * -> *). PandocMonad m => LP m Tok
    anyTok)
                          (Char -> LP m Tok
    forall (m :: * -> *). PandocMonad m => Char -> LP m Tok
    symbol Char
    ']')

    parenWrapped :: PandocMonad m => Monoid a => LP m a -> LP m a
    parenWrapped :: forall (m :: * -> *) a.
    (PandocMonad m, Monoid a) =>
    LP m a -> LP m a
    parenWrapped LP m a
    parser = LP m a -> LP m a
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (LP m a -> LP m a) -> LP m a -> LP m a
    forall a b. (a -> b) -> a -> b
    $ do
      Char -> LP m Tok
    forall (m :: * -> *). PandocMonad m => Char -> LP m Tok
    symbol Char
    '('
      [a] -> a
    forall a. Monoid a => [a] -> a
    mconcat ([a] -> a) -> ParsecT TokStream LaTeXState m [a] -> LP m a
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> LP m a -> LP m Tok -> ParsecT TokStream LaTeXState m [a]
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    manyTill LP m a
    parser (Char -> LP m Tok
    forall (m :: * -> *). PandocMonad m => Char -> LP m Tok
    symbol Char
    ')')

    dimenarg :: PandocMonad m => LP m Text
    dimenarg :: forall (m :: * -> *). PandocMonad m => LP m Text
    dimenarg = ParsecT TokStream LaTeXState m Text
    -> ParsecT TokStream LaTeXState m Text
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT TokStream LaTeXState m Text
     -> ParsecT TokStream LaTeXState m Text)
    -> ParsecT TokStream LaTeXState m Text
    -> ParsecT TokStream LaTeXState m Text
    forall a b. (a -> b) -> a -> b
    $ do
      ParsecT TokStream LaTeXState m ()
    -> ParsecT TokStream LaTeXState m ()
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m ()
    optional ParsecT TokStream LaTeXState m ()
    forall (m :: * -> *). PandocMonad m => LP m ()
    sp
      ch  <- Bool
    -> ParsecT TokStream LaTeXState m Bool
    -> ParsecT TokStream LaTeXState m Bool
    forall s (m :: * -> *) t a u.
    Stream s m t =>
    a -> ParsecT s u m a -> ParsecT s u m a
    option Bool
    False (ParsecT TokStream LaTeXState m Bool
     -> ParsecT TokStream LaTeXState m Bool)
    -> ParsecT TokStream LaTeXState m Bool
    -> ParsecT TokStream LaTeXState m Bool
    forall a b. (a -> b) -> a -> b
    $ Bool
    True Bool
    -> ParsecT TokStream LaTeXState m Tok
    -> ParsecT TokStream LaTeXState m Bool
    forall a b.
    a
    -> ParsecT TokStream LaTeXState m b
    -> ParsecT TokStream LaTeXState m a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ Char -> ParsecT TokStream LaTeXState m Tok
    forall (m :: * -> *). PandocMonad m => Char -> LP m Tok
    symbol Char
    '='
      minus <- option "" $ "-" <$ symbol '-'
      s1 <- option ""
            (do Tok _ _ s1 <- satisfyTok isWordTok
                guard (case T.uncons s1 of
                         Just (Char
    c,Text
    _) -> Char -> Bool
    isDigit Char
    c
                         Maybe (Char, Text)
    Nothing -> Bool
    False)
                pure s1)
      s2 <- option "" $ try $ do
              symbol '.'
              Tok _ _ t <-  satisfyTok isWordTok
              return ("." <> t)
      let s = Text
    s1 Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> Text
    s2
      let (num, rest) = T.span (\Char
    c -> Char -> Bool
    isDigit Char
    c Bool -> Bool -> Bool
    || Char
    c Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    == Char
    '.') s
      guard $ T.length num > 0
      guard $ rest `elem`
        ["", "pt","pc","in","bp","cm","mm","dd","cc","sp","ex","em",
         "mu", -- "mu" in math mode only
         "px" -- "px" with pdftex and luatex only
        ]
      return $ T.pack ['=' | ch] <> minus <> s

    ignore :: (Monoid a, PandocMonad m) => Text -> ParsecT s u m a
    ignore :: forall a (m :: * -> *) s u.
    (Monoid a, PandocMonad m) =>
    Text -> ParsecT s u m a
    ignore Text
    raw = do
      pos <- ParsecT s u m SourcePos
    forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
    getPosition
      report $ SkippedContent raw pos
      return mempty

    withRaw :: PandocMonad m => LP m a -> LP m (a, [Tok])
    withRaw :: forall (m :: * -> *) a. PandocMonad m => LP m a -> LP m (a, [Tok])
    withRaw LP m a
    parser = do
      rawTokensMap <- LaTeXState -> IntMap [Tok]
    sRawTokens (LaTeXState -> IntMap [Tok])
    -> ParsecT TokStream LaTeXState m LaTeXState
    -> ParsecT TokStream LaTeXState m (IntMap [Tok])
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT TokStream LaTeXState m LaTeXState
    forall (m :: * -> *) s u. Monad m => ParsecT s u m u
    getState
      let key = case IntMap [Tok] -> Maybe (Int, [Tok])
    forall a. IntMap a -> Maybe (Int, a)
    IntMap.lookupMax IntMap [Tok]
    rawTokensMap of
                   Maybe (Int, [Tok])
    Nothing     -> Int
    0
                   Just (Int
    n,[Tok]
    _)  -> Int
    n Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1
      -- insert empty list at key
      updateState $ \LaTeXState
    st -> LaTeXState
    st{ sRawTokens =
                                 IntMap.insert key [] $ sRawTokens st }
      result <- parser
      mbRevToks <- IntMap.lookup key . sRawTokens <$> getState
      raw <- case mbRevToks of
               Just [Tok]
    revtoks -> do
                 (LaTeXState -> LaTeXState) -> ParsecT TokStream LaTeXState m ()
    forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
    updateState ((LaTeXState -> LaTeXState) -> ParsecT TokStream LaTeXState m ())
    -> (LaTeXState -> LaTeXState) -> ParsecT TokStream LaTeXState m ()
    forall a b. (a -> b) -> a -> b
    $ \LaTeXState
    st -> LaTeXState
    st{ sRawTokens =
                                            IntMap.delete key $ sRawTokens st}
                 [Tok] -> ParsecT TokStream LaTeXState m [Tok]
    forall a. a -> ParsecT TokStream LaTeXState m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ([Tok] -> ParsecT TokStream LaTeXState m [Tok])
    -> [Tok] -> ParsecT TokStream LaTeXState m [Tok]
    forall a b. (a -> b) -> a -> b
    $ [Tok] -> [Tok]
    forall a. [a] -> [a]
    reverse [Tok]
    revtoks
               Maybe [Tok]
    Nothing      ->
                 PandocError -> ParsecT TokStream LaTeXState m [Tok]
    forall a. PandocError -> ParsecT TokStream LaTeXState m a
    forall e (m :: * -> *) a. MonadError e m => e -> m a
    throwError (PandocError -> ParsecT TokStream LaTeXState m [Tok])
    -> PandocError -> ParsecT TokStream LaTeXState m [Tok]
    forall a b. (a -> b) -> a -> b
    $ Text -> PandocError
    PandocShouldNeverHappenError (Text -> PandocError) -> Text -> PandocError
    forall a b. (a -> b) -> a -> b
    $
                    Text
    "sRawTokens has nothing at key " Text -> Text -> Text
    forall a. Semigroup a => a -> a -> a
    <> [Char] -> Text
    T.pack (Int -> [Char]
    forall a. Show a => a -> [Char]
    show Int
    key)
      return (result, raw)

    keyval :: PandocMonad m => LP m (Text, Text)
    keyval :: forall (m :: * -> *). PandocMonad m => LP m (Text, Text)
    keyval = ParsecT TokStream LaTeXState m (Text, Text)
    -> ParsecT TokStream LaTeXState m (Text, Text)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT TokStream LaTeXState m (Text, Text)
     -> ParsecT TokStream LaTeXState m (Text, Text))
    -> ParsecT TokStream LaTeXState m (Text, Text)
    -> ParsecT TokStream LaTeXState m (Text, Text)
    forall a b. (a -> b) -> a -> b
    $ do
      LP m ()
    forall (m :: * -> *). PandocMonad m => LP m ()
    sp
      key <- [Tok] -> Text
    untokenize ([Tok] -> Text)
    -> ParsecT TokStream LaTeXState m [Tok]
    -> ParsecT TokStream LaTeXState m Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT TokStream LaTeXState m Tok
    -> ParsecT TokStream LaTeXState m [Tok]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many1 (ParsecT TokStream LaTeXState m Tok -> LP 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 TokStream LaTeXState m Tok
    forall (m :: * -> *). PandocMonad m => Char -> LP m Tok
    symbol Char
    '=') LP m ()
    -> ParsecT TokStream LaTeXState m Tok
    -> ParsecT TokStream LaTeXState m Tok
    forall a b.
    ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m b
    -> ParsecT TokStream LaTeXState m b
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >>
                             (Char -> ParsecT TokStream LaTeXState m Tok
    forall (m :: * -> *). PandocMonad m => Char -> LP m Tok
    symbol Char
    '-' ParsecT TokStream LaTeXState m Tok
    -> ParsecT TokStream LaTeXState m Tok
    -> ParsecT TokStream LaTeXState m Tok
    forall a.
    ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> Char -> ParsecT TokStream LaTeXState m Tok
    forall (m :: * -> *). PandocMonad m => Char -> LP m Tok
    symbol Char
    '_' ParsecT TokStream LaTeXState m Tok
    -> ParsecT TokStream LaTeXState m Tok
    -> ParsecT TokStream LaTeXState m Tok
    forall a.
    ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> (Tok -> Bool) -> ParsecT TokStream LaTeXState m Tok
    forall (m :: * -> *). PandocMonad m => (Tok -> Bool) -> LP m Tok
    satisfyTok Tok -> Bool
    isWordTok))
      sp
      val <- option mempty $ do
               symbol '='
               sp
               (untokenize <$> braced) <|>
                 (mconcat <$> many1 (
                     (untokenize . snd <$> withRaw braced)
                     <|>
                     (untokenize <$> many1
                          (satisfyTok
                             (\case
                                    Tok SourcePos
    _ TokType
    Symbol Text
    "]" -> Bool
    False
                                    Tok SourcePos
    _ TokType
    Symbol Text
    "," -> Bool
    False
                                    Tok SourcePos
    _ TokType
    Symbol Text
    "{" -> Bool
    False
                                    Tok SourcePos
    _ TokType
    Symbol Text
    "}" -> Bool
    False
                                    Tok
    _                -> Bool
    True)))))
      sp
      optional (symbol ',')
      sp
      return (key, T.strip val)

    keyvals :: PandocMonad m => LP m [(Text, Text)]
    keyvals :: forall (m :: * -> *). PandocMonad m => LP m [(Text, Text)]
    keyvals = ParsecT TokStream LaTeXState m [(Text, Text)]
    -> ParsecT TokStream LaTeXState m [(Text, Text)]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT TokStream LaTeXState m [(Text, Text)]
     -> ParsecT TokStream LaTeXState m [(Text, Text)])
    -> ParsecT TokStream LaTeXState m [(Text, Text)]
    -> ParsecT TokStream LaTeXState m [(Text, Text)]
    forall a b. (a -> b) -> a -> b
    $ Char -> LP m Tok
    forall (m :: * -> *). PandocMonad m => Char -> LP m Tok
    symbol Char
    '[' LP m Tok
    -> ParsecT TokStream LaTeXState m [(Text, Text)]
    -> ParsecT TokStream LaTeXState m [(Text, Text)]
    forall a b.
    ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m b
    -> ParsecT TokStream LaTeXState m b
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> ParsecT TokStream LaTeXState m (Text, Text)
    -> LP m Tok -> ParsecT TokStream LaTeXState 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 TokStream LaTeXState m (Text, Text)
    forall (m :: * -> *). PandocMonad m => LP m (Text, Text)
    keyval (Char -> LP m Tok
    forall (m :: * -> *). PandocMonad m => Char -> LP m Tok
    symbol Char
    ']') ParsecT TokStream LaTeXState m [(Text, Text)]
    -> ParsecT TokStream LaTeXState m ()
    -> ParsecT TokStream LaTeXState m [(Text, Text)]
    forall a b.
    ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m b
    -> ParsecT TokStream LaTeXState m a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT TokStream LaTeXState m ()
    forall (m :: * -> *). PandocMonad m => LP m ()
    sp

    verbEnv :: PandocMonad m => Text -> LP m Text
    verbEnv :: forall (m :: * -> *). PandocMonad m => Text -> LP m Text
    verbEnv Text
    name = LP m Text -> LP m Text
    forall (m :: * -> *) a. PandocMonad m => LP m a -> LP m a
    withVerbatimMode (LP m Text -> LP m Text) -> LP m Text -> LP m Text
    forall a b. (a -> b) -> a -> b
    $ do
      ParsecT TokStream LaTeXState m ()
    -> ParsecT TokStream LaTeXState m ()
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m ()
    optional ParsecT TokStream LaTeXState m ()
    forall (m :: * -> *). PandocMonad m => LP m ()
    blankline
      res <- ParsecT TokStream LaTeXState m Tok
    -> ParsecT TokStream LaTeXState m ()
    -> ParsecT TokStream LaTeXState m [Tok]
    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 TokStream LaTeXState m Tok
    forall (m :: * -> *). PandocMonad m => LP m Tok
    anyTok (Text -> ParsecT TokStream LaTeXState m ()
    forall (m :: * -> *). PandocMonad m => Text -> LP m ()
    end_ Text
    name)
      return $ stripTrailingNewline
             $ untokenize res

    -- Strip single final newline and any spaces following it.
    -- Input is unchanged if it doesn't end with newline +
    -- optional spaces.
    stripTrailingNewline :: Text -> Text
    stripTrailingNewline :: Text -> Text
    stripTrailingNewline Text
    t =
      let (Text
    b, Text
    e) = HasCallStack => Text -> Text -> (Text, Text)
    Text -> Text -> (Text, Text)
    T.breakOnEnd Text
    "\n" Text
    t
      in  if (Char -> Bool) -> Text -> Bool
    T.all (Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    == Char
    ' ') Text
    e
             then Int -> Text -> Text
    T.dropEnd Int
    1 Text
    b
             else Text
    t

    begin_ :: PandocMonad m => Text -> LP m ()
    begin_ :: forall (m :: * -> *). PandocMonad m => Text -> LP m ()
    begin_ Text
    t = ParsecT TokStream LaTeXState m ()
    -> ParsecT TokStream LaTeXState m ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (do
      Text -> LP m Tok
    forall (m :: * -> *). PandocMonad m => Text -> LP m Tok
    controlSeq Text
    "begin"
      ParsecT TokStream LaTeXState m ()
    forall (m :: * -> *). PandocMonad m => LP m ()
    spaces
      txt <- [Tok] -> Text
    untokenize ([Tok] -> Text)
    -> ParsecT TokStream LaTeXState m [Tok]
    -> ParsecT TokStream LaTeXState m Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT TokStream LaTeXState m [Tok]
    forall (m :: * -> *). PandocMonad m => LP m [Tok]
    braced
      guard (t == txt)) ParsecT TokStream LaTeXState m ()
    -> [Char] -> ParsecT TokStream LaTeXState m ()
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> [Char] -> ParsecT s u m a
    <?> ([Char]
    "\\begin{" [Char] -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ Text -> [Char]
    T.unpack Text
    t [Char] -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ [Char]
    "}")

    end_ :: PandocMonad m => Text -> LP m ()
    end_ :: forall (m :: * -> *). PandocMonad m => Text -> LP m ()
    end_ Text
    t = ParsecT TokStream LaTeXState m ()
    -> ParsecT TokStream LaTeXState m ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (do
      Text -> LP m Tok
    forall (m :: * -> *). PandocMonad m => Text -> LP m Tok
    controlSeq Text
    "end"
      ParsecT TokStream LaTeXState m ()
    forall (m :: * -> *). PandocMonad m => LP m ()
    spaces
      txt <- [Tok] -> Text
    untokenize ([Tok] -> Text)
    -> ParsecT TokStream LaTeXState m [Tok]
    -> ParsecT TokStream LaTeXState m Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT TokStream LaTeXState m [Tok]
    forall (m :: * -> *). PandocMonad m => LP m [Tok]
    braced
      guard $ t == txt) ParsecT TokStream LaTeXState m ()
    -> [Char] -> ParsecT TokStream LaTeXState m ()
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> [Char] -> ParsecT s u m a
    <?> ([Char]
    "\\end{" [Char] -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ Text -> [Char]
    T.unpack Text
    t [Char] -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ [Char]
    "}")

    getRawCommand :: PandocMonad m => Text -> Text -> LP m Text
    getRawCommand :: forall (m :: * -> *). PandocMonad m => Text -> Text -> LP m Text
    getRawCommand Text
    name Text
    txt = do
      (_, rawargs) <- LP m () -> LP m ((), [Tok])
    forall (m :: * -> *) a. PandocMonad m => LP m a -> LP m (a, [Tok])
    withRaw (LP m () -> LP m ((), [Tok])) -> LP m () -> LP m ((), [Tok])
    forall a b. (a -> b) -> a -> b
    $
          case Text
    name of
               Text
    "write" -> do
                 ParsecT TokStream LaTeXState m [Tok] -> LP m ()
    forall (f :: * -> *) a. Functor f => f a -> f ()
    void (ParsecT TokStream LaTeXState m [Tok] -> LP m ())
    -> ParsecT TokStream LaTeXState m [Tok] -> LP m ()
    forall a b. (a -> b) -> a -> b
    $ ParsecT TokStream LaTeXState m Tok
    -> ParsecT TokStream LaTeXState m [Tok]
    forall a.
    ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m [a]
    forall (f :: * -> *) a. Alternative f => f a -> f [a]
    many (ParsecT TokStream LaTeXState m Tok
     -> ParsecT TokStream LaTeXState m [Tok])
    -> ParsecT TokStream LaTeXState m Tok
    -> ParsecT TokStream LaTeXState m [Tok]
    forall a b. (a -> b) -> a -> b
    $ (Tok -> Bool) -> ParsecT TokStream LaTeXState m Tok
    forall (m :: * -> *). PandocMonad m => (Tok -> Bool) -> LP m Tok
    satisfyTok Tok -> Bool
    isDigitTok -- digits
                 ParsecT TokStream LaTeXState m [Tok] -> LP m ()
    forall (f :: * -> *) a. Functor f => f a -> f ()
    void ParsecT TokStream LaTeXState m [Tok]
    forall (m :: * -> *). PandocMonad m => LP m [Tok]
    braced
               Text
    "titleformat" -> do
                 ParsecT TokStream LaTeXState m [Tok] -> LP m ()
    forall (f :: * -> *) a. Functor f => f a -> f ()
    void ParsecT TokStream LaTeXState m [Tok]
    forall (m :: * -> *). PandocMonad m => LP m [Tok]
    braced
                 LP m ()
    forall (m :: * -> *). PandocMonad m => LP m ()
    skipopts
                 ParsecT TokStream LaTeXState m [[Tok]] -> LP m ()
    forall (f :: * -> *) a. Functor f => f a -> f ()
    void (ParsecT TokStream LaTeXState m [[Tok]] -> LP m ())
    -> ParsecT TokStream LaTeXState m [[Tok]] -> LP m ()
    forall a b. (a -> b) -> a -> b
    $ Int
    -> ParsecT TokStream LaTeXState m [Tok]
    -> ParsecT TokStream LaTeXState m [[Tok]]
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    Int -> ParsecT s u m a -> ParsecT s u m [a]
    count Int
    4 ParsecT TokStream LaTeXState m [Tok]
    forall (m :: * -> *). PandocMonad m => LP m [Tok]
    braced
               Text
    "def" ->
                 ParsecT TokStream LaTeXState m [Tok] -> LP m ()
    forall (f :: * -> *) a. Functor f => f a -> f ()
    void (ParsecT TokStream LaTeXState m [Tok] -> LP m ())
    -> ParsecT TokStream LaTeXState m [Tok] -> LP m ()
    forall a b. (a -> b) -> a -> b
    $ ParsecT TokStream LaTeXState m Tok
    -> ParsecT TokStream LaTeXState m [Tok]
    -> ParsecT TokStream LaTeXState m [Tok]
    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 TokStream LaTeXState m Tok
    forall (m :: * -> *). PandocMonad m => LP m Tok
    anyTok ParsecT TokStream LaTeXState m [Tok]
    forall (m :: * -> *). PandocMonad m => LP m [Tok]
    braced
               Text
    "vadjust" ->
                 ParsecT TokStream LaTeXState m [Tok] -> LP m ()
    forall (f :: * -> *) a. Functor f => f a -> f ()
    void (ParsecT TokStream LaTeXState m Tok
    -> ParsecT TokStream LaTeXState m [Tok]
    -> ParsecT TokStream LaTeXState m [Tok]
    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 TokStream LaTeXState m Tok
    forall (m :: * -> *). PandocMonad m => LP m Tok
    anyTok ParsecT TokStream LaTeXState m [Tok]
    forall (m :: * -> *). PandocMonad m => LP m [Tok]
    braced) LP m () -> LP m () -> LP m ()
    forall a.
    ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|>
                    ParsecT TokStream LaTeXState m Tok -> LP m ()
    forall (f :: * -> *) a. Functor f => f a -> f ()
    void ((Tok -> Bool) -> ParsecT TokStream LaTeXState m Tok
    forall (m :: * -> *). PandocMonad m => (Tok -> Bool) -> LP m Tok
    satisfyTok Tok -> Bool
    isPreTok) -- see #7531
               Text
    _ | Text -> Bool
    isFontSizeCommand Text
    name -> () -> LP m ()
    forall a. a -> ParsecT TokStream LaTeXState m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()
                 | Text
    name Text -> [Text] -> Bool
    forall a. Eq a => a -> [a] -> Bool
    forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
    `elem` [Text
    "hfil", Text
    "hfill", Text
    "vfil", Text
    "vfill",
                                Text
    "hfilneg", Text
    "vfilneg"] -> () -> LP m ()
    forall a. a -> ParsecT TokStream LaTeXState m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()
                 | Text
    name Text -> [Text] -> Bool
    forall a. Eq a => a -> [a] -> Bool
    forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
    `elem` [Text
    "hskip", Text
    "vskip", Text
    "mskip"] -> do
                     LP m Text
    forall (m :: * -> *). PandocMonad m => LP m Text
    dimenarg
                     LP m Text -> LP m ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m ()
    skipMany (LP m Text -> LP m ()) -> LP m Text -> LP m ()
    forall a b. (a -> b) -> a -> b
    $ LP m Text -> LP m Text
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (LP m Text -> LP m Text) -> LP m Text -> LP m Text
    forall a b. (a -> b) -> a -> b
    $ do
                       LP m ()
    forall (m :: * -> *). PandocMonad m => LP m ()
    sp
                       (Tok -> Bool) -> ParsecT TokStream LaTeXState m Tok
    forall (m :: * -> *). PandocMonad m => (Tok -> Bool) -> LP m Tok
    satisfyTok ((Tok -> Bool) -> ParsecT TokStream LaTeXState m Tok)
    -> (Tok -> Bool) -> ParsecT TokStream LaTeXState m Tok
    forall a b. (a -> b) -> a -> b
    $
                         \case
                           Tok SourcePos
    _ TokType
    Word Text
    "plus" -> Bool
    True
                           Tok SourcePos
    _ TokType
    Word Text
    "minus" -> Bool
    True
                           Tok
    _ -> Bool
    False
                       LP m Text
    forall (m :: * -> *). PandocMonad m => LP m Text
    dimenarg
                 | Bool
    otherwise -> do
                   LP m ()
    forall (m :: * -> *). PandocMonad m => LP m ()
    skipopts
                   Text -> LP m Text -> LP 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
    "" (LP m Text -> LP m Text
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try LP m Text
    forall (m :: * -> *). PandocMonad m => LP m Text
    dimenarg)
                   ParsecT TokStream LaTeXState m [[Tok]] -> LP m ()
    forall (f :: * -> *) a. Functor f => f a -> f ()
    void (ParsecT TokStream LaTeXState m [[Tok]] -> LP m ())
    -> ParsecT TokStream LaTeXState m [[Tok]] -> LP m ()
    forall a b. (a -> b) -> a -> b
    $ ParsecT TokStream LaTeXState m [Tok]
    -> ParsecT TokStream LaTeXState m [[Tok]]
    forall a.
    ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m [a]
    forall (f :: * -> *) a. Alternative f => f a -> f [a]
    many ParsecT TokStream LaTeXState m [Tok]
    forall (m :: * -> *). PandocMonad m => LP m [Tok]
    braced
      return $ txt <> untokenize rawargs

    isPreTok :: Tok -> Bool
    isPreTok :: Tok -> Bool
    isPreTok (Tok SourcePos
    _ TokType
    Word Text
    "pre") = Bool
    True
    isPreTok Tok
    _ = Bool
    False

    isDigitTok :: Tok -> Bool
    isDigitTok :: Tok -> Bool
    isDigitTok (Tok SourcePos
    _ TokType
    Word Text
    t) = (Char -> Bool) -> Text -> Bool
    T.all Char -> Bool
    isDigit Text
    t
    isDigitTok Tok
    _              = Bool
    False

    skipopts :: PandocMonad m => LP m ()
    skipopts :: forall (m :: * -> *). PandocMonad m => LP m ()
    skipopts = ParsecT TokStream LaTeXState m ()
    -> ParsecT TokStream LaTeXState m ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m ()
    skipMany (ParsecT TokStream LaTeXState m Text
    -> ParsecT TokStream LaTeXState m ()
    forall (f :: * -> *) a. Functor f => f a -> f ()
    void ParsecT TokStream LaTeXState m Text
    forall (m :: * -> *). PandocMonad m => LP m Text
    overlaySpecification ParsecT TokStream LaTeXState m ()
    -> ParsecT TokStream LaTeXState m ()
    -> ParsecT TokStream LaTeXState m ()
    forall a.
    ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> ParsecT TokStream LaTeXState m Text
    -> ParsecT TokStream LaTeXState m ()
    forall (f :: * -> *) a. Functor f => f a -> f ()
    void ParsecT TokStream LaTeXState m Text
    forall (m :: * -> *). PandocMonad m => LP m Text
    rawopt)

    -- opts in angle brackets are used in beamer
    overlaySpecification :: PandocMonad m => LP m Text
    overlaySpecification :: forall (m :: * -> *). PandocMonad m => LP m Text
    overlaySpecification = ParsecT TokStream LaTeXState m Text
    -> ParsecT TokStream LaTeXState m Text
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT TokStream LaTeXState m Text
     -> ParsecT TokStream LaTeXState m Text)
    -> ParsecT TokStream LaTeXState m Text
    -> ParsecT TokStream LaTeXState m Text
    forall a b. (a -> b) -> a -> b
    $ do
      Char -> LP m Tok
    forall (m :: * -> *). PandocMonad m => Char -> LP m Tok
    symbol Char
    '<'
      t <- [Tok] -> Text
    untokenize ([Tok] -> Text)
    -> ParsecT TokStream LaTeXState m [Tok]
    -> ParsecT TokStream LaTeXState m Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> LP m Tok -> LP m Tok -> ParsecT TokStream LaTeXState m [Tok]
    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 LP m Tok
    forall (m :: * -> *). PandocMonad m => LP m Tok
    overlayTok (Char -> LP m Tok
    forall (m :: * -> *). PandocMonad m => Char -> LP m Tok
    symbol Char
    '>')
      -- see issue #3368
      guard $ not (T.all isLetter t) ||
              t `elem` ["beamer","presentation", "trans",
                        "handout","article", "second"]
      return $ "<" <> t <> ">"

    overlayTok :: PandocMonad m => LP m Tok
    overlayTok :: forall (m :: * -> *). PandocMonad m => LP m Tok
    overlayTok =
      (Tok -> Bool) -> LP m Tok
    forall (m :: * -> *). PandocMonad m => (Tok -> Bool) -> LP m Tok
    satisfyTok (\case
                        Tok SourcePos
    _ TokType
    Word Text
    _       -> Bool
    True
                        Tok SourcePos
    _ TokType
    Spaces Text
    _     -> Bool
    True
                        Tok SourcePos
    _ TokType
    Symbol Text
    c     -> Text
    c Text -> [Text] -> Bool
    forall a. Eq a => a -> [a] -> Bool
    forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
    `elem` [Text
    "-",Text
    "+",Text
    "@",Text
    "|",Text
    ":",Text
    ","]
                        Tok
    _                  -> Bool
    False)

    rawopt :: PandocMonad m => LP m Text
    rawopt :: forall (m :: * -> *). PandocMonad m => LP m Text
    rawopt = ParsecT TokStream LaTeXState m Text
    -> ParsecT TokStream LaTeXState m Text
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT TokStream LaTeXState m Text
     -> ParsecT TokStream LaTeXState m Text)
    -> ParsecT TokStream LaTeXState m Text
    -> ParsecT TokStream LaTeXState m Text
    forall a b. (a -> b) -> a -> b
    $ do
      LP m ()
    forall (m :: * -> *). PandocMonad m => LP m ()
    sp
      inner <- [Tok] -> Text
    untokenize ([Tok] -> Text)
    -> ParsecT TokStream LaTeXState m [Tok]
    -> ParsecT TokStream LaTeXState m Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT TokStream LaTeXState m [Tok]
    forall (m :: * -> *). PandocMonad m => LP m [Tok]
    bracketedToks
      sp
      return $ "[" <> inner <> "]"

    isFontSizeCommand :: Text -> Bool
    isFontSizeCommand :: Text -> Bool
    isFontSizeCommand Text
    "tiny" = Bool
    True
    isFontSizeCommand Text
    "scriptsize" = Bool
    True
    isFontSizeCommand Text
    "footnotesize" = Bool
    True
    isFontSizeCommand Text
    "small" = Bool
    True
    isFontSizeCommand Text
    "normalsize" = Bool
    True
    isFontSizeCommand Text
    "large" = Bool
    True
    isFontSizeCommand Text
    "Large" = Bool
    True
    isFontSizeCommand Text
    "LARGE" = Bool
    True
    isFontSizeCommand Text
    "huge" = Bool
    True
    isFontSizeCommand Text
    "Huge" = Bool
    True
    isFontSizeCommand Text
    _ = Bool
    False

    getNextNumber :: Monad m
                  => (LaTeXState -> DottedNum) -> LP m DottedNum
    getNextNumber :: forall (m :: * -> *).
    Monad m =>
    (LaTeXState -> DottedNum) -> LP m DottedNum
    getNextNumber LaTeXState -> DottedNum
    getCurrentNum = do
      st <- ParsecT TokStream LaTeXState m LaTeXState
    forall (m :: * -> *) s u. Monad m => ParsecT s u m u
    getState
      let chapnum =
            case LaTeXState -> DottedNum
    sLastHeaderNum LaTeXState
    st of
                 DottedNum (Int
    n:[Int]
    _) | LaTeXState -> Bool
    sHasChapters LaTeXState
    st -> Int -> Maybe Int
    forall a. a -> Maybe a
    Just Int
    n
                 DottedNum
    _                                 -> Maybe Int
    forall a. Maybe a
    Nothing
      return . DottedNum $
        case getCurrentNum st of
           DottedNum [Int
    m,Int
    n]  ->
             case Maybe Int
    chapnum of
                  Just Int
    m' | Int
    m' Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    m   -> [Int
    m, Int
    nInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    1]
                          | Bool
    otherwise -> [Int
    m', Int
    1]
                  Maybe Int
    Nothing             -> [Int
    1]
                                          -- shouldn't happen
           DottedNum [Int
    n]   ->
             case Maybe Int
    chapnum of
                  Just Int
    m  -> [Int
    m, Int
    1]
                  Maybe Int
    Nothing -> [Int
    n Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1]
           DottedNum
    _               ->
             case Maybe Int
    chapnum of
                   Just Int
    n  -> [Int
    n, Int
    1]
                   Maybe Int
    Nothing -> [Int
    1]

    label :: PandocMonad m => LP m ()
    label :: forall (m :: * -> *). PandocMonad m => LP m ()
    label = do
      Text -> LP m Tok
    forall (m :: * -> *). PandocMonad m => Text -> LP m Tok
    controlSeq Text
    "label"
      t <- LP m [Tok]
    forall (m :: * -> *). PandocMonad m => LP m [Tok]
    braced
      updateState $ \LaTeXState
    st -> LaTeXState
    st{ sLastLabel = Just $ untokenize t }

    setCaption :: PandocMonad m => LP m Inlines -> LP m ()
    setCaption :: forall (m :: * -> *). PandocMonad m => LP m Inlines -> LP m ()
    setCaption LP m Inlines
    inline = ParsecT TokStream LaTeXState m ()
    -> ParsecT TokStream LaTeXState m ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT TokStream LaTeXState m ()
     -> ParsecT TokStream LaTeXState m ())
    -> ParsecT TokStream LaTeXState m ()
    -> ParsecT TokStream LaTeXState m ()
    forall a b. (a -> b) -> a -> b
    $ do
      mbshort <- [Inline] -> Maybe [Inline]
    forall a. a -> Maybe a
    Just ([Inline] -> Maybe [Inline])
    -> (Inlines -> [Inline]) -> Inlines -> Maybe [Inline]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Inlines -> [Inline]
    forall a. Many a -> [a]
    toList (Inlines -> Maybe [Inline])
    -> LP m Inlines -> ParsecT TokStream LaTeXState m (Maybe [Inline])
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> LP m Inlines -> LP m Inlines
    forall (m :: * -> *) a.
    (PandocMonad m, Monoid a) =>
    LP m a -> LP m a
    bracketed LP m Inlines
    inline ParsecT TokStream LaTeXState m (Maybe [Inline])
    -> ParsecT TokStream LaTeXState m (Maybe [Inline])
    -> ParsecT TokStream LaTeXState m (Maybe [Inline])
    forall a.
    ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> Maybe [Inline] -> ParsecT TokStream LaTeXState m (Maybe [Inline])
    forall a. a -> ParsecT TokStream LaTeXState m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Maybe [Inline]
    forall a. Maybe a
    Nothing
      ils <- tokWith inline
      optional $ try $ spaces *> label
      updateState $ \LaTeXState
    st -> LaTeXState
    st{ sCaption = Just $
                                  Caption mbshort [Plain $ toList ils] }

    resetCaption :: PandocMonad m => LP m ()
    resetCaption :: forall (m :: * -> *). PandocMonad m => LP m ()
    resetCaption = (LaTeXState -> LaTeXState) -> ParsecT TokStream LaTeXState m ()
    forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
    updateState ((LaTeXState -> LaTeXState) -> ParsecT TokStream LaTeXState m ())
    -> (LaTeXState -> LaTeXState) -> ParsecT TokStream LaTeXState m ()
    forall a b. (a -> b) -> a -> b
    $ \LaTeXState
    st -> LaTeXState
    st{ sCaption   = Nothing
                                          , sLastLabel = Nothing }

    env :: PandocMonad m => Text -> LP m a -> LP m a
    env :: forall (m :: * -> *) a. PandocMonad m => Text -> LP m a -> LP m a
    env Text
    name LP m a
    p = do
      -- environments are groups as far as macros are concerned,
      -- so we need a local copy of the macro table (see above, bgroup, egroup):
      (LaTeXState -> LaTeXState) -> ParsecT TokStream LaTeXState m ()
    forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
    updateState ((LaTeXState -> LaTeXState) -> ParsecT TokStream LaTeXState m ())
    -> (LaTeXState -> LaTeXState) -> ParsecT TokStream LaTeXState m ()
    forall a b. (a -> b) -> a -> b
    $ \LaTeXState
    s -> LaTeXState
    s{ sMacros = NonEmpty.cons (NonEmpty.head (sMacros s))
                                                     (sMacros s) }
      result <- LP m a
    p
      updateState $ \LaTeXState
    s -> LaTeXState
    s{ sMacros = fromMaybe (sMacros s) $
          NonEmpty.nonEmpty (NonEmpty.tail (sMacros s)) }
      end_ name
      return result

    tokWith :: PandocMonad m => LP m Inlines -> LP m Inlines
    tokWith :: forall (m :: * -> *). PandocMonad m => LP m Inlines -> LP m Inlines
    tokWith LP m Inlines
    inlineParser = LP m Inlines -> LP m Inlines
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (LP m Inlines -> LP m Inlines) -> LP m Inlines -> LP m Inlines
    forall a b. (a -> b) -> a -> b
    $ LP m ()
    forall (m :: * -> *). PandocMonad m => LP m ()
    spaces LP m () -> LP m Inlines -> LP m Inlines
    forall a b.
    ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m b
    -> ParsecT TokStream LaTeXState m b
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >>
                                     LP m Inlines -> LP m Inlines
    forall (m :: * -> *) a.
    (PandocMonad m, Monoid a) =>
    LP m a -> LP m a
    grouped LP m Inlines
    inlineParser
                                LP m Inlines -> LP m Inlines -> LP m Inlines
    forall a.
    ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> (ParsecT TokStream LaTeXState m Tok
    -> ParsecT TokStream LaTeXState m Tok
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m a
    lookAhead ParsecT TokStream LaTeXState m Tok
    forall (m :: * -> *). PandocMonad m => LP m Tok
    anyControlSeq ParsecT TokStream LaTeXState m Tok -> LP m Inlines -> LP m Inlines
    forall a b.
    ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m b
    -> ParsecT TokStream LaTeXState m b
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> LP m Inlines
    inlineParser)
                                LP m Inlines -> LP m Inlines -> LP m Inlines
    forall a.
    ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    -> ParsecT TokStream LaTeXState m a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> LP m Inlines
    singleChar'
      where singleChar' :: LP m Inlines
    singleChar' = do
              Tok _ _ t <- ParsecT TokStream LaTeXState m Tok
    forall (m :: * -> *). PandocMonad m => LP m Tok
    singleChar
              return $ str t

    addMeta :: PandocMonad m => ToMetaValue a => Text -> a -> LP m ()
    addMeta :: forall (m :: * -> *) a.
    (PandocMonad m, ToMetaValue a) =>
    Text -> a -> LP m ()
    addMeta Text
    field a
    val = (LaTeXState -> LaTeXState) -> ParsecT TokStream LaTeXState m ()
    forall (m :: * -> *) u s. Monad m => (u -> u) -> ParsecT s u m ()
    updateState ((LaTeXState -> LaTeXState) -> ParsecT TokStream LaTeXState m ())
    -> (LaTeXState -> LaTeXState) -> ParsecT TokStream LaTeXState m ()
    forall a b. (a -> b) -> a -> b
    $ \LaTeXState
    st ->
       LaTeXState
    st{ sMeta = addMetaField field val $ sMeta st }

    -- remove label spans to avoid duplicated identifier
    removeLabel :: Walkable [Inline] a => Text -> a -> a
    removeLabel :: forall a. Walkable [Inline] a => Text -> a -> a
    removeLabel Text
    lbl = ([Inline] -> [Inline]) -> a -> a
    forall a b. Walkable a b => (a -> a) -> b -> b
    walk [Inline] -> [Inline]
    go
     where
      go :: [Inline] -> [Inline]
    go (Span (Text
    _,[Text]
    _,[(Text, Text)]
    kvs) [Inline]
    _ : [Inline]
    rest)
        | Just Text
    lbl' <- Text -> [(Text, Text)] -> Maybe Text
    forall a b. Eq a => a -> [(a, b)] -> Maybe b
    lookup Text
    "label" [(Text, Text)]
    kvs
        , Text
    lbl' Text -> Text -> Bool
    forall a. Eq a => a -> a -> Bool
    == Text
    lbl = [Inline] -> [Inline]
    go ((Inline -> Bool) -> [Inline] -> [Inline]
    forall a. (a -> Bool) -> [a] -> [a]
    dropWhile Inline -> Bool
    isSpaceOrSoftBreak [Inline]
    rest)
      go (Inline
    x:[Inline]
    xs) = Inline
    x Inline -> [Inline] -> [Inline]
    forall a. a -> [a] -> [a]
    : [Inline] -> [Inline]
    go [Inline]
    xs
      go [] = []
      isSpaceOrSoftBreak :: Inline -> Bool
    isSpaceOrSoftBreak Inline
    Space = Bool
    True
      isSpaceOrSoftBreak Inline
    SoftBreak = Bool
    True
      isSpaceOrSoftBreak Inline
    _ = Bool
    False