{-# LANGUAGE OverloadedLists #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE ScopedTypeVariables #-}

module Text.Pandoc.Readers.Typst.Math
  ( pMathMany
  )
where

import Control.Monad (MonadPlus (mplus))
import Data.Char (isAlphaNum, isDigit)
import Data.List (intercalate)
import qualified Data.Map as M
import Data.Maybe (fromMaybe)
import Data.Sequence (Seq)
import qualified Data.Sequence as Seq
import Data.Text (Text)
import qualified Data.Text as T
import qualified Data.Vector as V
import Text.Pandoc.Parsing ( many )
import Text.Pandoc.Class ( PandocMonad )
import Text.TeXMath.Types
  ( Alignment (..),
    Exp (..),
    FractionType (..),
    TeXSymbolType (..),
    TextType (..),
  )
import Text.TeXMath.Unicode.ToTeX (getSymbolType)
import Text.Pandoc.Readers.Typst.Parsing
    ( P, pTok, ignored, pWithContents, getField, chunks )
import Typst.Types

-- import Debug.Trace

withGroup :: [Exp] -> Exp
withGroup :: [Exp] -> Exp
withGroup [Item [Exp]
x] = Item [Exp]
x
withGroup [Exp]
xs = [Exp] -> Exp
EGrouped [Exp]
xs

data AttachmentStyle = Limits | LimitsDisplay | Scripts
  deriving (AttachmentStyle -> AttachmentStyle -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AttachmentStyle -> AttachmentStyle -> Bool
$c/= :: AttachmentStyle -> AttachmentStyle -> Bool
== :: AttachmentStyle -> AttachmentStyle -> Bool
$c== :: AttachmentStyle -> AttachmentStyle -> Bool
Eq, Int -> AttachmentStyle -> ShowS
[AttachmentStyle] -> ShowS
AttachmentStyle -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AttachmentStyle] -> ShowS
$cshowList :: [AttachmentStyle] -> ShowS
show :: AttachmentStyle -> String
$cshow :: AttachmentStyle -> String
showsPrec :: Int -> AttachmentStyle -> ShowS
$cshowsPrec :: Int -> AttachmentStyle -> ShowS
Show)

getAttachmentStyle :: PandocMonad m => M.Map Identifier Val -> P m (Maybe AttachmentStyle)
getAttachmentStyle :: forall (m :: * -> *).
PandocMonad m =>
Map Identifier Val -> P m (Maybe AttachmentStyle)
getAttachmentStyle Map Identifier Val
fields = do
  (Seq Content
base :: Seq Content) <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"base" Map Identifier Val
fields
  case Seq Content
base of
    [Elt Identifier
"math.op" Maybe SourcePos
_ Map Identifier Val
fs] -> do
      Val
limits <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"limits" Map Identifier Val
fs
      if Val
limits forall a. Eq a => a -> a -> Bool
== Bool -> Val
VBoolean Bool
True
         then forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just AttachmentStyle
Limits
         else forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a. Maybe a
Nothing
    [Elt Identifier
"math.limits" Maybe SourcePos
_ Map Identifier Val
fs] -> do
      Val
inl <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"inline" Map Identifier Val
fs
      if Val
inl forall a. Eq a => a -> a -> Bool
== Bool -> Val
VBoolean Bool
False
         then forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just AttachmentStyle
LimitsDisplay
         else forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just AttachmentStyle
Limits
    [Elt Identifier
"math.scripts" Maybe SourcePos
_ Map Identifier Val
_] -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just AttachmentStyle
Scripts
    Seq Content
_ -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a. Maybe a
Nothing

pMath :: PandocMonad m => P m Exp
pMath :: forall (m :: * -> *). PandocMonad m => P m Exp
pMath = forall (m :: * -> *).
PandocMonad m =>
(Content -> Bool) -> P m Content
pTok (forall a b. a -> b -> a
const Bool
True) forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). PandocMonad m => Content -> P m Exp
handleMath

handleMath :: PandocMonad m => Content -> P m Exp
handleMath :: forall (m :: * -> *). PandocMonad m => Content -> P m Exp
handleMath Content
tok =
  case Content
tok of
    Lab Text
t -> do
      forall (m :: * -> *). PandocMonad m => Text -> P m ()
ignored (Text
"label " forall a. Semigroup a => a -> a -> a
<> Text
t)
      forall (f :: * -> *) a. Applicative f => a -> f a
pure ([Exp] -> Exp
EGrouped [])
    Txt Text
t
      | (Char -> Bool) -> Text -> Bool
T.any Char -> Bool
isDigit Text
t -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Text -> Exp
ENumber Text
t
      | Text -> Int
T.length Text
t forall a. Eq a => a -> a -> Bool
== Int
1 ->
          case Text -> String
T.unpack Text
t of
            [Item String
c] | Bool -> Bool
not (Char -> Bool
isAlphaNum Item String
c) -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ TeXSymbolType -> Text -> Exp
ESymbol (Char -> TeXSymbolType
getSymbolType Item String
c) Text
t
            String
_ -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Text -> Exp
EIdentifier Text
t
      | Bool
