{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE OverloadedLists #-}
{-# LANGUAGE ScopedTypeVariables #-}
module Text.Pandoc.Readers.Typst
( readTypst
)
where
import Text.Pandoc.Class
import Text.Pandoc.Sources
import Text.Pandoc.Options
import Text.Pandoc.Definition
import Typst ( parseTypst, evaluateTypst )
import Text.Pandoc.Error (PandocError(..))
import Text.Pandoc.Shared (tshow, blocksToInlines)
import Control.Monad.Except (throwError)
import Control.Monad (MonadPlus (mplus), void, guard, foldM)
import qualified Data.Foldable as F
import qualified Data.Map as M
import Data.Maybe (catMaybes, fromMaybe)
import Data.Sequence (Seq)
import qualified Data.Sequence as Seq
import qualified Data.Set as Set
import Data.Text (Text)
import qualified Data.Text as T
import qualified Text.Pandoc.Builder as B
import Text.Pandoc.Walk
import Text.Parsec
import Text.TeXMath (writeTeX)
import Text.TeXMath.Shared (getSpaceChars)
import Text.Pandoc.Readers.Typst.Math (pMathMany)
import Text.Pandoc.Readers.Typst.Parsing (pTok, ignored, getField, P,
PState(..), defaultPState)
import Typst.Methods (formatNumber, applyPureFunction)
import Typst.Types
import qualified Data.Vector as V
readTypst :: (PandocMonad m, ToSources a)
=> ReaderOptions -> a -> m Pandoc
readTypst :: forall (m :: * -> *) a.
(PandocMonad m, ToSources a) =>
ReaderOptions -> a -> m Pandoc
readTypst ReaderOptions
_opts a
inp = do
let sources :: Sources
sources = a -> Sources
forall a. ToSources a => a -> Sources
toSources a
inp
let inputName :: SourceName
inputName = case Sources
sources of
Sources ((SourcePos
pos, Text
_):[(SourcePos, Text)]
_) -> SourcePos -> SourceName
sourceName SourcePos
pos
Sources
_ -> SourceName
""
case SourceName -> Text -> Either ParseError [Markup]
parseTypst SourceName
inputName (Sources -> Text
sourcesToText Sources
sources) of
Left ParseError
e -> PandocError -> m Pandoc
forall a. PandocError -> m a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (PandocError -> m Pandoc) -> PandocError -> m Pandoc
forall a b. (a -> b) -> a -> b
$ Text -> PandocError
PandocParseError (Text -> PandocError) -> Text -> PandocError
forall a b. (a -> b) -> a -> b
$ SourceName -> Text
T.pack (SourceName -> Text) -> SourceName -> Text
forall a b. (a -> b) -> a -> b
$ ParseError -> SourceName
forall a. Show a => a -> SourceName
show ParseError
e
Right [Markup]
parsed -> do
let ops :: Operations m
ops = Operations {
loadBytes :: SourceName -> m ByteString
loadBytes = SourceName -> m ByteString
forall (m :: * -> *). PandocMonad m => SourceName -> m ByteString
readFileStrict,
currentUTCTime :: m UTCTime
currentUTCTime = m UTCTime
forall (m :: * -> *). PandocMonad m => m UTCTime
getCurrentTime,
lookupEnvVar :: SourceName -> m (Maybe SourceName)
lookupEnvVar = (Maybe Text -> Maybe SourceName)
-> m (Maybe Text) -> m (Maybe SourceName)
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Text -> SourceName) -> Maybe Text -> Maybe SourceName
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Text -> SourceName
T.unpack) (m (Maybe Text) -> m (Maybe SourceName))
-> (SourceName -> m (Maybe Text))
-> SourceName
-> m (Maybe SourceName)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> m (Maybe Text)
forall (m :: * -> *). PandocMonad m => Text -> m (Maybe Text)
lookupEnv (Text -> m (Maybe Text))
-> (SourceName -> Text) -> SourceName -> m (Maybe Text)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SourceName -> Text
T.pack,
checkExistence :: SourceName -> m Bool
checkExistence = SourceName -> m Bool
forall (m :: * -> *). PandocMonad m => SourceName -> m Bool
fileExists }
res <- Operations m
-> SourceName -> [Markup] -> m (Either ParseError Content)
forall (m :: * -> *).
Monad m =>
Operations m
-> SourceName -> [Markup] -> m (Either ParseError Content)
evaluateTypst Operations m
ops SourceName
inputName [Markup]
parsed
case res of
Left ParseError
e -> PandocError -> m Pandoc
forall a. PandocError -> m a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (PandocError -> m Pandoc) -> PandocError -> m Pandoc
forall a b. (a -> b) -> a -> b
$ Text -> PandocError
PandocParseError (Text -> PandocError) -> Text -> PandocError
forall a b. (a -> b) -> a -> b
$ ParseError -> Text
forall a. Show a => a -> Text
tshow ParseError
e
Right Content
content -> do
let labs :: [Text]
labs = Seq Content -> [Text]
findLabels [Item (Seq Content)
Content
content]
ParsecT [Content] PState m Pandoc
-> PState
-> SourceName
-> [Content]
-> m (Either ParseError Pandoc)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> u -> SourceName -> s -> m (Either ParseError a)
runParserT ParsecT [Content] PState m Pandoc
forall (m :: * -> *). PandocMonad m => P m Pandoc
pPandoc PState
defaultPState{ sLabels = labs }
SourceName
inputName [Item [Content]
Content
content] m (Either ParseError Pandoc)
-> (Either ParseError Pandoc -> m Pandoc) -> m Pandoc
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>=
(ParseError -> m Pandoc)
-> (Pandoc -> m Pandoc) -> Either ParseError Pandoc -> m Pandoc
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (PandocError -> m Pandoc
forall a. PandocError -> m a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (PandocError -> m Pandoc)
-> (ParseError -> PandocError) -> ParseError -> m Pandoc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> PandocError
PandocParseError (Text -> PandocError)
-> (ParseError -> Text) -> ParseError -> PandocError
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SourceName -> Text
T.pack (SourceName -> Text)
-> (ParseError -> SourceName) -> ParseError -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ParseError -> SourceName
forall a. Show a => a -> SourceName
show) Pandoc -> m Pandoc
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
pBlockElt :: PandocMonad m => P m B.Blocks
pBlockElt :: forall (m :: * -> *). PandocMonad m => P m Blocks
pBlockElt = ParsecT [Content] PState m Blocks
-> ParsecT [Content] PState m Blocks
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (ParsecT [Content] PState m Blocks
-> ParsecT [Content] PState m Blocks)
-> ParsecT [Content] PState m Blocks
-> ParsecT [Content] PState m Blocks
forall a b. (a -> b) -> a -> b
$ do
res <- (Content -> Bool) -> P m Content
forall (m :: * -> *).
PandocMonad m =>
(Content -> Bool) -> P m Content
pTok (\Content
t -> Content -> Bool
isBlock Content
t Bool -> Bool -> Bool
|| Bool -> Bool
not (Content -> Bool
isInline Content
t))
mbident <- option Nothing $ Just <$> pLab
case res of
Elt name :: Identifier
name@(Identifier Text
tname) Maybe SourcePos
pos Map Identifier Val
fields -> do
case Identifier
-> Map
Identifier
(Maybe Text
-> Map Identifier Val -> ParsecT [Content] PState m Blocks)
-> Maybe
(Maybe Text
-> Map Identifier Val -> ParsecT [Content] PState m Blocks)
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup Identifier
name Map
Identifier
(Maybe Text
-> Map Identifier Val -> ParsecT [Content] PState m Blocks)
forall (m :: * -> *).
PandocMonad m =>
Map Identifier (Maybe Text -> Map Identifier Val -> P m Blocks)
blockHandlers of
Maybe
(Maybe Text
-> Map Identifier Val -> ParsecT [Content] PState m Blocks)
Nothing -> do
Text -> P m ()
forall (m :: * -> *). PandocMonad m => Text -> P m ()
ignored (Text
"unknown block element " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
tname Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
Text
" at " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Maybe SourcePos -> Text
forall a. Show a => a -> Text
tshow Maybe SourcePos
pos)
Blocks -> ParsecT [Content] PState m Blocks
forall a. a -> ParsecT [Content] PState m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Blocks
forall a. Monoid a => a
mempty
Just Maybe Text
-> Map Identifier Val -> ParsecT [Content] PState m Blocks
handler -> Maybe Text
-> Map Identifier Val -> ParsecT [Content] PState m Blocks
handler Maybe Text
mbident Map Identifier Val
fields
Content
_ -> Blocks -> ParsecT [Content] PState m Blocks
forall a. a -> ParsecT [Content] PState m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Blocks
forall a. Monoid a => a
mempty
pInline :: PandocMonad m => P m B.Inlines
pInline :: forall (m :: * -> *). PandocMonad m => P m Inlines
pInline = ParsecT [Content] PState m Inlines
-> ParsecT [Content] PState m Inlines
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (ParsecT [Content] PState m Inlines
-> ParsecT [Content] PState m Inlines)
-> ParsecT [Content] PState m Inlines
-> ParsecT [Content] PState m Inlines
forall a b. (a -> b) -> a -> b
$ do
res <- (Content -> Bool) -> P m Content
forall (m :: * -> *).
PandocMonad m =>
(Content -> Bool) -> P m Content
pTok (\Content
t -> Content -> Bool
isInline Content
t Bool -> Bool -> Bool
|| Bool -> Bool
not (Content -> Bool
isBlock Content
t))
case res of
Txt Text
t -> Inlines -> ParsecT [Content] PState m Inlines
forall a. a -> ParsecT [Content] PState m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Inlines -> ParsecT [Content] PState m Inlines)
-> Inlines -> ParsecT [Content] PState m Inlines
forall a b. (a -> b) -> a -> b
$ Text -> Inlines
B.text Text
t
Lab Text
name -> Inlines -> ParsecT [Content] PState m Inlines
forall a. a -> ParsecT [Content] PState m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Inlines -> ParsecT [Content] PState m Inlines)
-> Inlines -> ParsecT [Content] PState m Inlines
forall a b. (a -> b) -> a -> b
$ Attr -> Inlines -> Inlines
B.spanWith (Text
name, [], []) Inlines
forall a. Monoid a => a
mempty
Elt (Identifier Text
tname) Maybe SourcePos
_ Map Identifier Val
_
| Text
"math." Text -> Text -> Bool
`T.isPrefixOf` Text
tname
, Text
tname Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
/= Text
"math.equation" ->
Text -> Inlines
B.math (Text -> Inlines) -> ([Exp] -> Text) -> [Exp] -> Inlines
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Exp] -> Text
writeTeX ([Exp] -> Inlines)
-> ParsecT [Content] PState m [Exp]
-> ParsecT [Content] PState m Inlines
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Seq Content -> ParsecT [Content] PState m [Exp]
forall (m :: * -> *). PandocMonad m => Seq Content -> P m [Exp]
pMathMany (Content -> Seq Content
forall a. a -> Seq a
Seq.singleton Content
res)
Elt name :: Identifier
name@(Identifier Text
tname) Maybe SourcePos
pos Map Identifier Val
fields -> do
labs <- PState -> [Text]
sLabels (PState -> [Text])
-> ParsecT [Content] PState m PState
-> ParsecT [Content] PState m [Text]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT [Content] PState m PState
forall (m :: * -> *) s u. Monad m => ParsecT s u m u
getState
labelTarget <- (do result <- getField "target" fields
case result of
VLabel Text
t | Text
t Text -> [Text] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Text]
labs -> Bool -> ParsecT [Content] PState m Bool
forall a. a -> ParsecT [Content] PState m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
True
Val
_ -> Bool -> ParsecT [Content] PState m Bool
forall a. a -> ParsecT [Content] PState m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
False)
<|> pure False
if tname == "ref" && not labelTarget
then do
let targetToKey (Identifier Text
"target") = Text -> Identifier
Identifier Text
"key"
targetToKey Identifier
k = Identifier
k
case M.lookup "cite" inlineHandlers of
Maybe
(Maybe Text
-> Map Identifier Val -> ParsecT [Content] PState m Inlines)
Nothing -> do
Text -> P m ()
forall (m :: * -> *). PandocMonad m => Text -> P m ()
ignored (Text
"unknown inline element " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
tname Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
Text
" at " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Maybe SourcePos -> Text
forall a. Show a => a -> Text
tshow Maybe SourcePos
pos)
Inlines -> ParsecT [Content] PState m Inlines
forall a. a -> ParsecT [Content] PState m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Inlines
forall a. Monoid a => a
mempty
Just Maybe Text
-> Map Identifier Val -> ParsecT [Content] PState m Inlines
handler -> Maybe Text
-> Map Identifier Val -> ParsecT [Content] PState m Inlines
handler Maybe Text
forall a. Maybe a
Nothing ((Identifier -> Identifier)
-> Map Identifier Val -> Map Identifier Val
forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
M.mapKeys Identifier -> Identifier
targetToKey Map Identifier Val
fields)
else do
case M.lookup name inlineHandlers of
Maybe
(Maybe Text
-> Map Identifier Val -> ParsecT [Content] PState m Inlines)
Nothing -> do
Text -> P m ()
forall (m :: * -> *). PandocMonad m => Text -> P m ()
ignored (Text
"unknown inline element " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
tname Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
Text
" at " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Maybe SourcePos -> Text
forall a. Show a => a -> Text
tshow Maybe SourcePos
pos)
Inlines -> ParsecT [Content] PState m Inlines
forall a. a -> ParsecT [Content] PState m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Inlines
forall a. Monoid a => a
mempty
Just Maybe Text
-> Map Identifier Val -> ParsecT [Content] PState m Inlines
handler -> Maybe Text
-> Map Identifier Val -> ParsecT [Content] PState m Inlines
handler Maybe Text
forall a. Maybe a
Nothing Map Identifier Val
fields
pPandoc :: PandocMonad m => P m B.Pandoc
pPandoc :: forall (m :: * -> *). PandocMonad m => P m Pandoc
pPandoc = do
Elt "document" _ fields <- (Content -> Bool) -> P m Content
forall (m :: * -> *).
PandocMonad m =>
(Content -> Bool) -> P m Content
pTok Content -> Bool
isDocument
bs <- getField "body" fields >>= pWithContents pBlocks
pure $ B.doc bs
pBlocks :: PandocMonad m => P m B.Blocks
pBlocks :: forall (m :: * -> *). PandocMonad m => P m Blocks
pBlocks = [Blocks] -> Blocks
forall a. Monoid a => [a] -> a
mconcat ([Blocks] -> Blocks)
-> ParsecT [Content] PState m [Blocks]
-> ParsecT [Content] PState m Blocks
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT [Content] PState m Blocks
-> ParsecT [Content] PState m [Blocks]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many ParsecT [Content] PState m Blocks
forall (m :: * -> *). PandocMonad m => P m Blocks
pBlock
pBlock :: PandocMonad m => P m B.Blocks
pBlock :: forall (m :: * -> *). PandocMonad m => P m Blocks
pBlock = P m Blocks
forall (m :: * -> *). PandocMonad m => P m Blocks
pPara P m Blocks -> P m Blocks -> P m Blocks
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> P m Blocks
forall (m :: * -> *). PandocMonad m => P m Blocks
pBlockElt
pSpace :: PandocMonad m => P m Content
pSpace :: forall (m :: * -> *). PandocMonad m => P m Content
pSpace = (Content -> Bool) -> P m Content
forall (m :: * -> *).
PandocMonad m =>
(Content -> Bool) -> P m Content
pTok
( \case
Txt Text
t | (Char -> Bool) -> Text -> Bool
T.all (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
' ') Text
t -> Bool
True
Content
_ -> Bool
False )
pLab :: PandocMonad m => P m Text
pLab :: forall (m :: * -> *). PandocMonad m => P m Text
pLab = ParsecT [Content] PState m Text -> ParsecT [Content] PState m Text
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (ParsecT [Content] PState m Text
-> ParsecT [Content] PState m Text)
-> ParsecT [Content] PState m Text
-> ParsecT [Content] PState m Text
forall a b. (a -> b) -> a -> b
$ do
ParsecT [Content] PState m Content -> ParsecT [Content] PState m ()
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m ()
optional ParsecT [Content] PState m Content
forall (m :: * -> *). PandocMonad m => P m Content
pSpace
Lab t <- (Content -> Bool) -> ParsecT [Content] PState m Content
forall (m :: * -> *).
PandocMonad m =>
(Content -> Bool) -> P m Content
pTok
( \case
Lab Text
_ -> Bool
True
Content
_ -> Bool
False
)
pure t
isDocument :: Content -> Bool
isDocument :: Content -> Bool
isDocument (Elt Identifier
"document" Maybe SourcePos
_ Map Identifier Val
_) = Bool
True
isDocument Content
_ = Bool
False
isBlock :: Content -> Bool
isBlock :: Content -> Bool
isBlock (Elt Identifier
"raw" Maybe SourcePos
_ Map Identifier Val
fields) = Identifier -> Map Identifier Val -> Maybe Val
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup Identifier
"block" Map Identifier Val
fields Maybe Val -> Maybe Val -> Bool
forall a. Eq a => a -> a -> Bool
== Val -> Maybe Val
forall a. a -> Maybe a
Just (Bool -> Val
VBoolean Bool
True)
isBlock (Elt Identifier
name Maybe SourcePos
_ Map Identifier Val
_) = Identifier
name Identifier -> Set Identifier -> Bool
forall a. Ord a => a -> Set a -> Bool
`Set.member` Set Identifier
blockKeys
isBlock Lab{} = Bool
True
isBlock Content
_ = Bool
False
isInline :: Content -> Bool
isInline :: Content -> Bool
isInline (Elt Identifier
"raw" Maybe SourcePos
_ Map Identifier Val
fields) = Identifier -> Map Identifier Val -> Maybe Val
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup Identifier
"block" Map Identifier Val
fields Maybe Val -> Maybe Val -> Bool
forall a. Eq a => a -> a -> Bool
/= Val -> Maybe Val
forall a. a -> Maybe a
Just (Bool -> Val
VBoolean Bool
True)
isInline (Elt Identifier
name Maybe SourcePos
_ Map Identifier Val
_) = Identifier
name Identifier -> Set Identifier -> Bool
forall a. Ord a => a -> Set a -> Bool
`Set.member` Set Identifier
inlineKeys
isInline Lab{} = Bool
True
isInline Txt{} = Bool
True
blockKeys :: Set.Set Identifier
blockKeys :: Set Identifier
blockKeys = [Identifier] -> Set Identifier
forall a. Ord a => [a] -> Set a
Set.fromList ([Identifier] -> Set Identifier) -> [Identifier] -> Set Identifier
forall a b. (a -> b) -> a -> b
$ Map
Identifier
(Maybe Text -> Map Identifier Val -> P PandocPure Blocks)
-> [Identifier]
forall k a. Map k a -> [k]
M.keys
(Map
Identifier
(Maybe Text -> Map Identifier Val -> P PandocPure Blocks)
forall (m :: * -> *).
PandocMonad m =>
Map Identifier (Maybe Text -> Map Identifier Val -> P m Blocks)
blockHandlers :: M.Map Identifier
(Maybe Text -> M.Map Identifier Val -> P PandocPure B.Blocks))
inlineKeys :: Set.Set Identifier
inlineKeys :: Set Identifier
inlineKeys = [Identifier] -> Set Identifier
forall a. Ord a => [a] -> Set a
Set.fromList ([Identifier] -> Set Identifier) -> [Identifier] -> Set Identifier
forall a b. (a -> b) -> a -> b
$ Map
Identifier
(Maybe Text -> Map Identifier Val -> P PandocPure Inlines)
-> [Identifier]
forall k a. Map k a -> [k]
M.keys
(Map
Identifier
(Maybe Text -> Map Identifier Val -> P PandocPure Inlines)
forall (m :: * -> *).
PandocMonad m =>
Map Identifier (Maybe Text -> Map Identifier Val -> P m Inlines)
inlineHandlers :: M.Map Identifier
(Maybe Text -> M.Map Identifier Val -> P PandocPure B.Inlines))
blockHandlers :: PandocMonad m =>
M.Map Identifier
(Maybe Text -> M.Map Identifier Val -> P m B.Blocks)
blockHandlers :: forall (m :: * -> *).
PandocMonad m =>
Map Identifier (Maybe Text -> Map Identifier Val -> P m Blocks)
blockHandlers = [(Identifier, Maybe Text -> Map Identifier Val -> P m Blocks)]
-> Map Identifier (Maybe Text -> Map Identifier Val -> P m Blocks)
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList
[(Identifier
"text", \Maybe Text
_ Map Identifier Val
fields -> do
body <- Identifier
-> Map Identifier Val -> ParsecT [Content] PState m (Seq Content)
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields
notFollowedBy $ void $ pWithContents pInlines body
pWithContents pBlocks body)
,(Identifier
"box", \Maybe Text
_ Map Identifier Val
fields -> do
body <- Identifier
-> Map Identifier Val -> ParsecT [Content] PState m (Seq Content)
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields
B.divWith ("", ["box"], []) <$> pWithContents pBlocks body)
,(Identifier
"heading", \Maybe Text
mbident Map Identifier Val
fields -> do
body <- Identifier
-> Map Identifier Val -> ParsecT [Content] PState m (Seq Content)
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields
lev <- getField "level" fields <|> pure 1
B.headerWith (fromMaybe "" mbident,[],[]) lev
<$> pWithContents pInlines body)
,(Identifier
"quote", \Maybe Text
_ Map Identifier Val
fields -> do
Identifier -> Map Identifier Val -> ParsecT [Content] PState m Bool
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"block" Map Identifier Val
fields ParsecT [Content] PState m Bool
-> (Bool -> ParsecT [Content] PState m ())
-> ParsecT [Content] PState m ()
forall a b.
ParsecT [Content] PState m a
-> (a -> ParsecT [Content] PState m b)
-> ParsecT [Content] PState m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Bool -> ParsecT [Content] PState m ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard
body <- Identifier
-> Map Identifier Val -> ParsecT [Content] PState m (Seq Content)
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields ParsecT [Content] PState m (Seq Content)
-> (Seq Content -> P m Blocks) -> P m Blocks
forall a b.
ParsecT [Content] PState m a
-> (a -> ParsecT [Content] PState m b)
-> ParsecT [Content] PState m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= P m Blocks -> Seq Content -> P m Blocks
forall (m :: * -> *) a.
PandocMonad m =>
P m a -> Seq Content -> P m a
pWithContents P m Blocks
forall (m :: * -> *). PandocMonad m => P m Blocks
pBlocks
attribution' <- getField "attribution" fields
attribution <- if attribution' == mempty
then pure mempty
else (\Inlines
x -> Inlines -> Blocks
B.para (Inlines
"\x2014\xa0" Inlines -> Inlines -> Inlines
forall a. Semigroup a => a -> a -> a
<> Inlines
x)) <$>
(pWithContents pInlines attribution')
pure $ B.blockQuote $ body <> attribution)
,(Identifier
"list", \Maybe Text
_ Map Identifier Val
fields -> do
children <- Vector (Seq Content) -> [Seq Content]
forall a. Vector a -> [a]
V.toList (Vector (Seq Content) -> [Seq Content])
-> ParsecT [Content] PState m (Vector (Seq Content))
-> ParsecT [Content] PState m [Seq Content]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Identifier
-> Map Identifier Val
-> ParsecT [Content] PState m (Vector (Seq Content))
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"children" Map Identifier Val
fields
B.bulletList <$> mapM (pWithContents pBlocks) children)
,(Identifier
"list.item", \Maybe Text
_ Map Identifier Val
fields -> Identifier
-> Map Identifier Val -> ParsecT [Content] PState m (Seq Content)
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields ParsecT [Content] PState m (Seq Content)
-> (Seq Content -> P m Blocks) -> P m Blocks
forall a b.
ParsecT [Content] PState m a
-> (a -> ParsecT [Content] PState m b)
-> ParsecT [Content] PState m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= P m Blocks -> Seq Content -> P m Blocks
forall (m :: * -> *) a.
PandocMonad m =>
P m a -> Seq Content -> P m a
pWithContents P m Blocks
forall (m :: * -> *). PandocMonad m => P m Blocks
pBlocks)
,(Identifier
"enum", \Maybe Text
_ Map Identifier Val
fields -> do
children <- Vector (Seq Content) -> [Seq Content]
forall a. Vector a -> [a]
V.toList (Vector (Seq Content) -> [Seq Content])
-> ParsecT [Content] PState m (Vector (Seq Content))
-> ParsecT [Content] PState m [Seq Content]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Identifier
-> Map Identifier Val
-> ParsecT [Content] PState m (Vector (Seq Content))
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"children" Map Identifier Val
fields
mbstart <- getField "start" fields
start <- case mbstart of
Maybe Int
Nothing -> Int -> ParsecT [Content] PState m Int
forall a. a -> ParsecT [Content] PState m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
1
Just Int
x
| Int
x Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 -> Int -> ParsecT [Content] PState m Int
forall a. a -> ParsecT [Content] PState m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
x
| Bool
otherwise -> SourceName -> ParsecT [Content] PState m Int
forall a. SourceName -> ParsecT [Content] PState m a
forall (m :: * -> *) a. MonadFail m => SourceName -> m a
fail SourceName
"number must be positive"
(numbering :: Text) <- getField "numbering" fields `mplus` pure ""
let (sty, delim) =
case numbering of
Text
"1." -> (ListNumberStyle
B.Decimal, ListNumberDelim
B.Period)
Text
"1)" -> (ListNumberStyle
B.Decimal, ListNumberDelim
B.OneParen)
Text
"(1)" -> (ListNumberStyle
B.Decimal, ListNumberDelim
B.TwoParens)
Text
"a." -> (ListNumberStyle
B.LowerAlpha, ListNumberDelim
B.Period)
Text
"a)" -> (ListNumberStyle
B.LowerAlpha, ListNumberDelim
B.OneParen)
Text
"(a)" -> (ListNumberStyle
B.LowerAlpha, ListNumberDelim
B.TwoParens)
Text
"A." -> (ListNumberStyle
B.UpperAlpha, ListNumberDelim
B.Period)
Text
"A)" -> (ListNumberStyle
B.UpperAlpha, ListNumberDelim
B.OneParen)
Text
"(A)" -> (ListNumberStyle
B.UpperAlpha, ListNumberDelim
B.TwoParens)
Text
"i." -> (ListNumberStyle
B.LowerRoman, ListNumberDelim
B.Period)
Text
"i)" -> (ListNumberStyle
B.LowerRoman, ListNumberDelim
B.OneParen)
Text
"(i)" -> (ListNumberStyle
B.LowerRoman, ListNumberDelim
B.TwoParens)
Text
"I." -> (ListNumberStyle
B.UpperRoman, ListNumberDelim
B.Period)
Text
"I)" -> (ListNumberStyle
B.UpperRoman, ListNumberDelim
B.OneParen)
Text
"(I)" -> (ListNumberStyle
B.UpperRoman, ListNumberDelim
B.TwoParens)
Text
_ -> (ListNumberStyle
B.DefaultStyle, ListNumberDelim
B.DefaultDelim)
let listAttr = (Int
start, ListNumberStyle
sty, ListNumberDelim
delim)
B.orderedListWith listAttr <$> mapM (pWithContents pBlocks) children)
,(Identifier
"enum.item", \Maybe Text
_ Map Identifier Val
fields -> Identifier
-> Map Identifier Val -> ParsecT [Content] PState m (Seq Content)
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields ParsecT [Content] PState m (Seq Content)
-> (Seq Content -> P m Blocks) -> P m Blocks
forall a b.
ParsecT [Content] PState m a
-> (a -> ParsecT [Content] PState m b)
-> ParsecT [Content] PState m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= P m Blocks -> Seq Content -> P m Blocks
forall (m :: * -> *) a.
PandocMonad m =>
P m a -> Seq Content -> P m a
pWithContents P m Blocks
forall (m :: * -> *). PandocMonad m => P m Blocks
pBlocks)
,(Identifier
"terms", \Maybe Text
_ Map Identifier Val
fields -> do
children <- Vector Val -> [Val]
forall a. Vector a -> [a]
V.toList (Vector Val -> [Val])
-> ParsecT [Content] PState m (Vector Val)
-> ParsecT [Content] PState m [Val]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Identifier
-> Map Identifier Val -> ParsecT [Content] PState m (Vector Val)
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"children" Map Identifier Val
fields
B.definitionList
<$> mapM
( \case
VTermItem Seq Content
t Seq Content
d -> do
t' <- ParsecT [Content] PState m Inlines
-> Seq Content -> ParsecT [Content] PState m Inlines
forall (m :: * -> *) a.
PandocMonad m =>
P m a -> Seq Content -> P m a
pWithContents ParsecT [Content] PState m Inlines
forall (m :: * -> *). PandocMonad m => P m Inlines
pInlines Seq Content
t
d' <- pWithContents pBlocks d
pure (t', [d'])
Val
_ -> (Inlines, [Blocks])
-> ParsecT [Content] PState m (Inlines, [Blocks])
forall a. a -> ParsecT [Content] PState m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Inlines
forall a. Monoid a => a
mempty, [])
)
children)
,(Identifier
"terms.item", \Maybe Text
_ Map Identifier Val
fields -> Identifier
-> Map Identifier Val -> ParsecT [Content] PState m (Seq Content)
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields ParsecT [Content] PState m (Seq Content)
-> (Seq Content -> P m Blocks) -> P m Blocks
forall a b.
ParsecT [Content] PState m a
-> (a -> ParsecT [Content] PState m b)
-> ParsecT [Content] PState m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= P m Blocks -> Seq Content -> P m Blocks
forall (m :: * -> *) a.
PandocMonad m =>
P m a -> Seq Content -> P m a
pWithContents P m Blocks
forall (m :: * -> *). PandocMonad m => P m Blocks
pBlocks)
,(Identifier
"raw", \Maybe Text
mbident Map Identifier Val
fields -> do
txt <- (Char -> Bool) -> Text -> Text
T.filter (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
'\r') (Text -> Text)
-> ParsecT [Content] PState m Text
-> ParsecT [Content] PState m Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Identifier -> Map Identifier Val -> ParsecT [Content] PState m Text
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"text" Map Identifier Val
fields
mblang <- getField "lang" fields
let attr = (Text -> Maybe Text -> Text
forall a. a -> Maybe a -> a
fromMaybe Text
"" Maybe Text
mbident, [Text] -> (Item [Text] -> [Text]) -> Maybe (Item [Text]) -> [Text]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] (\Item [Text]
l -> [Item [Text]
l]) Maybe Text
Maybe (Item [Text])
mblang, [])
pure $ B.codeBlockWith attr txt)
,(Identifier
"parbreak", \Maybe Text
_ Map Identifier Val
_ -> Blocks -> P m Blocks
forall a. a -> ParsecT [Content] PState m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Blocks
forall a. Monoid a => a
mempty)
,(Identifier
"block", \Maybe Text
mbident Map Identifier Val
fields ->
(Blocks -> Blocks)
-> (Text -> Blocks -> Blocks) -> Maybe Text -> Blocks -> Blocks
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Blocks -> Blocks
forall a. a -> a
id (\Text
ident -> Attr -> Blocks -> Blocks
B.divWith (Text
ident, [], [])) Maybe Text
mbident
(Blocks -> Blocks) -> P m Blocks -> P m Blocks
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Identifier
-> Map Identifier Val -> ParsecT [Content] PState m (Seq Content)
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields ParsecT [Content] PState m (Seq Content)
-> (Seq Content -> P m Blocks) -> P m Blocks
forall a b.
ParsecT [Content] PState m a
-> (a -> ParsecT [Content] PState m b)
-> ParsecT [Content] PState m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= P m Blocks -> Seq Content -> P m Blocks
forall (m :: * -> *) a.
PandocMonad m =>
P m a -> Seq Content -> P m a
pWithContents P m Blocks
forall (m :: * -> *). PandocMonad m => P m Blocks
pBlocks))
,(Identifier
"place", \Maybe Text
_ Map Identifier Val
fields -> do
Text -> ParsecT [Content] PState m ()
forall (m :: * -> *). PandocMonad m => Text -> P m ()
ignored Text
"parameters of place"
Identifier
-> Map Identifier Val -> ParsecT [Content] PState m (Seq Content)
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields ParsecT [Content] PState m (Seq Content)
-> (Seq Content -> P m Blocks) -> P m Blocks
forall a b.
ParsecT [Content] PState m a
-> (a -> ParsecT [Content] PState m b)
-> ParsecT [Content] PState m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= P m Blocks -> Seq Content -> P m Blocks
forall (m :: * -> *) a.
PandocMonad m =>
P m a -> Seq Content -> P m a
pWithContents P m Blocks
forall (m :: * -> *). PandocMonad m => P m Blocks
pBlocks)
,(Identifier
"columns", \Maybe Text
_ Map Identifier Val
fields -> do
(cnt :: Integer) <- Identifier
-> Map Identifier Val -> ParsecT [Content] PState m Integer
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"count" Map Identifier Val
fields
B.divWith ("", ["columns-flow"], [("count", T.pack (show cnt))])
<$> (getField "body" fields >>= pWithContents pBlocks))
,(Identifier
"rect", \Maybe Text
_ Map Identifier Val
fields ->
Attr -> Blocks -> Blocks
B.divWith (Text
"", [Text
Item [Text]
"rect"], []) (Blocks -> Blocks) -> P m Blocks -> P m Blocks
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Identifier
-> Map Identifier Val -> ParsecT [Content] PState m (Seq Content)
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields ParsecT [Content] PState m (Seq Content)
-> (Seq Content -> P m Blocks) -> P m Blocks
forall a b.
ParsecT [Content] PState m a
-> (a -> ParsecT [Content] PState m b)
-> ParsecT [Content] PState m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= P m Blocks -> Seq Content -> P m Blocks
forall (m :: * -> *) a.
PandocMonad m =>
P m a -> Seq Content -> P m a
pWithContents P m Blocks
forall (m :: * -> *). PandocMonad m => P m Blocks
pBlocks))
,(Identifier
"circle", \Maybe Text
_ Map Identifier Val
fields ->
Attr -> Blocks -> Blocks
B.divWith (Text
"", [Text
Item [Text]
"circle"], []) (Blocks -> Blocks) -> P m Blocks -> P m Blocks
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Identifier
-> Map Identifier Val -> ParsecT [Content] PState m (Seq Content)
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields ParsecT [Content] PState m (Seq Content)
-> (Seq Content -> P m Blocks) -> P m Blocks
forall a b.
ParsecT [Content] PState m a
-> (a -> ParsecT [Content] PState m b)
-> ParsecT [Content] PState m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= P m Blocks -> Seq Content -> P m Blocks
forall (m :: * -> *) a.
PandocMonad m =>
P m a -> Seq Content -> P m a
pWithContents P m Blocks
forall (m :: * -> *). PandocMonad m => P m Blocks
pBlocks))
,(Identifier
"ellipse", \Maybe Text
_ Map Identifier Val
fields ->
Attr -> Blocks -> Blocks
B.divWith (Text
"", [Text
Item [Text]
"ellipse"], []) (Blocks -> Blocks) -> P m Blocks -> P m Blocks
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Identifier
-> Map Identifier Val -> ParsecT [Content] PState m (Seq Content)
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields ParsecT [Content] PState m (Seq Content)
-> (Seq Content -> P m Blocks) -> P m Blocks
forall a b.
ParsecT [Content] PState m a
-> (a -> ParsecT [Content] PState m b)
-> ParsecT [Content] PState m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= P m Blocks -> Seq Content -> P m Blocks
forall (m :: * -> *) a.
PandocMonad m =>
P m a -> Seq Content -> P m a
pWithContents P m Blocks
forall (m :: * -> *). PandocMonad m => P m Blocks
pBlocks))
,(Identifier
"polygon", \Maybe Text
_ Map Identifier Val
fields ->
Attr -> Blocks -> Blocks
B.divWith (Text
"", [Text
Item [Text]
"polygon"], []) (Blocks -> Blocks) -> P m Blocks -> P m Blocks
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Identifier
-> Map Identifier Val -> ParsecT [Content] PState m (Seq Content)
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields ParsecT [Content] PState m (Seq Content)
-> (Seq Content -> P m Blocks) -> P m Blocks
forall a b.
ParsecT [Content] PState m a
-> (a -> ParsecT [Content] PState m b)
-> ParsecT [Content] PState m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= P m Blocks -> Seq Content -> P m Blocks
forall (m :: * -> *) a.
PandocMonad m =>
P m a -> Seq Content -> P m a
pWithContents P m Blocks
forall (m :: * -> *). PandocMonad m => P m Blocks
pBlocks))
,(Identifier
"square", \Maybe Text
_ Map Identifier Val
fields ->
Attr -> Blocks -> Blocks
B.divWith (Text
"", [Text
Item [Text]
"square"], []) (Blocks -> Blocks) -> P m Blocks -> P m Blocks
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Identifier
-> Map Identifier Val -> ParsecT [Content] PState m (Seq Content)
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields ParsecT [Content] PState m (Seq Content)
-> (Seq Content -> P m Blocks) -> P m Blocks
forall a b.
ParsecT [Content] PState m a
-> (a -> ParsecT [Content] PState m b)
-> ParsecT [Content] PState m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= P m Blocks -> Seq Content -> P m Blocks
forall (m :: * -> *) a.
PandocMonad m =>
P m a -> Seq Content -> P m a
pWithContents P m Blocks
forall (m :: * -> *). PandocMonad m => P m Blocks
pBlocks))
,(Identifier
"align", \Maybe Text
_ Map Identifier Val
fields -> do
alignment <- Identifier -> Map Identifier Val -> ParsecT [Content] PState m Val
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"alignment" Map Identifier Val
fields
B.divWith ("", [], [("align", repr alignment)])
<$> (getField "body" fields >>= pWithContents pBlocks))
,(Identifier
"stack", \Maybe Text
_ Map Identifier Val
fields -> do
(dir :: Direction) <- Identifier
-> Map Identifier Val -> ParsecT [Content] PState m Direction
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"dir" Map Identifier Val
fields ParsecT [Content] PState m Direction
-> ParsecT [Content] PState m Direction
-> ParsecT [Content] PState m Direction
forall a.
ParsecT [Content] PState m a
-> ParsecT [Content] PState m a -> ParsecT [Content] PState m a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus` Direction -> ParsecT [Content] PState m Direction
forall a. a -> ParsecT [Content] PState m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Direction
Ltr
rawchildren <- getField "children" fields
children <-
mapM
( \case
val :: Val
val@(VFraction {}) ->
Blocks -> P m Blocks
forall a. a -> ParsecT [Content] PState m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Blocks -> P m Blocks) -> Blocks -> P m Blocks
forall a b. (a -> b) -> a -> b
$ Attr -> Blocks -> Blocks
B.divWith (Text
"", [], [(Text
"space", Val -> Text
repr Val
val)]) Blocks
forall a. Monoid a => a
mempty
Val
val -> Val -> ParsecT [Content] PState m (Seq Content)
forall a (m :: * -> *).
(FromVal a, MonadPlus m, MonadFail m) =>
Val -> m a
forall (m :: * -> *).
(MonadPlus m, MonadFail m) =>
Val -> m (Seq Content)
fromVal Val
val ParsecT [Content] PState m (Seq Content)
-> (Seq Content -> P m Blocks) -> P m Blocks
forall a b.
ParsecT [Content] PState m a
-> (a -> ParsecT [Content] PState m b)
-> ParsecT [Content] PState m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= P m Blocks -> Seq Content -> P m Blocks
forall (m :: * -> *) a.
PandocMonad m =>
P m a -> Seq Content -> P m a
pWithContents P m Blocks
forall (m :: * -> *). PandocMonad m => P m Blocks
pBlocks
)
(V.toList rawchildren)
pure $
B.divWith ("", [], [("stack", repr (VDirection dir))]) $
mconcat $
map (B.divWith ("", [], [])) children)
,(Identifier
"grid", \Maybe Text
mbident Map Identifier Val
fields -> Maybe Text -> Map Identifier Val -> P m Blocks
forall (m :: * -> *).
PandocMonad m =>
Maybe Text -> Map Identifier Val -> P m Blocks
parseTable Maybe Text
mbident Map Identifier Val
fields)
,(Identifier
"table", \Maybe Text
mbident Map Identifier Val
fields -> Maybe Text -> Map Identifier Val -> P m Blocks
forall (m :: * -> *).
PandocMonad m =>
Maybe Text -> Map Identifier Val -> P m Blocks
parseTable Maybe Text
mbident Map Identifier Val
fields)
,(Identifier
"figure", \Maybe Text
mbident Map Identifier Val
fields -> do
body <- Identifier
-> Map Identifier Val -> ParsecT [Content] PState m (Seq Content)
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields ParsecT [Content] PState m (Seq Content)
-> (Seq Content -> P m Blocks) -> P m Blocks
forall a b.
ParsecT [Content] PState m a
-> (a -> ParsecT [Content] PState m b)
-> ParsecT [Content] PState m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= P m Blocks -> Seq Content -> P m Blocks
forall (m :: * -> *) a.
PandocMonad m =>
P m a -> Seq Content -> P m a
pWithContents P m Blocks
forall (m :: * -> *). PandocMonad m => P m Blocks
pBlocks
(mbCaption :: Maybe (Seq Content)) <- getField "caption" fields
(caption :: B.Blocks) <- maybe mempty (pWithContents pBlocks) mbCaption
pure $ case B.toList body of
[B.Table Attr
attr Caption
_ [ColSpec]
colspecs TableHead
thead [TableBody]
tbodies TableFoot
tfoot] ->
Block -> Blocks
forall a. a -> Many a
B.singleton
(Attr
-> Caption
-> [ColSpec]
-> TableHead
-> [TableBody]
-> TableFoot
-> Block
B.Table Attr
attr (Maybe [Inline] -> [Block] -> Caption
B.Caption Maybe [Inline]
forall a. Maybe a
Nothing (Blocks -> [Block]
forall a. Many a -> [a]
B.toList Blocks
caption)) [ColSpec]
colspecs TableHead
thead [TableBody]
tbodies TableFoot
tfoot)
[Block]
_ -> Attr -> Caption -> Blocks -> Blocks
B.figureWith (Text -> Maybe Text -> Text
forall a. a -> Maybe a -> a
fromMaybe Text
"" Maybe Text
mbident, [], [])
(Maybe [Inline] -> [Block] -> Caption
B.Caption Maybe [Inline]
forall a. Maybe a
Nothing (Blocks -> [Block]
forall a. Many a -> [a]
B.toList Blocks
caption)) Blocks
body)
,(Identifier
"line", \Maybe Text
_ Map Identifier Val
fields ->
case ( Identifier -> Map Identifier Val -> Maybe Val
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup Identifier
"start" Map Identifier Val
fields
Maybe Val -> Maybe Val -> Maybe Val
forall a b. Maybe a -> Maybe b -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Identifier -> Map Identifier Val -> Maybe Val
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup Identifier
"end" Map Identifier Val
fields
Maybe Val -> Maybe Val -> Maybe Val
forall a b. Maybe a -> Maybe b -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Identifier -> Map Identifier Val -> Maybe Val
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup Identifier
"angle" Map Identifier Val
fields ) of
Maybe Val
Nothing -> Blocks -> P m Blocks
forall a. a -> ParsecT [Content] PState m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Blocks
B.horizontalRule
Maybe Val
_ -> Blocks -> P m Blocks
forall a. a -> ParsecT [Content] PState m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Blocks
forall a. Monoid a => a
mempty)
,(Identifier
"numbering", \Maybe Text
_ Map Identifier Val
fields -> do
numStyle <- Identifier -> Map Identifier Val -> ParsecT [Content] PState m Val
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"numbering" Map Identifier Val
fields
(nums :: V.Vector Integer) <- getField "numbers" fields
let toText Val
v = a -> Maybe a -> a
forall a. a -> Maybe a -> a
fromMaybe a
"" (Maybe a -> a) -> Maybe a -> a
forall a b. (a -> b) -> a -> b
$ Val -> Maybe a
forall a (m :: * -> *).
(FromVal a, MonadPlus m, MonadFail m) =>
Val -> m a
forall (m :: * -> *). (MonadPlus m, MonadFail m) => Val -> m a
fromVal Val
v
let toNum Integer
n =
case Val
numStyle of
VString Text
t -> Text -> Int -> Text
formatNumber Text
t (Integer -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
n)
VFunction Maybe Identifier
_ Map Identifier Val
_ Function
f ->
case Function -> [Val] -> Attempt Val
applyPureFunction Function
f [Integer -> Val
VInteger Integer
n] of
Success Val
x -> Val -> Text
forall {a}. (IsString a, FromVal a) => Val -> a
toText Val
x
Failure SourceName
_ -> Text
"?"
Val
_ -> Text
"?"
pure $ B.plain . B.text . mconcat . map toNum $ V.toList nums)
,(Identifier
"footnote.entry", \Maybe Text
_ Map Identifier Val
fields ->
Identifier
-> Map Identifier Val -> ParsecT [Content] PState m (Seq Content)
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields ParsecT [Content] PState m (Seq Content)
-> (Seq Content -> P m Blocks) -> P m Blocks
forall a b.
ParsecT [Content] PState m a
-> (a -> ParsecT [Content] PState m b)
-> ParsecT [Content] PState m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= P m Blocks -> Seq Content -> P m Blocks
forall (m :: * -> *) a.
PandocMonad m =>
P m a -> Seq Content -> P m a
pWithContents P m Blocks
forall (m :: * -> *). PandocMonad m => P m Blocks
pBlocks)
,(Identifier
"pad", \Maybe Text
_ Map Identifier Val
fields ->
Identifier
-> Map Identifier Val -> ParsecT [Content] PState m (Seq Content)
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields ParsecT [Content] PState m (Seq Content)
-> (Seq Content -> P m Blocks) -> P m Blocks
forall a b.
ParsecT [Content] PState m a
-> (a -> ParsecT [Content] PState m b)
-> ParsecT [Content] PState m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= P m Blocks -> Seq Content -> P m Blocks
forall (m :: * -> *) a.
PandocMonad m =>
P m a -> Seq Content -> P m a
pWithContents P m Blocks
forall (m :: * -> *). PandocMonad m => P m Blocks
pBlocks)
]
inlineHandlers :: PandocMonad m =>
M.Map Identifier (Maybe Text -> M.Map Identifier Val -> P m B.Inlines)
inlineHandlers :: forall (m :: * -> *).
PandocMonad m =>
Map Identifier (Maybe Text -> Map Identifier Val -> P m Inlines)
inlineHandlers = [(Identifier, Maybe Text -> Map Identifier Val -> P m Inlines)]
-> Map Identifier (Maybe Text -> Map Identifier Val -> P m Inlines)
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList
[(Identifier
"ref", \Maybe Text
_ Map Identifier Val
fields -> do
VLabel target <- Identifier -> Map Identifier Val -> ParsecT [Content] PState m Val
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"target" Map Identifier Val
fields
supplement' <- getField "supplement" fields
supplement <- case supplement' of
Val
VAuto ->
Inlines -> P m Inlines
forall a. a -> ParsecT [Content] PState m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Inlines -> P m Inlines) -> Inlines -> P m Inlines
forall a b. (a -> b) -> a -> b
$ Text -> Inlines
B.text (Text
"[" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
target Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"]")
VContent Seq Content
cs -> P m Inlines -> Seq Content -> P m Inlines
forall (m :: * -> *) a.
PandocMonad m =>
P m a -> Seq Content -> P m a
pWithContents P m Inlines
forall (m :: * -> *). PandocMonad m => P m Inlines
pInlines Seq Content
cs
VFunction Maybe Identifier
_ Map Identifier Val
_ Function
_f ->
Inlines -> P m Inlines
forall a. a -> ParsecT [Content] PState m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Inlines -> P m Inlines) -> Inlines -> P m Inlines
forall a b. (a -> b) -> a -> b
$ Text -> Inlines
B.text (Text
"[" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
target Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"]")
Val
_ -> Inlines -> P m Inlines
forall a. a -> ParsecT [Content] PState m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Inlines
forall a. Monoid a => a
mempty
pure $ B.linkWith ("", ["ref"], []) ("#" <> target) "" supplement)
,(Identifier
"linebreak", \Maybe Text
_ Map Identifier Val
_ -> Inlines -> P m Inlines
forall a. a -> ParsecT [Content] PState m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Inlines
B.linebreak)
,(Identifier
"text", \Maybe Text
_ Map Identifier Val
fields -> do
body <- Identifier
-> Map Identifier Val -> ParsecT [Content] PState m (Seq Content)
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields
(mbweight :: Maybe Text) <- getField "weight" fields
case mbweight of
Just Text
"bold" -> Inlines -> Inlines
B.strong (Inlines -> Inlines) -> P m Inlines -> P m Inlines
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> P m Inlines -> Seq Content -> P m Inlines
forall (m :: * -> *) a.
PandocMonad m =>
P m a -> Seq Content -> P m a
pWithContents P m Inlines
forall (m :: * -> *). PandocMonad m => P m Inlines
pInlines Seq Content
body
Maybe Text
_ -> P m Inlines -> Seq Content -> P m Inlines
forall (m :: * -> *) a.
PandocMonad m =>
P m a -> Seq Content -> P m a
pWithContents P m Inlines
forall (m :: * -> *). PandocMonad m => P m Inlines
pInlines Seq Content
body)
,(Identifier
"raw", \Maybe Text
_ Map Identifier Val
fields -> Text -> Inlines
B.code (Text -> Inlines) -> (Text -> Text) -> Text -> Inlines
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Bool) -> Text -> Text
T.filter (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
'\r') (Text -> Inlines) -> ParsecT [Content] PState m Text -> P m Inlines
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Identifier -> Map Identifier Val -> ParsecT [Content] PState m Text
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"text" Map Identifier Val
fields)
,(Identifier
"footnote", \Maybe Text
_ Map Identifier Val
fields ->
Blocks -> Inlines
B.note (Blocks -> Inlines)
-> ParsecT [Content] PState m Blocks -> P m Inlines
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Identifier
-> Map Identifier Val -> ParsecT [Content] PState m (Seq Content)
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields ParsecT [Content] PState m (Seq Content)
-> (Seq Content -> ParsecT [Content] PState m Blocks)
-> ParsecT [Content] PState m Blocks
forall a b.
ParsecT [Content] PState m a
-> (a -> ParsecT [Content] PState m b)
-> ParsecT [Content] PState m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ParsecT [Content] PState m Blocks
-> Seq Content -> ParsecT [Content] PState m Blocks
forall (m :: * -> *) a.
PandocMonad m =>
P m a -> Seq Content -> P m a
pWithContents ParsecT [Content] PState m Blocks
forall (m :: * -> *). PandocMonad m => P m Blocks
pBlocks))
,(Identifier
"cite", \Maybe Text
_ Map Identifier Val
fields -> do
VLabel key <- Identifier -> Map Identifier Val -> ParsecT [Content] PState m Val
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"key" Map Identifier Val
fields
(form :: Text) <- getField "form" fields <|> pure "normal"
let citation =
B.Citation
{ citationId :: Text
B.citationId = Text
key,
citationPrefix :: [Inline]
B.citationPrefix = [Inline]
forall a. Monoid a => a
mempty,
citationSuffix :: [Inline]
B.citationSuffix = [Inline]
forall a. Monoid a => a
mempty,
citationMode :: CitationMode
B.citationMode = case Text
form of
Text
"year" -> CitationMode
B.SuppressAuthor
Text
_ -> CitationMode
B.NormalCitation,
citationNoteNum :: Int
B.citationNoteNum = Int
0,
citationHash :: Int
B.citationHash = Int
0
}
pure $ B.cite [citation] (B.text $ "[" <> key <> "]"))
,(Identifier
"lower", \Maybe Text
_ Map Identifier Val
fields -> do
body <- Identifier
-> Map Identifier Val -> ParsecT [Content] PState m (Seq Content)
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"text" Map Identifier Val
fields
walk (modString T.toLower) <$> pWithContents pInlines body)
,(Identifier
"upper", \Maybe Text
_ Map Identifier Val
fields -> do
body <- Identifier
-> Map Identifier Val -> ParsecT [Content] PState m (Seq Content)
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"text" Map Identifier Val
fields
walk (modString T.toUpper) <$> pWithContents pInlines body)
,(Identifier
"emph", \Maybe Text
_ Map Identifier Val
fields -> do
body <- Identifier
-> Map Identifier Val -> ParsecT [Content] PState m (Seq Content)
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields
B.emph <$> pWithContents pInlines body)
,(Identifier
"strong", \Maybe Text
_ Map Identifier Val
fields -> do
body <- Identifier
-> Map Identifier Val -> ParsecT [Content] PState m (Seq Content)
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields
B.strong <$> pWithContents pInlines body)
,(Identifier
"sub", \Maybe Text
_ Map Identifier Val
fields -> do
body <- Identifier
-> Map Identifier Val -> ParsecT [Content] PState m (Seq Content)
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields
B.subscript <$> pWithContents pInlines body)
,(Identifier
"super", \Maybe Text
_ Map Identifier Val
fields -> do
body <- Identifier
-> Map Identifier Val -> ParsecT [Content] PState m (Seq Content)
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields
B.superscript <$> pWithContents pInlines body)
,(Identifier
"strike", \Maybe Text
_ Map Identifier Val
fields -> do
body <- Identifier
-> Map Identifier Val -> ParsecT [Content] PState m (Seq Content)
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields
B.strikeout <$> pWithContents pInlines body)
,(Identifier
"smallcaps", \Maybe Text
_ Map Identifier Val
fields -> do
body <- Identifier
-> Map Identifier Val -> ParsecT [Content] PState m (Seq Content)
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields
B.smallcaps <$> pWithContents pInlines body)
,(Identifier
"underline", \Maybe Text
_ Map Identifier Val
fields -> do
body <- Identifier
-> Map Identifier Val -> ParsecT [Content] PState m (Seq Content)
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields
B.underline <$> pWithContents pInlines body)
,(Identifier
"quote", \Maybe Text
_ Map Identifier Val
fields -> do
(Identifier -> Map Identifier Val -> ParsecT [Content] PState m Bool
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"block" Map Identifier Val
fields ParsecT [Content] PState m Bool
-> ParsecT [Content] PState m Bool
-> ParsecT [Content] PState m Bool
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Bool -> ParsecT [Content] PState m Bool
forall a. a -> ParsecT [Content] PState m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
False) ParsecT [Content] PState m Bool
-> (Bool -> ParsecT [Content] PState m ())
-> ParsecT [Content] PState m ()
forall a b.
ParsecT [Content] PState m a
-> (a -> ParsecT [Content] PState m b)
-> ParsecT [Content] PState m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Bool -> ParsecT [Content] PState m ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Bool -> ParsecT [Content] PState m ())
-> (Bool -> Bool) -> Bool -> ParsecT [Content] PState m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Bool
not
body <- Map Identifier Val -> ParsecT [Content] PState m (Seq Content)
forall (m :: * -> *).
PandocMonad m =>
Map Identifier Val -> P m (Seq Content)
getInlineBody Map Identifier Val
fields ParsecT [Content] PState m (Seq Content)
-> (Seq Content -> P m Inlines) -> P m Inlines
forall a b.
ParsecT [Content] PState m a
-> (a -> ParsecT [Content] PState m b)
-> ParsecT [Content] PState m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= P m Inlines -> Seq Content -> P m Inlines
forall (m :: * -> *) a.
PandocMonad m =>
P m a -> Seq Content -> P m a
pWithContents P m Inlines
forall (m :: * -> *). PandocMonad m => P m Inlines
pInlines
pure $ B.doubleQuoted $ B.trimInlines body)
,(Identifier
"link", \Maybe Text
_ Map Identifier Val
fields -> do
dest <- Identifier -> Map Identifier Val -> ParsecT [Content] PState m Val
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"dest" Map Identifier Val
fields
src <- case dest of
VString Text
t -> Text -> ParsecT [Content] PState m Text
forall a. a -> ParsecT [Content] PState m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Text
t
VLabel Text
t -> Text -> ParsecT [Content] PState m Text
forall a. a -> ParsecT [Content] PState m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Text -> ParsecT [Content] PState m Text)
-> Text -> ParsecT [Content] PState m Text
forall a b. (a -> b) -> a -> b
$ Text
"#" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
t
VDict OMap Identifier Val
_ -> do
Text -> ParsecT [Content] PState m ()
forall (m :: * -> *). PandocMonad m => Text -> P m ()
ignored Text
"link to location, linking to #"
Text -> ParsecT [Content] PState m Text
forall a. a -> ParsecT [Content] PState m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Text
"#"
Val
_ -> SourceName -> ParsecT [Content] PState m Text
forall a. SourceName -> ParsecT [Content] PState m a
forall (m :: * -> *) a. MonadFail m => SourceName -> m a
fail (SourceName -> ParsecT [Content] PState m Text)
-> SourceName -> ParsecT [Content] PState m Text
forall a b. (a -> b) -> a -> b
$ SourceName
"Expected string or label for dest"
body <- getField "body" fields
description <-
if null body
then
pure $
B.text $
if "mailto:" `T.isPrefixOf` src
then T.drop 7 src
else
if "tel:" `T.isPrefixOf` src
then T.drop 4 src
else src
else pWithContents pInlines body <|>
pWithContents
(B.fromList . blocksToInlines . B.toList <$> pBlocks) body
pure $ B.link src "" description)
,(Identifier
"image", \Maybe Text
_ Map Identifier Val
fields -> do
path <- Identifier -> Map Identifier Val -> ParsecT [Content] PState m Text
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"path" Map Identifier Val
fields
alt <- (B.text <$> getField "alt" fields) `mplus` pure mempty
(mbwidth :: Maybe Text) <-
fmap (renderLength False) <$> getField "width" fields
(mbheight :: Maybe Text) <-
fmap (renderLength False) <$> getField "height" fields
let attr =
( Text
"",
[],
[(Text, Text)]
-> (Text -> [(Text, Text)]) -> Maybe Text -> [(Text, Text)]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] (\Text
x -> [(Text
"width", Text
x)]) Maybe Text
mbwidth
[(Text, Text)] -> [(Text, Text)] -> [(Text, Text)]
forall a. [a] -> [a] -> [a]
++ [(Text, Text)]
-> (Text -> [(Text, Text)]) -> Maybe Text -> [(Text, Text)]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] (\Text
x -> [(Text
"height", Text
x)]) Maybe Text
mbheight
)
pure $ B.imageWith attr path "" alt)
,(Identifier
"box", \Maybe Text
_ Map Identifier Val
fields -> do
body <- Identifier
-> Map Identifier Val -> ParsecT [Content] PState m (Seq Content)
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields
B.spanWith ("", ["box"], []) <$> pWithContents pInlines body)
,(Identifier
"h", \Maybe Text
_ Map Identifier Val
fields -> do
amount <- Identifier
-> Map Identifier Val -> ParsecT [Content] PState m Length
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"amount" Map Identifier Val
fields ParsecT [Content] PState m Length
-> ParsecT [Content] PState m Length
-> ParsecT [Content] PState m Length
forall a.
ParsecT [Content] PState m a
-> ParsecT [Content] PState m a -> ParsecT [Content] PState m a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus` Length -> ParsecT [Content] PState m Length
forall a. a -> ParsecT [Content] PState m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Double -> LUnit -> Length
LExact Double
1 LUnit
LEm)
let em = case Length
amount of
LExact Double
x LUnit
LEm -> Double -> Rational
forall a. Real a => a -> Rational
toRational Double
x
Length
_ -> case Length
amount Length -> Length -> Length
forall a. Semigroup a => a -> a -> a
<> Double -> LUnit -> Length
LExact Double
0 LUnit
LPt of
LExact Double
x LUnit
LPt -> Double -> Rational
forall a. Real a => a -> Rational
toRational Double
x Rational -> Rational -> Rational
forall a. Fractional a => a -> a -> a
/ Rational
12
Length
_ -> Rational
1 Rational -> Rational -> Rational
forall a. Fractional a => a -> a -> a
/ Rational
3
pure $ B.text $ getSpaceChars em)
,(Identifier
"place", \Maybe Text
_ Map Identifier Val
fields -> do
Text -> ParsecT [Content] PState m ()
forall (m :: * -> *). PandocMonad m => Text -> P m ()
ignored Text
"parameters of place"
Identifier
-> Map Identifier Val -> ParsecT [Content] PState m (Seq Content)
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields ParsecT [Content] PState m (Seq Content)
-> (Seq Content -> P m Inlines) -> P m Inlines
forall a b.
ParsecT [Content] PState m a
-> (a -> ParsecT [Content] PState m b)
-> ParsecT [Content] PState m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= P m Inlines -> Seq Content -> P m Inlines
forall (m :: * -> *) a.
PandocMonad m =>
P m a -> Seq Content -> P m a
pWithContents P m Inlines
forall (m :: * -> *). PandocMonad m => P m Inlines
pInlines)
,(Identifier
"align", \Maybe Text
_ Map Identifier Val
fields -> do
alignment <- Identifier -> Map Identifier Val -> ParsecT [Content] PState m Val
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"alignment" Map Identifier Val
fields
B.spanWith ("", [], [("align", repr alignment)])
<$> (getField "body" fields >>= pWithContents pInlines))
,(Identifier
"sys.version", \Maybe Text
_ Map Identifier Val
_ -> Inlines -> P m Inlines
forall a. a -> ParsecT [Content] PState m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Inlines -> P m Inlines) -> Inlines -> P m Inlines
forall a b. (a -> b) -> a -> b
$ Text -> Inlines
B.text Text
"typst-hs")
,(Identifier
"math.equation", \Maybe Text
_ Map Identifier Val
fields -> do
body <- Identifier
-> Map Identifier Val -> ParsecT [Content] PState m (Seq Content)
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields
display <- getField "block" fields
(if display then B.displayMath else B.math) . writeTeX <$> pMathMany body)
,(Identifier
"pad", \Maybe Text
_ Map Identifier Val
fields ->
Identifier
-> Map Identifier Val -> ParsecT [Content] PState m (Seq Content)
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields ParsecT [Content] PState m (Seq Content)
-> (Seq Content -> P m Inlines) -> P m Inlines
forall a b.
ParsecT [Content] PState m a
-> (a -> ParsecT [Content] PState m b)
-> ParsecT [Content] PState m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= P m Inlines -> Seq Content -> P m Inlines
forall (m :: * -> *) a.
PandocMonad m =>
P m a -> Seq Content -> P m a
pWithContents P m Inlines
forall (m :: * -> *). PandocMonad m => P m Inlines
pInlines)
,(Identifier
"block", \Maybe Text
mbident Map Identifier Val
fields ->
(Inlines -> Inlines)
-> (Text -> Inlines -> Inlines) -> Maybe Text -> Inlines -> Inlines
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Inlines -> Inlines
forall a. a -> a
id (\Text
ident -> Attr -> Inlines -> Inlines
B.spanWith (Text
ident, [], [])) Maybe Text
mbident
(Inlines -> Inlines) -> P m Inlines -> P m Inlines
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Identifier
-> Map Identifier Val -> ParsecT [Content] PState m (Seq Content)
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields ParsecT [Content] PState m (Seq Content)
-> (Seq Content -> P m Inlines) -> P m Inlines
forall a b.
ParsecT [Content] PState m a
-> (a -> ParsecT [Content] PState m b)
-> ParsecT [Content] PState m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= P m Inlines -> Seq Content -> P m Inlines
forall (m :: * -> *) a.
PandocMonad m =>
P m a -> Seq Content -> P m a
pWithContents P m Inlines
forall (m :: * -> *). PandocMonad m => P m Inlines
pInlines))
]
getInlineBody :: PandocMonad m => M.Map Identifier Val -> P m (Seq Content)
getInlineBody :: forall (m :: * -> *).
PandocMonad m =>
Map Identifier Val -> P m (Seq Content)
getInlineBody Map Identifier Val
fields =
Seq Content -> Seq Content
parbreaksToLinebreaks (Seq Content -> Seq Content)
-> ParsecT [Content] PState m (Seq Content)
-> ParsecT [Content] PState m (Seq Content)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Identifier
-> Map Identifier Val -> ParsecT [Content] PState m (Seq Content)
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields
parbreaksToLinebreaks :: Seq Content -> Seq Content
parbreaksToLinebreaks :: Seq Content -> Seq Content
parbreaksToLinebreaks =
(Content -> Content) -> Seq Content -> Seq Content
forall a b. (a -> b) -> Seq a -> Seq b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Content -> Content
go (Seq Content -> Seq Content)
-> (Seq Content -> Seq Content) -> Seq Content -> Seq Content
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Content -> Bool) -> Seq Content -> Seq Content
forall a. (a -> Bool) -> Seq a -> Seq a
Seq.dropWhileL Content -> Bool
isParbreak (Seq Content -> Seq Content)
-> (Seq Content -> Seq Content) -> Seq Content -> Seq Content
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Content -> Bool) -> Seq Content -> Seq Content
forall a. (a -> Bool) -> Seq a -> Seq a
Seq.dropWhileR Content -> Bool
isParbreak
where
go :: Content -> Content
go (Elt Identifier
"parbreak" Maybe SourcePos
pos Map Identifier Val
_) = Identifier -> Maybe SourcePos -> Map Identifier Val -> Content
Elt Identifier
"linebreak" Maybe SourcePos
pos Map Identifier Val
forall a. Monoid a => a
mempty
go Content
x = Content
x
isParbreak :: Content -> Bool
isParbreak (Elt Identifier
"parbreak" Maybe SourcePos
_ Map Identifier Val
_) = Bool
True
isParbreak Content
_ = Bool
False
pPara :: PandocMonad m => P m B.Blocks
pPara :: forall (m :: * -> *). PandocMonad m => P m Blocks
pPara = do
ils <- Inlines -> Inlines
B.trimInlines (Inlines -> Inlines)
-> ([Inlines] -> Inlines) -> [Inlines] -> Inlines
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Inlines -> Inlines
collapseAdjacentCites (Inlines -> Inlines)
-> ([Inlines] -> Inlines) -> [Inlines] -> Inlines
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Inlines] -> Inlines
forall a. Monoid a => [a] -> a
mconcat ([Inlines] -> Inlines)
-> ParsecT [Content] PState m [Inlines]
-> ParsecT [Content] PState m Inlines
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT [Content] PState m Inlines
-> ParsecT [Content] PState m [Inlines]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many1 ParsecT [Content] PState m Inlines
forall (m :: * -> *). PandocMonad m => P m Inlines
pInline
optional pParBreak
pure $ if ils == mempty
then mempty
else B.para ils
pParBreak :: PandocMonad m => P m ()
pParBreak :: forall (m :: * -> *). PandocMonad m => P m ()
pParBreak =
ParsecT [Content] PState m Content -> ParsecT [Content] PState m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (ParsecT [Content] PState m Content
-> ParsecT [Content] PState m ())
-> ParsecT [Content] PState m Content
-> ParsecT [Content] PState m ()
forall a b. (a -> b) -> a -> b
$
(Content -> Bool) -> ParsecT [Content] PState m Content
forall (m :: * -> *).
PandocMonad m =>
(Content -> Bool) -> P m Content
pTok
( \case
Elt Identifier
"parbreak" Maybe SourcePos
_ Map Identifier Val
_ -> Bool
True
Content
_ -> Bool
False
)
pWithContents :: PandocMonad m => P m a -> Seq Content -> P m a
pWithContents :: forall (m :: * -> *) a.
PandocMonad m =>
P m a -> Seq Content -> P m a
pWithContents P m a
pa Seq Content
cs = P m a -> P m a
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (P m a -> P m a) -> P m a -> P m a
forall a b. (a -> b) -> a -> b
$ do
inp <- ParsecT [Content] PState m [Content]
forall (m :: * -> *) s u. Monad m => ParsecT s u m s
getInput
setInput $ F.toList cs
res <- pa
eof
setInput inp
pure res
pInlines :: PandocMonad m => P m B.Inlines
pInlines :: forall (m :: * -> *). PandocMonad m => P m Inlines
pInlines =
Inlines -> Inlines -> Inlines
forall a. Monoid a => a -> a -> a
mappend (Inlines -> Inlines -> Inlines)
-> ParsecT [Content] PState m Inlines
-> ParsecT [Content] PState m (Inlines -> Inlines)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Inlines -> Inlines
collapseAdjacentCites (Inlines -> Inlines)
-> ([Inlines] -> Inlines) -> [Inlines] -> Inlines
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Inlines] -> Inlines
forall a. Monoid a => [a] -> a
mconcat ([Inlines] -> Inlines)
-> ParsecT [Content] PState m [Inlines]
-> ParsecT [Content] PState m Inlines
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT [Content] PState m Inlines
-> ParsecT [Content] PState m [Inlines]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many ParsecT [Content] PState m Inlines
forall (m :: * -> *). PandocMonad m => P m Inlines
pInline)
ParsecT [Content] PState m (Inlines -> Inlines)
-> ParsecT [Content] PState m Inlines
-> ParsecT [Content] PState m Inlines
forall a b.
ParsecT [Content] PState m (a -> b)
-> ParsecT [Content] PState m a -> ParsecT [Content] PState m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ((Inlines
B.softbreak Inlines
-> ParsecT [Content] PState m ()
-> ParsecT [Content] PState m Inlines
forall a b.
a -> ParsecT [Content] PState m b -> ParsecT [Content] PState m a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ParsecT [Content] PState m ()
forall (m :: * -> *). PandocMonad m => P m ()
pParBreak) ParsecT [Content] PState m Inlines
-> ParsecT [Content] PState m Inlines
-> ParsecT [Content] PState m Inlines
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Inlines -> ParsecT [Content] PState m Inlines
forall a. a -> ParsecT [Content] PState m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Inlines
forall a. Monoid a => a
mempty)
collapseAdjacentCites :: B.Inlines -> B.Inlines
collapseAdjacentCites :: Inlines -> Inlines
collapseAdjacentCites = [Inline] -> Inlines
forall a. [a] -> Many a
B.fromList ([Inline] -> Inlines)
-> (Inlines -> [Inline]) -> Inlines -> Inlines
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Inline -> [Inline] -> [Inline])
-> [Inline] -> [Inline] -> [Inline]
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr Inline -> [Inline] -> [Inline]
go [] ([Inline] -> [Inline])
-> (Inlines -> [Inline]) -> Inlines -> [Inline]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Inlines -> [Inline]
forall a. Many a -> [a]
B.toList
where
go :: Inline -> [Inline] -> [Inline]
go (Cite [Citation]
cs1 [Inline]
ils1) (Cite [Citation]
cs2 [Inline]
ils2 : [Inline]
xs) =
[Citation] -> [Inline] -> Inline
Cite ([Citation]
cs1 [Citation] -> [Citation] -> [Citation]
forall a. [a] -> [a] -> [a]
++ [Citation]
cs2) ([Inline]
ils1 [Inline] -> [Inline] -> [Inline]
forall a. Semigroup a => a -> a -> a
<> [Inline]
ils2) Inline -> [Inline] -> [Inline]
forall a. a -> [a] -> [a]
: [Inline]
xs
go (Cite [Citation]
cs1 [Inline]
ils1) (Inline
Space : Cite [Citation]
cs2 [Inline]
ils2 : [Inline]
xs) =
[Citation] -> [Inline] -> Inline
Cite ([Citation]
cs1 [Citation] -> [Citation] -> [Citation]
forall a. [a] -> [a] -> [a]
++ [Citation]
cs2) ([Inline]
ils1 [Inline] -> [Inline] -> [Inline]
forall a. Semigroup a => a -> a -> a
<> [Inline]
ils2) Inline -> [Inline] -> [Inline]
forall a. a -> [a] -> [a]
: [Inline]
xs
go Inline
x [Inline]
xs = Inline
xInline -> [Inline] -> [Inline]
forall a. a -> [a] -> [a]
:[Inline]
xs
modString :: (Text -> Text) -> B.Inline -> B.Inline
modString :: (Text -> Text) -> Inline -> Inline
modString Text -> Text
f (B.Str Text
t) = Text -> Inline
B.Str (Text -> Text
f Text
t)
modString Text -> Text
_ Inline
x = Inline
x
findLabels :: Seq.Seq Content -> [Text]
findLabels :: Seq Content -> [Text]
findLabels = (Content -> [Text] -> [Text]) -> [Text] -> Seq Content -> [Text]
forall a b. (a -> b -> b) -> b -> Seq a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr Content -> [Text] -> [Text]
go []
where
go :: Content -> [Text] -> [Text]
go (Txt{}) = [Text] -> [Text]
forall a. a -> a
id
go (Lab Text
t) = (Text
t Text -> [Text] -> [Text]
forall a. a -> [a] -> [a]
:)
go (Elt{ eltFields :: Content -> Map Identifier Val
eltFields = Map Identifier Val
fs }) = \[Text]
ts -> (Val -> [Text] -> [Text]) -> [Text] -> Map Identifier Val -> [Text]
forall a b. (a -> b -> b) -> b -> Map Identifier a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr Val -> [Text] -> [Text]
go' [Text]
ts Map Identifier Val
fs
go' :: Val -> [Text] -> [Text]
go' (VContent Seq Content
cs) = (Seq Content -> [Text]
findLabels Seq Content
cs [Text] -> [Text] -> [Text]
forall a. [a] -> [a] -> [a]
++)
go' Val
_ = [Text] -> [Text]
forall a. a -> a
id
parseTable :: PandocMonad m
=> Maybe Text -> M.Map Identifier Val -> P m B.Blocks
parseTable :: forall (m :: * -> *).
PandocMonad m =>
Maybe Text -> Map Identifier Val -> P m Blocks
parseTable Maybe Text
mbident Map Identifier Val
fields = do
children <- Vector (Seq Content) -> [Seq Content]
forall a. Vector a -> [a]
V.toList (Vector (Seq Content) -> [Seq Content])
-> ParsecT [Content] PState m (Vector (Seq Content))
-> ParsecT [Content] PState m [Seq Content]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Identifier
-> Map Identifier Val
-> ParsecT [Content] PState m (Vector (Seq Content))
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"children" Map Identifier Val
fields
(columns :: Val) <- getField "columns" fields
let toWidth (VFraction Double
f) = a -> Maybe a
forall a. a -> Maybe a
Just (Double -> a
forall b. Integral b => Double -> b
forall a b. (RealFrac a, Integral b) => a -> b
floor (Double -> a) -> Double -> a
forall a b. (a -> b) -> a -> b
$ Double
1000 Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
f)
toWidth Val
_ = Maybe a
forall a. Maybe a
Nothing
let normalizeWidths [Maybe Int]
xs =
let givenwidths :: [Int]
givenwidths = [Maybe Int] -> [Int]
forall a. [Maybe a] -> [a]
catMaybes [Maybe Int]
xs
(Int
totgivenwidth :: Int) = [Int] -> Int
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum [Int]
givenwidths
avgwidth :: Int
avgwidth = Int
totgivenwidth Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` [Int] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Int]
givenwidths
totwidth :: Int
totwidth = Int
avgwidth Int -> Int -> Int
forall a. Num a => a -> a -> a
* [Maybe Int] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Maybe Int]
xs
in if [Int] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Int]
givenwidths
then Int -> ColWidth -> [ColWidth]
forall a. Int -> a -> [a]
replicate ([Maybe Int] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Maybe Int]
xs) ColWidth
B.ColWidthDefault
else
(Maybe Int -> ColWidth) -> [Maybe Int] -> [ColWidth]
forall a b. (a -> b) -> [a] -> [b]
map
( \case
Just Int
x ->
Double -> ColWidth
B.ColWidth (Int -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
x Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Int -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
totwidth)
Maybe Int
Nothing ->
Double -> ColWidth
B.ColWidth
(Int -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
avgwidth Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Int -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
totwidth)
)
[Maybe Int]
xs
widths <- case columns of
VInteger Integer
x -> [ColWidth] -> ParsecT [Content] PState m [ColWidth]
forall a. a -> ParsecT [Content] PState m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([ColWidth] -> ParsecT [Content] PState m [ColWidth])
-> [ColWidth] -> ParsecT [Content] PState m [ColWidth]
forall a b. (a -> b) -> a -> b
$ Int -> ColWidth -> [ColWidth]
forall a. Int -> a -> [a]
replicate (Integer -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
x) ColWidth
B.ColWidthDefault
VArray Vector Val
x -> [ColWidth] -> ParsecT [Content] PState m [ColWidth]
forall a. a -> ParsecT [Content] PState m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([ColWidth] -> ParsecT [Content] PState m [ColWidth])
-> [ColWidth] -> ParsecT [Content] PState m [ColWidth]
forall a b. (a -> b) -> a -> b
$ [Maybe Int] -> [ColWidth]
normalizeWidths ([Maybe Int] -> [ColWidth]) -> [Maybe Int] -> [ColWidth]
forall a b. (a -> b) -> a -> b
$ (Val -> Maybe Int) -> [Val] -> [Maybe Int]
forall a b. (a -> b) -> [a] -> [b]
map Val -> Maybe Int
forall {a}. Integral a => Val -> Maybe a
toWidth (Vector Val -> [Val]
forall a. Vector a -> [a]
V.toList Vector Val
x)
Val
VNone -> [ColWidth] -> ParsecT [Content] PState m [ColWidth]
forall a. a -> ParsecT [Content] PState m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Item [ColWidth]
ColWidth
B.ColWidthDefault]
Val
_ -> SourceName -> ParsecT [Content] PState m [ColWidth]
forall a. SourceName -> ParsecT [Content] PState m a
forall (m :: * -> *) a. MonadFail m => SourceName -> m a
fail (SourceName -> ParsecT [Content] PState m [ColWidth])
-> SourceName -> ParsecT [Content] PState m [ColWidth]
forall a b. (a -> b) -> a -> b
$ SourceName
"Could not determine number of columns: " SourceName -> SourceName -> SourceName
forall a. Semigroup a => a -> a -> a
<> Val -> SourceName
forall a. Show a => a -> SourceName
show Val
columns
let numcols = [ColWidth] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [ColWidth]
widths
align <- getField "align" fields
let toAlign (VAlignment (Just Horiz
horiz) Maybe Vert
_) =
case Horiz
horiz of
Horiz
HorizStart -> Alignment
B.AlignLeft
Horiz
HorizLeft -> Alignment
B.AlignLeft
Horiz
HorizEnd -> Alignment
B.AlignRight
Horiz
HorizRight -> Alignment
B.AlignRight
Horiz
HorizCenter -> Alignment
B.AlignCenter
toAlign Val
_ = Alignment
B.AlignDefault
aligns <-
case align of
VAlignment {} -> [Alignment] -> ParsecT [Content] PState m [Alignment]
forall a. a -> ParsecT [Content] PState m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([Alignment] -> ParsecT [Content] PState m [Alignment])
-> [Alignment] -> ParsecT [Content] PState m [Alignment]
forall a b. (a -> b) -> a -> b
$ Int -> Alignment -> [Alignment]
forall a. Int -> a -> [a]
replicate Int
numcols (Val -> Alignment
toAlign Val
align)
VArray Vector Val
v -> [Alignment] -> ParsecT [Content] PState m [Alignment]
forall a. a -> ParsecT [Content] PState m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([Alignment] -> ParsecT [Content] PState m [Alignment])
-> [Alignment] -> ParsecT [Content] PState m [Alignment]
forall a b. (a -> b) -> a -> b
$ (Val -> Alignment) -> [Val] -> [Alignment]
forall a b. (a -> b) -> [a] -> [b]
map Val -> Alignment
toAlign (Vector Val -> [Val]
forall a. Vector a -> [a]
V.toList Vector Val
v)
VFunction Maybe Identifier
_ Map Identifier Val
_ Function
f -> do
(Integer -> ParsecT [Content] PState m Alignment)
-> [Integer] -> ParsecT [Content] PState m [Alignment]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM
( \Integer
colnum -> case Function -> [Val] -> Attempt Val
applyPureFunction
Function
f
[Integer -> Val
VInteger Integer
colnum, Integer -> Val
VInteger Integer
0] of
Success Val
x -> Alignment -> ParsecT [Content] PState m Alignment
forall a. a -> ParsecT [Content] PState m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Alignment -> ParsecT [Content] PState m Alignment)
-> Alignment -> ParsecT [Content] PState m Alignment
forall a b. (a -> b) -> a -> b
$ Val -> Alignment
toAlign Val
x
Failure SourceName
e -> SourceName -> ParsecT [Content] PState m Alignment
forall a. SourceName -> ParsecT [Content] PState m a
forall (m :: * -> *) a. MonadFail m => SourceName -> m a
fail SourceName
e
)
[Integer
Item [Integer]
0 .. (Int -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
numcols Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
- Integer
1)]
Val
_ -> [Alignment] -> ParsecT [Content] PState m [Alignment]
forall a. a -> ParsecT [Content] PState m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([Alignment] -> ParsecT [Content] PState m [Alignment])
-> [Alignment] -> ParsecT [Content] PState m [Alignment]
forall a b. (a -> b) -> a -> b
$ Int -> Alignment -> [Alignment]
forall a. Int -> a -> [a]
replicate Int
numcols Alignment
B.AlignDefault
let colspecs = [Alignment] -> [ColWidth] -> [ColSpec]
forall a b. [a] -> [b] -> [(a, b)]
zip ([Alignment]
aligns [Alignment] -> [Alignment] -> [Alignment]
forall a. [a] -> [a] -> [a]
++ Alignment -> [Alignment]
forall a. a -> [a]
repeat Alignment
B.AlignDefault) [ColWidth]
widths
let addCell' Cell
cell Maybe ([Int], [[Cell]])
Nothing = Cell -> Maybe ([Int], [[Cell]]) -> Maybe ([Int], [[Cell]])
addCell' Cell
cell (([Int], [[Cell]]) -> Maybe ([Int], [[Cell]])
forall a. a -> Maybe a
Just ([], []))
addCell' cell :: Cell
cell@(B.Cell Attr
_ Alignment
_ (B.RowSpan Int
rowspan) (B.ColSpan Int
colspan) [Block]
_)
(Just ([Int]
freecols, [[Cell]]
revrows)) =
let freecols' :: [Int]
freecols' =
case (Int
rowspan Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) Int -> Int -> Int
forall a. Num a => a -> a -> a
- [Int] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Int]
freecols of
Int
n | Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
0 -> [Int]
freecols
| Bool
otherwise -> [Int]
freecols [Int] -> [Int] -> [Int]
forall a. [a] -> [a] -> [a]
++ Int -> Int -> [Int]
forall a. Int -> a -> [a]
replicate Int
n Int
numcols
in case [Int]
freecols' of
[] ->
SourceName -> Maybe ([Int], [[Cell]])
forall a. HasCallStack => SourceName -> a
error SourceName
"empty freecols'"
Int
x:[Int]
xs
| Int
colspan Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
x
-> let ([Int]
as, [Int]
bs) = Int -> [Int] -> ([Int], [Int])
forall a. Int -> [a] -> ([a], [a])
splitAt Int
rowspan (Int
xInt -> [Int] -> [Int]
forall a. a -> [a] -> [a]
:[Int]
xs)
in ([Int], [[Cell]]) -> Maybe ([Int], [[Cell]])
forall a. a -> Maybe a
Just
((Int -> Int) -> [Int] -> [Int]
forall a b. (a -> b) -> [a] -> [b]
map (\Int
z -> Int
z Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
colspan) [Int]
as [Int] -> [Int] -> [Int]
forall a. [a] -> [a] -> [a]
++ [Int]
bs,
case [[Cell]]
revrows of
[] -> [[Item [Cell]
Cell
cell]]
[Cell]
r:[[Cell]]
rs -> (Cell
cellCell -> [Cell] -> [Cell]
forall a. a -> [a] -> [a]
:[Cell]
r)[Cell] -> [[Cell]] -> [[Cell]]
forall a. a -> [a] -> [a]
:[[Cell]]
rs)
| Bool
otherwise ->
let ([Int]
as, [Int]
bs) = Int -> [Int] -> ([Int], [Int])
forall a. Int -> [a] -> ([a], [a])
splitAt Int
rowspan [Int]
xs
in ([Int], [[Cell]]) -> Maybe ([Int], [[Cell]])
forall a. a -> Maybe a
Just ((Int -> Int) -> [Int] -> [Int]
forall a b. (a -> b) -> [a] -> [b]
map (\Int
z -> Int
z Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
colspan) [Int]
as [Int] -> [Int] -> [Int]
forall a. [a] -> [a] -> [a]
++ [Int]
bs, [Item [Cell]
Cell
cell][Cell] -> [[Cell]] -> [[Cell]]
forall a. a -> [a] -> [a]
:[[Cell]]
revrows)
let addCell TableSection
tableSection Cell
cell (TableData Map TableSection ([Int], [[Cell]])
tdata) =
Map TableSection ([Int], [[Cell]]) -> TableData
TableData ((Maybe ([Int], [[Cell]]) -> Maybe ([Int], [[Cell]]))
-> TableSection
-> Map TableSection ([Int], [[Cell]])
-> Map TableSection ([Int], [[Cell]])
forall k a.
Ord k =>
(Maybe a -> Maybe a) -> k -> Map k a -> Map k a
M.alter (Cell -> Maybe ([Int], [[Cell]]) -> Maybe ([Int], [[Cell]])
addCell' Cell
cell) TableSection
tableSection Map TableSection ([Int], [[Cell]])
tdata)
let toCell TableSection
tableSection TableData
tableData Seq Content
contents = do
case Seq Content
contents of
[Elt (Identifier Text
"grid.cell") Maybe SourcePos
_pos Map Identifier Val
fs] -> do
bs <- Blocks -> [Block]
forall a. Many a -> [a]
B.toList (Blocks -> [Block])
-> ParsecT [Content] PState m Blocks
-> ParsecT [Content] PState m [Block]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Identifier
-> Map Identifier Val -> ParsecT [Content] PState m (Seq Content)
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fs ParsecT [Content] PState m (Seq Content)
-> (Seq Content -> ParsecT [Content] PState m Blocks)
-> ParsecT [Content] PState m Blocks
forall a b.
ParsecT [Content] PState m a
-> (a -> ParsecT [Content] PState m b)
-> ParsecT [Content] PState m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ParsecT [Content] PState m Blocks
-> Seq Content -> ParsecT [Content] PState m Blocks
forall (m :: * -> *) a.
PandocMonad m =>
P m a -> Seq Content -> P m a
pWithContents ParsecT [Content] PState m Blocks
forall (m :: * -> *). PandocMonad m => P m Blocks
pBlocks)
rowspan <- getField "rowspan" fs <|> pure 1
colspan <- getField "colspan" fs <|> pure 1
align' <- (toAlign <$> getField "align" fs) <|> pure B.AlignDefault
pure $ addCell tableSection
(B.Cell B.nullAttr align' (B.RowSpan rowspan)
(B.ColSpan colspan) bs) tableData
[Elt (Identifier Text
"table.cell") Maybe SourcePos
pos Map Identifier Val
fs] ->
TableSection
-> TableData -> Seq Content -> ParsecT [Content] PState m TableData
toCell TableSection
tableSection TableData
tableData [Identifier -> Maybe SourcePos -> Map Identifier Val -> Content
Elt (Text -> Identifier
Identifier Text
"grid.cell") Maybe SourcePos
pos Map Identifier Val
fs]
[Elt (Identifier Text
"table.vline") Maybe SourcePos
_pos Map Identifier Val
_fs] -> TableData -> ParsecT [Content] PState m TableData
forall a. a -> ParsecT [Content] PState m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TableData
tableData
[Elt (Identifier Text
"table.hline") Maybe SourcePos
_pos Map Identifier Val
_fs] -> TableData -> ParsecT [Content] PState m TableData
forall a. a -> ParsecT [Content] PState m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TableData
tableData
[Elt (Identifier Text
"grid.vline") Maybe SourcePos
_pos Map Identifier Val
_fs] -> TableData -> ParsecT [Content] PState m TableData
forall a. a -> ParsecT [Content] PState m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TableData
tableData
[Elt (Identifier Text
"grid.hline") Maybe SourcePos
_pos Map Identifier Val
_fs] -> TableData -> ParsecT [Content] PState m TableData
forall a. a -> ParsecT [Content] PState m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TableData
tableData
[Elt (Identifier Text
"table.header") Maybe SourcePos
_pos Map Identifier Val
fs] ->
Identifier
-> Map Identifier Val
-> ParsecT [Content] PState m (Vector (Seq Content))
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"children" Map Identifier Val
fs ParsecT [Content] PState m (Vector (Seq Content))
-> (Vector (Seq Content) -> ParsecT [Content] PState m TableData)
-> ParsecT [Content] PState m TableData
forall a b.
ParsecT [Content] PState m a
-> (a -> ParsecT [Content] PState m b)
-> ParsecT [Content] PState m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>=
(TableData -> Seq Content -> ParsecT [Content] PState m TableData)
-> TableData
-> [Seq Content]
-> ParsecT [Content] PState m TableData
forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldM (TableSection
-> TableData -> Seq Content -> ParsecT [Content] PState m TableData
toCell TableSection
THeader) TableData
tableData ([Seq Content] -> ParsecT [Content] PState m TableData)
-> (Vector (Seq Content) -> [Seq Content])
-> Vector (Seq Content)
-> ParsecT [Content] PState m TableData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vector (Seq Content) -> [Seq Content]
forall a. Vector a -> [a]
V.toList
[Elt (Identifier Text
"table.footer") Maybe SourcePos
_pos Map Identifier Val
fs] ->
Identifier
-> Map Identifier Val
-> ParsecT [Content] PState m (Vector (Seq Content))
forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"children" Map Identifier Val
fs ParsecT [Content] PState m (Vector (Seq Content))
-> (Vector (Seq Content) -> ParsecT [Content] PState m TableData)
-> ParsecT [Content] PState m TableData
forall a b.
ParsecT [Content] PState m a
-> (a -> ParsecT [Content] PState m b)
-> ParsecT [Content] PState m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>=
(TableData -> Seq Content -> ParsecT [Content] PState m TableData)
-> TableData
-> [Seq Content]
-> ParsecT [Content] PState m TableData
forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldM (TableSection
-> TableData -> Seq Content -> ParsecT [Content] PState m TableData
toCell TableSection
TFooter) TableData
tableData ([Seq Content] -> ParsecT [Content] PState m TableData)
-> (Vector (Seq Content) -> [Seq Content])
-> Vector (Seq Content)
-> ParsecT [Content] PState m TableData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vector (Seq Content) -> [Seq Content]
forall a. Vector a -> [a]
V.toList
Seq Content
_ -> do
bs <- Blocks -> [Block]
forall a. Many a -> [a]
B.toList (Blocks -> [Block])
-> ParsecT [Content] PState m Blocks
-> ParsecT [Content] PState m [Block]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT [Content] PState m Blocks
-> Seq Content -> ParsecT [Content] PState m Blocks
forall (m :: * -> *) a.
PandocMonad m =>
P m a -> Seq Content -> P m a
pWithContents ParsecT [Content] PState m Blocks
forall (m :: * -> *). PandocMonad m => P m Blocks
pBlocks Seq Content
contents
pure $ addCell tableSection
(B.Cell B.nullAttr B.AlignDefault (B.RowSpan 1) (B.ColSpan 1) bs)
tableData
tableData <- foldM (toCell TBody) (TableData mempty) children
let getRows TableSection
tablePart = ([Cell] -> Row) -> [[Cell]] -> [Row]
forall a b. (a -> b) -> [a] -> [b]
map (Attr -> [Cell] -> Row
B.Row Attr
B.nullAttr ([Cell] -> Row) -> ([Cell] -> [Cell]) -> [Cell] -> Row
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Cell] -> [Cell]
forall a. [a] -> [a]
reverse)
([[Cell]] -> [Row])
-> (TableData -> [[Cell]]) -> TableData -> [Row]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [[Cell]]
-> (([Int], [[Cell]]) -> [[Cell]])
-> Maybe ([Int], [[Cell]])
-> [[Cell]]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] ([[Cell]] -> [[Cell]]
forall a. [a] -> [a]
reverse ([[Cell]] -> [[Cell]])
-> (([Int], [[Cell]]) -> [[Cell]]) -> ([Int], [[Cell]]) -> [[Cell]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Int], [[Cell]]) -> [[Cell]]
forall a b. (a, b) -> b
snd)
(Maybe ([Int], [[Cell]]) -> [[Cell]])
-> (TableData -> Maybe ([Int], [[Cell]])) -> TableData -> [[Cell]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TableSection
-> Map TableSection ([Int], [[Cell]]) -> Maybe ([Int], [[Cell]])
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup TableSection
tablePart (Map TableSection ([Int], [[Cell]]) -> Maybe ([Int], [[Cell]]))
-> (TableData -> Map TableSection ([Int], [[Cell]]))
-> TableData
-> Maybe ([Int], [[Cell]])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TableData -> Map TableSection ([Int], [[Cell]])
unTableData
let headRows = TableSection -> TableData -> [Row]
getRows TableSection
THeader TableData
tableData
let bodyRows = TableSection -> TableData -> [Row]
getRows TableSection
TBody TableData
tableData
let footRows = TableSection -> TableData -> [Row]
getRows TableSection
TFooter TableData
tableData
pure $
B.tableWith
(fromMaybe "" mbident, [], [])
(B.Caption mempty mempty)
colspecs
(B.TableHead B.nullAttr headRows)
[B.TableBody B.nullAttr 0 [] bodyRows]
(B.TableFoot B.nullAttr footRows)
data TableSection = | TBody |
deriving (Int -> TableSection -> SourceName -> SourceName
[TableSection] -> SourceName -> SourceName
TableSection -> SourceName
(Int -> TableSection -> SourceName -> SourceName)
-> (TableSection -> SourceName)
-> ([TableSection] -> SourceName -> SourceName)
-> Show TableSection
forall a.
(Int -> a -> SourceName -> SourceName)
-> (a -> SourceName) -> ([a] -> SourceName -> SourceName) -> Show a
$cshowsPrec :: Int -> TableSection -> SourceName -> SourceName
showsPrec :: Int -> TableSection -> SourceName -> SourceName
$cshow :: TableSection -> SourceName
show :: TableSection -> SourceName
$cshowList :: [TableSection] -> SourceName -> SourceName
showList :: [TableSection] -> SourceName -> SourceName
Show, Eq TableSection
Eq TableSection =>
(TableSection -> TableSection -> Ordering)
-> (TableSection -> TableSection -> Bool)
-> (TableSection -> TableSection -> Bool)
-> (TableSection -> TableSection -> Bool)
-> (TableSection -> TableSection -> Bool)
-> (TableSection -> TableSection -> TableSection)
-> (TableSection -> TableSection -> TableSection)
-> Ord TableSection
TableSection -> TableSection -> Bool
TableSection -> TableSection -> Ordering
TableSection -> TableSection -> TableSection
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: TableSection -> TableSection -> Ordering
compare :: TableSection -> TableSection -> Ordering
$c< :: TableSection -> TableSection -> Bool
< :: TableSection -> TableSection -> Bool
$c<= :: TableSection -> TableSection -> Bool
<= :: TableSection -> TableSection -> Bool
$c> :: TableSection -> TableSection -> Bool
> :: TableSection -> TableSection -> Bool
$c>= :: TableSection -> TableSection -> Bool
>= :: TableSection -> TableSection -> Bool
$cmax :: TableSection -> TableSection -> TableSection
max :: TableSection -> TableSection -> TableSection
$cmin :: TableSection -> TableSection -> TableSection
min :: TableSection -> TableSection -> TableSection
Ord, TableSection -> TableSection -> Bool
(TableSection -> TableSection -> Bool)
-> (TableSection -> TableSection -> Bool) -> Eq TableSection
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TableSection -> TableSection -> Bool
== :: TableSection -> TableSection -> Bool
$c/= :: TableSection -> TableSection -> Bool
/= :: TableSection -> TableSection -> Bool
Eq)
newtype TableData =
TableData { TableData -> Map TableSection ([Int], [[Cell]])
unTableData :: M.Map TableSection ([Int], [[Cell]]) }
deriving (Int -> TableData -> SourceName -> SourceName
[TableData] -> SourceName -> SourceName
TableData -> SourceName
(Int -> TableData -> SourceName -> SourceName)
-> (TableData -> SourceName)
-> ([TableData] -> SourceName -> SourceName)
-> Show TableData
forall a.
(Int -> a -> SourceName -> SourceName)
-> (a -> SourceName) -> ([a] -> SourceName -> SourceName) -> Show a
$cshowsPrec :: Int -> TableData -> SourceName -> SourceName
showsPrec :: Int -> TableData -> SourceName -> SourceName
$cshow :: TableData -> SourceName
show :: TableData -> SourceName
$cshowList :: [TableData] -> SourceName -> SourceName
showList :: [TableData] -> SourceName -> SourceName
Show)