otherwise -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ TextType -> Text -> Exp
EText TextType
TextNormal Text
t
    Elt Identifier
"math.dif" Maybe SourcePos
_ Map Identifier Val
_ -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Text -> Exp
EIdentifier Text
"d"
    Elt Identifier
"math.Dif" Maybe SourcePos
_ Map Identifier Val
_ -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Text -> Exp
EIdentifier Text
"D"
    Elt Identifier
"math.equation" Maybe SourcePos
_ Map Identifier Val
fields -> forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped
    Elt Identifier
"text" Maybe SourcePos
_ Map Identifier Val
fields -> do
      Seq Content
body <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields
      (Maybe Text
mbweight :: Maybe Text) <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"weight" Map Identifier Val
fields
      case Maybe Text
mbweight of
        Just Text
"bold" -> TextType -> [Exp] -> Exp
EStyled TextType
TextBold forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). PandocMonad m => Seq Content -> P m [Exp]
pMathMany Seq Content
body
        Maybe Text
_ -> forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped Seq Content
body
    Elt Identifier
"math.op" Maybe SourcePos
_ Map Identifier Val
fields -> Text -> Exp
EMathOperator forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"text" Map Identifier Val
fields
    Elt Identifier
"math.frac" Maybe SourcePos
_ Map Identifier Val
fields -> do
      Exp
num <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"num" Map Identifier Val
fields forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped
      Exp
denom <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"denom" Map Identifier Val
fields forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped
      forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ FractionType -> Exp -> Exp -> Exp
EFraction FractionType
NormalFrac Exp
num Exp
denom
    Elt Identifier
"math.accent" Maybe SourcePos
_ Map Identifier Val
fields -> do
      Exp
base <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"base" Map Identifier Val
fields forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped
      Exp
acc <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"accent" Map Identifier Val
fields forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped
      let acc' :: Exp
acc' = case Exp
acc of
            ESymbol TeXSymbolType
_ Text
t -> TeXSymbolType -> Text -> Exp
ESymbol TeXSymbolType
Accent Text
t
            Exp
_ -> Exp
acc
      forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Bool -> Exp -> Exp -> Exp
EOver Bool
False Exp
base Exp
acc'
    Elt Identifier
"math.attach" Maybe SourcePos
_ Map Identifier Val
fields -> do
      Exp
base <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"base" Map Identifier Val
fields forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped
      Maybe (Seq Content)
t' <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"t" Map Identifier Val
fields
      Maybe (Seq Content)
b' <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"b" Map Identifier Val
fields
      Maybe (Seq Content)
tr' <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"tr" Map Identifier Val
fields
      Maybe (Seq Content)
tl' <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"tl" Map Identifier Val
fields
      Maybe (Seq Content)
br' <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"br" Map Identifier Val
fields
      Maybe (Seq Content)
bl' <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"bl" Map Identifier Val
fields
      Maybe AttachmentStyle
attachmentStyle <- forall (m :: * -> *).
PandocMonad m =>
Map Identifier Val -> P m (Maybe AttachmentStyle)
getAttachmentStyle Map Identifier Val
fields
      let limits :: Bool
limits = case Maybe AttachmentStyle
attachmentStyle of
                     Just AttachmentStyle
Limits -> Bool
True
                     Just AttachmentStyle
LimitsDisplay -> Bool
True
                     Maybe AttachmentStyle
_ -> Bool
False
      let convertible :: Bool
convertible = Maybe AttachmentStyle
attachmentStyle forall a. Eq a => a -> a -> Bool
== forall a. a -> Maybe a
Just AttachmentStyle
LimitsDisplay
      let (Maybe (Seq Content)
mbt, Maybe (Seq Content)
mbtr) =
            case (Maybe (Seq Content)
t', Maybe (Seq Content)
tr') of
              (Just Seq Content
top, Just Seq Content
topright) -> (forall a. a -> Maybe a
Just Seq Content
top, forall a. a -> Maybe a
Just Seq Content
topright)
              (Just Seq Content
top, Maybe (Seq Content)
Nothing)
                | Bool
limits -> (forall a. a -> Maybe a
Just Seq Content
top, forall a. Maybe a
Nothing)
                | Bool
otherwise -> (forall a. Maybe a
Nothing, forall a. a -> Maybe a
Just Seq Content
top)
              (Maybe (Seq Content)
Nothing, Just Seq Content
topright) -> (forall a. Maybe a
Nothing, forall a. a -> Maybe a
Just Seq Content
topright)
              (Maybe (Seq Content)
Nothing, Maybe (Seq Content)
Nothing) -> (forall a. Maybe a
Nothing, forall a. Maybe a
Nothing)
      let (Maybe (Seq Content)
mbb, Maybe (Seq Content)
mbbr) =
            case (Maybe (Seq Content)
b', Maybe (Seq Content)
br') of
              (Just Seq Content
bot, Just Seq Content
botright) -> (forall a. a -> Maybe a
Just Seq Content
bot, forall a. a -> Maybe a
Just Seq Content
botright)
              (Just Seq Content
bot, Maybe (Seq Content)
Nothing)
                | Bool
limits -> (forall a. a -> Maybe a
Just Seq Content
bot, forall a. Maybe a
Nothing)
                | Bool
otherwise -> (forall a. Maybe a
Nothing, forall a. a -> Maybe a
Just Seq Content
bot)
              (Maybe (Seq Content)
Nothing, Just Seq Content
topright) -> (forall a. Maybe a
Nothing, forall a. a -> Maybe a
Just Seq Content
topright)
              (Maybe (Seq Content)
Nothing, Maybe (Seq Content)
Nothing) -> (forall a. Maybe a
Nothing, forall a. Maybe a
Nothing)
      let dummy :: Exp
dummy = [Exp] -> Exp
EGrouped []
      let addPrefix :: Exp -> ParsecT [Content] () m Exp
addPrefix Exp
x =
            case (Maybe (Seq Content)
tl', Maybe (Seq Content)
bl') of
              (Maybe (Seq Content)
Nothing, Maybe (Seq Content)
Nothing) -> forall (f :: * -> *) a. Applicative f => a -> f a
pure Exp
x
              (Just Seq Content
top, Maybe (Seq Content)
Nothing) -> do
                Exp
res <- Exp -> Exp -> Exp
ESuper Exp
dummy forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped Seq Content
top
                forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ [Exp] -> Exp
EGrouped [Exp
res, Exp
x]
              (Maybe (Seq Content)
Nothing, Just Seq Content
bot) -> do
                Exp
res <- Exp -> Exp -> Exp
ESub Exp
dummy forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped Seq Content
bot
                forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ [Exp] -> Exp
EGrouped [Exp
res, Exp
x]
              (Just Seq Content
top, Just Seq Content
bot) -> do
                Exp
res <- Exp -> Exp -> Exp -> Exp
ESubsup Exp
dummy forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped Seq Content
bot forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped Seq Content
top
                forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ [Exp] -> Exp
EGrouped [Exp
res, Exp
x]

      Exp
base' <- case (Maybe (Seq Content)
mbtr, Maybe (Seq Content)
mbbr) of
        (Maybe (Seq Content)
Nothing, Maybe (Seq Content)
Nothing) -> forall (f :: * -> *) a. Applicative f => a -> f a
pure Exp
base
        (Maybe (Seq Content)
Nothing, Just Seq Content
br) -> Exp -> Exp -> Exp
ESub Exp
base forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped Seq Content
br
        (Just Seq Content
tr, Maybe (Seq Content)
Nothing) -> Exp -> Exp -> Exp
ESuper Exp
base forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped Seq Content
tr
        (Just Seq Content
tr, Just Seq Content
br) -> Exp -> Exp -> Exp -> Exp
ESubsup Exp
base forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped Seq Content
br forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped Seq Content
tr

      Exp
suffix <- case (Maybe (Seq Content)
mbt, Maybe (Seq Content)
mbb) of
        (Maybe (Seq Content)
Nothing, Maybe (Seq Content)
Nothing) -> forall (f :: * -> *) a. Applicative f => a -> f a
pure Exp
base'
        (Maybe (Seq Content)
Nothing, Just Seq Content
bot) -> Bool -> Exp -> Exp -> Exp
EUnder Bool
convertible Exp
base' forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped Seq Content
bot
        (Just Seq Content
top, Maybe (Seq Content)
Nothing) -> Bool -> Exp -> Exp -> Exp
EOver Bool
convertible Exp
base' forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped Seq Content
top
        (Just Seq Content
top, Just Seq Content
bot) -> Bool -> Exp -> Exp -> Exp -> Exp
EUnderover Bool
convertible Exp
base'
                                  forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped Seq Content
bot forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped Seq Content
top

      forall {m :: * -> *}.
PandocMonad m =>
Exp -> ParsecT [Content] () m Exp
addPrefix Exp
suffix
    Elt Identifier
"math.serif" Maybe SourcePos
_ Map Identifier Val
fields ->
      TextType -> [Exp] -> Exp
EStyled TextType
TextNormal forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). PandocMonad m => Seq Content -> P m [Exp]
pMathMany)
    Elt Identifier
"math.sans" Maybe SourcePos
_ Map Identifier Val
fields ->
      TextType -> [Exp] -> Exp
EStyled TextType
TextSansSerif forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). PandocMonad m => Seq Content -> P m [Exp]
pMathMany)
    Elt Identifier
"math.frak" Maybe SourcePos
_ Map Identifier Val
fields ->
      TextType -> [Exp] -> Exp
EStyled TextType
TextFraktur forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). PandocMonad m => Seq Content -> P m [Exp]
pMathMany)
    Elt Identifier
"math.mono" Maybe SourcePos
_ Map Identifier Val
fields ->
      TextType -> [Exp] -> Exp
EStyled TextType
TextMonospace forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). PandocMonad m => Seq Content -> P m [Exp]
pMathMany)
    Elt Identifier
"math.cal" Maybe SourcePos
_ Map Identifier Val
fields ->
      TextType -> [Exp] -> Exp
EStyled TextType
TextScript forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). PandocMonad m => Seq Content -> P m [Exp]
pMathMany)
    Elt Identifier
"math.bb" Maybe SourcePos
_ Map Identifier Val
fields ->
      TextType -> [Exp] -> Exp
EStyled TextType
TextDoubleStruck forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). PandocMonad m => Seq Content -> P m [Exp]
pMathMany)
    Elt Identifier
"math.upright" Maybe SourcePos
_ Map Identifier Val
fields ->
      TextType -> [Exp] -> Exp
EStyled TextType
TextNormal forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). PandocMonad m => Seq Content -> P m [Exp]
pMathMany)
    Elt Identifier
"math.bold" Maybe SourcePos
_ Map Identifier Val
fields ->
      TextType -> [Exp] -> Exp
EStyled TextType
TextBold forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). PandocMonad m => Seq Content -> P m [Exp]
pMathMany)
    Elt Identifier
"math.italic" Maybe SourcePos
_ Map Identifier Val
fields ->
      TextType -> [Exp] -> Exp
EStyled TextType
TextItalic forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). PandocMonad m => Seq Content -> P m [Exp]
pMathMany)
    Elt Identifier
"math.underline" Maybe SourcePos
_ Map Identifier Val
fields ->
      Bool -> Exp -> Exp -> Exp
EUnder Bool
False
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped)
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Applicative f => a -> f a
pure (TeXSymbolType -> Text -> Exp
ESymbol TeXSymbolType
TUnder Text
"_")
    Elt Identifier
"math.overline" Maybe SourcePos
_ Map Identifier Val
fields ->
      Bool -> Exp -> Exp -> Exp
EUnder Bool
False
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped)
        forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a. Applicative f => a -> f a
pure (TeXSymbolType -> Text -> Exp
ESymbol TeXSymbolType
TOver Text
"\175")
    Elt Identifier
"math.underbrace" Maybe SourcePos
_ Map Identifier Val
fields -> do
      Maybe (Seq Content)
mbAnn <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"annotation" Map Identifier Val
fields
      Exp
body <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped
      let x :: Exp
x = Bool -> Exp -> Exp -> Exp
EUnder Bool
False Exp
body (TeXSymbolType -> Text -> Exp
ESymbol TeXSymbolType
TUnder Text
"\9183")
      case Maybe (Seq Content)
mbAnn of
        Maybe (Seq Content)
Nothing -> forall (f :: * -> *) a. Applicative f => a -> f a
pure Exp
x
        Just Seq Content
ann -> Bool -> Exp -> Exp -> Exp
EUnder Bool
False Exp
x forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped Seq Content
ann
    Elt Identifier
"math.overbrace" Maybe SourcePos
_ Map Identifier Val
fields -> do
      Maybe (Seq Content)
mbAnn <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"annotation" Map Identifier Val
fields
      Exp
body <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped
      let x :: Exp
x = Bool -> Exp -> Exp -> Exp
EOver Bool
False Exp
body (TeXSymbolType -> Text -> Exp
ESymbol TeXSymbolType
TOver Text
"\9182")
      case Maybe (Seq Content)
mbAnn of
        Maybe (Seq Content)
Nothing -> forall (f :: * -> *) a. Applicative f => a -> f a
pure Exp
x
        Just Seq Content
ann -> Bool -> Exp -> Exp -> Exp
EOver Bool
False Exp
x forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped Seq Content
ann
    Elt Identifier
"math.underbracket" Maybe SourcePos
_ Map Identifier Val
fields -> do
      Maybe (Seq Content)
mbAnn <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"annotation" Map Identifier Val
fields
      Exp
body <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped
      let x :: Exp
x = Bool -> Exp -> Exp -> Exp
EUnder Bool
False Exp
body (TeXSymbolType -> Text -> Exp
ESymbol TeXSymbolType
TUnder Text
"\9141")
      case Maybe (Seq Content)
mbAnn of
        Maybe (Seq Content)
Nothing -> forall (f :: * -> *) a. Applicative f => a -> f a
pure Exp
x
        Just Seq Content
ann -> Bool -> Exp -> Exp -> Exp
EUnder Bool
False Exp
x forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped Seq Content
ann
    Elt Identifier
"math.overbracket" Maybe SourcePos
_ Map Identifier Val
fields -> do
      Maybe (Seq Content)
mbAnn <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"annotation" Map Identifier Val
fields
      Exp
body <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped
      let x :: Exp
x = Bool -> Exp -> Exp -> Exp
EOver Bool
False Exp
body (TeXSymbolType -> Text -> Exp
ESymbol TeXSymbolType
TOver Text
"\9140")
      case Maybe (Seq Content)
mbAnn of
        Maybe (Seq Content)
Nothing -> forall (f :: * -> *) a. Applicative f => a -> f a
pure Exp
x
        Just Seq Content
ann -> Bool -> Exp -> Exp -> Exp
EOver Bool
False Exp
x forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped Seq Content
ann
    Elt Identifier
"math.scripts" Maybe SourcePos
_ Map Identifier Val
fields -> forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped
    Elt Identifier
"math.limits" Maybe SourcePos
_ Map Identifier Val
fields -> forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped
    Elt Identifier
"math.root" Maybe SourcePos
_ Map Identifier Val
fields -> do
      Maybe (Seq Content)
mbindex <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"index" Map Identifier Val
fields
      Exp
radicand <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"radicand" Map Identifier Val
fields forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped
      case Maybe (Seq Content)
mbindex of
        Maybe (Seq Content)
Nothing -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Exp -> Exp
ESqrt Exp
radicand
        Just Seq Content
index -> do
          Exp
index' <- forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped Seq Content
index
          forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Exp -> Exp -> Exp
ERoot Exp
index' Exp
radicand
    Elt Identifier
"math.sqrt" Maybe SourcePos
_ Map Identifier Val
fields ->
      Exp -> Exp
ESqrt forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"radicand" Map Identifier Val
fields forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped)
    Elt Identifier
"math.abs" Maybe SourcePos
_ Map Identifier Val
fields -> do
      Exp
body <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped
      forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Text -> Text -> [InEDelimited] -> Exp
EDelimited Text
"|" Text
"|" [forall a b. b -> Either a b
Right Exp
body]
    Elt Identifier
"math.floor" Maybe SourcePos
_ Map Identifier Val
fields -> do
      Exp
body <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped
      forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Text -> Text -> [InEDelimited] -> Exp
EDelimited Text
"\8970" Text
"\8971" [forall a b. b -> Either a b
Right Exp
body]
    Elt Identifier
"math.ceil" Maybe SourcePos
_ Map Identifier Val
fields -> do
      Exp
body <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped
      forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Text -> Text -> [InEDelimited] -> Exp
EDelimited Text
"\8968" Text
"\8969" [forall a b. b -> Either a b
Right Exp
body]
    Elt Identifier
"math.norm" Maybe SourcePos
_ Map Identifier Val
fields -> do
      Exp
body <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped
      forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Text -> Text -> [InEDelimited] -> Exp
EDelimited Text
"\8741" Text
"\8741" [forall a b. b -> Either a b
Right Exp
body]
    Elt Identifier
"math.round" Maybe SourcePos
_ Map Identifier Val
fields -> do
      Exp
body <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped
      forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Text -> Text -> [InEDelimited] -> Exp
EDelimited Text
"\8970" Text
"\8969" [forall a b. b -> Either a b
Right Exp
body]
    Elt Identifier
"math.lr" Maybe SourcePos
_ Map Identifier Val
fields -> do
      [[Exp]]
bodyparts <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM forall (m :: * -> *). PandocMonad m => Seq Content -> P m [Exp]
pMathMany forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Vector a -> [a]
V.toList
      let rawbody :: [Exp]
rawbody = forall a. [a] -> [[a]] -> [a]
intercalate [TeXSymbolType -> Text -> Exp
ESymbol TeXSymbolType
Pun Text
","] [[Exp]]
bodyparts
      let (Text
op, [Exp]
rest) =
            case [Exp]
rawbody of
              (ESymbol TeXSymbolType
_ Text
t : [Exp]
xs) -> (Text
t, [Exp]
xs)
              [Exp]
_ -> (Text
"", [Exp]
rawbody)
      let ([Either a Exp]
body, Text
cl) =
            case forall a. [a] -> [a]
reverse [Exp]
rest of
              (ESymbol TeXSymbolType
_ Text
t : [Exp]
_) -> (forall a b. (a -> b) -> [a] -> [b]
map forall a b. b -> Either a b
Right (forall a. [a] -> [a]
init [Exp]
rest), Text
t)
              [Exp]
_ -> (forall a b. (a -> b) -> [a] -> [b]
map forall a b. b -> Either a b
Right [Exp]
rest, Text
"")
      forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Text -> Text -> [InEDelimited] -> Exp
EDelimited Text
op Text
cl forall {a}. [Either a Exp]
body
    Elt Identifier
"math.binom" Maybe SourcePos
_ Map Identifier Val
fields -> do
      Exp
up <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"upper" Map Identifier Val
fields forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped
      Exp
low <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"lower" Map Identifier Val
fields forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped
      forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Text -> Text -> [InEDelimited] -> Exp
EDelimited Text
"(" Text
")" [forall a b. b -> Either a b
Right (FractionType -> Exp -> Exp -> Exp
EFraction FractionType
NoLineFrac Exp
up Exp
low)]
    Elt Identifier
"math.cases" Maybe SourcePos
_ Map Identifier Val
fields -> do
      (Maybe Text
delim :: Maybe Text) <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"delim" Map Identifier Val
fields
      ([Seq Content]
children :: [Seq Content]) <-
        forall a b. (a -> b) -> [a] -> [b]
map Val -> Seq Content
valToContent forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Vector a -> [a]
V.toList forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"children" Map Identifier Val
fields
      let isAlignPoint :: Content -> Bool
isAlignPoint (Elt Identifier
"math.alignpoint" Maybe SourcePos
_ Map Identifier Val
_) = Bool
True
          isAlignPoint Content
_ = Bool
False
      let formatRow :: Seq Content -> ParsecT [Content] () m [[Exp]]
formatRow Seq Content
vs = case forall a. (a -> Bool) -> Seq a -> (Seq a, Seq a)
Seq.breakl Content -> Bool
isAlignPoint Seq Content
vs of
            (Seq Content
xs, Seq Content
ys) -> do
              case forall a. Seq a -> ViewL a
Seq.viewl Seq Content
ys of
                Content
_ Seq.:< Seq Content
rest -> do
                  [Exp]
xs' <- forall (m :: * -> *). PandocMonad m => Seq Content -> P m [Exp]
pMathMany Seq Content
xs
                  [Exp]
ys' <- forall (m :: * -> *). PandocMonad m => Seq Content -> P m [Exp]
pMathMany Seq Content
rest
                  forall (f :: * -> *) a. Applicative f => a -> f a
pure [[Exp]
xs', [Exp]
ys']
                ViewL Content
_ -> (forall a. a -> [a] -> [a]
: []) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). PandocMonad m => Seq Content -> P m [Exp]
pMathMany Seq Content
vs
      [[[Exp]]]
rows <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM forall {m :: * -> *}.
PandocMonad m =>
Seq Content -> ParsecT [Content] () m [[Exp]]
formatRow [Seq Content]
children
      forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$
        Text -> Text -> [InEDelimited] -> Exp
EDelimited
          (forall a. a -> Maybe a -> a
fromMaybe Text
"{" Maybe Text
delim)
          Text
""
          [forall a b. b -> Either a b
Right ([Alignment] -> [[[Exp]]] -> Exp
EArray [Alignment
AlignLeft, Alignment
AlignLeft] [[[Exp]]]
rows)]
    Elt Identifier
"math.vec" Maybe SourcePos
_ Map Identifier Val
fields -> do
      (Text
op, Text
cl) <- forall (m :: * -> *).
PandocMonad m =>
Map Identifier Val -> P m (Text, Text)
arrayDelims Map Identifier Val
fields
      [[[Exp]]]
rows <-
        forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"children" Map Identifier Val
fields
          forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a. a -> [a] -> [a]
: []) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). PandocMonad m => Seq Content -> P m [Exp]
pMathMany) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Vector a -> [a]
V.toList
      forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$
        Text -> Text -> [InEDelimited] -> Exp
EDelimited
          Text
op
          Text
cl
          [forall a b. b -> Either a b
Right ([Alignment] -> [[[Exp]]] -> Exp
EArray [Alignment
AlignCenter] [[[Exp]]]
rows)]
    Elt Identifier
"math.mat" Maybe SourcePos
_ Map Identifier Val
fields -> do
      (Text
op, Text
cl) <- forall (m :: * -> *).
PandocMonad m =>
Map Identifier Val -> P m (Text, Text)
arrayDelims Map Identifier Val
fields
      let formatCell :: Val -> ParsecT [Content] () m (Alignment, [Exp])
formatCell Val
x = do
            let content :: Seq Content
content = Val -> Seq Content
valToContent Val
x
            let align :: Alignment
align = case forall a. Seq a -> ViewL a
Seq.viewl Seq Content
content of
                  Elt Identifier
"math.alignpoint" Maybe SourcePos
_ Map Identifier Val
_ Seq.:< Seq Content
_ -> Alignment
AlignLeft
                  ViewL Content
_ -> case forall a. Seq a -> ViewR a
Seq.viewr Seq Content
content of
                    Seq Content
_ Seq.:> Elt Identifier
"math.alignpoint" Maybe SourcePos
_ Map Identifier Val
_ -> Alignment
AlignRight
                    ViewR Content
_ -> Alignment
AlignCenter
            [Exp]
exp' <- forall (m :: * -> *). PandocMonad m => Seq Content -> P m [Exp]
pMathMany Seq Content
content
            forall (f :: * -> *) a. Applicative f => a -> f a
pure (Alignment
align, [Exp]
exp')
      let formatRow :: Val -> ParsecT [Content] () m [(Alignment, [Exp])]
formatRow (VArray Vector Val
vs) = forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM forall {m :: * -> *}.
PandocMonad m =>
Val -> ParsecT [Content] () m (Alignment, [Exp])
formatCell (forall a. Vector a -> [a]
V.toList Vector Val
vs)
          formatRow Val
_ = forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"mat expected array"
      (Vector Val
rawrows :: V.Vector Val) <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"rows" Map Identifier Val
fields
      [[(Alignment, [Exp])]]
rows <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM forall {m :: * -> *}.
PandocMonad m =>
Val -> ParsecT [Content] () m [(Alignment, [Exp])]
formatRow (forall a. Vector a -> [a]
V.toList Vector Val
rawrows)
      let aligns :: [Alignment]
aligns =
            case [[(Alignment, [Exp])]]
rows of
              [] -> []
              ([(Alignment, [Exp])]
r : [[(Alignment, [Exp])]]
_) -> forall a b. (a -> b) -> [a] -> [b]
map forall a b. (a, b) -> a
fst [(Alignment, [Exp])]
r
      forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$
        Text -> Text -> [InEDelimited] -> Exp
EDelimited
          Text
op
          Text
cl
          [forall a b. b -> Either a b
Right ([Alignment] -> [[[Exp]]] -> Exp
EArray [Alignment]
aligns (forall a b. (a -> b) -> [a] -> [b]
map (forall a b. (a -> b) -> [a] -> [b]
map forall a b. (a, b) -> b
snd) [[(Alignment, [Exp])]]
rows))]
    Elt Identifier
"hide" Maybe SourcePos
_ Map Identifier Val
fields -> do
      Exp -> Exp
EPhantom forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped)
    Elt Identifier
"h" Maybe SourcePos
_ Map Identifier Val
fields -> do
      Length
amount <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"amount" Map Identifier Val
fields
      let em :: Rational
em = case Length
amount of
            LExact Double
x LUnit
LEm -> forall a. Real a => a -> Rational
toRational Double
x
            Length
_ -> case Length
amount forall a. Semigroup a => a -> a -> a
<> Double -> LUnit -> Length
LExact Double
0 LUnit
LPt of -- force to Pt
              LExact Double
x LUnit
LPt -> forall a. Real a => a -> Rational
toRational Double
x forall a. Fractional a => a -> a -> a
/ Rational
12
              Length
_ -> Rational
1 forall a. Fractional a => a -> a -> a
/ Rational
3 -- guess!
      forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ Rational -> Exp
ESpace Rational
em
    Elt Identifier
"grid" Maybe SourcePos
_ Map Identifier Val
fields -> do
      [[Exp]]
children <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"children" Map Identifier Val
fields forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM forall (m :: * -> *). PandocMonad m => Seq Content -> P m [Exp]
pMathMany forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Vector a -> [a]
V.toList
      (Val
columns :: Val) <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"columns" Map Identifier Val
fields
      Int
numcols <- case Val
columns of
        VInteger Integer
x -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
x
        VArray Vector Val
x -> forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a. Vector a -> Int
V.length Vector Val
x
        Val
VNone -> forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
1
        Val
_ -> forall (m :: * -> *) a. MonadFail m => String -> m a
fail forall a b. (a -> b) -> a -> b
$ String
"Could not determine number of columns: " forall a. Semigroup a => a -> a -> a
<> forall a. Show a => a -> String
show Val
columns
      let rows :: [[[Exp]]]
rows = forall a. Int -> [a] -> [[a]]
chunks Int
numcols [[Exp]]
children
      forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ [Alignment] -> [[[Exp]]] -> Exp
EArray (forall a. Int -> a -> [a]
replicate Int
numcols Alignment
AlignLeft) [[[Exp]]]
rows
    Elt Identifier
"table" Maybe SourcePos
pos Map Identifier Val
fields -> forall (m :: * -> *). PandocMonad m => Content -> P m Exp
handleMath (Identifier -> Maybe SourcePos -> Map Identifier Val -> Content
Elt Identifier
"grid" Maybe SourcePos
pos Map Identifier Val
fields)
    Elt Identifier
"link" Maybe SourcePos
_ Map Identifier Val
fields -> do
      Seq Content
body <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields
      forall (m :: * -> *). PandocMonad m => Text -> P m ()
ignored Text
"hyperlink in math"
      forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped Seq Content
body
    Elt Identifier
"math.display" Maybe SourcePos
_ Map Identifier Val
fields -> do
      Seq Content
content <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"content" Map Identifier Val
fields
      forall (m :: * -> *). PandocMonad m => Text -> P m ()
ignored Text
"display"
      forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped Seq Content
content
    Elt Identifier
"math.inline" Maybe SourcePos
_ Map Identifier Val
fields -> do
      Seq Content
content <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"content" Map Identifier Val
fields
      forall (m :: * -> *). PandocMonad m => Text -> P m ()
ignored Text
"inline"
      forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped Seq Content
content
    Elt Identifier
"math.script" Maybe SourcePos
_ Map Identifier Val
fields -> do
      Seq Content
content <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"content" Map Identifier Val
fields
      forall (m :: * -> *). PandocMonad m => Text -> P m ()
ignored Text
"script"
      forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped Seq Content
content
    Elt Identifier
"math.sscript" Maybe SourcePos
_ Map Identifier Val
fields -> do
      Seq Content
content <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"content" Map Identifier Val
fields
      forall (m :: * -> *). PandocMonad m => Text -> P m ()
ignored Text
"sscript"
      forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped Seq Content
content
    Elt (Identifier Text
name) Maybe SourcePos
_ Map Identifier Val
fields -> do
      Seq Content
body <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"body" Map Identifier Val
fields forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus` forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a. Monoid a => a
mempty
      forall (m :: * -> *). PandocMonad m => Text -> P m ()
ignored Text
name
      forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped Seq Content
body

arrayDelims :: PandocMonad m => M.Map Identifier Val -> P m (Text, Text)
arrayDelims :: forall (m :: * -> *).
PandocMonad m =>
Map Identifier Val -> P m (Text, Text)
arrayDelims Map Identifier Val
fields = do
  (Maybe Text
mbdelim :: Maybe Text) <- forall (m :: * -> *) a.
(MonadFail m, MonadPlus m, FromVal a) =>
Identifier -> Map Identifier Val -> m a
getField Identifier
"delim" Map Identifier Val
fields
  forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ case Maybe Text
mbdelim of
    Just Text
"(" -> (Text
"(", Text
")")
    Just Text
"[" -> (Text
"[", Text
"]")
    Just Text
"{" -> (Text
"{", Text
"}")
    Just Text
"|" -> (Text
"|", Text
"|")
    Just Text
"||" -> (Text
"\8741", Text
"\8741")
    Maybe Text
_ -> (Text
"(", Text
")")

pMathMany :: PandocMonad m => Seq Content -> P m [Exp]
pMathMany :: forall (m :: * -> *). PandocMonad m => Seq Content -> P m [Exp]
pMathMany Seq Content
cs = do
  -- check for "alignpoint" and "linebreak" elements
  -- and use an array structure for alignment
  let lns :: [Seq Content]
lns = Seq Content -> [Seq Content]
splitOnLinebreaks Seq Content
cs
  case [Seq Content]
lns of
    [] -> forall (f :: * -> *) a. Applicative f => a -> f a
pure []
    [Item [Seq Content]
ln] | Bool -> Bool
not (forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any Content -> Bool
isAlignpoint Item [Seq Content]
ln) -> forall (m :: * -> *) a.
PandocMonad m =>
P m a -> Seq Content -> P m a
pWithContents (forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many forall (m :: * -> *). PandocMonad m => P m Exp
pMath) Item [Seq Content]
ln
    [Seq Content]
_ -> do
      [[[Exp]]]
rows <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (forall (m :: * -> *) a.
PandocMonad m =>
P m a -> Seq Content -> P m a
pWithContents (forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many forall (m :: * -> *). PandocMonad m => P m Exp
pMath)) forall b c a. (b -> c) -> (a -> b) -> a -> c
. Seq Content -> [Seq Content]
splitOnAlignpoints) [Seq Content]
lns
      let numcols :: Int
numcols = forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a
maximum forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map forall (t :: * -> *) a. Foldable t => t a -> Int
length [[[Exp]]]
rows
      let cols :: [Alignment]
cols = forall a. Int -> [a] -> [a]
take Int
numcols forall a b. (a -> b) -> a -> b
$ Alignment
AlignRight forall a. a -> [a] -> [a]
: forall a. [a] -> [a]
cycle [Alignment
AlignLeft, Alignment
AlignRight]
      forall (f :: * -> *) a. Applicative f => a -> f a
pure [[Alignment] -> [[[Exp]]] -> Exp
EArray [Alignment]
cols [[[Exp]]]
rows]

pMathGrouped :: PandocMonad m => Seq Content -> P m Exp
pMathGrouped :: forall (m :: * -> *). PandocMonad m => Seq Content -> P m Exp
pMathGrouped = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [Exp] -> Exp
withGroup forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). PandocMonad m => Seq Content -> P m [Exp]
pMathMany

splitOnLinebreaks :: Seq Content -> [Seq Content]
splitOnLinebreaks :: Seq Content -> [Seq Content]
splitOnLinebreaks Seq Content
xs =
  if forall a. Seq a -> Bool
Seq.null Seq Content
bs
    then
      if forall (t :: * -> *) a. Foldable t => t a -> Bool
null Seq Content
as
        then []
        else [Seq Content
as]
    else Seq Content
as forall a. a -> [a] -> [a]
: Seq Content -> [Seq Content]
splitOnLinebreaks (forall a. Int -> Seq a -> Seq a
Seq.drop Int
1 Seq Content
bs)
  where
    (Seq Content
as, Seq Content
bs) = forall a. (a -> Bool) -> Seq a -> (Seq a, Seq a)
Seq.breakl Content -> Bool
isLinebreak Seq Content
xs
    isLinebreak :: Content -> Bool
isLinebreak (Elt Identifier
"linebreak" Maybe SourcePos
_ Map Identifier Val
_) = Bool
True
    isLinebreak Content
_ = Bool
False

splitOnAlignpoints :: Seq Content -> [Seq Content]
splitOnAlignpoints :: Seq Content -> [Seq Content]
splitOnAlignpoints Seq Content
xs =
  if forall a. Seq a -> Bool
Seq.null Seq Content
bs
    then
      if forall (t :: * -> *) a. Foldable t => t a -> Bool
null Seq Content
as
        then []
        else [Seq Content
as]
    else Seq Content
as forall a. a -> [a] -> [a]
: Seq Content -> [Seq Content]
splitOnAlignpoints (forall a. Int -> Seq a -> Seq a
Seq.drop Int
1 Seq Content
bs)
  where
    (Seq Content
as, Seq Content
bs) = forall a. (a -> Bool) -> Seq a -> (Seq a, Seq a)
Seq.breakl Content -> Bool
isAlignpoint Seq Content
xs

isAlignpoint :: Content -> Bool
isAlignpoint :: Content -> Bool
isAlignpoint (Elt Identifier
"math.alignpoint" Maybe SourcePos
_ Map Identifier Val
_) = Bool
True
isAlignpoint Content
_ = Bool
False