{-# LANGUAGE LambdaCase          #-}
{-# LANGUAGE MultiWayIf          #-}
{-# LANGUAGE OverloadedStrings   #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications    #-}
{-# LANGUAGE ViewPatterns        #-}
{- |
   Module      : Text.Pandoc.Writers.HTML
   Copyright   : Copyright (C) 2006-2021 John MacFarlane
   License     : GNU GPL, version 2 or above

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

Conversion of 'Pandoc' documents to HTML.
-}
module Text.Pandoc.Writers.HTML (
  writeHtml4,
  writeHtml4String,
  writeHtml5,
  writeHtml5String,
  writeHtmlStringForEPUB,
  writeS5,
  writeSlidy,
  writeSlideous,
  writeDZSlides,
  writeRevealJs,
  tagWithAttributes
  ) where
import Control.Monad.State.Strict
import Data.Char (ord)
import Data.List (intercalate, intersperse, partition, delete, (\\), foldl')
import Data.List.NonEmpty (NonEmpty((:|)))
import Data.Maybe (fromMaybe, isJust, isNothing)
import qualified Data.Set as Set
import Data.Text (Text)
import qualified Data.Text as T
import qualified Data.Text.Lazy as TL
import Network.HTTP (urlEncode)
import Network.URI (URI (..), parseURIReference)
import Numeric (showHex)
import Text.DocLayout (render, literal)
import Text.Blaze.Internal (MarkupM (Empty), customLeaf, customParent)
import Text.DocTemplates (FromContext (lookupContext), Context (..))
import Text.Blaze.Html hiding (contents)
import Text.Pandoc.Definition
import Text.Pandoc.Highlighting (formatHtmlBlock, formatHtmlInline, highlight,
                                 styleToCss)
import Text.Pandoc.ImageSize
import Text.Pandoc.Options
import Text.Pandoc.Shared
import Text.Pandoc.Slides
import Text.Pandoc.Templates (renderTemplate)
import Text.Pandoc.Walk
import Text.Pandoc.Writers.Math
import Text.Pandoc.Writers.Shared
import qualified Text.Pandoc.Writers.AnnotatedTable as Ann
import Text.Pandoc.XML (escapeStringForXML, fromEntities, toEntities,
                        html5Attributes, html4Attributes, rdfaAttributes)
import qualified Text.Blaze.XHtml5 as H5
import qualified Text.Blaze.XHtml5.Attributes as A5
import Control.Monad.Except (throwError)
import System.FilePath (takeBaseName)
import Text.Blaze.Html.Renderer.Text (renderHtml)
import qualified Text.Blaze.XHtml1.Transitional as H
import qualified Text.Blaze.XHtml1.Transitional.Attributes as A
import Text.Pandoc.Class.PandocMonad (PandocMonad, report)
import Text.Pandoc.Class.PandocPure (runPure)
import Text.Pandoc.Error
import Text.Pandoc.Logging
import Text.Pandoc.MIME (mediaCategory)
import Text.TeXMath
import Text.XML.Light (elChildren, unode, unqual)
import qualified Text.XML.Light as XML
import Text.XML.Light.Output

data WriterState = WriterState
    { WriterState -> [Html]
stNotes        :: [Html]  -- ^ List of notes
    , WriterState -> Bool
stMath         :: Bool    -- ^ Math is used in document
    , WriterState -> Bool
stQuotes       :: Bool    -- ^ <q> tag is used
    , WriterState -> Bool
stHighlighting :: Bool    -- ^ Syntax highlighting is used
    , WriterState -> Bool
stHtml5        :: Bool    -- ^ Use HTML5
    , WriterState -> Maybe EPUBVersion
stEPUBVersion  :: Maybe EPUBVersion -- ^ EPUB version if for epub
    , WriterState -> HTMLSlideVariant
stSlideVariant :: HTMLSlideVariant
    , WriterState -> Int
stSlideLevel   :: Int     -- ^ Slide level
    , WriterState -> Bool
stInSection    :: Bool    -- ^ Content is in a section (revealjs)
    , WriterState -> Int
stCodeBlockNum :: Int     -- ^ Number of code block
    , WriterState -> Bool
stCsl          :: Bool    -- ^ Has CSL references
    , WriterState -> Maybe Int
stCslEntrySpacing :: Maybe Int  -- ^ CSL entry spacing
    }

defaultWriterState :: WriterState
defaultWriterState :: WriterState
defaultWriterState = WriterState :: [Html]
-> Bool
-> Bool
-> Bool
-> Bool
-> Maybe EPUBVersion
-> HTMLSlideVariant
-> Int
-> Bool
-> Int
-> Bool
-> Maybe Int
-> WriterState
WriterState {stNotes :: [Html]
stNotes= [], stMath :: Bool
stMath = Bool
False, stQuotes :: Bool
stQuotes = Bool
False,
                                  stHighlighting :: Bool
stHighlighting = Bool
False,
                                  stHtml5 :: Bool
stHtml5 = Bool
False,
                                  stEPUBVersion :: Maybe EPUBVersion
stEPUBVersion = Maybe EPUBVersion
forall a. Maybe a
Nothing,
                                  stSlideVariant :: HTMLSlideVariant
stSlideVariant = HTMLSlideVariant
NoSlides,
                                  stSlideLevel :: Int
stSlideLevel = Int
1,
                                  stInSection :: Bool
stInSection = Bool
False,
                                  stCodeBlockNum :: Int
stCodeBlockNum = Int
0,
                                  stCsl :: Bool
stCsl = Bool
False,
                                  stCslEntrySpacing :: Maybe Int
stCslEntrySpacing = Maybe Int
forall a. Maybe a
Nothing}

-- Helpers to render HTML with the appropriate function.

strToHtml :: Text -> Html
strToHtml :: Text -> Html
strToHtml = [Char] -> Html
strToHtml' ([Char] -> Html) -> (Text -> [Char]) -> Text -> Html
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> [Char]
T.unpack
  where
    strToHtml' :: [Char] -> Html
strToHtml' (Char
'\'':[Char]
xs) = [Char] -> Html
preEscapedString [Char]
"\'" Html -> Html -> Html
forall a. Monoid a => a -> a -> a
`mappend` [Char] -> Html
strToHtml' [Char]
xs
    strToHtml' (Char
'"' :[Char]
xs) = [Char] -> Html
preEscapedString [Char]
"\"" Html -> Html -> Html
forall a. Monoid a => a -> a -> a
`mappend` [Char] -> Html
strToHtml' [Char]
xs
    strToHtml' (Char
x:[Char]
xs) | Char -> Bool
needsVariationSelector Char
x
                      = [Char] -> Html
preEscapedString [Char
x, Char
'\xFE0E'] Html -> Html -> Html
forall a. Monoid a => a -> a -> a
`mappend`
                        case [Char]
xs of
                          (Char
'\xFE0E':[Char]
ys) -> [Char] -> Html
strToHtml' [Char]
ys
                          [Char]
_             -> [Char] -> Html
strToHtml' [Char]
xs
    strToHtml' xs :: [Char]
xs@(Char
_:[Char]
_) = case (Char -> Bool) -> [Char] -> ([Char], [Char])
forall a. (a -> Bool) -> [a] -> ([a], [a])
break (\Char
c -> Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'\'' Bool -> Bool -> Bool
|| Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'"' Bool -> Bool -> Bool
||
                                       Char -> Bool
needsVariationSelector Char
c) [Char]
xs of
                            ([Char]
_ ,[]) -> [Char] -> Html
forall a. ToMarkup a => a -> Html
toHtml [Char]
xs
                            ([Char]
ys,[Char]
zs) -> [Char] -> Html
forall a. ToMarkup a => a -> Html
toHtml [Char]
ys Html -> Html -> Html
forall a. Monoid a => a -> a -> a
`mappend` [Char] -> Html
strToHtml' [Char]
zs
    strToHtml' [] = Html
""

-- See #5469: this prevents iOS from substituting emojis.
needsVariationSelector :: Char -> Bool
needsVariationSelector :: Char -> Bool
needsVariationSelector Char
'↩' = Bool
True
needsVariationSelector Char
'↔' = Bool
True
needsVariationSelector Char
_   = Bool
False

-- | Hard linebreak.
nl :: WriterOptions -> Html
nl :: WriterOptions -> Html
nl WriterOptions
opts = if WriterOptions -> WrapOption
writerWrapText WriterOptions
opts WrapOption -> WrapOption -> Bool
forall a. Eq a => a -> a -> Bool
== WrapOption
WrapNone
             then Html
forall a. Monoid a => a
mempty
             else [Char] -> Html
preEscapedString [Char]
"\n"

-- | Convert Pandoc document to Html 5 string.
writeHtml5String :: PandocMonad m => WriterOptions -> Pandoc -> m Text
writeHtml5String :: WriterOptions -> Pandoc -> m Text
writeHtml5String = WriterState -> WriterOptions -> Pandoc -> m Text
forall (m :: * -> *).
PandocMonad m =>
WriterState -> WriterOptions -> Pandoc -> m Text
writeHtmlString'
                      WriterState
defaultWriterState{ stHtml5 :: Bool
stHtml5 = Bool
True }

-- | Convert Pandoc document to Html 5 structure.
writeHtml5 :: PandocMonad m => WriterOptions -> Pandoc -> m Html
writeHtml5 :: WriterOptions -> Pandoc -> m Html
writeHtml5 = WriterState -> WriterOptions -> Pandoc -> m Html
forall (m :: * -> *).
PandocMonad m =>
WriterState -> WriterOptions -> Pandoc -> m Html
writeHtml' WriterState
defaultWriterState{ stHtml5 :: Bool
stHtml5 = Bool
True }

-- | Convert Pandoc document to Html 4 string.
writeHtml4String :: PandocMonad m => WriterOptions -> Pandoc -> m Text
writeHtml4String :: WriterOptions -> Pandoc -> m Text
writeHtml4String = WriterState -> WriterOptions -> Pandoc -> m Text
forall (m :: * -> *).
PandocMonad m =>
WriterState -> WriterOptions -> Pandoc -> m Text
writeHtmlString'
                      WriterState
defaultWriterState{ stHtml5 :: Bool
stHtml5 = Bool
False }

-- | Convert Pandoc document to Html 4 structure.
writeHtml4 :: PandocMonad m => WriterOptions -> Pandoc -> m Html
writeHtml4 :: WriterOptions -> Pandoc -> m Html
writeHtml4 = WriterState -> WriterOptions -> Pandoc -> m Html
forall (m :: * -> *).
PandocMonad m =>
WriterState -> WriterOptions -> Pandoc -> m Html
writeHtml' WriterState
defaultWriterState{ stHtml5 :: Bool
stHtml5 = Bool
False }

-- | Convert Pandoc document to Html appropriate for an epub version.
writeHtmlStringForEPUB :: PandocMonad m
                       => EPUBVersion -> WriterOptions -> Pandoc
                       -> m Text
writeHtmlStringForEPUB :: EPUBVersion -> WriterOptions -> Pandoc -> m Text
writeHtmlStringForEPUB EPUBVersion
version WriterOptions
o = WriterState -> WriterOptions -> Pandoc -> m Text
forall (m :: * -> *).
PandocMonad m =>
WriterState -> WriterOptions -> Pandoc -> m Text
writeHtmlString'
                      WriterState
defaultWriterState{ stHtml5 :: Bool
stHtml5 = EPUBVersion
version EPUBVersion -> EPUBVersion -> Bool
forall a. Eq a => a -> a -> Bool
== EPUBVersion
EPUB3,
                                          stEPUBVersion :: Maybe EPUBVersion
stEPUBVersion = EPUBVersion -> Maybe EPUBVersion
forall a. a -> Maybe a
Just EPUBVersion
version } WriterOptions
o

-- | Convert Pandoc document to Reveal JS HTML slide show.
writeRevealJs :: PandocMonad m
              => WriterOptions -> Pandoc -> m Text
writeRevealJs :: WriterOptions -> Pandoc -> m Text
writeRevealJs = HTMLSlideVariant -> WriterOptions -> Pandoc -> m Text
forall (m :: * -> *).
PandocMonad m =>
HTMLSlideVariant -> WriterOptions -> Pandoc -> m Text
writeHtmlSlideShow' HTMLSlideVariant
RevealJsSlides

-- | Convert Pandoc document to S5 HTML slide show.
writeS5 :: PandocMonad m
        => WriterOptions -> Pandoc -> m Text
writeS5 :: WriterOptions -> Pandoc -> m Text
writeS5 = HTMLSlideVariant -> WriterOptions -> Pandoc -> m Text
forall (m :: * -> *).
PandocMonad m =>
HTMLSlideVariant -> WriterOptions -> Pandoc -> m Text
writeHtmlSlideShow' HTMLSlideVariant
S5Slides

-- | Convert Pandoc document to Slidy HTML slide show.
writeSlidy :: PandocMonad m
           => WriterOptions -> Pandoc -> m Text
writeSlidy :: WriterOptions -> Pandoc -> m Text
writeSlidy = HTMLSlideVariant -> WriterOptions -> Pandoc -> m Text
forall (m :: * -> *).
PandocMonad m =>
HTMLSlideVariant -> WriterOptions -> Pandoc -> m Text
writeHtmlSlideShow' HTMLSlideVariant
SlidySlides

-- | Convert Pandoc document to Slideous HTML slide show.
writeSlideous :: PandocMonad m
              => WriterOptions -> Pandoc -> m Text
writeSlideous :: WriterOptions -> Pandoc -> m Text
writeSlideous = HTMLSlideVariant -> WriterOptions -> Pandoc -> m Text
forall (m :: * -> *).
PandocMonad m =>
HTMLSlideVariant -> WriterOptions -> Pandoc -> m Text
writeHtmlSlideShow' HTMLSlideVariant
SlideousSlides

-- | Convert Pandoc document to DZSlides HTML slide show.
writeDZSlides :: PandocMonad m
              => WriterOptions -> Pandoc -> m Text
writeDZSlides :: WriterOptions -> Pandoc -> m Text
writeDZSlides = HTMLSlideVariant -> WriterOptions -> Pandoc -> m Text
forall (m :: * -> *).
PandocMonad m =>
HTMLSlideVariant -> WriterOptions -> Pandoc -> m Text
writeHtmlSlideShow' HTMLSlideVariant
DZSlides

writeHtmlSlideShow' :: PandocMonad m
                    => HTMLSlideVariant -> WriterOptions -> Pandoc -> m Text
writeHtmlSlideShow' :: HTMLSlideVariant -> WriterOptions -> Pandoc -> m Text
writeHtmlSlideShow' HTMLSlideVariant
variant = WriterState -> WriterOptions -> Pandoc -> m Text
forall (m :: * -> *).
PandocMonad m =>
WriterState -> WriterOptions -> Pandoc -> m Text
writeHtmlString'
    WriterState
defaultWriterState{ stSlideVariant :: HTMLSlideVariant
stSlideVariant = HTMLSlideVariant
variant
                      , stHtml5 :: Bool
stHtml5 = case HTMLSlideVariant
variant of
                                       HTMLSlideVariant
RevealJsSlides -> Bool
True
                                       HTMLSlideVariant
S5Slides       -> Bool
False
                                       HTMLSlideVariant
SlidySlides    -> Bool
False
                                       HTMLSlideVariant
DZSlides       -> Bool
True
                                       HTMLSlideVariant
SlideousSlides -> Bool
False
                                       HTMLSlideVariant
NoSlides       -> Bool
False
                      }

renderHtml' :: Html -> Text
renderHtml' :: Html -> Text
renderHtml' = Text -> Text
TL.toStrict (Text -> Text) -> (Html -> Text) -> Html -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Html -> Text
renderHtml

writeHtmlString' :: PandocMonad m
                 => WriterState -> WriterOptions -> Pandoc -> m Text
writeHtmlString' :: WriterState -> WriterOptions -> Pandoc -> m Text
writeHtmlString' WriterState
st WriterOptions
opts Pandoc
d = do
  (Html
body, Context Text
context) <- StateT WriterState m (Html, Context Text)
-> WriterState -> m (Html, Context Text)
forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
evalStateT (WriterOptions
-> Pandoc -> StateT WriterState m (Html, Context Text)
forall (m :: * -> *).
PandocMonad m =>
WriterOptions
-> Pandoc -> StateT WriterState m (Html, Context Text)
pandocToHtml WriterOptions
opts Pandoc
d) WriterState
st
  (if WriterOptions -> Bool
writerPreferAscii WriterOptions
opts
      then Text -> Text
toEntities
      else Text -> Text
forall a. a -> a
id) (Text -> Text) -> m Text -> m Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
    case WriterOptions -> Maybe (Template Text)
writerTemplate WriterOptions
opts of
       Maybe (Template Text)
Nothing -> Text -> m Text
forall (m :: * -> *) a. Monad m => a -> m a
return (Text -> m Text) -> Text -> m Text
forall a b. (a -> b) -> a -> b
$ Html -> Text
renderHtml' Html
body
       Just Template Text
tpl -> do
         -- warn if empty lang
         Bool -> m () -> m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Maybe Text -> Bool
forall a. Maybe a -> Bool
isNothing (Text -> Context Text -> Maybe Text
forall a b. FromContext a b => Text -> Context a -> Maybe b
getField Text
"lang" Context Text
context :: Maybe Text)) (m () -> m ()) -> m () -> m ()
forall a b. (a -> b) -> a -> b
$
           LogMessage -> m ()
forall (m :: * -> *). PandocMonad m => LogMessage -> m ()
report LogMessage
NoLangSpecified
         -- check for empty pagetitle
         Context Text
context' <-
            case Text -> Context Text -> Maybe Text
forall a b. FromContext a b => Text -> Context a -> Maybe b
getField Text
"pagetitle" Context Text
context of
                 Just (Text
s :: Text) | Bool -> Bool
not (Text -> Bool
T.null Text
s) -> Context Text -> m (Context Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Context Text
context
                 Maybe Text
_ -> do
                   let fallback :: Text
fallback = [Char] -> Text
T.pack ([Char] -> Text) -> [Char] -> Text
forall a b. (a -> b) -> a -> b
$
                         case Text -> Context Text -> Maybe [Text]
forall a b. FromContext a b => Text -> Context a -> Maybe b
lookupContext Text
"sourcefile"
                                   (WriterOptions -> Context Text
writerVariables WriterOptions
opts) of
                           Maybe [Text]
Nothing    -> [Char]
"Untitled"
                           Just []    -> [Char]
"Untitled"
                           Just (Text
x:[Text]
_) -> [Char] -> [Char]
takeBaseName ([Char] -> [Char]) -> [Char] -> [Char]
forall a b. (a -> b) -> a -> b
$ Text -> [Char]
T.unpack Text
x
                   LogMessage -> m ()
forall (m :: * -> *). PandocMonad m => LogMessage -> m ()
report (LogMessage -> m ()) -> LogMessage -> m ()
forall a b. (a -> b) -> a -> b
$ Text -> LogMessage
NoTitleElement Text
fallback
                   Context Text -> m (Context Text)
forall (m :: * -> *) a. Monad m => a -> m a
return (Context Text -> m (Context Text))
-> Context Text -> m (Context Text)
forall a b. (a -> b) -> a -> b
$ Text -> Text -> Context Text -> Context Text
forall a b. ToContext a b => Text -> b -> Context a -> Context a
resetField Text
"pagetitle" Text
fallback Context Text
context
         Text -> m Text
forall (m :: * -> *) a. Monad m => a -> m a
return (Text -> m Text) -> Text -> m Text
forall a b. (a -> b) -> a -> b
$ Maybe Int -> Doc Text -> Text
forall a. HasChars a => Maybe Int -> Doc a -> a
render Maybe Int
forall a. Maybe a
Nothing (Doc Text -> Text) -> Doc Text -> Text
forall a b. (a -> b) -> a -> b
$ Template Text -> Context Text -> Doc Text
forall a b.
(TemplateTarget a, ToContext a b) =>
Template a -> b -> Doc a
renderTemplate Template Text
tpl
             (Text -> Text -> Context Text -> Context Text
forall a b. ToContext a b => Text -> b -> Context a -> Context a
defField Text
"body" (Html -> Text
renderHtml' Html
body) Context Text
context')

writeHtml' :: PandocMonad m => WriterState -> WriterOptions -> Pandoc -> m Html
writeHtml' :: WriterState -> WriterOptions -> Pandoc -> m Html
writeHtml' WriterState
st WriterOptions
opts Pandoc
d =
  case WriterOptions -> Maybe (Template Text)
writerTemplate WriterOptions
opts of
       Just Template Text
_ -> Text -> Html
preEscapedText (Text -> Html) -> m Text -> m Html
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> WriterState -> WriterOptions -> Pandoc -> m Text
forall (m :: * -> *).
PandocMonad m =>
WriterState -> WriterOptions -> Pandoc -> m Text
writeHtmlString' WriterState
st WriterOptions
opts Pandoc
d
       Maybe (Template Text)
Nothing
         | WriterOptions -> Bool
writerPreferAscii WriterOptions
opts
            -> Text -> Html
preEscapedText (Text -> Html) -> m Text -> m Html
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> WriterState -> WriterOptions -> Pandoc -> m Text
forall (m :: * -> *).
PandocMonad m =>
WriterState -> WriterOptions -> Pandoc -> m Text
writeHtmlString' WriterState
st WriterOptions
opts Pandoc
d
         | Bool
otherwise -> do
            (Html
body, Context Text
_) <- StateT WriterState m (Html, Context Text)
-> WriterState -> m (Html, Context Text)
forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
evalStateT (WriterOptions
-> Pandoc -> StateT WriterState m (Html, Context Text)
forall (m :: * -> *).
PandocMonad m =>
WriterOptions
-> Pandoc -> StateT WriterState m (Html, Context Text)
pandocToHtml WriterOptions
opts Pandoc
d) WriterState
st
            Html -> m Html
forall (m :: * -> *) a. Monad m => a -> m a
return Html
body

-- result is (title, authors, date, toc, body, new variables)
pandocToHtml :: PandocMonad m
             => WriterOptions
             -> Pandoc
             -> StateT WriterState m (Html, Context Text)
pandocToHtml :: WriterOptions
-> Pandoc -> StateT WriterState m (Html, Context Text)
pandocToHtml WriterOptions
opts (Pandoc Meta
meta [Block]
blocks) = do
  let slideLevel :: Int
slideLevel = Int -> Maybe Int -> Int
forall a. a -> Maybe a -> a
fromMaybe ([Block] -> Int
getSlideLevel [Block]
blocks) (Maybe Int -> Int) -> Maybe Int -> Int
forall a b. (a -> b) -> a -> b
$ WriterOptions -> Maybe Int
writerSlideLevel WriterOptions
opts
  (WriterState -> WriterState) -> StateT WriterState m ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((WriterState -> WriterState) -> StateT WriterState m ())
-> (WriterState -> WriterState) -> StateT WriterState m ()
forall a b. (a -> b) -> a -> b
$ \WriterState
st -> WriterState
st{ stSlideLevel :: Int
stSlideLevel = Int
slideLevel }
  Context Text
metadata <- WriterOptions
-> ([Block] -> StateT WriterState m (Doc Text))
-> ([Inline] -> StateT WriterState m (Doc Text))
-> Meta
-> StateT WriterState m (Context Text)
forall (m :: * -> *) a.
(Monad m, TemplateTarget a) =>
WriterOptions
-> ([Block] -> m (Doc a))
-> ([Inline] -> m (Doc a))
-> Meta
-> m (Context a)
metaToContext WriterOptions
opts
              ((Html -> Doc Text)
-> StateT WriterState m Html -> StateT WriterState m (Doc Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Text -> Doc Text
forall a. HasChars a => a -> Doc a
literal (Text -> Doc Text) -> (Html -> Text) -> Html -> Doc Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Html -> Text
renderHtml') (StateT WriterState m Html -> StateT WriterState m (Doc Text))
-> ([Block] -> StateT WriterState m Html)
-> [Block]
-> StateT WriterState m (Doc Text)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. WriterOptions -> [Block] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Block] -> StateT WriterState m Html
blockListToHtml WriterOptions
opts)
              ((Html -> Doc Text)
-> StateT WriterState m Html -> StateT WriterState m (Doc Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Text -> Doc Text
forall a. HasChars a => a -> Doc a
literal (Text -> Doc Text) -> (Html -> Text) -> Html -> Doc Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Html -> Text
renderHtml') (StateT WriterState m Html -> StateT WriterState m (Doc Text))
-> ([Inline] -> StateT WriterState m Html)
-> [Inline]
-> StateT WriterState m (Doc Text)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. WriterOptions -> [Inline] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Inline] -> StateT WriterState m Html
inlineListToHtml WriterOptions
opts)
              Meta
meta
  let stringifyHTML :: [Inline] -> Text
stringifyHTML = Text -> Text
escapeStringForXML (Text -> Text) -> ([Inline] -> Text) -> [Inline] -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Inline] -> Text
forall a. Walkable Inline a => a -> Text
stringify
  let authsMeta :: [Text]
authsMeta = ([Inline] -> Text) -> [[Inline]] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
map [Inline] -> Text
stringifyHTML ([[Inline]] -> [Text]) -> [[Inline]] -> [Text]
forall a b. (a -> b) -> a -> b
$ Meta -> [[Inline]]
docAuthors Meta
meta
  let dateMeta :: Text
dateMeta  = [Inline] -> Text
stringifyHTML ([Inline] -> Text) -> [Inline] -> Text
forall a b. (a -> b) -> a -> b
$ Meta -> [Inline]
docDate Meta
meta
  let descriptionMeta :: Text
descriptionMeta = Text -> Text
escapeStringForXML (Text -> Text) -> Text -> Text
forall a b. (a -> b) -> a -> b
$
                          Text -> Meta -> Text
lookupMetaString Text
"description" Meta
meta
  HTMLSlideVariant
slideVariant <- (WriterState -> HTMLSlideVariant)
-> StateT WriterState m HTMLSlideVariant
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets WriterState -> HTMLSlideVariant
stSlideVariant
  let sects :: [Block]
sects = WriterOptions -> [Block] -> [Block]
adjustNumbers WriterOptions
opts ([Block] -> [Block]) -> [Block] -> [Block]
forall a b. (a -> b) -> a -> b
$
              Bool -> Maybe Int -> [Block] -> [Block]
makeSections (WriterOptions -> Bool
writerNumberSections WriterOptions
opts) Maybe Int
forall a. Maybe a
Nothing ([Block] -> [Block]) -> [Block] -> [Block]
forall a b. (a -> b) -> a -> b
$
              if HTMLSlideVariant
slideVariant HTMLSlideVariant -> HTMLSlideVariant -> Bool
forall a. Eq a => a -> a -> Bool
== HTMLSlideVariant
NoSlides
                 then [Block]
blocks
                 else Int -> [Block] -> [Block]
prepSlides Int
slideLevel [Block]
blocks
  Maybe Text
toc <- if WriterOptions -> Bool
writerTableOfContents WriterOptions
opts Bool -> Bool -> Bool
&& HTMLSlideVariant
slideVariant HTMLSlideVariant -> HTMLSlideVariant -> Bool
forall a. Eq a => a -> a -> Bool
/= HTMLSlideVariant
S5Slides
            then (Html -> Text) -> Maybe Html -> Maybe Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Html -> Text
renderHtml' (Maybe Html -> Maybe Text)
-> StateT WriterState m (Maybe Html)
-> StateT WriterState m (Maybe Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> WriterOptions -> [Block] -> StateT WriterState m (Maybe Html)
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Block] -> StateT WriterState m (Maybe Html)
tableOfContents WriterOptions
opts [Block]
sects
            else Maybe Text -> StateT WriterState m (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
forall a. Maybe a
Nothing
  Html
blocks' <- WriterOptions -> [Block] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Block] -> StateT WriterState m Html
blockListToHtml WriterOptions
opts [Block]
sects
  WriterState
st <- StateT WriterState m WriterState
forall s (m :: * -> *). MonadState s m => m s
get
  Html
notes <- WriterOptions -> [Html] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Html] -> StateT WriterState m Html
footnoteSection WriterOptions
opts ([Html] -> [Html]
forall a. [a] -> [a]
reverse (WriterState -> [Html]
stNotes WriterState
st))
  let thebody :: Html
thebody = Html
blocks' Html -> Html -> Html
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Html
notes
  let math :: Html
math = case WriterOptions -> HTMLMathMethod
writerHTMLMathMethod WriterOptions
opts of
        MathJax Text
url
          | HTMLSlideVariant
slideVariant HTMLSlideVariant -> HTMLSlideVariant -> Bool
forall a. Eq a => a -> a -> Bool
/= HTMLSlideVariant
RevealJsSlides ->
          -- mathjax is handled via a special plugin in revealjs
            Html -> Html
H.script (Html -> Html) -> Attribute -> Html -> Html
forall h. Attributable h => h -> Attribute -> h
! AttributeValue -> Attribute
A.src (Text -> AttributeValue
forall a. ToValue a => a -> AttributeValue
toValue Text
url)
                    (Html -> Html) -> Attribute -> Html -> Html
forall h. Attributable h => h -> Attribute -> h
! AttributeValue -> Attribute
A.type_ AttributeValue
"text/javascript"
                    (Html -> Html) -> Html -> Html
forall a b. (a -> b) -> a -> b
$ case HTMLSlideVariant
slideVariant of
                            HTMLSlideVariant
SlideousSlides ->
                              [Char] -> Html
preEscapedString
                              [Char]
"MathJax.Hub.Queue([\"Typeset\",MathJax.Hub]);"
                            HTMLSlideVariant
_ -> Html
forall a. Monoid a => a
mempty
        KaTeX Text
url -> do
          Html -> Html
H.script (Html -> Html) -> Attribute -> Html -> Html
forall h. Attributable h => h -> Attribute -> h
!
            AttributeValue -> Attribute
A.src (Text -> AttributeValue
forall a. ToValue a => a -> AttributeValue
toValue (Text -> AttributeValue) -> Text -> AttributeValue
forall a b. (a -> b) -> a -> b
$ Text
url Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"katex.min.js") (Html -> Html) -> Html -> Html
forall a b. (a -> b) -> a -> b
$ Html
forall a. Monoid a => a
mempty
          WriterOptions -> Html
nl WriterOptions
opts
          let katexFlushLeft :: Text
katexFlushLeft =
                case Text -> Context Text -> Maybe [Text]
forall a b. FromContext a b => Text -> Context a -> Maybe b
lookupContext Text
"classoption" Context Text
metadata of
                  Just [Text]
clsops | Text
"fleqn" Text -> [Text] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` ([Text]
clsops :: [Text]) -> Text
"true"
                  Maybe [Text]
_ -> Text
"false"
          Html -> Html
H.script (Html -> Html) -> Html -> Html
forall a b. (a -> b) -> a -> b
$ Text -> Html
text (Text -> Html) -> Text -> Html
forall a b. (a -> b) -> a -> b
$ [Text] -> Text
T.unlines [
              Text
"document.addEventListener(\"DOMContentLoaded\", function () {"
            , Text
" var mathElements = document.getElementsByClassName(\"math\");"
            , Text
" var macros = [];"
            , Text
" for (var i = 0; i < mathElements.length; i++) {"
            , Text
"  var texText = mathElements[i].firstChild;"
            , Text
"  if (mathElements[i].tagName == \"SPAN\") {"
            , Text
"   katex.render(texText.data, mathElements[i], {"
            , Text
"    displayMode: mathElements[i].classList.contains('display'),"
            , Text
"    throwOnError: false,"
            , Text
"    macros: macros,"
            , Text
"    fleqn: " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
katexFlushLeft
            , Text
"   });"
            , Text
"}}});"
            ]
          WriterOptions -> Html
nl WriterOptions
opts
          Html
H.link Html -> Attribute -> Html
forall h. Attributable h => h -> Attribute -> h
! AttributeValue -> Attribute
A.rel AttributeValue
"stylesheet" Html -> Attribute -> Html
forall h. Attributable h => h -> Attribute -> h
!
            AttributeValue -> Attribute
A.href (Text -> AttributeValue
forall a. ToValue a => a -> AttributeValue
toValue (Text -> AttributeValue) -> Text -> AttributeValue
forall a b. (a -> b) -> a -> b
$ Text
url Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"katex.min.css")

        HTMLMathMethod
_ -> case Text -> Context Text -> Maybe Text
forall a b. FromContext a b => Text -> Context a -> Maybe b
lookupContext Text
"mathml-script"
                  (WriterOptions -> Context Text
writerVariables WriterOptions
opts) of
                    Just Text
s | Bool -> Bool
not (WriterState -> Bool
stHtml5 WriterState
st) ->
                      Html -> Html
H.script (Html -> Html) -> Attribute -> Html -> Html
forall h. Attributable h => h -> Attribute -> h
! AttributeValue -> Attribute
A.type_ AttributeValue
"text/javascript"
                        (Html -> Html) -> Html -> Html
forall a b. (a -> b) -> a -> b
$ [Char] -> Html
preEscapedString
                          ([Char]
"/*<![CDATA[*/\n" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
T.unpack Text
s [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++
                          [Char]
"/*]]>*/\n")
                          | Bool
otherwise -> Html
forall a. Monoid a => a
mempty
                    Maybe Text
Nothing -> Html
forall a. Monoid a => a
mempty
  let Maybe [Text]
mCss :: Maybe [Text] = Text -> Context Text -> Maybe [Text]
forall a b. FromContext a b => Text -> Context a -> Maybe b
lookupContext Text
"css" Context Text
metadata
  let context :: Context Text
context =   (if WriterState -> Bool
stHighlighting WriterState
st
                      then case WriterOptions -> Maybe Style
writerHighlightStyle WriterOptions
opts of
                                Just Style
sty -> Text -> Text -> Context Text -> Context Text
forall a b. ToContext a b => Text -> b -> Context a -> Context a
defField Text
"highlighting-css"
                                              ([Char] -> Text
T.pack ([Char] -> Text) -> [Char] -> Text
forall a b. (a -> b) -> a -> b
$ Style -> [Char]
styleToCss Style
sty)
                                Maybe Style
Nothing  -> Context Text -> Context Text
forall a. a -> a
id
                      else Context Text -> Context Text
forall a. a -> a
id) (Context Text -> Context Text)
-> (Context Text -> Context Text) -> Context Text -> Context Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
                  (if WriterState -> Bool
stCsl WriterState
st
                      then Text -> Bool -> Context Text -> Context Text
forall a b. ToContext a b => Text -> b -> Context a -> Context a
defField Text
"csl-css" Bool
True (Context Text -> Context Text)
-> (Context Text -> Context Text) -> Context Text -> Context Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
                           (case WriterState -> Maybe Int
stCslEntrySpacing WriterState
st of
                              Maybe Int
Nothing -> Context Text -> Context Text
forall a. a -> a
id
                              Just Int
0  -> Context Text -> Context Text
forall a. a -> a
id
                              Just Int
n  ->
                                Text -> Text -> Context Text -> Context Text
forall a b. ToContext a b => Text -> b -> Context a -> Context a
defField Text
"csl-entry-spacing"
                                  (Int -> Text
forall a. Show a => a -> Text
tshow Int
n Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"em"))
                      else Context Text -> Context Text
forall a. a -> a
id) (Context Text -> Context Text)
-> (Context Text -> Context Text) -> Context Text -> Context Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
                  (if WriterState -> Bool
stMath WriterState
st
                      then Text -> Text -> Context Text -> Context Text
forall a b. ToContext a b => Text -> b -> Context a -> Context a
defField Text
"math" (Html -> Text
renderHtml' Html
math)
                      else Context Text -> Context Text
forall a. a -> a
id) (Context Text -> Context Text)
-> (Context Text -> Context Text) -> Context Text -> Context Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
                  (case WriterOptions -> HTMLMathMethod
writerHTMLMathMethod WriterOptions
opts of
                        MathJax Text
u -> Text -> Bool -> Context Text -> Context Text
forall a b. ToContext a b => Text -> b -> Context a -> Context a
defField Text
"mathjax" Bool
True (Context Text -> Context Text)
-> (Context Text -> Context Text) -> Context Text -> Context Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
                                     Text -> Text -> Context Text -> Context Text
forall a b. ToContext a b => Text -> b -> Context a -> Context a
defField Text
"mathjaxurl"
                                       ((Char -> Bool) -> Text -> Text
T.takeWhile (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/=Char
'?') Text
u)
                        HTMLMathMethod
_         -> Text -> Bool -> Context Text -> Context Text
forall a b. ToContext a b => Text -> b -> Context a -> Context a
defField Text
"mathjax" Bool
False) (Context Text -> Context Text)
-> (Context Text -> Context Text) -> Context Text -> Context Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
                  (case WriterOptions -> HTMLMathMethod
writerHTMLMathMethod WriterOptions
opts of
                        HTMLMathMethod
PlainMath -> Text -> Bool -> Context Text -> Context Text
forall a b. ToContext a b => Text -> b -> Context a -> Context a
defField Text
"displaymath-css" Bool
True
                        WebTeX Text
_  -> Text -> Bool -> Context Text -> Context Text
forall a b. ToContext a b => Text -> b -> Context a -> Context a
defField Text
"displaymath-css" Bool
True
                        HTMLMathMethod
_         -> Context Text -> Context Text
forall a. a -> a
id) (Context Text -> Context Text)
-> (Context Text -> Context Text) -> Context Text -> Context Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
                  Text -> Bool -> Context Text -> Context Text
forall a b. ToContext a b => Text -> b -> Context a -> Context a
defField Text
"document-css" (Maybe [Text] -> Bool
forall a. Maybe a -> Bool
isNothing Maybe [Text]
mCss Bool -> Bool -> Bool
&& HTMLSlideVariant
slideVariant HTMLSlideVariant -> HTMLSlideVariant -> Bool
forall a. Eq a => a -> a -> Bool
== HTMLSlideVariant
NoSlides) (Context Text -> Context Text)
-> (Context Text -> Context Text) -> Context Text -> Context Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
                  Text -> Bool -> Context Text -> Context Text
forall a b. ToContext a b => Text -> b -> Context a -> Context a
defField Text
"quotes" (WriterState -> Bool
stQuotes WriterState
st) (Context Text -> Context Text)
-> (Context Text -> Context Text) -> Context Text -> Context Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
                  -- for backwards compatibility we populate toc
                  -- with the contents of the toc, rather than a
                  -- boolean:
                  (Context Text -> Context Text)
-> (Text -> Context Text -> Context Text)
-> Maybe Text
-> Context Text
-> Context Text
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Context Text -> Context Text
forall a. a -> a
id (Text -> Text -> Context Text -> Context Text
forall a b. ToContext a b => Text -> b -> Context a -> Context a
defField Text
"toc") Maybe Text
toc (Context Text -> Context Text)
-> (Context Text -> Context Text) -> Context Text -> Context Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
                  (Context Text -> Context Text)
-> (Text -> Context Text -> Context Text)
-> Maybe Text
-> Context Text
-> Context Text
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Context Text -> Context Text
forall a. a -> a
id (Text -> Text -> Context Text -> Context Text
forall a b. ToContext a b => Text -> b -> Context a -> Context a
defField Text
"table-of-contents") Maybe Text
toc (Context Text -> Context Text)
-> (Context Text -> Context Text) -> Context Text -> Context Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
                  Text -> [Text] -> Context Text -> Context Text
forall a b. ToContext a b => Text -> b -> Context a -> Context a
defField Text
"author-meta" [Text]
authsMeta (Context Text -> Context Text)
-> (Context Text -> Context Text) -> Context Text -> Context Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
                  (Context Text -> Context Text)
-> (Text -> Context Text -> Context Text)
-> Maybe Text
-> Context Text
-> Context Text
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Context Text -> Context Text
forall a. a -> a
id (Text -> Text -> Context Text -> Context Text
forall a b. ToContext a b => Text -> b -> Context a -> Context a
defField Text
"date-meta")
                    (Text -> Maybe Text
normalizeDate Text
dateMeta) (Context Text -> Context Text)
-> (Context Text -> Context Text) -> Context Text -> Context Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
                  Text -> Text -> Context Text -> Context Text
forall a b. ToContext a b => Text -> b -> Context a -> Context a
defField Text
"description-meta" Text
descriptionMeta (Context Text -> Context Text)
-> (Context Text -> Context Text) -> Context Text -> Context Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
                  Text -> Text -> Context Text -> Context Text
forall a b. ToContext a b => Text -> b -> Context a -> Context a
defField Text
"pagetitle"
                      ([Inline] -> Text
stringifyHTML ([Inline] -> Text) -> (Meta -> [Inline]) -> Meta -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Meta -> [Inline]
docTitle (Meta -> Text) -> Meta -> Text
forall a b. (a -> b) -> a -> b
$ Meta
meta) (Context Text -> Context Text)
-> (Context Text -> Context Text) -> Context Text -> Context Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
                  Text -> Text -> Context Text -> Context Text
forall a b. ToContext a b => Text -> b -> Context a -> Context a
defField Text
"idprefix" (WriterOptions -> Text
writerIdentifierPrefix WriterOptions
opts) (Context Text -> Context Text)
-> (Context Text -> Context Text) -> Context Text -> Context Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
                  -- these should maybe be set in pandoc.hs
                  Text -> Text -> Context Text -> Context Text
forall a b. ToContext a b => Text -> b -> Context a -> Context a
defField Text
"slidy-url"
                    (Text
"https://www.w3.org/Talks/Tools/Slidy2" :: Text) (Context Text -> Context Text)
-> (Context Text -> Context Text) -> Context Text -> Context Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
                  Text -> Text -> Context Text -> Context Text
forall a b. ToContext a b => Text -> b -> Context a -> Context a
defField Text
"slideous-url" (Text
"slideous" :: Text) (Context Text -> Context Text)
-> (Context Text -> Context Text) -> Context Text -> Context Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
                  Text -> Text -> Context Text -> Context Text
forall a b. ToContext a b => Text -> b -> Context a -> Context a
defField Text
"revealjs-url" (Text
"https://unpkg.com/reveal.js@^4/" :: Text) (Context Text -> Context Text) -> Context Text -> Context Text
forall a b. (a -> b) -> a -> b
$
                  Text -> Text -> Context Text -> Context Text
forall a b. ToContext a b => Text -> b -> Context a -> Context a
defField Text
"s5-url" (Text
"s5/default" :: Text) (Context Text -> Context Text)
-> (Context Text -> Context Text) -> Context Text -> Context Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
                  Text -> Bool -> Context Text -> Context Text
forall a b. ToContext a b => Text -> b -> Context a -> Context a
defField Text
"html5" (WriterState -> Bool
stHtml5 WriterState
st) (Context Text -> Context Text) -> Context Text -> Context Text
forall a b. (a -> b) -> a -> b
$
                  Context Text
metadata
  (Html, Context Text) -> StateT WriterState m (Html, Context Text)
forall (m :: * -> *) a. Monad m => a -> m a
return (Html
thebody, Context Text
context)

-- | Like Text.XHtml's identifier, but adds the writerIdentifierPrefix
prefixedId :: WriterOptions -> Text -> Attribute
prefixedId :: WriterOptions -> Text -> Attribute
prefixedId WriterOptions
opts Text
s =
  case Text
s of
    Text
"" -> Attribute
forall a. Monoid a => a
mempty
    Text
_  -> AttributeValue -> Attribute
A.id (AttributeValue -> Attribute) -> AttributeValue -> Attribute
forall a b. (a -> b) -> a -> b
$ Text -> AttributeValue
forall a. ToValue a => a -> AttributeValue
toValue (Text -> AttributeValue) -> Text -> AttributeValue
forall a b. (a -> b) -> a -> b
$ WriterOptions -> Text
writerIdentifierPrefix WriterOptions
opts Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
s

toList :: PandocMonad m
       => (Html -> Html)
       -> WriterOptions
       -> [Html]
       -> StateT WriterState m Html
toList :: (Html -> Html)
-> WriterOptions -> [Html] -> StateT WriterState m Html
toList Html -> Html
listop WriterOptions
opts [Html]
items = do
    HTMLSlideVariant
slideVariant <- (WriterState -> HTMLSlideVariant)
-> StateT WriterState m HTMLSlideVariant
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets WriterState -> HTMLSlideVariant
stSlideVariant
    Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$
      if WriterOptions -> Bool
writerIncremental WriterOptions
opts
         then if HTMLSlideVariant
slideVariant HTMLSlideVariant -> HTMLSlideVariant -> Bool
forall a. Eq a => a -> a -> Bool
/= HTMLSlideVariant
RevealJsSlides
                 then  Html -> Html
listop ([Html] -> Html
forall a. Monoid a => [a] -> a
mconcat [Html]
items) Html -> Attribute -> Html
forall h. Attributable h => h -> Attribute -> h
! AttributeValue -> Attribute
A.class_ AttributeValue
"incremental"
                 else Html -> Html
listop (Html -> Html) -> Html -> Html
forall a b. (a -> b) -> a -> b
$ [Html] -> Html
forall a. Monoid a => [a] -> a
mconcat ([Html] -> Html) -> [Html] -> Html
forall a b. (a -> b) -> a -> b
$ (Html -> Html) -> [Html] -> [Html]
forall a b. (a -> b) -> [a] -> [b]
map (Html -> Attribute -> Html
forall h. Attributable h => h -> Attribute -> h
! AttributeValue -> Attribute
A.class_ AttributeValue
"fragment") [Html]
items
         else Html -> Html
listop (Html -> Html) -> Html -> Html
forall a b. (a -> b) -> a -> b
$ [Html] -> Html
forall a. Monoid a => [a] -> a
mconcat [Html]
items

unordList :: PandocMonad m
          => WriterOptions -> [Html] -> StateT WriterState m Html
unordList :: WriterOptions -> [Html] -> StateT WriterState m Html
unordList WriterOptions
opts = (Html -> Html)
-> WriterOptions -> [Html] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
(Html -> Html)
-> WriterOptions -> [Html] -> StateT WriterState m Html
toList Html -> Html
H.ul WriterOptions
opts ([Html] -> StateT WriterState m Html)
-> ([Html] -> [Html]) -> [Html] -> StateT WriterState m Html
forall b c a. (b -> c) -> (a -> b) -> a -> c
. WriterOptions -> [Html] -> [Html]
toListItems WriterOptions
opts

ordList :: PandocMonad m
        => WriterOptions -> [Html] -> StateT WriterState m Html
ordList :: WriterOptions -> [Html] -> StateT WriterState m Html
ordList WriterOptions
opts = (Html -> Html)
-> WriterOptions -> [Html] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
(Html -> Html)
-> WriterOptions -> [Html] -> StateT WriterState m Html
toList Html -> Html
H.ol WriterOptions
opts ([Html] -> StateT WriterState m Html)
-> ([Html] -> [Html]) -> [Html] -> StateT WriterState m Html
forall b c a. (b -> c) -> (a -> b) -> a -> c
. WriterOptions -> [Html] -> [Html]
toListItems WriterOptions
opts

defList :: PandocMonad m
        => WriterOptions -> [Html] -> StateT WriterState m Html
defList :: WriterOptions -> [Html] -> StateT WriterState m Html
defList WriterOptions
opts [Html]
items = (Html -> Html)
-> WriterOptions -> [Html] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
(Html -> Html)
-> WriterOptions -> [Html] -> StateT WriterState m Html
toList Html -> Html
H.dl WriterOptions
opts ([Html]
items [Html] -> [Html] -> [Html]
forall a. [a] -> [a] -> [a]
++ [WriterOptions -> Html
nl WriterOptions
opts])

isTaskListItem :: [Block] -> Bool
isTaskListItem :: [Block] -> Bool
isTaskListItem (Plain (Str Text
"☐":Inline
Space:[Inline]
_):[Block]
_) = Bool
True
isTaskListItem (Plain (Str Text
"☒":Inline
Space:[Inline]
_):[Block]
_) = Bool
True
isTaskListItem (Para  (Str Text
"☐":Inline
Space:[Inline]
_):[Block]
_) = Bool
True
isTaskListItem (Para  (Str Text
"☒":Inline
Space:[Inline]
_):[Block]
_) = Bool
True
isTaskListItem [Block]
_                           = Bool
False

listItemToHtml :: PandocMonad m
               => WriterOptions -> [Block] -> StateT WriterState m Html
listItemToHtml :: WriterOptions -> [Block] -> StateT WriterState m Html
listItemToHtml WriterOptions
opts [Block]
bls
  | Plain (Str Text
"☐":Inline
Space:[Inline]
is) : [Block]
bs <- [Block]
bls = Bool
-> (Html -> Html)
-> [Inline]
-> [Block]
-> StateT WriterState m Html
forall (m :: * -> *) a.
PandocMonad m =>
Bool
-> (Html -> MarkupM a)
-> [Inline]
-> [Block]
-> StateT WriterState m Html
taskListItem Bool
False Html -> Html
forall a. a -> a
id  [Inline]
is [Block]
bs
  | Plain (Str Text
"☒":Inline
Space:[Inline]
is) : [Block]
bs <- [Block]
bls = Bool
-> (Html -> Html)
-> [Inline]
-> [Block]
-> StateT WriterState m Html
forall (m :: * -> *) a.
PandocMonad m =>
Bool
-> (Html -> MarkupM a)
-> [Inline]
-> [Block]
-> StateT WriterState m Html
taskListItem Bool
True  Html -> Html
forall a. a -> a
id  [Inline]
is [Block]
bs
  | Para  (Str Text
"☐":Inline
Space:[Inline]
is) : [Block]
bs <- [Block]
bls = Bool
-> (Html -> Html)
-> [Inline]
-> [Block]
-> StateT WriterState m Html
forall (m :: * -> *) a.
PandocMonad m =>
Bool
-> (Html -> MarkupM a)
-> [Inline]
-> [Block]
-> StateT WriterState m Html
taskListItem Bool
False Html -> Html
H.p [Inline]
is [Block]
bs
  | Para  (Str Text
"☒":Inline
Space:[Inline]
is) : [Block]
bs <- [Block]
bls = Bool
-> (Html -> Html)
-> [Inline]
-> [Block]
-> StateT WriterState m Html
forall (m :: * -> *) a.
PandocMonad m =>
Bool
-> (Html -> MarkupM a)
-> [Inline]
-> [Block]
-> StateT WriterState m Html
taskListItem Bool
True  Html -> Html
H.p [Inline]
is [Block]
bs
  | Bool
otherwise = WriterOptions -> [Block] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Block] -> StateT WriterState m Html
blockListToHtml WriterOptions
opts [Block]
bls
  where
    taskListItem :: Bool
-> (Html -> MarkupM a)
-> [Inline]
-> [Block]
-> StateT WriterState m Html
taskListItem Bool
checked Html -> MarkupM a
constr [Inline]
is [Block]
bs = do
      let checkbox :: Html
checkbox  = if Bool
checked
                      then Html
checkbox' Html -> Attribute -> Html
forall h. Attributable h => h -> Attribute -> h
! AttributeValue -> Attribute
A.checked AttributeValue
""
                      else Html
checkbox'
          checkbox' :: Html
checkbox' = Html
H.input Html -> Attribute -> Html
forall h. Attributable h => h -> Attribute -> h
! AttributeValue -> Attribute
A.type_ AttributeValue
"checkbox" Html -> Attribute -> Html
forall h. Attributable h => h -> Attribute -> h
! AttributeValue -> Attribute
A.disabled AttributeValue
"" Html -> Html -> Html
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> WriterOptions -> Html
nl WriterOptions
opts
      Html
isContents <- WriterOptions -> [Inline] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Inline] -> StateT WriterState m Html
inlineListToHtml WriterOptions
opts [Inline]
is
      Html
bsContents <- WriterOptions -> [Block] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Block] -> StateT WriterState m Html
blockListToHtml WriterOptions
opts [Block]
bs
      Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ Html -> MarkupM a
constr (Html
checkbox Html -> Html -> Html
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Html
isContents) MarkupM a -> Html -> Html
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Html
bsContents

-- | Construct table of contents from list of elements.
tableOfContents :: PandocMonad m => WriterOptions -> [Block]
                -> StateT WriterState m (Maybe Html)
tableOfContents :: WriterOptions -> [Block] -> StateT WriterState m (Maybe Html)
tableOfContents WriterOptions
_ [] = Maybe Html -> StateT WriterState m (Maybe Html)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Html
forall a. Maybe a
Nothing
tableOfContents WriterOptions
opts [Block]
sects = do
  -- in reveal.js, we need #/apples, not #apples:
  HTMLSlideVariant
slideVariant <- (WriterState -> HTMLSlideVariant)
-> StateT WriterState m HTMLSlideVariant
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets WriterState -> HTMLSlideVariant
stSlideVariant
  let opts' :: WriterOptions
opts' = case HTMLSlideVariant
slideVariant of
                HTMLSlideVariant
RevealJsSlides ->
                  WriterOptions
opts{ writerIdentifierPrefix :: Text
writerIdentifierPrefix =
                          Text
"/" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> WriterOptions -> Text
writerIdentifierPrefix WriterOptions
opts }
                HTMLSlideVariant
_ -> WriterOptions
opts
  case WriterOptions -> [Block] -> Block
toTableOfContents WriterOptions
opts [Block]
sects of
    bl :: Block
bl@(BulletList ([Block]
_:[[Block]]
_)) -> Html -> Maybe Html
forall a. a -> Maybe a
Just (Html -> Maybe Html)
-> StateT WriterState m Html -> StateT WriterState m (Maybe Html)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> WriterOptions -> Block -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Block -> StateT WriterState m Html
blockToHtml WriterOptions
opts' Block
bl
    Block
_                     -> Maybe Html -> StateT WriterState m (Maybe Html)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Html
forall a. Maybe a
Nothing

-- | Convert list of Note blocks to a footnote <div>.
-- Assumes notes are sorted.
footnoteSection :: PandocMonad m
                => WriterOptions -> [Html] -> StateT WriterState m Html
footnoteSection :: WriterOptions -> [Html] -> StateT WriterState m Html
footnoteSection WriterOptions
opts [Html]
notes = do
  Bool
html5 <- (WriterState -> Bool) -> StateT WriterState m Bool
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets WriterState -> Bool
stHtml5
  HTMLSlideVariant
slideVariant <- (WriterState -> HTMLSlideVariant)
-> StateT WriterState m HTMLSlideVariant
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets WriterState -> HTMLSlideVariant
stSlideVariant
  let hrtag :: Html
hrtag = if Bool
html5 then Html
H5.hr else Html
H.hr
  Maybe EPUBVersion
epubVersion <- (WriterState -> Maybe EPUBVersion)
-> StateT WriterState m (Maybe EPUBVersion)
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets WriterState -> Maybe EPUBVersion
stEPUBVersion
  let container :: Html -> Html
container Html
x
        | Bool
html5
        , Maybe EPUBVersion
epubVersion Maybe EPUBVersion -> Maybe EPUBVersion -> Bool
forall a. Eq a => a -> a -> Bool
== EPUBVersion -> Maybe EPUBVersion
forall a. a -> Maybe a
Just EPUBVersion
EPUB3
                = Html -> Html
H5.section (Html -> Html) -> Attribute -> Html -> Html
forall h. Attributable h => h -> Attribute -> h
! AttributeValue -> Attribute
A.class_ AttributeValue
"footnotes"
                             (Html -> Html) -> Attribute -> Html -> Html
forall h. Attributable h => h -> Attribute -> h
! Tag -> AttributeValue -> Attribute
customAttribute Tag
"epub:type" AttributeValue
"footnotes" (Html -> Html) -> Html -> Html
forall a b. (a -> b) -> a -> b
$ Html
x
        | Bool
html5 = Html -> Html
H5.section (Html -> Html) -> Attribute -> Html -> Html
forall h. Attributable h => h -> Attribute -> h
! AttributeValue -> Attribute
A.class_ AttributeValue
"footnotes"
                             (Html -> Html) -> Attribute -> Html -> Html
forall h. Attributable h => h -> Attribute -> h
! Tag -> AttributeValue -> Attribute
customAttribute Tag
"role" AttributeValue
"doc-endnotes"
                             (Html -> Html) -> Html -> Html
forall a b. (a -> b) -> a -> b
$ Html
x
        | HTMLSlideVariant
slideVariant HTMLSlideVariant -> HTMLSlideVariant -> Bool
forall a. Eq a => a -> a -> Bool
/= HTMLSlideVariant
NoSlides = Html -> Html
H.div (Html -> Html) -> Attribute -> Html -> Html
forall h. Attributable h => h -> Attribute -> h
! AttributeValue -> Attribute
A.class_ AttributeValue
"footnotes slide" (Html -> Html) -> Html -> Html
forall a b. (a -> b) -> a -> b
$ Html
x
        | Bool
otherwise = Html -> Html
H.div (Html -> Html) -> Attribute -> Html -> Html
forall h. Attributable h => h -> Attribute -> h
! AttributeValue -> Attribute
A.class_ AttributeValue
"footnotes" (Html -> Html) -> Html -> Html
forall a b. (a -> b) -> a -> b
$ Html
x
  Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$
    if [Html] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Html]
notes
       then Html
forall a. Monoid a => a
mempty
       else WriterOptions -> Html
nl WriterOptions
opts Html -> Html -> Html
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Html -> Html
container (WriterOptions -> Html
nl WriterOptions
opts Html -> Html -> Html
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Html
hrtag Html -> Html -> Html
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> WriterOptions -> Html
nl WriterOptions
opts Html -> Html -> Html
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
              Html -> Html
H.ol ([Html] -> Html
forall a. Monoid a => [a] -> a
mconcat [Html]
notes Html -> Html -> Html
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> WriterOptions -> Html
nl WriterOptions
opts) Html -> Html -> Html
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> WriterOptions -> Html
nl WriterOptions
opts)

-- | Parse a mailto link; return Just (name, domain) or Nothing.
parseMailto :: Text -> Maybe (Text, Text)
parseMailto :: Text -> Maybe (Text, Text)
parseMailto Text
s =
  case (Char -> Bool) -> Text -> (Text, Text)
T.break (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
==Char
':') Text
s of
       (Text
xs,Text -> Maybe (Char, Text)
T.uncons -> Just (Char
':',Text
addr)) | Text -> Text
T.toLower Text
xs Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"mailto" -> do
         let (Text
name', Text
rest) = (Char -> Bool) -> Text -> (Text, Text)
T.span (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/=Char
'@') Text
addr
         let domain :: Text
domain = Int -> Text -> Text
T.drop Int
1 Text
rest
         (Text, Text) -> Maybe (Text, Text)
forall (m :: * -> *) a. Monad m => a -> m a
return (Text
name', Text
domain)
       (Text, Text)
_ -> [Char] -> Maybe (Text, Text)
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
Prelude.fail [Char]
"not a mailto: URL"

-- | Obfuscate a "mailto:" link.
obfuscateLink :: PandocMonad m
              => WriterOptions -> Attr -> Html -> Text
              -> StateT WriterState m Html
obfuscateLink :: WriterOptions -> Attr -> Html -> Text -> StateT WriterState m Html
obfuscateLink WriterOptions
opts Attr
attr Html
txt Text
s | WriterOptions -> ObfuscationMethod
writerEmailObfuscation WriterOptions
opts ObfuscationMethod -> ObfuscationMethod -> Bool
forall a. Eq a => a -> a -> Bool
== ObfuscationMethod
NoObfuscation =
  WriterOptions -> Attr -> Html -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Attr -> Html -> StateT WriterState m Html
addAttrs WriterOptions
opts Attr
attr (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ Html -> Html
H.a (Html -> Html) -> Attribute -> Html -> Html
forall h. Attributable h => h -> Attribute -> h
! AttributeValue -> Attribute
A.href (Text -> AttributeValue
forall a. ToValue a => a -> AttributeValue
toValue Text
s) (Html -> Html) -> Html -> Html
forall a b. (a -> b) -> a -> b
$ Html
txt
obfuscateLink WriterOptions
opts Attr
attr (Text -> Text
TL.toStrict (Text -> Text) -> (Html -> Text) -> Html -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Html -> Text
renderHtml -> Text
txt) Text
s =
  let meth :: ObfuscationMethod
meth = WriterOptions -> ObfuscationMethod
writerEmailObfuscation WriterOptions
opts
      s' :: Text
s' = Text -> Text
T.toLower (Int -> Text -> Text
T.take Int
7 Text
s) Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Int -> Text -> Text
T.drop Int
7 Text
s
  in  case Text -> Maybe (Text, Text)
parseMailto Text
s' of
        (Just (Text
name', Text
domain)) ->
          let domain' :: Text
domain'  = Text -> Text -> Text -> Text
T.replace Text
"." Text
" dot " Text
domain
              at' :: Text
at'      = Char -> Text
obfuscateChar Char
'@'
              (Text
linkText, Text
altText) =
                 if Text
txt Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Int -> Text -> Text
T.drop Int
7 Text
s' -- autolink
                    then (Text
"e", Text
name' Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
" at " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
domain')
                    else (Text
"'" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text -> Text
obfuscateString Text
txt Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"'",
                          Text
txt Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
" (" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
name' Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
" at " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
domain' Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
")")
              (Text
_, [Text]
classNames, [(Text, Text)]
_) = Attr
attr
              classNamesStr :: Text
classNamesStr = [Text] -> Text
T.concat ([Text] -> Text) -> [Text] -> Text
forall a b. (a -> b) -> a -> b
$ (Text -> Text) -> [Text] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
map (Text
" "Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>) [Text]
classNames
          in  case ObfuscationMethod
meth of
                ObfuscationMethod
ReferenceObfuscation ->
                     -- need to use preEscapedString or &'s are escaped to &amp; in URL
                     Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$
                     Text -> Html
preEscapedText (Text -> Html) -> Text -> Html
forall a b. (a -> b) -> a -> b
$ Text
"<a href=\"" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text -> Text
obfuscateString Text
s'
                     Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"\" class=\"email\">" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text -> Text
obfuscateString Text
txt Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"</a>"
                ObfuscationMethod
JavascriptObfuscation ->
                     Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$
                     (Html -> Html
H.script (Html -> Html) -> Attribute -> Html -> Html
forall h. Attributable h => h -> Attribute -> h
! AttributeValue -> Attribute
A.type_ AttributeValue
"text/javascript" (Html -> Html) -> Html -> Html
forall a b. (a -> b) -> a -> b
$
                     Text -> Html
preEscapedText (Text
"\n<!--\nh='" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
                     Text -> Text
obfuscateString Text
domain Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"';a='" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
at' Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"';n='" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
                     Text -> Text
obfuscateString Text
name' Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"';e=n+a+h;\n" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
                     Text
"document.write('<a h'+'ref'+'=\"ma'+'ilto'+':'+e+'\" clas'+'s=\"em' + 'ail" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
                     Text
classNamesStr Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"\">'+" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
                     Text
linkText  Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"+'<\\/'+'a'+'>');\n// -->\n")) Html -> Html -> Html
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
                     Html -> Html
H.noscript (Text -> Html
preEscapedText (Text -> Html) -> Text -> Html
forall a b. (a -> b) -> a -> b
$ Text -> Text
obfuscateString Text
altText)
                ObfuscationMethod
_ -> PandocError -> StateT WriterState m Html
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError (PandocError -> StateT WriterState m Html)
-> PandocError -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ Text -> PandocError
PandocSomeError (Text -> PandocError) -> Text -> PandocError
forall a b. (a -> b) -> a -> b
$ Text
"Unknown obfuscation method: " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> ObfuscationMethod -> Text
forall a. Show a => a -> Text
tshow ObfuscationMethod
meth
        Maybe (Text, Text)
_ -> WriterOptions -> Attr -> Html -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Attr -> Html -> StateT WriterState m Html
addAttrs WriterOptions
opts Attr
attr (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ Html -> Html
H.a (Html -> Html) -> Attribute -> Html -> Html
forall h. Attributable h => h -> Attribute -> h
! AttributeValue -> Attribute
A.href (Text -> AttributeValue
forall a. ToValue a => a -> AttributeValue
toValue Text
s) (Html -> Html) -> Html -> Html
forall a b. (a -> b) -> a -> b
$ Text -> Html
forall a. ToMarkup a => a -> Html
toHtml Text
txt  -- malformed email

-- | Obfuscate character as entity.
obfuscateChar :: Char -> Text
obfuscateChar :: Char -> Text
obfuscateChar Char
char =
  let num :: Int
num    = Char -> Int
ord Char
char
      numstr :: [Char]
numstr = if Int -> Bool
forall a. Integral a => a -> Bool
even Int
num then Int -> [Char]
forall a. Show a => a -> [Char]
show Int
num else [Char]
"x" [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> Int -> [Char] -> [Char]
forall a. (Integral a, Show a) => a -> [Char] -> [Char]
showHex Int
num [Char]
""
  in  Text
"&#" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
T.pack [Char]
numstr Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
";"

-- | Obfuscate string using entities.
obfuscateString :: Text -> Text
obfuscateString :: Text -> Text
obfuscateString = (Char -> Text) -> Text -> Text
T.concatMap Char -> Text
obfuscateChar (Text -> Text) -> (Text -> Text) -> Text -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Text
fromEntities

-- | Create HTML tag with attributes.
tagWithAttributes :: WriterOptions
                  -> Bool -- ^ True for HTML5
                  -> Bool -- ^ True if self-closing tag
                  -> Text -- ^ Tag text
                  -> Attr -- ^ Pandoc style tag attributes
                  -> Text
tagWithAttributes :: WriterOptions -> Bool -> Bool -> Text -> Attr -> Text
tagWithAttributes WriterOptions
opts Bool
html5 Bool
selfClosing Text
tagname Attr
attr =
  let mktag :: PandocPure Text
mktag = (Text -> Text
TL.toStrict (Text -> Text) -> (Html -> Text) -> Html -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Html -> Text
renderHtml (Html -> Text) -> PandocPure Html -> PandocPure Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT WriterState PandocPure Html
-> WriterState -> PandocPure Html
forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
evalStateT
               (WriterOptions -> Attr -> Html -> StateT WriterState PandocPure Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Attr -> Html -> StateT WriterState m Html
addAttrs WriterOptions
opts Attr
attr (Tag -> Bool -> Html
customLeaf (Text -> Tag
textTag Text
tagname) Bool
selfClosing))
               WriterState
defaultWriterState{ stHtml5 :: Bool
stHtml5 = Bool
html5 })
  in  case PandocPure Text -> Either PandocError Text
forall a. PandocPure a -> Either PandocError a
runPure PandocPure Text
mktag of
           Left PandocError
_  -> Text
forall a. Monoid a => a
mempty
           Right Text
t -> Text
t

addAttrs :: PandocMonad m
         => WriterOptions -> Attr -> Html -> StateT WriterState m Html
addAttrs :: WriterOptions -> Attr -> Html -> StateT WriterState m Html
addAttrs WriterOptions
opts Attr
attr Html
h = (Html -> Attribute -> Html) -> Html -> [Attribute] -> Html
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' (!) Html
h ([Attribute] -> Html)
-> StateT WriterState m [Attribute] -> StateT WriterState m Html
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> WriterOptions -> Attr -> StateT WriterState m [Attribute]
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Attr -> StateT WriterState m [Attribute]
attrsToHtml WriterOptions
opts Attr
attr

toAttrs :: PandocMonad m
        => [(Text, Text)] -> StateT WriterState m [Attribute]
toAttrs :: [(Text, Text)] -> StateT WriterState m [Attribute]
toAttrs [(Text, Text)]
kvs = do
  Bool
html5 <- (WriterState -> Bool) -> StateT WriterState m Bool
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets WriterState -> Bool
stHtml5
  Maybe EPUBVersion
mbEpubVersion <- (WriterState -> Maybe EPUBVersion)
-> StateT WriterState m (Maybe EPUBVersion)
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets WriterState -> Maybe EPUBVersion
stEPUBVersion
  [Attribute] -> [Attribute]
forall a. [a] -> [a]
reverse ([Attribute] -> [Attribute])
-> ((Set Text, [Attribute]) -> [Attribute])
-> (Set Text, [Attribute])
-> [Attribute]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Set Text, [Attribute]) -> [Attribute]
forall a b. (a, b) -> b
snd ((Set Text, [Attribute]) -> [Attribute])
-> StateT WriterState m (Set Text, [Attribute])
-> StateT WriterState m [Attribute]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((Set Text, [Attribute])
 -> (Text, Text) -> StateT WriterState m (Set Text, [Attribute]))
-> (Set Text, [Attribute])
-> [(Text, Text)]
-> StateT WriterState m (Set Text, [Attribute])
forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldM (Bool
-> Maybe EPUBVersion
-> (Set Text, [Attribute])
-> (Text, Text)
-> StateT WriterState m (Set Text, [Attribute])
forall (m :: * -> *).
PandocMonad m =>
Bool
-> Maybe EPUBVersion
-> (Set Text, [Attribute])
-> (Text, Text)
-> m (Set Text, [Attribute])
go Bool
html5 Maybe EPUBVersion
mbEpubVersion) (Set Text
forall a. Set a
Set.empty, []) [(Text, Text)]
kvs
 where
  go :: Bool
-> Maybe EPUBVersion
-> (Set Text, [Attribute])
-> (Text, Text)
-> m (Set Text, [Attribute])
go Bool
html5 Maybe EPUBVersion
mbEpubVersion (Set Text
keys, [Attribute]
attrs) (Text
k,Text
v) = do
    if Text
k Text -> Set Text -> Bool
forall a. Ord a => a -> Set a -> Bool
`Set.member` Set Text
keys
       then do
         LogMessage -> m ()
forall (m :: * -> *). PandocMonad m => LogMessage -> m ()
report (LogMessage -> m ()) -> LogMessage -> m ()
forall a b. (a -> b) -> a -> b
$ Text -> Text -> LogMessage
DuplicateAttribute Text
k Text
v
         (Set Text, [Attribute]) -> m (Set Text, [Attribute])
forall (m :: * -> *) a. Monad m => a -> m a
return (Set Text
keys, [Attribute]
attrs)
       else (Set Text, [Attribute]) -> m (Set Text, [Attribute])
forall (m :: * -> *) a. Monad m => a -> m a
return (Text -> Set Text -> Set Text
forall a. Ord a => a -> Set a -> Set a
Set.insert Text
k Set Text
keys, Bool
-> Maybe EPUBVersion -> Text -> Text -> [Attribute] -> [Attribute]
forall a.
ToValue a =>
Bool
-> Maybe EPUBVersion -> Text -> a -> [Attribute] -> [Attribute]
addAttr Bool
html5 Maybe EPUBVersion
mbEpubVersion Text
k Text
v [Attribute]
attrs)
  addAttr :: Bool
-> Maybe EPUBVersion -> Text -> a -> [Attribute] -> [Attribute]
addAttr Bool
html5 Maybe EPUBVersion
mbEpubVersion Text
x a
y
    | Bool
html5
      = if Text
x Text -> Set Text -> Bool
forall a. Ord a => a -> Set a -> Bool
`Set.member` (Set Text
html5Attributes Set Text -> Set Text -> Set Text
forall a. Semigroup a => a -> a -> a
<> Set Text
rdfaAttributes)
             Bool -> Bool -> Bool
|| (Char -> Bool) -> Text -> Bool
T.any (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
':') Text
x -- e.g. epub: namespace
             Bool -> Bool -> Bool
|| Text
"data-" Text -> Text -> Bool
`T.isPrefixOf` Text
x
             Bool -> Bool -> Bool
|| Text
"aria-" Text -> Text -> Bool
`T.isPrefixOf` Text
x
           then (Tag -> AttributeValue -> Attribute
customAttribute (Text -> Tag
textTag Text
x) (a -> AttributeValue
forall a. ToValue a => a -> AttributeValue
toValue a
y) Attribute -> [Attribute] -> [Attribute]
forall a. a -> [a] -> [a]
:)
           else (Tag -> AttributeValue -> Attribute
customAttribute (Text -> Tag
textTag (Text
"data-" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
x)) (a -> AttributeValue
forall a. ToValue a => a -> AttributeValue
toValue a
y) Attribute -> [Attribute] -> [Attribute]
forall a. a -> [a] -> [a]
:)
    | Maybe EPUBVersion
mbEpubVersion Maybe EPUBVersion -> Maybe EPUBVersion -> Bool
forall a. Eq a => a -> a -> Bool
== EPUBVersion -> Maybe EPUBVersion
forall a. a -> Maybe a
Just EPUBVersion
EPUB2
    , Bool -> Bool
not (Text
x Text -> Set Text -> Bool
forall a. Ord a => a -> Set a -> Bool
`Set.member` (Set Text
html4Attributes Set Text -> Set Text -> Set Text
forall a. Semigroup a => a -> a -> a
<> Set Text
rdfaAttributes) Bool -> Bool -> Bool
||
      Text
"xml:" Text -> Text -> Bool
`T.isPrefixOf` Text
x)
      = [Attribute] -> [Attribute]
forall a. a -> a
id
    | Bool
otherwise
      = (Tag -> AttributeValue -> Attribute
customAttribute (Text -> Tag
textTag Text
x) (a -> AttributeValue
forall a. ToValue a => a -> AttributeValue
toValue a
y) Attribute -> [Attribute] -> [Attribute]
forall a. a -> [a] -> [a]
:)

attrsToHtml :: PandocMonad m
            => WriterOptions -> Attr -> StateT WriterState m [Attribute]
attrsToHtml :: WriterOptions -> Attr -> StateT WriterState m [Attribute]
attrsToHtml WriterOptions
opts (Text
id',[Text]
classes',[(Text, Text)]
keyvals) = do
  [Attribute]
attrs <- [(Text, Text)] -> StateT WriterState m [Attribute]
forall (m :: * -> *).
PandocMonad m =>
[(Text, Text)] -> StateT WriterState m [Attribute]
toAttrs [(Text, Text)]
keyvals
  [Attribute] -> StateT WriterState m [Attribute]
forall (m :: * -> *) a. Monad m => a -> m a
return ([Attribute] -> StateT WriterState m [Attribute])
-> [Attribute] -> StateT WriterState m [Attribute]
forall a b. (a -> b) -> a -> b
$
    [WriterOptions -> Text -> Attribute
prefixedId WriterOptions
opts Text
id' | Bool -> Bool
not (Text -> Bool
T.null Text
id')] [Attribute] -> [Attribute] -> [Attribute]
forall a. [a] -> [a] -> [a]
++
    [AttributeValue -> Attribute
A.class_ (Text -> AttributeValue
forall a. ToValue a => a -> AttributeValue
toValue (Text -> AttributeValue) -> Text -> AttributeValue
forall a b. (a -> b) -> a -> b
$ [Text] -> Text
T.unwords [Text]
classes') | Bool -> Bool
not ([Text] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Text]
classes')] [Attribute] -> [Attribute] -> [Attribute]
forall a. [a] -> [a] -> [a]
++ [Attribute]
attrs

imgAttrsToHtml :: PandocMonad m
               => WriterOptions -> Attr -> StateT WriterState m [Attribute]
imgAttrsToHtml :: WriterOptions -> Attr -> StateT WriterState m [Attribute]
imgAttrsToHtml WriterOptions
opts Attr
attr = do
  [Attribute]
attrs <- WriterOptions -> Attr -> StateT WriterState m [Attribute]
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Attr -> StateT WriterState m [Attribute]
attrsToHtml WriterOptions
opts (Text
ident,[Text]
cls,[(Text, Text)]
kvs')
  [Attribute]
dimattrs <- [(Text, Text)] -> StateT WriterState m [Attribute]
forall (m :: * -> *).
PandocMonad m =>
[(Text, Text)] -> StateT WriterState m [Attribute]
toAttrs (Attr -> [(Text, Text)]
dimensionsToAttrList Attr
attr)
  [Attribute] -> StateT WriterState m [Attribute]
forall (m :: * -> *) a. Monad m => a -> m a
return ([Attribute] -> StateT WriterState m [Attribute])
-> [Attribute] -> StateT WriterState m [Attribute]
forall a b. (a -> b) -> a -> b
$ [Attribute]
attrs [Attribute] -> [Attribute] -> [Attribute]
forall a. [a] -> [a] -> [a]
++ [Attribute]
dimattrs
  where
    (Text
ident,[Text]
cls,[(Text, Text)]
kvs) = Attr
attr
    kvs' :: [(Text, Text)]
kvs' = ((Text, Text) -> Bool) -> [(Text, Text)] -> [(Text, Text)]
forall a. (a -> Bool) -> [a] -> [a]
filter (Text, Text) -> Bool
forall a b. (Eq a, IsString a) => (a, b) -> Bool
isNotDim [(Text, Text)]
kvs
    isNotDim :: (a, b) -> Bool
isNotDim (a
"width", b
_)  = Bool
False
    isNotDim (a
"height", b
_) = Bool
False
    isNotDim (a, b)
_             = Bool
True

dimensionsToAttrList :: Attr -> [(Text, Text)]
dimensionsToAttrList :: Attr -> [(Text, Text)]
dimensionsToAttrList Attr
attr = [(Text, Text)] -> [(Text, Text)]
consolidateStyles ([(Text, Text)] -> [(Text, Text)])
-> [(Text, Text)] -> [(Text, Text)]
forall a b. (a -> b) -> a -> b
$ Direction -> [(Text, Text)]
go Direction
Width [(Text, Text)] -> [(Text, Text)] -> [(Text, Text)]
forall a. [a] -> [a] -> [a]
++ Direction -> [(Text, Text)]
go Direction
Height
  where
    consolidateStyles :: [(Text, Text)] -> [(Text, Text)]
    consolidateStyles :: [(Text, Text)] -> [(Text, Text)]
consolidateStyles [(Text, Text)]
xs =
      case ((Text, Text) -> Bool)
-> [(Text, Text)] -> ([(Text, Text)], [(Text, Text)])
forall a. (a -> Bool) -> [a] -> ([a], [a])
partition (Text, Text) -> Bool
forall a b. (Eq a, IsString a) => (a, b) -> Bool
isStyle [(Text, Text)]
xs of
           ([], [(Text, Text)]
_)    -> [(Text, Text)]
xs
           ([(Text, Text)]
ss, [(Text, Text)]
rest) -> (Text
"style", Text -> [Text] -> Text
T.intercalate Text
";" ([Text] -> Text) -> [Text] -> Text
forall a b. (a -> b) -> a -> b
$ ((Text, Text) -> Text) -> [(Text, Text)] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
map (Text, Text) -> Text
forall a b. (a, b) -> b
snd [(Text, Text)]
ss) (Text, Text) -> [(Text, Text)] -> [(Text, Text)]
forall a. a -> [a] -> [a]
: [(Text, Text)]
rest
    isStyle :: (a, b) -> Bool
isStyle (a
"style", b
_) = Bool
True
    isStyle (a, b)
_            = Bool
False
    go :: Direction -> [(Text, Text)]
go Direction
dir = case Direction -> Attr -> Maybe Dimension
dimension Direction
dir Attr
attr of
               (Just (Pixel Integer
a)) -> [(Direction -> Text
forall a. Show a => a -> Text
tshow Direction
dir, Integer -> Text
forall a. Show a => a -> Text
tshow Integer
a)]
               (Just Dimension
x)         -> [(Text
"style", Direction -> Text
forall a. Show a => a -> Text
tshow Direction
dir Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
":" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Dimension -> Text
forall a. Show a => a -> Text
tshow Dimension
x)]
               Maybe Dimension
Nothing          -> []

figure :: PandocMonad m
       => WriterOptions -> Attr -> [Inline] -> (Text, Text)
       -> StateT WriterState m Html
figure :: WriterOptions
-> Attr -> [Inline] -> (Text, Text) -> StateT WriterState m Html
figure WriterOptions
opts Attr
attr [Inline]
txt (Text
s,Text
tit) = do
  Bool
html5 <- (WriterState -> Bool) -> StateT WriterState m Bool
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets WriterState -> Bool
stHtml5
  -- Screen-readers will normally read the @alt@ text and the figure; we
  -- want to avoid them reading the same text twice. With HTML5 we can
  -- use aria-hidden for the caption; with HTML4, we use an empty
  -- alt-text instead.
  let alt :: [Inline]
alt = if Bool
html5 then [Inline]
txt else [Text -> Inline
Str Text
""]
  let tocapt :: Html -> Html
tocapt = if Bool
html5
                  then Html -> Html
H5.figcaption (Html -> Html) -> Attribute -> Html -> Html
forall h. Attributable h => h -> Attribute -> h
!
                       Tag -> AttributeValue -> Attribute
H5.customAttribute (Text -> Tag
textTag Text
"aria-hidden")
                                          (Text -> AttributeValue
forall a. ToValue a => a -> AttributeValue
toValue @Text Text
"true")
                  else Html -> Html
H.p (Html -> Html) -> Attribute -> Html -> Html
forall h. Attributable h => h -> Attribute -> h
! AttributeValue -> Attribute
A.class_ AttributeValue
"caption"
  Html
img <- WriterOptions -> Inline -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Inline -> StateT WriterState m Html
inlineToHtml WriterOptions
opts (Attr -> [Inline] -> (Text, Text) -> Inline
Image Attr
attr [Inline]
alt (Text
s,Text
tit))
  Html
capt <- if [Inline] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Inline]
txt
             then Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return Html
forall a. Monoid a => a
mempty
             else Html -> Html
tocapt (Html -> Html)
-> StateT WriterState m Html -> StateT WriterState m Html
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` WriterOptions -> [Inline] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Inline] -> StateT WriterState m Html
inlineListToHtml WriterOptions
opts [Inline]
txt
  Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ if Bool
html5
              then Html -> Html
H5.figure (Html -> Html) -> Html -> Html
forall a b. (a -> b) -> a -> b
$ [Html] -> Html
forall a. Monoid a => [a] -> a
mconcat
                    [WriterOptions -> Html
nl WriterOptions
opts, Html
img, Html
capt, WriterOptions -> Html
nl WriterOptions
opts]
              else Html -> Html
H.div (Html -> Html) -> Attribute -> Html -> Html
forall h. Attributable h => h -> Attribute -> h
! AttributeValue -> Attribute
A.class_ AttributeValue
"figure" (Html -> Html) -> Html -> Html
forall a b. (a -> b) -> a -> b
$ [Html] -> Html
forall a. Monoid a => [a] -> a
mconcat
                    [WriterOptions -> Html
nl WriterOptions
opts, Html
img, WriterOptions -> Html
nl WriterOptions
opts, Html
capt, WriterOptions -> Html
nl WriterOptions
opts]


adjustNumbers :: WriterOptions -> [Block] -> [Block]
adjustNumbers :: WriterOptions -> [Block] -> [Block]
adjustNumbers WriterOptions
opts [Block]
doc =
  if (Int -> Bool) -> [Int] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all (Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
==Int
0) (WriterOptions -> [Int]
writerNumberOffset WriterOptions
opts)
     then [Block]
doc
     else (Block -> Block) -> [Block] -> [Block]
forall a b. Walkable a b => (a -> a) -> b -> b
walk Block -> Block
go [Block]
doc
  where
   go :: Block -> Block
go (Header Int
level (Text
ident,[Text]
classes,[(Text, Text)]
kvs) [Inline]
lst) =
     Int -> Attr -> [Inline] -> Block
Header Int
level (Text
ident,[Text]
classes,((Text, Text) -> (Text, Text)) -> [(Text, Text)] -> [(Text, Text)]
forall a b. (a -> b) -> [a] -> [b]
map (Text, Text) -> (Text, Text)
forall a. (Eq a, IsString a) => (a, Text) -> (a, Text)
fixnum [(Text, Text)]
kvs) [Inline]
lst
   go Block
x = Block
x
   fixnum :: (a, Text) -> (a, Text)
fixnum (a
"number",Text
num) = (a
"number",
                               [Int] -> Text
showSecNum ([Int] -> Text) -> [Int] -> Text
forall a b. (a -> b) -> a -> b
$ (Int -> Int -> Int) -> [Int] -> [Int] -> [Int]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith Int -> Int -> Int
forall a. Num a => a -> a -> a
(+)
                               (WriterOptions -> [Int]
writerNumberOffset WriterOptions
opts [Int] -> [Int] -> [Int]
forall a. [a] -> [a] -> [a]
++ Int -> [Int]
forall a. a -> [a]
repeat Int
0)
                               ((Text -> Int) -> [Text] -> [Int]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> Maybe Int -> Int
forall a. a -> Maybe a -> a
fromMaybe Int
0 (Maybe Int -> Int) -> (Text -> Maybe Int) -> Text -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Maybe Int
forall (m :: * -> *) a. (MonadPlus m, Read a) => Text -> m a
safeRead) ([Text] -> [Int]) -> [Text] -> [Int]
forall a b. (a -> b) -> a -> b
$
                                (Char -> Bool) -> Text -> [Text]
T.split (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
==Char
'.') Text
num))
   fixnum (a, Text)
x = (a, Text)
x
   showSecNum :: [Int] -> Text
showSecNum = Text -> [Text] -> Text
T.intercalate Text
"." ([Text] -> Text) -> ([Int] -> [Text]) -> [Int] -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> Text) -> [Int] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
map Int -> Text
forall a. Show a => a -> Text
tshow

-- | Convert Pandoc block element to HTML.
blockToHtml :: PandocMonad m => WriterOptions -> Block -> StateT WriterState m Html
blockToHtml :: WriterOptions -> Block -> StateT WriterState m Html
blockToHtml WriterOptions
_ Block
Null = Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return Html
forall a. Monoid a => a
mempty
blockToHtml WriterOptions
opts (Plain [Inline]
lst) = WriterOptions -> [Inline] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Inline] -> StateT WriterState m Html
inlineListToHtml WriterOptions
opts [Inline]
lst
blockToHtml WriterOptions
opts (Para [Image attr :: Attr
attr@(Text
_,[Text]
classes,[(Text, Text)]
_) [Inline]
txt (Text
src,Text
tit)])
  | Text
"stretch" Text -> [Text] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Text]
classes = do
  HTMLSlideVariant
slideVariant <- (WriterState -> HTMLSlideVariant)
-> StateT WriterState m HTMLSlideVariant
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets WriterState -> HTMLSlideVariant
stSlideVariant
  case HTMLSlideVariant
slideVariant of
       HTMLSlideVariant
RevealJsSlides ->
         -- a "stretched" image in reveal.js must be a direct child
         -- of the slide container
         WriterOptions -> Inline -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Inline -> StateT WriterState m Html
inlineToHtml WriterOptions
opts (Attr -> [Inline] -> (Text, Text) -> Inline
Image Attr
attr [Inline]
txt (Text
src, Text
tit))
       HTMLSlideVariant
_ -> WriterOptions
-> Attr -> [Inline] -> (Text, Text) -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions
-> Attr -> [Inline] -> (Text, Text) -> StateT WriterState m Html
figure WriterOptions
opts Attr
attr [Inline]
txt (Text
src, Text
tit)
-- title beginning with fig: indicates that the image is a figure
blockToHtml WriterOptions
opts (Para [Image Attr
attr [Inline]
txt (Text
s,Text -> Text -> Maybe Text
T.stripPrefix Text
"fig:" -> Just Text
tit)]) =
  WriterOptions
-> Attr -> [Inline] -> (Text, Text) -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions
-> Attr -> [Inline] -> (Text, Text) -> StateT WriterState m Html
figure WriterOptions
opts Attr
attr [Inline]
txt (Text
s,Text
tit)
blockToHtml WriterOptions
opts (Para [Inline]
lst) = do
  Html
contents <- WriterOptions -> [Inline] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Inline] -> StateT WriterState m Html
inlineListToHtml WriterOptions
opts [Inline]
lst
  case Html
contents of
       Empty ()
_ | Bool -> Bool
not (Extension -> WriterOptions -> Bool
forall a. HasSyntaxExtensions a => Extension -> a -> Bool
isEnabled Extension
Ext_empty_paragraphs WriterOptions
opts) -> Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return Html
forall a. Monoid a => a
mempty
       Html
_ -> Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ Html -> Html
H.p Html
contents
blockToHtml WriterOptions
opts (LineBlock [[Inline]]
lns) =
  if WriterOptions -> WrapOption
writerWrapText WriterOptions
opts WrapOption -> WrapOption -> Bool
forall a. Eq a => a -> a -> Bool
== WrapOption
WrapNone
  then WriterOptions -> Block -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Block -> StateT WriterState m Html
blockToHtml WriterOptions
opts (Block -> StateT WriterState m Html)
-> Block -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ [[Inline]] -> Block
linesToPara [[Inline]]
lns
  else do
    Html
htmlLines <- WriterOptions -> [Inline] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Inline] -> StateT WriterState m Html
inlineListToHtml WriterOptions
opts ([Inline] -> StateT WriterState m Html)
-> [Inline] -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ [Inline] -> [[Inline]] -> [Inline]
forall a. [a] -> [[a]] -> [a]
intercalate [Inline
LineBreak] [[Inline]]
lns
    Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ Html -> Html
H.div (Html -> Html) -> Attribute -> Html -> Html
forall h. Attributable h => h -> Attribute -> h
! AttributeValue -> Attribute
A.class_ AttributeValue
"line-block" (Html -> Html) -> Html -> Html
forall a b. (a -> b) -> a -> b
$ Html
htmlLines
blockToHtml WriterOptions
opts (Div (Text
ident, Text
"section":[Text]
dclasses, [(Text, Text)]
dkvs)
                   (Header Int
level
                     hattr :: Attr
hattr@(Text
hident,[Text]
hclasses,[(Text, Text)]
hkvs) [Inline]
ils : [Block]
xs)) = do
  HTMLSlideVariant
slideVariant <- (WriterState -> HTMLSlideVariant)
-> StateT WriterState m HTMLSlideVariant
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets WriterState -> HTMLSlideVariant
stSlideVariant
  Int
slideLevel <- (WriterState -> Int) -> StateT WriterState m Int
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets WriterState -> Int
stSlideLevel
  let slide :: Bool
slide = HTMLSlideVariant
slideVariant HTMLSlideVariant -> HTMLSlideVariant -> Bool
forall a. Eq a => a -> a -> Bool
/= HTMLSlideVariant
NoSlides Bool -> Bool -> Bool
&&
               Int
level Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
slideLevel {- DROPPED old fix for #5168 here -}
  Bool
html5 <- (WriterState -> Bool) -> StateT WriterState m Bool
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets WriterState -> Bool
stHtml5
  let titleSlide :: Bool
titleSlide = Bool
slide Bool -> Bool -> Bool
&& Int
level Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
slideLevel
  let level' :: Int
level' = if Int
level Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
slideLevel Bool -> Bool -> Bool
&& HTMLSlideVariant
slideVariant HTMLSlideVariant -> HTMLSlideVariant -> Bool
forall a. Eq a => a -> a -> Bool
== HTMLSlideVariant
SlidySlides
                  then Int
1 -- see #3566
                  else Int
level
  Html
header' <- if [Inline]
ils [Inline] -> [Inline] -> Bool
forall a. Eq a => a -> a -> Bool
== [Text -> Inline
Str Text
"\0"]  -- marker for hrule
                then Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return Html
forall a. Monoid a => a
mempty
                else WriterOptions -> Block -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Block -> StateT WriterState m Html
blockToHtml WriterOptions
opts (Int -> Attr -> [Inline] -> Block
Header Int
level' Attr
hattr [Inline]
ils)
  let isSec :: Block -> Bool
isSec (Div (Text
_,Text
"section":[Text]
_,[(Text, Text)]
_) [Block]
_) = Bool
True
      isSec (Div Attr
_ [Block]
zs)                = (Block -> Bool) -> [Block] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any Block -> Bool
isSec [Block]
zs
      isSec Block
_                         = Bool
False
  let isPause :: Block -> Bool
isPause (Para [Str Text
".",Inline
Space,Str Text
".",Inline
Space,Str Text
"."]) = Bool
True
      isPause Block
_                                            = Bool
False
  let fragmentClass :: Text
fragmentClass = case HTMLSlideVariant
slideVariant of
                           HTMLSlideVariant
RevealJsSlides -> Text
"fragment"
                           HTMLSlideVariant
_              -> Text
"incremental"
  let inDiv' :: [Block] -> [Block]
inDiv' [Block]
zs = Format -> Text -> Block
RawBlock (Text -> Format
Format Text
"html") (Text
"<div class=\""
                       Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
fragmentClass Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"\">") Block -> [Block] -> [Block]
forall a. a -> [a] -> [a]
:
                   ([Block]
zs [Block] -> [Block] -> [Block]
forall a. [a] -> [a] -> [a]
++ [Format -> Text -> Block
RawBlock (Text -> Format
Format Text
"html") Text
"</div>"])
  let breakOnPauses :: [Block] -> [Block]
breakOnPauses [Block]
zs = case (Block -> Bool) -> [Block] -> [[Block]]
forall a. (a -> Bool) -> [a] -> [[a]]
splitBy Block -> Bool
isPause [Block]
zs of
                           []   -> []
                           [Block]
y:[[Block]]
ys -> [Block]
y [Block] -> [Block] -> [Block]
forall a. [a] -> [a] -> [a]
++ ([Block] -> [Block]) -> [[Block]] -> [Block]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap [Block] -> [Block]
inDiv' [[Block]]
ys
  let ([Block]
titleBlocks, [Block]
innerSecs) =
        if Bool
titleSlide
           -- title slides have no content of their own
           then let ([Block]
as, [Block]
bs) = (Block -> Bool) -> [Block] -> ([Block], [Block])
forall a. (a -> Bool) -> [a] -> ([a], [a])
break Block -> Bool
isSec [Block]
xs
                in  ([Block] -> [Block]
breakOnPauses [Block]
as, [Block]
bs)
           else ([], [Block] -> [Block]
breakOnPauses [Block]
xs)
  let secttag :: Html -> Html
secttag  = if Bool
html5
                    then Html -> Html
H5.section
                    else Html -> Html
H.div
  Html
titleContents <- WriterOptions -> [Block] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Block] -> StateT WriterState m Html
blockListToHtml WriterOptions
opts [Block]
titleBlocks
  Bool
inSection <- (WriterState -> Bool) -> StateT WriterState m Bool
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets WriterState -> Bool
stInSection
  Html
innerContents <- do
    (WriterState -> WriterState) -> StateT WriterState m ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((WriterState -> WriterState) -> StateT WriterState m ())
-> (WriterState -> WriterState) -> StateT WriterState m ()
forall a b. (a -> b) -> a -> b
$ \WriterState
st -> WriterState
st{ stInSection :: Bool
stInSection = Bool
True }
    Html
res <- WriterOptions -> [Block] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Block] -> StateT WriterState m Html
blockListToHtml WriterOptions
opts [Block]
innerSecs
    (WriterState -> WriterState) -> StateT WriterState m ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((WriterState -> WriterState) -> StateT WriterState m ())
-> (WriterState -> WriterState) -> StateT WriterState m ()
forall a b. (a -> b) -> a -> b
$ \WriterState
st -> WriterState
st{ stInSection :: Bool
stInSection = Bool
inSection }
    Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return Html
res
  let classes' :: [Text]
classes' = [Text] -> [Text]
forall a. Ord a => [a] -> [a]
ordNub ([Text] -> [Text]) -> [Text] -> [Text]
forall a b. (a -> b) -> a -> b
$
                  [Text
"title-slide" | Bool
titleSlide] [Text] -> [Text] -> [Text]
forall a. [a] -> [a] -> [a]
++ [Text
"slide" | Bool
slide] [Text] -> [Text] -> [Text]
forall a. [a] -> [a] -> [a]
++
                  [Text
"section" | (Bool
slide Bool -> Bool -> Bool
|| WriterOptions -> Bool
writerSectionDivs WriterOptions
opts) Bool -> Bool -> Bool
&&
                               Bool -> Bool
not Bool
html5 ] [Text] -> [Text] -> [Text]
forall a. [a] -> [a] -> [a]
++
                  [Text
"level" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Int -> Text
forall a. Show a => a -> Text
tshow Int
level | Bool
slide Bool -> Bool -> Bool
|| WriterOptions -> Bool
writerSectionDivs WriterOptions
opts ]
                  [Text] -> [Text] -> [Text]
forall a. Semigroup a => a -> a -> a
<> [Text]
dclasses
  let attr :: Attr
attr = (Text
ident, [Text]
classes', [(Text, Text)]
dkvs)
  if Bool
titleSlide
     then do
       Html
t <- WriterOptions -> Attr -> Html -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Attr -> Html -> StateT WriterState m Html
addAttrs WriterOptions
opts Attr
attr (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$
             Html -> Html
secttag (Html -> Html) -> Html -> Html
forall a b. (a -> b) -> a -> b
$ WriterOptions -> Html
nl WriterOptions
opts Html -> Html -> Html
forall a. Semigroup a => a -> a -> a
<> Html
header' Html -> Html -> Html
forall a. Semigroup a => a -> a -> a
<> WriterOptions -> Html
nl WriterOptions
opts Html -> Html -> Html
forall a. Semigroup a => a -> a -> a
<> Html
titleContents Html -> Html -> Html
forall a. Semigroup a => a -> a -> a
<> WriterOptions -> Html
nl WriterOptions
opts
       -- ensure 2D nesting for revealjs, but only for one level;
       -- revealjs doesn't like more than one level of nesting
       Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$
         if HTMLSlideVariant
slideVariant HTMLSlideVariant -> HTMLSlideVariant -> Bool
forall a. Eq a => a -> a -> Bool
== HTMLSlideVariant
RevealJsSlides Bool -> Bool -> Bool
&& Bool -> Bool
not Bool
inSection Bool -> Bool -> Bool
&&
              Bool -> Bool
not ([Block] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Block]
innerSecs)
            then Html -> Html
H5.section (WriterOptions -> Html
nl WriterOptions
opts Html -> Html -> Html
forall a. Semigroup a => a -> a -> a
<> Html
t Html -> Html -> Html
forall a. Semigroup a => a -> a -> a
<> WriterOptions -> Html
nl WriterOptions
opts Html -> Html -> Html
forall a. Semigroup a => a -> a -> a
<> Html
innerContents)
            else Html
t Html -> Html -> Html
forall a. Semigroup a => a -> a -> a
<> WriterOptions -> Html
nl WriterOptions
opts Html -> Html -> Html
forall a. Semigroup a => a -> a -> a
<> if [Block] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Block]
innerSecs
                                    then Html
forall a. Monoid a => a
mempty
                                    else Html
innerContents Html -> Html -> Html
forall a. Semigroup a => a -> a -> a
<> WriterOptions -> Html
nl WriterOptions
opts
     else if WriterOptions -> Bool
writerSectionDivs WriterOptions
opts Bool -> Bool -> Bool
|| Bool
slide Bool -> Bool -> Bool
||
              (Text
hident Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
/= Text
ident Bool -> Bool -> Bool
&& Bool -> Bool
not (Text -> Bool
T.null Text
hident Bool -> Bool -> Bool
|| Text -> Bool
T.null Text
ident)) Bool -> Bool -> Bool
||
              ([Text]
hclasses [Text] -> [Text] -> Bool
forall a. Eq a => a -> a -> Bool
/= [Text]
dclasses) Bool -> Bool -> Bool
|| ([(Text, Text)]
hkvs [(Text, Text)] -> [(Text, Text)] -> Bool
forall a. Eq a => a -> a -> Bool
/= [(Text, Text)]
dkvs)
          then WriterOptions -> Attr -> Html -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Attr -> Html -> StateT WriterState m Html
addAttrs WriterOptions
opts Attr
attr
               (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ Html -> Html
secttag
               (Html -> Html) -> Html -> Html
forall a b. (a -> b) -> a -> b
$ WriterOptions -> Html
nl WriterOptions
opts Html -> Html -> Html
forall a. Semigroup a => a -> a -> a
<> Html
header' Html -> Html -> Html
forall a. Semigroup a => a -> a -> a
<> WriterOptions -> Html
nl WriterOptions
opts Html -> Html -> Html
forall a. Semigroup a => a -> a -> a
<>
                 if [Block] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Block]
innerSecs
                    then Html
forall a. Monoid a => a
mempty
                    else Html
innerContents Html -> Html -> Html
forall a. Semigroup a => a -> a -> a
<> WriterOptions -> Html
nl WriterOptions
opts
          else do
            let attr' :: Attr
attr' = (Text
ident, [Text]
classes' [Text] -> [Text] -> [Text]
forall a. Eq a => [a] -> [a] -> [a]
\\ [Text]
hclasses, [(Text, Text)]
dkvs [(Text, Text)] -> [(Text, Text)] -> [(Text, Text)]
forall a. Eq a => [a] -> [a] -> [a]
\\ [(Text, Text)]
hkvs)
            Html
t <- WriterOptions -> Attr -> Html -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Attr -> Html -> StateT WriterState m Html
addAttrs WriterOptions
opts Attr
attr' Html
header'
            Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ Html
t Html -> Html -> Html
forall a. Semigroup a => a -> a -> a
<>
                     if [Block] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Block]
innerSecs
                        then Html
forall a. Monoid a => a
mempty
                        else WriterOptions -> Html
nl WriterOptions
opts Html -> Html -> Html
forall a. Semigroup a => a -> a -> a
<> Html
innerContents
blockToHtml WriterOptions
opts (Div attr :: Attr
attr@(Text
ident, [Text]
classes, [(Text, Text)]
kvs') [Block]
bs) = do
  Bool
html5 <- (WriterState -> Bool) -> StateT WriterState m Bool
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets WriterState -> Bool
stHtml5
  HTMLSlideVariant
slideVariant <- (WriterState -> HTMLSlideVariant)
-> StateT WriterState m HTMLSlideVariant
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets WriterState -> HTMLSlideVariant
stSlideVariant
  let isCslBibBody :: Bool
isCslBibBody = Text
ident Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"refs" Bool -> Bool -> Bool
|| Text
"csl-bib-body" Text -> [Text] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Text]
classes
  Bool -> StateT WriterState m () -> StateT WriterState m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
isCslBibBody (StateT WriterState m () -> StateT WriterState m ())
-> StateT WriterState m () -> StateT WriterState m ()
forall a b. (a -> b) -> a -> b
$ (WriterState -> WriterState) -> StateT WriterState m ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((WriterState -> WriterState) -> StateT WriterState m ())
-> (WriterState -> WriterState) -> StateT WriterState m ()
forall a b. (a -> b) -> a -> b
$ \WriterState
st -> WriterState
st{ stCsl :: Bool
stCsl = Bool
True
                                        , stCslEntrySpacing :: Maybe Int
stCslEntrySpacing =
                                           Text -> [(Text, Text)] -> Maybe Text
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup Text
"entry-spacing" [(Text, Text)]
kvs' Maybe Text -> (Text -> Maybe Int) -> Maybe Int
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>=
                                           Text -> Maybe Int
forall (m :: * -> *) a. (MonadPlus m, Read a) => Text -> m a
safeRead }
  let isCslBibEntry :: Bool
isCslBibEntry = Text
"csl-entry" Text -> [Text] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Text]
classes
  let kvs :: [(Text, Text)]
kvs = [(Text
k,Text
v) | (Text
k,Text
v) <- [(Text, Text)]
kvs', Text
k Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
/= Text
"width"] [(Text, Text)] -> [(Text, Text)] -> [(Text, Text)]
forall a. [a] -> [a] -> [a]
++
            [(Text
"style", Text
"width:" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
w Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
";") | Text
"column" Text -> [Text] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Text]
classes,
             (Text
"width", Text
w) <- [(Text, Text)]
kvs'] [(Text, Text)] -> [(Text, Text)] -> [(Text, Text)]
forall a. [a] -> [a] -> [a]
++
            [(Text
"role", Text
"doc-bibliography") | Bool
isCslBibBody Bool -> Bool -> Bool
&& Bool
html5] [(Text, Text)] -> [(Text, Text)] -> [(Text, Text)]
forall a. [a] -> [a] -> [a]
++
            [(Text
"role", Text
"doc-biblioentry") | Bool
isCslBibEntry Bool -> Bool -> Bool
&& Bool
html5]
  let speakerNotes :: Bool
speakerNotes = Text
"notes" Text -> [Text] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Text]
classes
  -- we don't want incremental output inside speaker notes, see #1394
  let opts' :: WriterOptions
opts' = if | Bool
speakerNotes -> WriterOptions
opts{ writerIncremental :: Bool
writerIncremental = Bool
False }
                 | Text
"incremental" Text -> [Text] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Text]
classes -> WriterOptions
opts{ writerIncremental :: Bool
writerIncremental = Bool
True }
                 | Text
"nonincremental" Text -> [Text] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Text]
classes -> WriterOptions
opts{ writerIncremental :: Bool
writerIncremental = Bool
False }
                 | Bool
otherwise -> WriterOptions
opts
      -- we remove "incremental" and "nonincremental" if we're in a
      -- slide presentaiton format.
      classes' :: [Text]
classes' = case HTMLSlideVariant
slideVariant of
        HTMLSlideVariant
NoSlides -> [Text]
classes
        HTMLSlideVariant
_ -> (Text -> Bool) -> [Text] -> [Text]
forall a. (a -> Bool) -> [a] -> [a]
filter (\Text
k -> Text
k Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
/= Text
"incremental" Bool -> Bool -> Bool
&& Text
k Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
/= Text
"nonincremental") [Text]
classes
  let paraToPlain :: Block -> Block
paraToPlain (Para [Inline]
ils) = [Inline] -> Block
Plain [Inline]
ils
      paraToPlain Block
x          = Block
x
  let bs' :: [Block]
bs' = if Text
"csl-entry" Text -> [Text] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Text]
classes'
               then (Block -> Block) -> [Block] -> [Block]
forall a b. Walkable a b => (a -> a) -> b -> b
walk Block -> Block
paraToPlain [Block]
bs
               else [Block]
bs
  Html
contents <- if Text
"columns" Text -> [Text] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Text]
classes'
                 then -- we don't use blockListToHtml because it inserts
                      -- a newline between the column divs, which throws
                      -- off widths! see #4028
                      [Html] -> Html
forall a. Monoid a => [a] -> a
mconcat ([Html] -> Html)
-> StateT WriterState m [Html] -> StateT WriterState m Html
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Block -> StateT WriterState m Html)
-> [Block] -> StateT WriterState m [Html]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (WriterOptions -> Block -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Block -> StateT WriterState m Html
blockToHtml WriterOptions
opts) [Block]
bs'
                 else WriterOptions -> [Block] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Block] -> StateT WriterState m Html
blockListToHtml WriterOptions
opts' [Block]
bs'
  let contents' :: Html
contents' = WriterOptions -> Html
nl WriterOptions
opts Html -> Html -> Html
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Html
contents Html -> Html -> Html
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> WriterOptions -> Html
nl WriterOptions
opts
  let (Html -> Html
divtag, [Text]
classes'') = if Bool
html5 Bool -> Bool -> Bool
&& Text
"section" Text -> [Text] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Text]
classes'
                            then (Html -> Html
H5.section, (Text -> Bool) -> [Text] -> [Text]
forall a. (a -> Bool) -> [a] -> [a]
filter (Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
/= Text
"section") [Text]
classes')
                            else (Html -> Html
H.div, [Text]
classes')
  if Bool
speakerNotes
     then case HTMLSlideVariant
slideVariant of
               HTMLSlideVariant
RevealJsSlides -> WriterOptions -> Attr -> Html -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Attr -> Html -> StateT WriterState m Html
addAttrs WriterOptions
opts' Attr
attr (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$
                           Html -> Html
H5.aside Html
contents'
               HTMLSlideVariant
DZSlides       -> do
                 Html
t <- WriterOptions -> Attr -> Html -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Attr -> Html -> StateT WriterState m Html
addAttrs WriterOptions
opts' Attr
attr (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$
                             Html -> Html
H5.div Html
contents'
                 Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ Html
t Html -> Attribute -> Html
forall h. Attributable h => h -> Attribute -> h
! Tag -> AttributeValue -> Attribute
H5.customAttribute Tag
"role" AttributeValue
"note"
               HTMLSlideVariant
NoSlides       -> WriterOptions -> Attr -> Html -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Attr -> Html -> StateT WriterState m Html
addAttrs WriterOptions
opts' Attr
attr (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$
                           Html -> Html
H.div Html
contents'
               HTMLSlideVariant
_              -> Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return Html
forall a. Monoid a => a
mempty
     else WriterOptions -> Attr -> Html -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Attr -> Html -> StateT WriterState m Html
addAttrs WriterOptions
opts (Text
ident, [Text]
classes'', [(Text, Text)]
kvs) (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$
              Html -> Html
divtag Html
contents'
blockToHtml WriterOptions
opts (RawBlock Format
f Text
str) = do
  Bool
ishtml <- Format -> StateT WriterState m Bool
forall (m :: * -> *).
PandocMonad m =>
Format -> StateT WriterState m Bool
isRawHtml Format
f
  if Bool
ishtml
     then Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ Text -> Html
preEscapedText Text
str
     else if (Format
f Format -> Format -> Bool
forall a. Eq a => a -> a -> Bool
== Text -> Format
Format Text
"latex" Bool -> Bool -> Bool
|| Format
f Format -> Format -> Bool
forall a. Eq a => a -> a -> Bool
== Text -> Format
Format Text
"tex") Bool -> Bool -> Bool
&&
             HTMLMathMethod -> Bool
allowsMathEnvironments (WriterOptions -> HTMLMathMethod
writerHTMLMathMethod WriterOptions
opts) Bool -> Bool -> Bool
&&
             Text -> Bool
isMathEnvironment Text
str
             then WriterOptions -> Block -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Block -> StateT WriterState m Html
blockToHtml WriterOptions
opts (Block -> StateT WriterState m Html)
-> Block -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ [Inline] -> Block
Plain [MathType -> Text -> Inline
Math MathType
DisplayMath Text
str]
             else do
               LogMessage -> StateT WriterState m ()
forall (m :: * -> *). PandocMonad m => LogMessage -> m ()
report (LogMessage -> StateT WriterState m ())
-> LogMessage -> StateT WriterState m ()
forall a b. (a -> b) -> a -> b
$ Block -> LogMessage
BlockNotRendered (Format -> Text -> Block
RawBlock Format
f Text
str)
               Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return Html
forall a. Monoid a => a
mempty
blockToHtml WriterOptions
_ Block
HorizontalRule = do
  Bool
html5 <- (WriterState -> Bool) -> StateT WriterState m Bool
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets WriterState -> Bool
stHtml5
  Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ if Bool
html5 then Html
H5.hr else Html
H.hr
blockToHtml WriterOptions
opts (CodeBlock (Text
id',[Text]
classes,[(Text, Text)]
keyvals) Text
rawCode) = do
  Text
id'' <- if Text -> Bool
T.null Text
id'
             then do
               (WriterState -> WriterState) -> StateT WriterState m ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((WriterState -> WriterState) -> StateT WriterState m ())
-> (WriterState -> WriterState) -> StateT WriterState m ()
forall a b. (a -> b) -> a -> b
$ \WriterState
st -> WriterState
st{ stCodeBlockNum :: Int
stCodeBlockNum = WriterState -> Int
stCodeBlockNum WriterState
st Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1 }
               Int
codeblocknum <- (WriterState -> Int) -> StateT WriterState m Int
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets WriterState -> Int
stCodeBlockNum
               Text -> StateT WriterState m Text
forall (m :: * -> *) a. Monad m => a -> m a
return (WriterOptions -> Text
writerIdentifierPrefix WriterOptions
opts Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"cb" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Int -> Text
forall a. Show a => a -> Text
tshow Int
codeblocknum)
             else Text -> StateT WriterState m Text
forall (m :: * -> *) a. Monad m => a -> m a
return (WriterOptions -> Text
writerIdentifierPrefix WriterOptions
opts Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
id')
  let tolhs :: Bool
tolhs = Extension -> WriterOptions -> Bool
forall a. HasSyntaxExtensions a => Extension -> a -> Bool
isEnabled Extension
Ext_literate_haskell WriterOptions
opts Bool -> Bool -> Bool
&&
                (Text -> Bool) -> [Text] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (\Text
c -> Text -> Text
T.toLower Text
c Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"haskell") [Text]
classes Bool -> Bool -> Bool
&&
                (Text -> Bool) -> [Text] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (\Text
c -> Text -> Text
T.toLower Text
c Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"literate") [Text]
classes
      classes' :: [Text]
classes' = if Bool
tolhs
                    then (Text -> Text) -> [Text] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
map (\Text
c -> if Text -> Text
T.toLower Text
c Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"haskell"
                                       then Text
"literatehaskell"
                                       else Text
c) [Text]
classes
                    else [Text]
classes
      adjCode :: Text
adjCode  = if Bool
tolhs
                    then [Text] -> Text
T.unlines ([Text] -> Text) -> (Text -> [Text]) -> Text -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Text -> Text) -> [Text] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
map (Text
"> " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>) ([Text] -> [Text]) -> (Text -> [Text]) -> Text -> [Text]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> [Text]
T.lines (Text -> Text) -> Text -> Text
forall a b. (a -> b) -> a -> b
$ Text
rawCode
                    else Text
rawCode
      hlCode :: Either Text Html
hlCode   = if Maybe Style -> Bool
forall a. Maybe a -> Bool
isJust (WriterOptions -> Maybe Style
writerHighlightStyle WriterOptions
opts)
                    then SyntaxMap
-> (FormatOptions -> [SourceLine] -> Html)
-> Attr
-> Text
-> Either Text Html
forall a.
SyntaxMap
-> (FormatOptions -> [SourceLine] -> a)
-> Attr
-> Text
-> Either Text a
highlight (WriterOptions -> SyntaxMap
writerSyntaxMap WriterOptions
opts) FormatOptions -> [SourceLine] -> Html
formatHtmlBlock
                            (Text
id'',[Text]
classes',[(Text, Text)]
keyvals) Text
adjCode
                    else Text -> Either Text Html
forall a b. a -> Either a b
Left Text
""
  case Either Text Html
hlCode of
         Left Text
msg -> do
           Bool -> StateT WriterState m () -> StateT WriterState m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (Text -> Bool
T.null Text
msg) (StateT WriterState m () -> StateT WriterState m ())
-> StateT WriterState m () -> StateT WriterState m ()
forall a b. (a -> b) -> a -> b
$
             LogMessage -> StateT WriterState m ()
forall (m :: * -> *). PandocMonad m => LogMessage -> m ()
report (LogMessage -> StateT WriterState m ())
-> LogMessage -> StateT WriterState m ()
forall a b. (a -> b) -> a -> b
$ Text -> LogMessage
CouldNotHighlight Text
msg
           WriterOptions -> Attr -> Html -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Attr -> Html -> StateT WriterState m Html
addAttrs WriterOptions
opts (Text
id',[Text]
classes,[(Text, Text)]
keyvals)
             (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ Html -> Html
H.pre (Html -> Html) -> Html -> Html
forall a b. (a -> b) -> a -> b
$ Html -> Html
H.code (Html -> Html) -> Html -> Html
forall a b. (a -> b) -> a -> b
$ Text -> Html
forall a. ToMarkup a => a -> Html
toHtml Text
adjCode
         Right Html
h -> (WriterState -> WriterState) -> StateT WriterState m ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (\WriterState
st -> WriterState
st{ stHighlighting :: Bool
stHighlighting = Bool
True }) StateT WriterState m ()
-> StateT WriterState m Html -> StateT WriterState m Html
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
                    -- we set writerIdentifierPrefix to "" since id'' already
                    -- includes it:
                    WriterOptions -> Attr -> Html -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Attr -> Html -> StateT WriterState m Html
addAttrs WriterOptions
opts{writerIdentifierPrefix :: Text
writerIdentifierPrefix = Text
""} (Text
id'',[],[(Text, Text)]
keyvals) Html
h
blockToHtml WriterOptions
opts (BlockQuote [Block]
blocks) = do
  -- in S5, treat list in blockquote specially
  -- if default is incremental, make it nonincremental;
  -- otherwise incremental
  HTMLSlideVariant
slideVariant <- (WriterState -> HTMLSlideVariant)
-> StateT WriterState m HTMLSlideVariant
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets WriterState -> HTMLSlideVariant
stSlideVariant
  if HTMLSlideVariant
slideVariant HTMLSlideVariant -> HTMLSlideVariant -> Bool
forall a. Eq a => a -> a -> Bool
/= HTMLSlideVariant
NoSlides
     then let inc :: Bool
inc = Bool -> Bool
not (WriterOptions -> Bool
writerIncremental WriterOptions
opts) in
          case [Block]
blocks of
             [BulletList [[Block]]
lst]  -> WriterOptions -> Block -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Block -> StateT WriterState m Html
blockToHtml (WriterOptions
opts {writerIncremental :: Bool
writerIncremental = Bool
inc})
                                  ([[Block]] -> Block
BulletList [[Block]]
lst)
             [OrderedList ListAttributes
attribs [[Block]]
lst] ->
                                  WriterOptions -> Block -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Block -> StateT WriterState m Html
blockToHtml (WriterOptions
opts {writerIncremental :: Bool
writerIncremental = Bool
inc})
                                  (ListAttributes -> [[Block]] -> Block
OrderedList ListAttributes
attribs [[Block]]
lst)
             [DefinitionList [([Inline], [[Block]])]
lst] ->
                                  WriterOptions -> Block -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Block -> StateT WriterState m Html
blockToHtml (WriterOptions
opts {writerIncremental :: Bool
writerIncremental = Bool
inc})
                                  ([([Inline], [[Block]])] -> Block
DefinitionList [([Inline], [[Block]])]
lst)
             [Block]
_                 -> do Html
contents <- WriterOptions -> [Block] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Block] -> StateT WriterState m Html
blockListToHtml WriterOptions
opts [Block]
blocks
                                     Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ Html -> Html
H.blockquote
                                            (Html -> Html) -> Html -> Html
forall a b. (a -> b) -> a -> b
$ WriterOptions -> Html
nl WriterOptions
opts Html -> Html -> Html
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Html
contents Html -> Html -> Html
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> WriterOptions -> Html
nl WriterOptions
opts
     else do
       Html
contents <- WriterOptions -> [Block] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Block] -> StateT WriterState m Html
blockListToHtml WriterOptions
opts [Block]
blocks
       Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ Html -> Html
H.blockquote (Html -> Html) -> Html -> Html
forall a b. (a -> b) -> a -> b
$ WriterOptions -> Html
nl WriterOptions
opts Html -> Html -> Html
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Html
contents Html -> Html -> Html
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> WriterOptions -> Html
nl WriterOptions
opts
blockToHtml WriterOptions
opts (Header Int
level (Text
ident,[Text]
classes,[(Text, Text)]
kvs) [Inline]
lst) = do
  Html
contents <- WriterOptions -> [Inline] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Inline] -> StateT WriterState m Html
inlineListToHtml WriterOptions
opts [Inline]
lst
  let secnum :: Text
secnum = Text -> Maybe Text -> Text
forall a. a -> Maybe a -> a
fromMaybe Text
forall a. Monoid a => a
mempty (Maybe Text -> Text) -> Maybe Text -> Text
forall a b. (a -> b) -> a -> b
$ Text -> [(Text, Text)] -> Maybe Text
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup Text
"number" [(Text, Text)]
kvs
  let contents' :: Html
contents' = if WriterOptions -> Bool
writerNumberSections WriterOptions
opts Bool -> Bool -> Bool
&& Bool -> Bool
not (Text -> Bool
T.null Text
secnum)
                     Bool -> Bool -> Bool
&& Text
"unnumbered" Text -> [Text] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` [Text]
classes
                     then (Html -> Html
H.span (Html -> Html) -> Attribute -> Html -> Html
forall h. Attributable h => h -> Attribute -> h
! AttributeValue -> Attribute
A.class_ AttributeValue
"header-section-number"
                             (Html -> Html) -> Html -> Html
forall a b. (a -> b) -> a -> b
$ Text -> Html
forall a. ToMarkup a => a -> Html
toHtml Text
secnum) Html -> Html -> Html
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Text -> Html
strToHtml Text
" " Html -> Html -> Html
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Html
contents
                     else Html
contents
  Bool
html5 <- (WriterState -> Bool) -> StateT WriterState m Bool
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets WriterState -> Bool
stHtml5
  let kvs' :: [(Text, Text)]
kvs' = if Bool
html5
             then [(Text, Text)]
kvs
             else [ (Text
k, Text
v) | (Text
k, Text
v) <- [(Text, Text)]
kvs
                           , Text
k Text -> [Text] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` ([Text
"lang", Text
"dir", Text
"title", Text
"style"
                                      , Text
"align"] [Text] -> [Text] -> [Text]
forall a. [a] -> [a] -> [a]
++ [Text]
intrinsicEventsHTML4)]
  WriterOptions -> Attr -> Html -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Attr -> Html -> StateT WriterState m Html
addAttrs WriterOptions
opts (Text
ident,[Text]
classes,[(Text, Text)]
kvs')
         (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ case Int
level of
              Int
1 -> Html -> Html
H.h1 Html
contents'
              Int
2 -> Html -> Html
H.h2 Html
contents'
              Int
3 -> Html -> Html
H.h3 Html
contents'
              Int
4 -> Html -> Html
H.h4 Html
contents'
              Int
5 -> Html -> Html
H.h5 Html
contents'
              Int
6 -> Html -> Html
H.h6 Html
contents'
              Int
_ -> Html -> Html
H.p (Html -> Html) -> Attribute -> Html -> Html
forall h. Attributable h => h -> Attribute -> h
! AttributeValue -> Attribute
A.class_ AttributeValue
"heading" (Html -> Html) -> Html -> Html
forall a b. (a -> b) -> a -> b
$ Html
contents'
blockToHtml WriterOptions
opts (BulletList [[Block]]
lst) = do
  [Html]
contents <- ([Block] -> StateT WriterState m Html)
-> [[Block]] -> StateT WriterState m [Html]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (WriterOptions -> [Block] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Block] -> StateT WriterState m Html
listItemToHtml WriterOptions
opts) [[Block]]
lst
  let isTaskList :: Bool
isTaskList = Bool -> Bool
not ([[Block]] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [[Block]]
lst) Bool -> Bool -> Bool
&& ([Block] -> Bool) -> [[Block]] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all [Block] -> Bool
isTaskListItem [[Block]]
lst
  (if Bool
isTaskList then (Html -> Attribute -> Html
forall h. Attributable h => h -> Attribute -> h
! AttributeValue -> Attribute
A.class_ AttributeValue
"task-list") else Html -> Html
forall a. a -> a
id) (Html -> Html)
-> StateT WriterState m Html -> StateT WriterState m Html
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
    WriterOptions -> [Html] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Html] -> StateT WriterState m Html
unordList WriterOptions
opts [Html]
contents
blockToHtml WriterOptions
opts (OrderedList (Int
startnum, ListNumberStyle
numstyle, ListNumberDelim
_) [[Block]]
lst) = do
  [Html]
contents <- ([Block] -> StateT WriterState m Html)
-> [[Block]] -> StateT WriterState m [Html]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (WriterOptions -> [Block] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Block] -> StateT WriterState m Html
listItemToHtml WriterOptions
opts) [[Block]]
lst
  Bool
html5 <- (WriterState -> Bool) -> StateT WriterState m Bool
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets WriterState -> Bool
stHtml5
  let numstyle' :: Text
numstyle' = case ListNumberStyle
numstyle of
                       ListNumberStyle
Example -> Text
"decimal"
                       ListNumberStyle
_       -> Text -> Text
camelCaseToHyphenated (Text -> Text) -> Text -> Text
forall a b. (a -> b) -> a -> b
$ ListNumberStyle -> Text
forall a. Show a => a -> Text
tshow ListNumberStyle
numstyle
  let attribs :: [Attribute]
attribs = [AttributeValue -> Attribute
A.start (AttributeValue -> Attribute) -> AttributeValue -> Attribute
forall a b. (a -> b) -> a -> b
$ Int -> AttributeValue
forall a. ToValue a => a -> AttributeValue
toValue Int
startnum | Int
startnum Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= Int
1] [Attribute] -> [Attribute] -> [Attribute]
forall a. [a] -> [a] -> [a]
++
                [AttributeValue -> Attribute
A.class_ AttributeValue
"example" | ListNumberStyle
numstyle ListNumberStyle -> ListNumberStyle -> Bool
forall a. Eq a => a -> a -> Bool
== ListNumberStyle
Example] [Attribute] -> [Attribute] -> [Attribute]
forall a. [a] -> [a] -> [a]
++
                (if ListNumberStyle
numstyle ListNumberStyle -> ListNumberStyle -> Bool
forall a. Eq a => a -> a -> Bool
/= ListNumberStyle
DefaultStyle
                   then if Bool
html5
                           then [AttributeValue -> Attribute
A.type_ (AttributeValue -> Attribute) -> AttributeValue -> Attribute
forall a b. (a -> b) -> a -> b
$
                                 case ListNumberStyle
numstyle of
                                      ListNumberStyle
Decimal    -> AttributeValue
"1"
                                      ListNumberStyle
LowerAlpha -> AttributeValue
"a"
                                      ListNumberStyle
UpperAlpha -> AttributeValue
"A"
                                      ListNumberStyle
LowerRoman -> AttributeValue
"i"
                                      ListNumberStyle
UpperRoman -> AttributeValue
"I"
                                      ListNumberStyle
_          -> AttributeValue
"1"]
                           else [AttributeValue -> Attribute
A.style (AttributeValue -> Attribute) -> AttributeValue -> Attribute
forall a b. (a -> b) -> a -> b
$ Text -> AttributeValue
forall a. ToValue a => a -> AttributeValue
toValue (Text -> AttributeValue) -> Text -> AttributeValue
forall a b. (a -> b) -> a -> b
$ Text
"list-style-type: " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
                                   Text
numstyle']
                   else [])
  Html
l <- WriterOptions -> [Html] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Html] -> StateT WriterState m Html
ordList WriterOptions
opts [Html]
contents
  Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ (Html -> Attribute -> Html) -> Html -> [Attribute] -> Html
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' (!) Html
l [Attribute]
attribs
blockToHtml WriterOptions
opts (DefinitionList [([Inline], [[Block]])]
lst) = do
  [Html]
contents <- (([Inline], [[Block]]) -> StateT WriterState m Html)
-> [([Inline], [[Block]])] -> StateT WriterState m [Html]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (\([Inline]
term, [[Block]]
defs) ->
                  do Html
term' <- (Html -> Html)
-> StateT WriterState m Html -> StateT WriterState m Html
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM Html -> Html
H.dt (StateT WriterState m Html -> StateT WriterState m Html)
-> StateT WriterState m Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ WriterOptions -> [Inline] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Inline] -> StateT WriterState m Html
inlineListToHtml WriterOptions
opts [Inline]
term
                     [Html]
defs' <- ([Block] -> StateT WriterState m Html)
-> [[Block]] -> StateT WriterState m [Html]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((Html -> Html)
-> StateT WriterState m Html -> StateT WriterState m Html
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (\Html
x -> Html -> Html
H.dd (Html
x Html -> Html -> Html
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> WriterOptions -> Html
nl WriterOptions
opts)) (StateT WriterState m Html -> StateT WriterState m Html)
-> ([Block] -> StateT WriterState m Html)
-> [Block]
-> StateT WriterState m Html
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
                                    WriterOptions -> [Block] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Block] -> StateT WriterState m Html
blockListToHtml WriterOptions
opts) [[Block]]
defs
                     Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ [Html] -> Html
forall a. Monoid a => [a] -> a
mconcat ([Html] -> Html) -> [Html] -> Html
forall a b. (a -> b) -> a -> b
$ WriterOptions -> Html
nl WriterOptions
opts Html -> [Html] -> [Html]
forall a. a -> [a] -> [a]
: Html
term' Html -> [Html] -> [Html]
forall a. a -> [a] -> [a]
: WriterOptions -> Html
nl WriterOptions
opts Html -> [Html] -> [Html]
forall a. a -> [a] -> [a]
:
                                        Html -> [Html] -> [Html]
forall a. a -> [a] -> [a]
intersperse (WriterOptions -> Html
nl WriterOptions
opts) [Html]
defs') [([Inline], [[Block]])]
lst
  WriterOptions -> [Html] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Html] -> StateT WriterState m Html
defList WriterOptions
opts [Html]
contents
blockToHtml WriterOptions
opts (Table Attr
attr Caption
caption [ColSpec]
colspecs TableHead
thead [TableBody]
tbody TableFoot
tfoot) =
  WriterOptions -> Table -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Table -> StateT WriterState m Html
tableToHtml WriterOptions
opts (Attr
-> Caption
-> [ColSpec]
-> TableHead
-> [TableBody]
-> TableFoot
-> Table
Ann.toTable Attr
attr Caption
caption [ColSpec]
colspecs TableHead
thead [TableBody]
tbody TableFoot
tfoot)

tableToHtml :: PandocMonad m
            => WriterOptions
            -> Ann.Table
            -> StateT WriterState m Html
tableToHtml :: WriterOptions -> Table -> StateT WriterState m Html
tableToHtml WriterOptions
opts (Ann.Table Attr
attr Caption
caption [ColSpec]
colspecs TableHead
thead [TableBody]
tbodies TableFoot
tfoot) = do
  Html
captionDoc <- case Caption
caption of
    Caption Maybe [Inline]
_ [] -> Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return Html
forall a. Monoid a => a
mempty
    Caption Maybe [Inline]
_ [Block]
longCapt -> do
      Html
cs <- WriterOptions -> [Block] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Block] -> StateT WriterState m Html
blockListToHtml WriterOptions
opts [Block]
longCapt
      Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ do
        Html -> Html
H.caption Html
cs
        WriterOptions -> Html
nl WriterOptions
opts
  Html
coltags <- WriterOptions -> [ColSpec] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [ColSpec] -> StateT WriterState m Html
colSpecListToHtml WriterOptions
opts [ColSpec]
colspecs
  Html
head' <- WriterOptions -> TableHead -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> TableHead -> StateT WriterState m Html
tableHeadToHtml WriterOptions
opts TableHead
thead
  [Html]
bodies <- Html -> [Html] -> [Html]
forall a. a -> [a] -> [a]
intersperse (WriterOptions -> Html
nl WriterOptions
opts) ([Html] -> [Html])
-> StateT WriterState m [Html] -> StateT WriterState m [Html]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (TableBody -> StateT WriterState m Html)
-> [TableBody] -> StateT WriterState m [Html]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (WriterOptions -> TableBody -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> TableBody -> StateT WriterState m Html
tableBodyToHtml WriterOptions
opts) [TableBody]
tbodies
  Html
foot' <- WriterOptions -> TableFoot -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> TableFoot -> StateT WriterState m Html
tableFootToHtml WriterOptions
opts TableFoot
tfoot
  let (Text
ident,[Text]
classes,[(Text, Text)]
kvs) = Attr
attr
  -- When widths of columns are < 100%, we need to set width for the whole
  -- table, or some browsers give us skinny columns with lots of space
  -- between:
  let colWidth :: ColWidth -> Double
colWidth = \case
        ColWidth Double
d -> Double
d
        ColWidth
ColWidthDefault -> Double
0
  let totalWidth :: Double
totalWidth = [Double] -> Double
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Double] -> Double)
-> ([ColSpec] -> [Double]) -> [ColSpec] -> Double
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ColSpec -> Double) -> [ColSpec] -> [Double]
forall a b. (a -> b) -> [a] -> [b]
map (ColWidth -> Double
colWidth (ColWidth -> Double) -> (ColSpec -> ColWidth) -> ColSpec -> Double
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ColSpec -> ColWidth
forall a b. (a, b) -> b
snd) ([ColSpec] -> Double) -> [ColSpec] -> Double
forall a b. (a -> b) -> a -> b
$ [ColSpec]
colspecs
  let attr' :: Attr
attr' = case Text -> [(Text, Text)] -> Maybe Text
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup Text
"style" [(Text, Text)]
kvs of
                Maybe Text
Nothing | Double
totalWidth Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
< Double
1 Bool -> Bool -> Bool
&& Double
totalWidth Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
> Double
0
                  -> (Text
ident,[Text]
classes, (Text
"style",Text
"width:" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
                         [Char] -> Text
T.pack (Int -> [Char]
forall a. Show a => a -> [Char]
show (Double -> Int
forall a b. (RealFrac a, Integral b) => a -> b
round (Double
totalWidth Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
100) :: Int))
                         Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"%;")(Text, Text) -> [(Text, Text)] -> [(Text, Text)]
forall a. a -> [a] -> [a]
:[(Text, Text)]
kvs)
                Maybe Text
_ -> Attr
attr
  WriterOptions -> Attr -> Html -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Attr -> Html -> StateT WriterState m Html
addAttrs WriterOptions
opts Attr
attr' (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ Html -> Html
H.table (Html -> Html) -> Html -> Html
forall a b. (a -> b) -> a -> b
$ do
    WriterOptions -> Html
nl WriterOptions
opts
    Html
captionDoc
    Html
coltags
    Html
head'
    [Html] -> Html
forall a. Monoid a => [a] -> a
mconcat [Html]
bodies
    Html
foot'
    WriterOptions -> Html
nl WriterOptions
opts

tableBodyToHtml :: PandocMonad m
                => WriterOptions
                -> Ann.TableBody
                -> StateT WriterState m Html
tableBodyToHtml :: WriterOptions -> TableBody -> StateT WriterState m Html
tableBodyToHtml WriterOptions
opts (Ann.TableBody Attr
attr RowHeadColumns
_rowHeadCols [HeaderRow]
inthead [BodyRow]
rows) =
  WriterOptions -> Attr -> Html -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Attr -> Html -> StateT WriterState m Html
addAttrs WriterOptions
opts Attr
attr (Html -> StateT WriterState m Html)
-> (Html -> Html) -> Html -> StateT WriterState m Html
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Html -> Html
H.tbody (Html -> StateT WriterState m Html)
-> StateT WriterState m Html -> StateT WriterState m Html
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< do
    Html
intermediateHead <-
      if [HeaderRow] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [HeaderRow]
inthead
      then Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return Html
forall a. Monoid a => a
mempty
      else WriterOptions
-> TablePart -> [HeaderRow] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions
-> TablePart -> [HeaderRow] -> StateT WriterState m Html
headerRowsToHtml WriterOptions
opts TablePart
Thead [HeaderRow]
inthead
    Html
bodyRows <- WriterOptions -> [BodyRow] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [BodyRow] -> StateT WriterState m Html
bodyRowsToHtml WriterOptions
opts [BodyRow]
rows
    Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ Html
intermediateHead Html -> Html -> Html
forall a. Semigroup a => a -> a -> a
<> Html
bodyRows

tableHeadToHtml :: PandocMonad m
                => WriterOptions
                -> Ann.TableHead
                -> StateT WriterState m Html
tableHeadToHtml :: WriterOptions -> TableHead -> StateT WriterState m Html
tableHeadToHtml WriterOptions
opts (Ann.TableHead Attr
attr [HeaderRow]
rows) =
  WriterOptions
-> TablePart -> Attr -> [HeaderRow] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions
-> TablePart -> Attr -> [HeaderRow] -> StateT WriterState m Html
tablePartToHtml WriterOptions
opts TablePart
Thead Attr
attr [HeaderRow]
rows

tableFootToHtml :: PandocMonad m
                => WriterOptions
                -> Ann.TableFoot
                -> StateT WriterState m Html
tableFootToHtml :: WriterOptions -> TableFoot -> StateT WriterState m Html
tableFootToHtml WriterOptions
opts (Ann.TableFoot Attr
attr [HeaderRow]
rows) =
  WriterOptions
-> TablePart -> Attr -> [HeaderRow] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions
-> TablePart -> Attr -> [HeaderRow] -> StateT WriterState m Html
tablePartToHtml WriterOptions
opts TablePart
Tfoot Attr
attr [HeaderRow]
rows

tablePartToHtml :: PandocMonad m
                => WriterOptions
                -> TablePart
                -> Attr
                -> [Ann.HeaderRow]
                -> StateT WriterState m Html
tablePartToHtml :: WriterOptions
-> TablePart -> Attr -> [HeaderRow] -> StateT WriterState m Html
tablePartToHtml WriterOptions
opts TablePart
tblpart Attr
attr [HeaderRow]
rows =
  if [HeaderRow] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [HeaderRow]
rows Bool -> Bool -> Bool
|| (HeaderRow -> Bool) -> [HeaderRow] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all HeaderRow -> Bool
isEmptyRow [HeaderRow]
rows
  then Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return Html
forall a. Monoid a => a
mempty
  else do
    let tag' :: Html -> Html
tag' = case TablePart
tblpart of
                 TablePart
Thead -> Html -> Html
H.thead
                 TablePart
Tfoot -> Html -> Html
H.tfoot
                 TablePart
Tbody -> Html -> Html
H.tbody -- this would be unexpected
    Html
contents <- WriterOptions
-> TablePart -> [HeaderRow] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions
-> TablePart -> [HeaderRow] -> StateT WriterState m Html
headerRowsToHtml WriterOptions
opts TablePart
tblpart [HeaderRow]
rows
    Html
tablePartElement <- WriterOptions -> Attr -> Html -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Attr -> Html -> StateT WriterState m Html
addAttrs WriterOptions
opts Attr
attr (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ Html -> Html
tag' Html
contents
    Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ do
      Html
tablePartElement
      WriterOptions -> Html
nl WriterOptions
opts
  where
    isEmptyRow :: HeaderRow -> Bool
isEmptyRow (Ann.HeaderRow Attr
_attr RowNumber
_rownum [Cell]
cells) = (Cell -> Bool) -> [Cell] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Cell -> Bool
isEmptyCell [Cell]
cells
    isEmptyCell :: Cell -> Bool
isEmptyCell (Ann.Cell NonEmpty ColSpec
_colspecs ColNumber
_colnum Cell
cell) =
      Cell
cell Cell -> Cell -> Bool
forall a. Eq a => a -> a -> Bool
== Attr -> Alignment -> RowSpan -> ColSpan -> [Block] -> Cell
Cell Attr
nullAttr Alignment
AlignDefault (Int -> RowSpan
RowSpan Int
1) (Int -> ColSpan
ColSpan Int
1) []

-- | The part of a table; header, footer, or body.
data TablePart = Thead | Tfoot | Tbody
  deriving (TablePart -> TablePart -> Bool
(TablePart -> TablePart -> Bool)
-> (TablePart -> TablePart -> Bool) -> Eq TablePart
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TablePart -> TablePart -> Bool
$c/= :: TablePart -> TablePart -> Bool
== :: TablePart -> TablePart -> Bool
$c== :: TablePart -> TablePart -> Bool
Eq)

data CellType = HeaderCell | BodyCell

data TableRow = TableRow TablePart Attr Ann.RowNumber Ann.RowHead Ann.RowBody

headerRowsToHtml :: PandocMonad m
                 => WriterOptions
                 -> TablePart
                 -> [Ann.HeaderRow]
                 -> StateT WriterState m Html
headerRowsToHtml :: WriterOptions
-> TablePart -> [HeaderRow] -> StateT WriterState m Html
headerRowsToHtml WriterOptions
opts TablePart
tablepart =
  WriterOptions -> [TableRow] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [TableRow] -> StateT WriterState m Html
rowListToHtml WriterOptions
opts ([TableRow] -> StateT WriterState m Html)
-> ([HeaderRow] -> [TableRow])
-> [HeaderRow]
-> StateT WriterState m Html
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (HeaderRow -> TableRow) -> [HeaderRow] -> [TableRow]
forall a b. (a -> b) -> [a] -> [b]
map HeaderRow -> TableRow
toTableRow
  where
    toTableRow :: HeaderRow -> TableRow
toTableRow (Ann.HeaderRow Attr
attr RowNumber
rownum [Cell]
rowbody) =
      TablePart -> Attr -> RowNumber -> [Cell] -> [Cell] -> TableRow
TableRow TablePart
tablepart Attr
attr RowNumber
rownum [] [Cell]
rowbody

bodyRowsToHtml :: PandocMonad m
               => WriterOptions
               -> [Ann.BodyRow]
               -> StateT WriterState m Html
bodyRowsToHtml :: WriterOptions -> [BodyRow] -> StateT WriterState m Html
bodyRowsToHtml WriterOptions
opts =
  WriterOptions -> [TableRow] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [TableRow] -> StateT WriterState m Html
rowListToHtml WriterOptions
opts ([TableRow] -> StateT WriterState m Html)
-> ([BodyRow] -> [TableRow])
-> [BodyRow]
-> StateT WriterState m Html
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (RowNumber -> BodyRow -> TableRow)
-> [RowNumber] -> [BodyRow] -> [TableRow]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith RowNumber -> BodyRow -> TableRow
toTableRow [RowNumber
1..]
  where
    toTableRow :: RowNumber -> BodyRow -> TableRow
toTableRow RowNumber
rownum (Ann.BodyRow Attr
attr RowNumber
_rownum [Cell]
rowhead [Cell]
rowbody) =
      TablePart -> Attr -> RowNumber -> [Cell] -> [Cell] -> TableRow
TableRow TablePart
Tbody Attr
attr RowNumber
rownum [Cell]
rowhead [Cell]
rowbody


rowListToHtml :: PandocMonad m
              => WriterOptions
              -> [TableRow]
              -> StateT WriterState m Html
rowListToHtml :: WriterOptions -> [TableRow] -> StateT WriterState m Html
rowListToHtml WriterOptions
opts [TableRow]
rows =
  (\[Html]
x -> WriterOptions -> Html
nl WriterOptions
opts Html -> Html -> Html
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> [Html] -> Html
forall a. Monoid a => [a] -> a
mconcat [Html]
x) ([Html] -> Html)
-> StateT WriterState m [Html] -> StateT WriterState m Html
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
     (TableRow -> StateT WriterState m Html)
-> [TableRow] -> StateT WriterState m [Html]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (WriterOptions -> TableRow -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> TableRow -> StateT WriterState m Html
tableRowToHtml WriterOptions
opts) [TableRow]
rows

colSpecListToHtml :: PandocMonad m
                  => WriterOptions
                  -> [ColSpec]
                  -> StateT WriterState m Html
colSpecListToHtml :: WriterOptions -> [ColSpec] -> StateT WriterState m Html
colSpecListToHtml WriterOptions
opts [ColSpec]
colspecs = do
  Bool
html5 <- (WriterState -> Bool) -> StateT WriterState m Bool
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets WriterState -> Bool
stHtml5
  let hasDefaultWidth :: (a, ColWidth) -> Bool
hasDefaultWidth (a
_, ColWidth
ColWidthDefault) = Bool
True
      hasDefaultWidth (a, ColWidth)
_                    = Bool
False

  let percent :: a -> [Char]
percent a
w = Integer -> [Char]
forall a. Show a => a -> [Char]
show (a -> Integer
forall a b. (RealFrac a, Integral b) => a -> b
truncate (a
100a -> a -> a
forall a. Num a => a -> a -> a
*a
w) :: Integer) [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> [Char]
"%"

  let col :: ColWidth -> Html
      col :: ColWidth -> Html
col ColWidth
cw = do
        Html
H.col Html -> Attribute -> Html
forall h. Attributable h => h -> Attribute -> h
! case ColWidth
cw of
          ColWidth
ColWidthDefault -> Attribute
forall a. Monoid a => a
mempty
          ColWidth Double
w -> if Bool
html5
                        then AttributeValue -> Attribute
A.style ([Char] -> AttributeValue
forall a. ToValue a => a -> AttributeValue
toValue ([Char] -> AttributeValue) -> [Char] -> AttributeValue
forall a b. (a -> b) -> a -> b
$ [Char]
"width: " [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> Double -> [Char]
forall a. RealFrac a => a -> [Char]
percent Double
w)
                        else AttributeValue -> Attribute
A.width ([Char] -> AttributeValue
forall a. ToValue a => a -> AttributeValue
toValue ([Char] -> AttributeValue) -> [Char] -> AttributeValue
forall a b. (a -> b) -> a -> b
$ Double -> [Char]
forall a. RealFrac a => a -> [Char]
percent Double
w)
        WriterOptions -> Html
nl WriterOptions
opts

  Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$
    if (ColSpec -> Bool) -> [ColSpec] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all ColSpec -> Bool
forall a. (a, ColWidth) -> Bool
hasDefaultWidth [ColSpec]
colspecs
    then Html
forall a. Monoid a => a
mempty
    else do
      Html -> Html
H.colgroup (Html -> Html) -> Html -> Html
forall a b. (a -> b) -> a -> b
$ do
        WriterOptions -> Html
nl WriterOptions
opts
        (ColSpec -> Html) -> [ColSpec] -> Html
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (ColWidth -> Html
col (ColWidth -> Html) -> (ColSpec -> ColWidth) -> ColSpec -> Html
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ColSpec -> ColWidth
forall a b. (a, b) -> b
snd) [ColSpec]
colspecs
      WriterOptions -> Html
nl WriterOptions
opts

tableRowToHtml :: PandocMonad m
               => WriterOptions
               -> TableRow
               -> StateT WriterState m Html
tableRowToHtml :: WriterOptions -> TableRow -> StateT WriterState m Html
tableRowToHtml WriterOptions
opts (TableRow TablePart
tblpart Attr
attr RowNumber
rownum [Cell]
rowhead [Cell]
rowbody) = do
  let rowclass :: Text
rowclass = case RowNumber
rownum of
        Ann.RowNumber Int
x | Int
x Int -> Int -> Int
forall a. Integral a => a -> a -> a
`rem` Int
2 Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1   -> Text
"odd"
        RowNumber
_               | TablePart
tblpart TablePart -> TablePart -> Bool
forall a. Eq a => a -> a -> Bool
/= TablePart
Thead -> Text
"even"
        RowNumber
_                                  -> Text
"header"
  let attr' :: Attr
attr' = case Attr
attr of
                (Text
id', [Text]
classes, [(Text, Text)]
rest) -> (Text
id', Text
rowclassText -> [Text] -> [Text]
forall a. a -> [a] -> [a]
:[Text]
classes, [(Text, Text)]
rest)
  let celltype :: CellType
celltype = case TablePart
tblpart of
                   TablePart
Thead -> CellType
HeaderCell
                   TablePart
_     -> CellType
BodyCell
  [Html]
headcells <- (Cell -> StateT WriterState m Html)
-> [Cell] -> StateT WriterState m [Html]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (WriterOptions -> CellType -> Cell -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> CellType -> Cell -> StateT WriterState m Html
cellToHtml WriterOptions
opts CellType
HeaderCell) [Cell]
rowhead
  [Html]
bodycells <- (Cell -> StateT WriterState m Html)
-> [Cell] -> StateT WriterState m [Html]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (WriterOptions -> CellType -> Cell -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> CellType -> Cell -> StateT WriterState m Html
cellToHtml WriterOptions
opts CellType
celltype) [Cell]
rowbody
  Html
rowHtml <- WriterOptions -> Attr -> Html -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Attr -> Html -> StateT WriterState m Html
addAttrs WriterOptions
opts Attr
attr' (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ Html -> Html
H.tr (Html -> Html) -> Html -> Html
forall a b. (a -> b) -> a -> b
$ do
    WriterOptions -> Html
nl WriterOptions
opts
    [Html] -> Html
forall a. Monoid a => [a] -> a
mconcat [Html]
headcells
    [Html] -> Html
forall a. Monoid a => [a] -> a
mconcat [Html]
bodycells
  Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ do
    Html
rowHtml
    WriterOptions -> Html
nl WriterOptions
opts

alignmentToString :: Alignment -> Maybe Text
alignmentToString :: Alignment -> Maybe Text
alignmentToString = \case
  Alignment
AlignLeft    -> Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"left"
  Alignment
AlignRight   -> Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"right"
  Alignment
AlignCenter  -> Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"center"
  Alignment
AlignDefault -> Maybe Text
forall a. Maybe a
Nothing

colspanAttrib :: ColSpan -> Attribute
colspanAttrib :: ColSpan -> Attribute
colspanAttrib = \case
  ColSpan Int
1 -> Attribute
forall a. Monoid a => a
mempty
  ColSpan Int
n -> AttributeValue -> Attribute
A.colspan (Int -> AttributeValue
forall a. ToValue a => a -> AttributeValue
toValue Int
n)

rowspanAttrib :: RowSpan -> Attribute
rowspanAttrib :: RowSpan -> Attribute
rowspanAttrib = \case
  RowSpan Int
1 -> Attribute
forall a. Monoid a => a
mempty
  RowSpan Int
n -> AttributeValue -> Attribute
A.rowspan (Int -> AttributeValue
forall a. ToValue a => a -> AttributeValue
toValue Int
n)

cellToHtml :: PandocMonad m
           => WriterOptions
           -> CellType
           -> Ann.Cell
           -> StateT WriterState m Html
cellToHtml :: WriterOptions -> CellType -> Cell -> StateT WriterState m Html
cellToHtml WriterOptions
opts CellType
celltype (Ann.Cell (ColSpec
colspec :| [ColSpec]
_) ColNumber
_colNum Cell
cell) =
  let align :: Alignment
align = ColSpec -> Alignment
forall a b. (a, b) -> a
fst ColSpec
colspec
  in WriterOptions
-> CellType -> Alignment -> Cell -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions
-> CellType -> Alignment -> Cell -> StateT WriterState m Html
tableCellToHtml WriterOptions
opts CellType
celltype Alignment
align Cell
cell

tableCellToHtml :: PandocMonad m
                => WriterOptions
                -> CellType
                -> Alignment
                -> Cell
                -> StateT WriterState m Html
tableCellToHtml :: WriterOptions
-> CellType -> Alignment -> Cell -> StateT WriterState m Html
tableCellToHtml WriterOptions
opts CellType
ctype Alignment
colAlign (Cell Attr
attr Alignment
align RowSpan
rowspan ColSpan
colspan [Block]
item) = do
  Html
contents <- WriterOptions -> [Block] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Block] -> StateT WriterState m Html
blockListToHtml WriterOptions
opts [Block]
item
  Bool
html5 <- (WriterState -> Bool) -> StateT WriterState m Bool
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets WriterState -> Bool
stHtml5
  let tag' :: Html -> Html
tag' = case CellType
ctype of
        CellType
BodyCell   -> Html -> Html
H.td
        CellType
HeaderCell -> Html -> Html
H.th
  let align' :: Alignment
align' = case Alignment
align of
        Alignment
AlignDefault -> Alignment
colAlign
        Alignment
_            -> Alignment
align
  let alignAttribs :: Attribute
alignAttribs = case Alignment -> Maybe Text
alignmentToString Alignment
align' of
        Maybe Text
Nothing ->
          Attribute
forall a. Monoid a => a
mempty
        Just Text
alignStr ->
          if Bool
html5
          then AttributeValue -> Attribute
A.style (Text -> AttributeValue
forall a. ToValue a => a -> AttributeValue
toValue (Text -> AttributeValue) -> Text -> AttributeValue
forall a b. (a -> b) -> a -> b
$ Text
"text-align: " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
alignStr Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
";")
          else AttributeValue -> Attribute
A.align (Text -> AttributeValue
forall a. ToValue a => a -> AttributeValue
toValue Text
alignStr)
  [Attribute]
otherAttribs <- WriterOptions -> Attr -> StateT WriterState m [Attribute]
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Attr -> StateT WriterState m [Attribute]
attrsToHtml WriterOptions
opts Attr
attr
  let attribs :: Attribute
attribs = [Attribute] -> Attribute
forall a. Monoid a => [a] -> a
mconcat
              ([Attribute] -> Attribute) -> [Attribute] -> Attribute
forall a b. (a -> b) -> a -> b
$ Attribute
alignAttribs
              Attribute -> [Attribute] -> [Attribute]
forall a. a -> [a] -> [a]
: ColSpan -> Attribute
colspanAttrib ColSpan
colspan
              Attribute -> [Attribute] -> [Attribute]
forall a. a -> [a] -> [a]
: RowSpan -> Attribute
rowspanAttrib RowSpan
rowspan
              Attribute -> [Attribute] -> [Attribute]
forall a. a -> [a] -> [a]
: [Attribute]
otherAttribs
  Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ do
    Html -> Html
tag' (Html -> Html) -> Attribute -> Html -> Html
forall h. Attributable h => h -> Attribute -> h
! Attribute
attribs (Html -> Html) -> Html -> Html
forall a b. (a -> b) -> a -> b
$ Html
contents
    WriterOptions -> Html
nl WriterOptions
opts

toListItems :: WriterOptions -> [Html] -> [Html]
toListItems :: WriterOptions -> [Html] -> [Html]
toListItems WriterOptions
opts [Html]
items = (Html -> Html) -> [Html] -> [Html]
forall a b. (a -> b) -> [a] -> [b]
map (WriterOptions -> Html -> Html
toListItem WriterOptions
opts) [Html]
items [Html] -> [Html] -> [Html]
forall a. [a] -> [a] -> [a]
++ [WriterOptions -> Html
nl WriterOptions
opts]

toListItem :: WriterOptions -> Html -> Html
toListItem :: WriterOptions -> Html -> Html
toListItem WriterOptions
opts Html
item = WriterOptions -> Html
nl WriterOptions
opts Html -> Html -> Html
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Html -> Html
H.li Html
item

blockListToHtml :: PandocMonad m
                => WriterOptions -> [Block] -> StateT WriterState m Html
blockListToHtml :: WriterOptions -> [Block] -> StateT WriterState m Html
blockListToHtml WriterOptions
opts [Block]
lst =
  [Html] -> Html
forall a. Monoid a => [a] -> a
mconcat ([Html] -> Html) -> ([Html] -> [Html]) -> [Html] -> Html
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Html -> [Html] -> [Html]
forall a. a -> [a] -> [a]
intersperse (WriterOptions -> Html
nl WriterOptions
opts) ([Html] -> [Html]) -> ([Html] -> [Html]) -> [Html] -> [Html]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Html -> Bool) -> [Html] -> [Html]
forall a. (a -> Bool) -> [a] -> [a]
filter Html -> Bool
forall a. MarkupM a -> Bool
nonempty
    ([Html] -> Html)
-> StateT WriterState m [Html] -> StateT WriterState m Html
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Block -> StateT WriterState m Html)
-> [Block] -> StateT WriterState m [Html]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (WriterOptions -> Block -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Block -> StateT WriterState m Html
blockToHtml WriterOptions
opts) [Block]
lst
  where nonempty :: MarkupM a -> Bool
nonempty (Empty a
_) = Bool
False
        nonempty MarkupM a
_         = Bool
True

-- | Convert list of Pandoc inline elements to HTML.
inlineListToHtml :: PandocMonad m => WriterOptions -> [Inline] -> StateT WriterState m Html
inlineListToHtml :: WriterOptions -> [Inline] -> StateT WriterState m Html
inlineListToHtml WriterOptions
opts [Inline]
lst = [Html] -> Html
forall a. Monoid a => [a] -> a
mconcat ([Html] -> Html)
-> StateT WriterState m [Html] -> StateT WriterState m Html
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Inline -> StateT WriterState m Html)
-> [Inline] -> StateT WriterState m [Html]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (WriterOptions -> Inline -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Inline -> StateT WriterState m Html
inlineToHtml WriterOptions
opts) [Inline]
lst

-- | Annotates a MathML expression with the tex source
annotateMML :: XML.Element -> Text -> XML.Element
annotateMML :: Element -> Text -> Element
annotateMML Element
e Text
tex = Element -> Element
math ([Char] -> [Element] -> Element
forall t. Node t => [Char] -> t -> Element
unode [Char]
"semantics" [Element
cs, [Char] -> ([Attr], [Char]) -> Element
forall t. Node t => [Char] -> t -> Element
unode [Char]
"annotation" ([Attr]
annotAttrs, Text -> [Char]
T.unpack Text
tex)])
  where
    cs :: Element
cs = case Element -> [Element]
elChildren Element
e of
          []  -> [Char] -> () -> Element
forall t. Node t => [Char] -> t -> Element
unode [Char]
"mrow" ()
          [Element
x] -> Element
x
          [Element]
xs  -> [Char] -> [Element] -> Element
forall t. Node t => [Char] -> t -> Element
unode [Char]
"mrow" [Element]
xs
    math :: Element -> Element
math Element
childs = QName -> [Attr] -> [Content] -> Maybe Integer -> Element
XML.Element QName
q [Attr]
as [Element -> Content
XML.Elem Element
childs] Maybe Integer
l
      where
        (XML.Element QName
q [Attr]
as [Content]
_ Maybe Integer
l) = Element
e
    annotAttrs :: [Attr]
annotAttrs = [QName -> [Char] -> Attr
XML.Attr ([Char] -> QName
unqual [Char]
"encoding") [Char]
"application/x-tex"]


-- | Convert Pandoc inline element to HTML.
inlineToHtml :: PandocMonad m
             => WriterOptions -> Inline -> StateT WriterState m Html
inlineToHtml :: WriterOptions -> Inline -> StateT WriterState m Html
inlineToHtml WriterOptions
opts Inline
inline = do
  Bool
html5 <- (WriterState -> Bool) -> StateT WriterState m Bool
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets WriterState -> Bool
stHtml5
  case Inline
inline of
    (Str Text
str)      -> Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ Text -> Html
strToHtml Text
str
    Inline
Space          -> Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ Text -> Html
strToHtml Text
" "
    Inline
SoftBreak      -> Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ case WriterOptions -> WrapOption
writerWrapText WriterOptions
opts of
                                     WrapOption
WrapNone     -> Text -> Html
preEscapedText Text
" "
                                     WrapOption
WrapAuto     -> Text -> Html
preEscapedText Text
" "
                                     WrapOption
WrapPreserve -> Text -> Html
preEscapedText Text
"\n"
    Inline
LineBreak      -> Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ do
                        if Bool
html5 then Html
H5.br else Html
H.br
                        Text -> Html
strToHtml Text
"\n"
    (Span (Text
"",[Text
cls],[]) [Inline]
ils)
        | Text
cls Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"csl-block" Bool -> Bool -> Bool
|| Text
cls Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"csl-left-margin" Bool -> Bool -> Bool
||
          Text
cls Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"csl-right-inline" Bool -> Bool -> Bool
|| Text
cls Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
"csl-indent"
        -> WriterOptions -> [Inline] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Inline] -> StateT WriterState m Html
inlineListToHtml WriterOptions
opts [Inline]
ils StateT WriterState m Html
-> (Html -> StateT WriterState m Html) -> StateT WriterState m Html
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Text -> Html -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
Text -> Html -> StateT WriterState m Html
inDiv Text
cls

    (Span (Text
id',[Text]
classes,[(Text, Text)]
kvs) [Inline]
ils) ->
                        let spanLikeTag :: Maybe (Html -> Html)
spanLikeTag = case [Text]
classes of
                                (Text
c:[Text]
_) -> do
                                  Bool -> Maybe ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Text
c Text -> Set Text -> Bool
forall a. Ord a => a -> Set a -> Bool
`Set.member` Set Text
htmlSpanLikeElements)
                                  (Html -> Html) -> Maybe (Html -> Html)
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Html -> Html) -> Maybe (Html -> Html))
-> (Html -> Html) -> Maybe (Html -> Html)
forall a b. (a -> b) -> a -> b
$ Tag -> Html -> Html
customParent (Text -> Tag
textTag Text
c)
                                [Text]
_   -> Maybe (Html -> Html)
forall a. Maybe a
Nothing
                        in case Maybe (Html -> Html)
spanLikeTag of
                            Just Html -> Html
tag -> do
                              Html
h <- WriterOptions -> [Inline] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Inline] -> StateT WriterState m Html
inlineListToHtml WriterOptions
opts [Inline]
ils
                              WriterOptions -> Attr -> Html -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Attr -> Html -> StateT WriterState m Html
addAttrs WriterOptions
opts (Text
id',[Text] -> [Text]
forall a. [a] -> [a]
tail [Text]
classes',[(Text, Text)]
kvs') (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ Html -> Html
tag Html
h
                            Maybe (Html -> Html)
Nothing -> do
                              Html
h <- WriterOptions -> [Inline] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Inline] -> StateT WriterState m Html
inlineListToHtml WriterOptions
opts [Inline]
ils
                              WriterOptions -> Attr -> Html -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Attr -> Html -> StateT WriterState m Html
addAttrs WriterOptions
opts (Text
id',[Text]
classes',[(Text, Text)]
kvs') (Html -> Html
H.span Html
h)
                            where
                              styles :: [Text]
styles = [Text
"font-style:normal;"
                                       | Text
"csl-no-emph" Text -> [Text] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Text]
classes]
                                    [Text] -> [Text] -> [Text]
forall a. [a] -> [a] -> [a]
++ [Text
"font-weight:normal;"
                                       | Text
"csl-no-strong" Text -> [Text] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Text]
classes]
                                    [Text] -> [Text] -> [Text]
forall a. [a] -> [a] -> [a]
++ [Text
"font-variant:normal;"
                                       | Text
"csl-no-smallcaps" Text -> [Text] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Text]
classes]
                              kvs' :: [(Text, Text)]
kvs' = if [Text] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Text]
styles
                                        then [(Text, Text)]
kvs
                                        else (Text
"style", [Text] -> Text
T.concat [Text]
styles) (Text, Text) -> [(Text, Text)] -> [(Text, Text)]
forall a. a -> [a] -> [a]
: [(Text, Text)]
kvs
                              classes' :: [Text]
classes' = [ Text
c | Text
c <- [Text]
classes
                                         , Text
c Text -> [Text] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` [ Text
"csl-no-emph"
                                                       , Text
"csl-no-strong"
                                                       , Text
"csl-no-smallcaps"
                                                       ]
                                         ]

    (Emph [Inline]
lst)       -> Html -> Html
H.em (Html -> Html)
-> StateT WriterState m Html -> StateT WriterState m Html
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> WriterOptions -> [Inline] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Inline] -> StateT WriterState m Html
inlineListToHtml WriterOptions
opts [Inline]
lst
    (Underline [Inline]
lst)  -> Html -> Html
H.u (Html -> Html)
-> StateT WriterState m Html -> StateT WriterState m Html
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> WriterOptions -> [Inline] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Inline] -> StateT WriterState m Html
inlineListToHtml WriterOptions
opts [Inline]
lst
    (Strong [Inline]
lst)     -> Html -> Html
H.strong (Html -> Html)
-> StateT WriterState m Html -> StateT WriterState m Html
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> WriterOptions -> [Inline] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Inline] -> StateT WriterState m Html
inlineListToHtml WriterOptions
opts [Inline]
lst
    (Code attr :: Attr
attr@(Text
ids,[Text]
cs,[(Text, Text)]
kvs) Text
str)
                     -> case Either Text Html
hlCode of
                             Left Text
msg -> do
                               Bool -> StateT WriterState m () -> StateT WriterState m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (Text -> Bool
T.null Text
msg) (StateT WriterState m () -> StateT WriterState m ())
-> StateT WriterState m () -> StateT WriterState m ()
forall a b. (a -> b) -> a -> b
$
                                 LogMessage -> StateT WriterState m ()
forall (m :: * -> *). PandocMonad m => LogMessage -> m ()
report (LogMessage -> StateT WriterState m ())
-> LogMessage -> StateT WriterState m ()
forall a b. (a -> b) -> a -> b
$ Text -> LogMessage
CouldNotHighlight Text
msg
                               WriterOptions -> Attr -> Html -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Attr -> Html -> StateT WriterState m Html
addAttrs WriterOptions
opts (Text
ids,[Text]
cs',[(Text, Text)]
kvs) (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$
                                 (Html -> Html) -> Maybe (Html -> Html) -> Html -> Html
forall a. a -> Maybe a -> a
fromMaybe Html -> Html
H.code Maybe (Html -> Html)
sampOrVar (Html -> Html) -> Html -> Html
forall a b. (a -> b) -> a -> b
$
                                 Text -> Html
strToHtml Text
str
                             Right Html
h -> do
                               (WriterState -> WriterState) -> StateT WriterState m ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((WriterState -> WriterState) -> StateT WriterState m ())
-> (WriterState -> WriterState) -> StateT WriterState m ()
forall a b. (a -> b) -> a -> b
$ \WriterState
st -> WriterState
st{ stHighlighting :: Bool
stHighlighting = Bool
True }
                               WriterOptions -> Attr -> Html -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Attr -> Html -> StateT WriterState m Html
addAttrs WriterOptions
opts (Text
ids,[],[(Text, Text)]
kvs) (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$
                                 (Html -> Html) -> Maybe (Html -> Html) -> Html -> Html
forall a. a -> Maybe a -> a
fromMaybe Html -> Html
forall a. a -> a
id Maybe (Html -> Html)
sampOrVar Html
h
                        where hlCode :: Either Text Html
hlCode = if Maybe Style -> Bool
forall a. Maybe a -> Bool
isJust (WriterOptions -> Maybe Style
writerHighlightStyle WriterOptions
opts)
                                          then SyntaxMap
-> (FormatOptions -> [SourceLine] -> Html)
-> Attr
-> Text
-> Either Text Html
forall a.
SyntaxMap
-> (FormatOptions -> [SourceLine] -> a)
-> Attr
-> Text
-> Either Text a
highlight
                                                 (WriterOptions -> SyntaxMap
writerSyntaxMap WriterOptions
opts)
                                                 FormatOptions -> [SourceLine] -> Html
formatHtmlInline Attr
attr Text
str
                                          else Text -> Either Text Html
forall a b. a -> Either a b
Left Text
""
                              (Maybe (Html -> Html)
sampOrVar,[Text]
cs')
                                | Text
"sample" Text -> [Text] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Text]
cs =
                                      ((Html -> Html) -> Maybe (Html -> Html)
forall a. a -> Maybe a
Just Html -> Html
H.samp,Text
"sample" Text -> [Text] -> [Text]
forall a. Eq a => a -> [a] -> [a]
`delete` [Text]
cs)
                                | Text
"variable" Text -> [Text] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Text]
cs =
                                      ((Html -> Html) -> Maybe (Html -> Html)
forall a. a -> Maybe a
Just Html -> Html
H.var,Text
"variable" Text -> [Text] -> [Text]
forall a. Eq a => a -> [a] -> [a]
`delete` [Text]
cs)
                                | Bool
otherwise = (Maybe (Html -> Html)
forall a. Maybe a
Nothing,[Text]
cs)
    (Strikeout [Inline]
lst)  -> Html -> Html
H.del (Html -> Html)
-> StateT WriterState m Html -> StateT WriterState m Html
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> WriterOptions -> [Inline] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Inline] -> StateT WriterState m Html
inlineListToHtml WriterOptions
opts [Inline]
lst
    (SmallCaps [Inline]
lst)   -> (Html -> Html
H.span (Html -> Html) -> Attribute -> Html -> Html
forall h. Attributable h => h -> Attribute -> h
! AttributeValue -> Attribute
A.class_ AttributeValue
"smallcaps") (Html -> Html)
-> StateT WriterState m Html -> StateT WriterState m Html
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                           WriterOptions -> [Inline] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Inline] -> StateT WriterState m Html
inlineListToHtml WriterOptions
opts [Inline]
lst
    (Superscript [Inline]
lst) -> Html -> Html
H.sup (Html -> Html)
-> StateT WriterState m Html -> StateT WriterState m Html
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> WriterOptions -> [Inline] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Inline] -> StateT WriterState m Html
inlineListToHtml WriterOptions
opts [Inline]
lst
    (Subscript [Inline]
lst)   -> Html -> Html
H.sub (Html -> Html)
-> StateT WriterState m Html -> StateT WriterState m Html
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> WriterOptions -> [Inline] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Inline] -> StateT WriterState m Html
inlineListToHtml WriterOptions
opts [Inline]
lst
    (Quoted QuoteType
quoteType [Inline]
lst) ->
                        let (Html
leftQuote, Html
rightQuote) = case QuoteType
quoteType of
                              QuoteType
SingleQuote -> (Text -> Html
strToHtml Text
"‘",
                                              Text -> Html
strToHtml Text
"’")
                              QuoteType
DoubleQuote -> (Text -> Html
strToHtml Text
"“",
                                              Text -> Html
strToHtml Text
"”")

                        in if WriterOptions -> Bool
writerHtmlQTags WriterOptions
opts
                               then do
                                 (WriterState -> WriterState) -> StateT WriterState m ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((WriterState -> WriterState) -> StateT WriterState m ())
-> (WriterState -> WriterState) -> StateT WriterState m ()
forall a b. (a -> b) -> a -> b
$ \WriterState
st -> WriterState
st{ stQuotes :: Bool
stQuotes = Bool
True }
                                 let (Maybe Attr
maybeAttr, [Inline]
lst') = case [Inline]
lst of
                                      [Span attr :: Attr
attr@(Text
_, [Text]
_, [(Text, Text)]
kvs) [Inline]
cs]
                                        | ((Text, Text) -> Bool) -> [(Text, Text)] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any ((Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
==Text
"cite") (Text -> Bool) -> ((Text, Text) -> Text) -> (Text, Text) -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Text, Text) -> Text
forall a b. (a, b) -> a
fst) [(Text, Text)]
kvs
                                          -> (Attr -> Maybe Attr
forall a. a -> Maybe a
Just Attr
attr, [Inline]
cs)
                                      [Inline]
cs -> (Maybe Attr
forall a. Maybe a
Nothing, [Inline]
cs)
                                 let addAttrsMb :: Maybe Attr -> Html -> StateT WriterState m Html
addAttrsMb = (Html -> StateT WriterState m Html)
-> (Attr -> Html -> StateT WriterState m Html)
-> Maybe Attr
-> Html
-> StateT WriterState m Html
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return (WriterOptions -> Attr -> Html -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Attr -> Html -> StateT WriterState m Html
addAttrs WriterOptions
opts)
                                 WriterOptions -> [Inline] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Inline] -> StateT WriterState m Html
inlineListToHtml WriterOptions
opts [Inline]
lst' StateT WriterState m Html
-> (Html -> StateT WriterState m Html) -> StateT WriterState m Html
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>=
                                   Maybe Attr -> Html -> StateT WriterState m Html
addAttrsMb Maybe Attr
maybeAttr (Html -> StateT WriterState m Html)
-> (Html -> Html) -> Html -> StateT WriterState m Html
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Html -> Html
H.q
                               else (\Html
x -> Html
leftQuote Html -> Html -> Html
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Html
x Html -> Html -> Html
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Html
rightQuote)
                                    (Html -> Html)
-> StateT WriterState m Html -> StateT WriterState m Html
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` WriterOptions -> [Inline] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Inline] -> StateT WriterState m Html
inlineListToHtml WriterOptions
opts [Inline]
lst
    (Math MathType
t Text
str) -> do
      (WriterState -> WriterState) -> StateT WriterState m ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (\WriterState
st -> WriterState
st {stMath :: Bool
stMath = Bool
True})
      let mathClass :: AttributeValue
mathClass = Text -> AttributeValue
forall a. ToValue a => a -> AttributeValue
toValue (Text -> AttributeValue) -> Text -> AttributeValue
forall a b. (a -> b) -> a -> b
$ (Text
"math " :: Text) Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
                      if MathType
t MathType -> MathType -> Bool
forall a. Eq a => a -> a -> Bool
== MathType
InlineMath then Text
"inline" else Text
"display"
      case WriterOptions -> HTMLMathMethod
writerHTMLMathMethod WriterOptions
opts of
           WebTeX Text
url -> do
              let imtag :: Html
imtag = if Bool
html5 then Html
H5.img else Html
H.img
              let s :: Text
s = case MathType
t of
                           MathType
InlineMath  -> Text
"\\textstyle "
                           MathType
DisplayMath -> Text
"\\displaystyle "
              Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ Html
imtag Html -> Attribute -> Html
forall h. Attributable h => h -> Attribute -> h
! AttributeValue -> Attribute
A.style AttributeValue
"vertical-align:middle"
                             Html -> Attribute -> Html
forall h. Attributable h => h -> Attribute -> h
! AttributeValue -> Attribute
A.src (Text -> AttributeValue
forall a. ToValue a => a -> AttributeValue
toValue (Text -> AttributeValue) -> Text -> AttributeValue
forall a b. (a -> b) -> a -> b
$ Text
url Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> [Char] -> Text
T.pack ([Char] -> [Char]
urlEncode (Text -> [Char]
T.unpack (Text -> [Char]) -> Text -> [Char]
forall a b. (a -> b) -> a -> b
$ Text
s Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
str)))
                             Html -> Attribute -> Html
forall h. Attributable h => h -> Attribute -> h
! AttributeValue -> Attribute
A.alt (Text -> AttributeValue
forall a. ToValue a => a -> AttributeValue
toValue Text
str)
                             Html -> Attribute -> Html
forall h. Attributable h => h -> Attribute -> h
! AttributeValue -> Attribute
A.title (Text -> AttributeValue
forall a. ToValue a => a -> AttributeValue
toValue Text
str)
                             Html -> Attribute -> Html
forall h. Attributable h => h -> Attribute -> h
! AttributeValue -> Attribute
A.class_ AttributeValue
mathClass
           HTMLMathMethod
GladTeX ->
              Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$
                Tag -> Html -> Html
customParent (Text -> Tag
textTag Text
"eq") (Html -> Html) -> Attribute -> Html -> Html
forall h. Attributable h => h -> Attribute -> h
!
                  Tag -> AttributeValue -> Attribute
customAttribute Tag
"env"
                    (Text -> AttributeValue
forall a. ToValue a => a -> AttributeValue
toValue (Text -> AttributeValue) -> Text -> AttributeValue
forall a b. (a -> b) -> a -> b
$ if MathType
t MathType -> MathType -> Bool
forall a. Eq a => a -> a -> Bool
== MathType
InlineMath
                                  then (Text
"math" :: Text)
                                  else Text
"displaymath") (Html -> Html) -> Html -> Html
forall a b. (a -> b) -> a -> b
$ Text -> Html
strToHtml Text
str
           HTMLMathMethod
MathML -> do
              let conf :: ConfigPP
conf = (QName -> Bool) -> ConfigPP -> ConfigPP
useShortEmptyTags (Bool -> QName -> Bool
forall a b. a -> b -> a
const Bool
False)
                           ConfigPP
defaultConfigPP
              Either Inline Element
res <- m (Either Inline Element)
-> StateT WriterState m (Either Inline Element)
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m (Either Inline Element)
 -> StateT WriterState m (Either Inline Element))
-> m (Either Inline Element)
-> StateT WriterState m (Either Inline Element)
forall a b. (a -> b) -> a -> b
$ (DisplayType -> [Exp] -> Element)
-> MathType -> Text -> m (Either Inline Element)
forall (m :: * -> *) a.
PandocMonad m =>
(DisplayType -> [Exp] -> a)
-> MathType -> Text -> m (Either Inline a)
convertMath DisplayType -> [Exp] -> Element
writeMathML MathType
t Text
str
              case Either Inline Element
res of
                    Right Element
r  -> Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ [Char] -> Html
preEscapedString ([Char] -> Html) -> [Char] -> Html
forall a b. (a -> b) -> a -> b
$
                        ConfigPP -> Element -> [Char]
ppcElement ConfigPP
conf (Element -> Text -> Element
annotateMML Element
r Text
str)
                    Left Inline
il  -> (Html -> Html
H.span (Html -> Html) -> Attribute -> Html -> Html
forall h. Attributable h => h -> Attribute -> h
! AttributeValue -> Attribute
A.class_ AttributeValue
mathClass) (Html -> Html)
-> StateT WriterState m Html -> StateT WriterState m Html
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                                   WriterOptions -> Inline -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Inline -> StateT WriterState m Html
inlineToHtml WriterOptions
opts Inline
il
           MathJax Text
_ -> Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ Html -> Html
H.span (Html -> Html) -> Attribute -> Html -> Html
forall h. Attributable h => h -> Attribute -> h
! AttributeValue -> Attribute
A.class_ AttributeValue
mathClass (Html -> Html) -> Html -> Html
forall a b. (a -> b) -> a -> b
$ Text -> Html
forall a. ToMarkup a => a -> Html
toHtml (Text -> Html) -> Text -> Html
forall a b. (a -> b) -> a -> b
$
              case MathType
t of
                MathType
InlineMath  -> Text
"\\(" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
str Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"\\)"
                MathType
DisplayMath -> Text
"\\[" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
str Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"\\]"
           KaTeX Text
_ -> Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ Html -> Html
H.span (Html -> Html) -> Attribute -> Html -> Html
forall h. Attributable h => h -> Attribute -> h
! AttributeValue -> Attribute
A.class_ AttributeValue
mathClass (Html -> Html) -> Html -> Html
forall a b. (a -> b) -> a -> b
$ Text -> Html
forall a. ToMarkup a => a -> Html
toHtml (Text -> Html) -> Text -> Html
forall a b. (a -> b) -> a -> b
$
              case MathType
t of
                MathType
InlineMath  -> Text
str
                MathType
DisplayMath -> Text
str
           HTMLMathMethod
PlainMath -> do
              Html
x <- m [Inline] -> StateT WriterState m [Inline]
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (MathType -> Text -> m [Inline]
forall (m :: * -> *).
PandocMonad m =>
MathType -> Text -> m [Inline]
texMathToInlines MathType
t Text
str) StateT WriterState m [Inline]
-> ([Inline] -> StateT WriterState m Html)
-> StateT WriterState m Html
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= WriterOptions -> [Inline] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Inline] -> StateT WriterState m Html
inlineListToHtml WriterOptions
opts
              Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ Html -> Html
H.span (Html -> Html) -> Attribute -> Html -> Html
forall h. Attributable h => h -> Attribute -> h
! AttributeValue -> Attribute
A.class_ AttributeValue
mathClass (Html -> Html) -> Html -> Html
forall a b. (a -> b) -> a -> b
$ Html
x
    (RawInline Format
f Text
str) -> do
      Bool
ishtml <- Format -> StateT WriterState m Bool
forall (m :: * -> *).
PandocMonad m =>
Format -> StateT WriterState m Bool
isRawHtml Format
f
      if Bool
ishtml
         then Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ Text -> Html
preEscapedText Text
str
         else if (Format
f Format -> Format -> Bool
forall a. Eq a => a -> a -> Bool
== Text -> Format
Format Text
"latex" Bool -> Bool -> Bool
|| Format
f Format -> Format -> Bool
forall a. Eq a => a -> a -> Bool
== Text -> Format
Format Text
"tex") Bool -> Bool -> Bool
&&
                HTMLMathMethod -> Bool
allowsMathEnvironments (WriterOptions -> HTMLMathMethod
writerHTMLMathMethod WriterOptions
opts) Bool -> Bool -> Bool
&&
                Text -> Bool
isMathEnvironment Text
str
                then WriterOptions -> Inline -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Inline -> StateT WriterState m Html
inlineToHtml WriterOptions
opts (Inline -> StateT WriterState m Html)
-> Inline -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ MathType -> Text -> Inline
Math MathType
DisplayMath Text
str
                else do
                  LogMessage -> StateT WriterState m ()
forall (m :: * -> *). PandocMonad m => LogMessage -> m ()
report (LogMessage -> StateT WriterState m ())
-> LogMessage -> StateT WriterState m ()
forall a b. (a -> b) -> a -> b
$ Inline -> LogMessage
InlineNotRendered Inline
inline
                  Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return Html
forall a. Monoid a => a
mempty
    (Link Attr
attr [Inline]
txt (Text
s,Text
_)) | Text
"mailto:" Text -> Text -> Bool
`T.isPrefixOf` Text
s -> do
                        Html
linkText <- WriterOptions -> [Inline] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Inline] -> StateT WriterState m Html
inlineListToHtml WriterOptions
opts [Inline]
txt
                        WriterOptions -> Attr -> Html -> Text -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Attr -> Html -> Text -> StateT WriterState m Html
obfuscateLink WriterOptions
opts Attr
attr Html
linkText Text
s
    (Link (Text
ident,[Text]
classes,[(Text, Text)]
kvs) [Inline]
txt (Text
s,Text
tit)) -> do
                        Html
linkText <- WriterOptions -> [Inline] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Inline] -> StateT WriterState m Html
inlineListToHtml WriterOptions
opts [Inline]
txt
                        HTMLSlideVariant
slideVariant <- (WriterState -> HTMLSlideVariant)
-> StateT WriterState m HTMLSlideVariant
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets WriterState -> HTMLSlideVariant
stSlideVariant
                        let s' :: Text
s' = case Text -> Maybe (Char, Text)
T.uncons Text
s of
                                   Just (Char
'#',Text
xs) -> let prefix :: Text
prefix = if HTMLSlideVariant
slideVariant HTMLSlideVariant -> HTMLSlideVariant -> Bool
forall a. Eq a => a -> a -> Bool
== HTMLSlideVariant
RevealJsSlides
                                                             then Text
"/"
                                                             else WriterOptions -> Text
writerIdentifierPrefix WriterOptions
opts
                                             in  Text
"#" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
prefix Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
xs
                                   Maybe (Char, Text)
_ -> Text
s
                        let link :: Html
link = Html -> Html
H.a (Html -> Html) -> Attribute -> Html -> Html
forall h. Attributable h => h -> Attribute -> h
! AttributeValue -> Attribute
A.href (Text -> AttributeValue
forall a. ToValue a => a -> AttributeValue
toValue Text
s') (Html -> Html) -> Html -> Html
forall a b. (a -> b) -> a -> b
$ Html
linkText
                        Html
link' <- WriterOptions -> Attr -> Html -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Attr -> Html -> StateT WriterState m Html
addAttrs WriterOptions
opts (Text
ident, [Text]
classes, [(Text, Text)]
kvs) Html
link
                        Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ if Text -> Bool
T.null Text
tit
                                    then Html
link'
                                    else Html
link' Html -> Attribute -> Html
forall h. Attributable h => h -> Attribute -> h
! AttributeValue -> Attribute
A.title (Text -> AttributeValue
forall a. ToValue a => a -> AttributeValue
toValue Text
tit)
    (Image Attr
attr [Inline]
txt (Text
s,Text
tit)) -> do
                        let alternate :: Text
alternate = [Inline] -> Text
forall a. Walkable Inline a => a -> Text
stringify [Inline]
txt
                        HTMLSlideVariant
slideVariant <- (WriterState -> HTMLSlideVariant)
-> StateT WriterState m HTMLSlideVariant
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets WriterState -> HTMLSlideVariant
stSlideVariant
                        let isReveal :: Bool
isReveal = HTMLSlideVariant
slideVariant HTMLSlideVariant -> HTMLSlideVariant -> Bool
forall a. Eq a => a -> a -> Bool
== HTMLSlideVariant
RevealJsSlides
                        [Attribute]
attrs <- WriterOptions -> Attr -> StateT WriterState m [Attribute]
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Attr -> StateT WriterState m [Attribute]
imgAttrsToHtml WriterOptions
opts Attr
attr
                        let attributes :: [Attribute]
attributes =
                              -- reveal.js uses data-src for lazy loading
                              (if Bool
isReveal
                                  then Tag -> AttributeValue -> Attribute
customAttribute Tag
"data-src" (AttributeValue -> Attribute) -> AttributeValue -> Attribute
forall a b. (a -> b) -> a -> b
$ Text -> AttributeValue
forall a. ToValue a => a -> AttributeValue
toValue Text
s
                                  else AttributeValue -> Attribute
A.src (AttributeValue -> Attribute) -> AttributeValue -> Attribute
forall a b. (a -> b) -> a -> b
$ Text -> AttributeValue
forall a. ToValue a => a -> AttributeValue
toValue Text
s) Attribute -> [Attribute] -> [Attribute]
forall a. a -> [a] -> [a]
:
                              [AttributeValue -> Attribute
A.title (AttributeValue -> Attribute) -> AttributeValue -> Attribute
forall a b. (a -> b) -> a -> b
$ Text -> AttributeValue
forall a. ToValue a => a -> AttributeValue
toValue Text
tit | Bool -> Bool
not (Text -> Bool
T.null Text
tit)] [Attribute] -> [Attribute] -> [Attribute]
forall a. [a] -> [a] -> [a]
++
                              [Attribute]
attrs
                            imageTag :: (Html, [Attribute])
imageTag = (if Bool
html5 then Html
H5.img else Html
H.img
                              , [AttributeValue -> Attribute
A.alt (AttributeValue -> Attribute) -> AttributeValue -> Attribute
forall a b. (a -> b) -> a -> b
$ Text -> AttributeValue
forall a. ToValue a => a -> AttributeValue
toValue Text
alternate | Bool -> Bool
not ([Inline] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Inline]
txt)] )
                            mediaTag :: (Html -> a) -> Text -> (a, [Attribute])
mediaTag Html -> a
tg Text
fallbackTxt =
                              let linkTxt :: Text
linkTxt = if [Inline] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Inline]
txt
                                            then Text
fallbackTxt
                                            else Text
alternate
                              in (Html -> a
tg (Html -> a) -> Html -> a
forall a b. (a -> b) -> a -> b
$ Html -> Html
H.a (Html -> Html) -> Attribute -> Html -> Html
forall h. Attributable h => h -> Attribute -> h
! AttributeValue -> Attribute
A.href (Text -> AttributeValue
forall a. ToValue a => a -> AttributeValue
toValue Text
s) (Html -> Html) -> Html -> Html
forall a b. (a -> b) -> a -> b
$ Text -> Html
forall a. ToMarkup a => a -> Html
toHtml Text
linkTxt
                                 , [AttributeValue -> Attribute
A5.controls AttributeValue
""] )
                            normSrc :: [Char]
normSrc = [Char] -> (URI -> [Char]) -> Maybe URI -> [Char]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Text -> [Char]
T.unpack Text
s) URI -> [Char]
uriPath ([Char] -> Maybe URI
parseURIReference ([Char] -> Maybe URI) -> [Char] -> Maybe URI
forall a b. (a -> b) -> a -> b
$ Text -> [Char]
T.unpack Text
s)
                            (Html
tag, [Attribute]
specAttrs) = case [Char] -> Maybe Text
mediaCategory [Char]
normSrc of
                              Just Text
"image" -> (Html, [Attribute])
imageTag
                              Just Text
"video" -> (Html -> Html) -> Text -> (Html, [Attribute])
forall a. (Html -> a) -> Text -> (a, [Attribute])
mediaTag Html -> Html
H5.video Text
"Video"
                              Just Text
"audio" -> (Html -> Html) -> Text -> (Html, [Attribute])
forall a. (Html -> a) -> Text -> (a, [Attribute])
mediaTag Html -> Html
H5.audio Text
"Audio"
                              Just Text
_       -> (Html
H5.embed, [])
                              Maybe Text
_            -> (Html, [Attribute])
imageTag
                        Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ (Html -> Attribute -> Html) -> Html -> [Attribute] -> Html
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' (!) Html
tag ([Attribute] -> Html) -> [Attribute] -> Html
forall a b. (a -> b) -> a -> b
$ [Attribute]
attributes [Attribute] -> [Attribute] -> [Attribute]
forall a. [a] -> [a] -> [a]
++ [Attribute]
specAttrs
                        -- note:  null title included, as in Markdown.pl
    (Note [Block]
contents) -> do
                        [Html]
notes <- (WriterState -> [Html]) -> StateT WriterState m [Html]
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets WriterState -> [Html]
stNotes
                        let number :: Int
number = [Html] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Html]
notes Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1
                        let ref :: Text
ref = Int -> Text
forall a. Show a => a -> Text
tshow Int
number
                        Html
htmlContents <- WriterOptions -> Text -> [Block] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> Text -> [Block] -> StateT WriterState m Html
blockListToNote WriterOptions
opts Text
ref [Block]
contents
                        Maybe EPUBVersion
epubVersion <- (WriterState -> Maybe EPUBVersion)
-> StateT WriterState m (Maybe EPUBVersion)
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets WriterState -> Maybe EPUBVersion
stEPUBVersion
                        -- push contents onto front of notes
                        (WriterState -> WriterState) -> StateT WriterState m ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((WriterState -> WriterState) -> StateT WriterState m ())
-> (WriterState -> WriterState) -> StateT WriterState m ()
forall a b. (a -> b) -> a -> b
$ \WriterState
st -> WriterState
st {stNotes :: [Html]
stNotes = Html
htmlContentsHtml -> [Html] -> [Html]
forall a. a -> [a] -> [a]
:[Html]
notes}
                        HTMLSlideVariant
slideVariant <- (WriterState -> HTMLSlideVariant)
-> StateT WriterState m HTMLSlideVariant
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets WriterState -> HTMLSlideVariant
stSlideVariant
                        let revealSlash :: Text
revealSlash = [Char] -> Text
T.pack [Char
'/' | HTMLSlideVariant
slideVariant HTMLSlideVariant -> HTMLSlideVariant -> Bool
forall a. Eq a => a -> a -> Bool
== HTMLSlideVariant
RevealJsSlides]
                        let link :: Html
link = Html -> Html
H.a (Html -> Html) -> Attribute -> Html -> Html
forall h. Attributable h => h -> Attribute -> h
! AttributeValue -> Attribute
A.href (Text -> AttributeValue
forall a. ToValue a => a -> AttributeValue
toValue (Text -> AttributeValue) -> Text -> AttributeValue
forall a b. (a -> b) -> a -> b
$ Text
"#" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
                                         Text
revealSlash Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
                                         WriterOptions -> Text
writerIdentifierPrefix WriterOptions
opts Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"fn" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
ref)
                                       (Html -> Html) -> Attribute -> Html -> Html
forall h. Attributable h => h -> Attribute -> h
! AttributeValue -> Attribute
A.class_ AttributeValue
"footnote-ref"
                                       (Html -> Html) -> Attribute -> Html -> Html
forall h. Attributable h => h -> Attribute -> h
! WriterOptions -> Text -> Attribute
prefixedId WriterOptions
opts (Text
"fnref" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
ref)
                                       (Html -> Html) -> Html -> Html
forall a b. (a -> b) -> a -> b
$ (if Maybe EPUBVersion -> Bool
forall a. Maybe a -> Bool
isJust Maybe EPUBVersion
epubVersion
                                             then Html -> Html
forall a. a -> a
id
                                             else Html -> Html
H.sup)
                                       (Html -> Html) -> Html -> Html
forall a b. (a -> b) -> a -> b
$ Text -> Html
forall a. ToMarkup a => a -> Html
toHtml Text
ref
                        Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ case Maybe EPUBVersion
epubVersion of
                                      Just EPUBVersion
EPUB3 -> Html
link Html -> Attribute -> Html
forall h. Attributable h => h -> Attribute -> h
! Tag -> AttributeValue -> Attribute
customAttribute Tag
"epub:type" AttributeValue
"noteref"
                                      Maybe EPUBVersion
_ | Bool
html5  -> Html
link Html -> Attribute -> Html
forall h. Attributable h => h -> Attribute -> h
! Tag -> AttributeValue -> Attribute
H5.customAttribute
                                                      Tag
"role" AttributeValue
"doc-noteref"
                                      Maybe EPUBVersion
_          -> Html
link
    (Cite [Citation]
cits [Inline]
il)-> do Html
contents <- WriterOptions -> [Inline] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Inline] -> StateT WriterState m Html
inlineListToHtml WriterOptions
opts ((Inline -> Inline) -> [Inline] -> [Inline]
forall a b. Walkable a b => (a -> a) -> b -> b
walk Inline -> Inline
addRoleToLink [Inline]
il)
                        let citationIds :: Text
citationIds = [Text] -> Text
T.unwords ([Text] -> Text) -> [Text] -> Text
forall a b. (a -> b) -> a -> b
$ (Citation -> Text) -> [Citation] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
map Citation -> Text
citationId [Citation]
cits
                        let result :: Html
result = Html -> Html
H.span (Html -> Html) -> Attribute -> Html -> Html
forall h. Attributable h => h -> Attribute -> h
! AttributeValue -> Attribute
A.class_ AttributeValue
"citation" (Html -> Html) -> Html -> Html
forall a b. (a -> b) -> a -> b
$ Html
contents
                        Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ if Bool
html5
                                    then Html
result Html -> Attribute -> Html
forall h. Attributable h => h -> Attribute -> h
! Tag -> AttributeValue -> Attribute
customAttribute Tag
"data-cites" (Text -> AttributeValue
forall a. ToValue a => a -> AttributeValue
toValue Text
citationIds)
                                    else Html
result

addRoleToLink :: Inline -> Inline
addRoleToLink :: Inline -> Inline
addRoleToLink (Link (Text
id',[Text]
classes,[(Text, Text)]
kvs) [Inline]
ils (Text
src,Text
tit)) =
  Attr -> [Inline] -> (Text, Text) -> Inline
Link (Text
id',[Text]
classes,(Text
"role",Text
"doc-biblioref")(Text, Text) -> [(Text, Text)] -> [(Text, Text)]
forall a. a -> [a] -> [a]
:[(Text, Text)]
kvs) [Inline]
ils (Text
src,Text
tit)
addRoleToLink Inline
x = Inline
x

blockListToNote :: PandocMonad m
                => WriterOptions -> Text -> [Block]
                -> StateT WriterState m Html
blockListToNote :: WriterOptions -> Text -> [Block] -> StateT WriterState m Html
blockListToNote WriterOptions
opts Text
ref [Block]
blocks = do
  Bool
html5 <- (WriterState -> Bool) -> StateT WriterState m Bool
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets WriterState -> Bool
stHtml5
  -- If last block is Para or Plain, include the backlink at the end of
  -- that block. Otherwise, insert a new Plain block with the backlink.
  let kvs :: [(Text, Text)]
kvs = [(Text
"role",Text
"doc-backlink") | Bool
html5]
  let backlink :: [Inline]
backlink = [Attr -> [Inline] -> (Text, Text) -> Inline
Link (Text
"",[Text
"footnote-back"],[(Text, Text)]
kvs)
                    [Text -> Inline
Str Text
"↩"] (Text
"#" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"fnref" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
ref,Text
"")]
  let blocks' :: [Block]
blocks'  = if [Block] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Block]
blocks
                    then []
                    else let lastBlock :: Block
lastBlock   = [Block] -> Block
forall a. [a] -> a
last [Block]
blocks
                             otherBlocks :: [Block]
otherBlocks = [Block] -> [Block]
forall a. [a] -> [a]
init [Block]
blocks
                         in  case Block
lastBlock of
                                  Para [Image Attr
_ [Inline]
_ (Text
_,Text
tit)]
                                      | Text
"fig:" Text -> Text -> Bool
`T.isPrefixOf` Text
tit
                                            -> [Block]
otherBlocks [Block] -> [Block] -> [Block]
forall a. [a] -> [a] -> [a]
++ [Block
lastBlock,
                                                  [Inline] -> Block
Plain [Inline]
backlink]
                                  Para [Inline]
lst  -> [Block]
otherBlocks [Block] -> [Block] -> [Block]
forall a. [a] -> [a] -> [a]
++
                                                 [[Inline] -> Block
Para ([Inline]
lst [Inline] -> [Inline] -> [Inline]
forall a. [a] -> [a] -> [a]
++ [Inline]
backlink)]
                                  Plain [Inline]
lst -> [Block]
otherBlocks [Block] -> [Block] -> [Block]
forall a. [a] -> [a] -> [a]
++
                                                 [[Inline] -> Block
Plain ([Inline]
lst [Inline] -> [Inline] -> [Inline]
forall a. [a] -> [a] -> [a]
++ [Inline]
backlink)]
                                  Block
_         -> [Block]
otherBlocks [Block] -> [Block] -> [Block]
forall a. [a] -> [a] -> [a]
++ [Block
lastBlock,
                                                 [Inline] -> Block
Plain [Inline]
backlink]
  Html
contents <- WriterOptions -> [Block] -> StateT WriterState m Html
forall (m :: * -> *).
PandocMonad m =>
WriterOptions -> [Block] -> StateT WriterState m Html
blockListToHtml WriterOptions
opts [Block]
blocks'
  let noteItem :: Html
noteItem = Html -> Html
H.li (Html -> Html) -> Attribute -> Html -> Html
forall h. Attributable h => h -> Attribute -> h
! WriterOptions -> Text -> Attribute
prefixedId WriterOptions
opts (Text
"fn" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
ref) (Html -> Html) -> Html -> Html
forall a b. (a -> b) -> a -> b
$ Html
contents
  Maybe EPUBVersion
epubVersion <- (WriterState -> Maybe EPUBVersion)
-> StateT WriterState m (Maybe EPUBVersion)
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets WriterState -> Maybe EPUBVersion
stEPUBVersion
  let noteItem' :: Html
noteItem' = case Maybe EPUBVersion
epubVersion of
                       Just EPUBVersion
EPUB3 -> Html
noteItem Html -> Attribute -> Html
forall h. Attributable h => h -> Attribute -> h
!
                                       Tag -> AttributeValue -> Attribute
customAttribute Tag
"epub:type" AttributeValue
"footnote"
                       Maybe EPUBVersion
_ | Bool
html5  -> Html
noteItem Html -> Attribute -> Html
forall h. Attributable h => h -> Attribute -> h
!
                                       Tag -> AttributeValue -> Attribute
customAttribute Tag
"role" AttributeValue
"doc-endnote"
                       Maybe EPUBVersion
_          -> Html
noteItem
  Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$ WriterOptions -> Html
nl WriterOptions
opts Html -> Html -> Html
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Html
noteItem'

inDiv :: PandocMonad m=> Text -> Html -> StateT WriterState m Html
inDiv :: Text -> Html -> StateT WriterState m Html
inDiv Text
cls Html
x = do
  Bool
html5 <- (WriterState -> Bool) -> StateT WriterState m Bool
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets WriterState -> Bool
stHtml5
  Html -> StateT WriterState m Html
forall (m :: * -> *) a. Monad m => a -> m a
return (Html -> StateT WriterState m Html)
-> Html -> StateT WriterState m Html
forall a b. (a -> b) -> a -> b
$
    (if Bool
html5 then Html -> Html
H5.div else Html -> Html
H.div)
                Html
x Html -> Attribute -> Html
forall h. Attributable h => h -> Attribute -> h
! AttributeValue -> Attribute
A.class_ (Text -> AttributeValue
forall a. ToValue a => a -> AttributeValue
toValue Text
cls)

isMathEnvironment :: Text -> Bool
isMathEnvironment :: Text -> Bool
isMathEnvironment Text
s = Text
"\\begin{" Text -> Text -> Bool
`T.isPrefixOf` Text
s Bool -> Bool -> Bool
&&
                         Text
envName Text -> [Text] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Text]
mathmlenvs
  where envName :: Text
envName = (Char -> Bool) -> Text -> Text
T.takeWhile (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
'}') (Int -> Text -> Text
T.drop Int
7 Text
s)
        mathmlenvs :: [Text]
mathmlenvs = [ Text
"align"
                     , Text
"align*"
                     , Text
"alignat"
                     , Text
"alignat*"
                     , Text
"aligned"
                     , Text
"alignedat"
                     , Text
"array"
                     , Text
"Bmatrix"
                     , Text
"bmatrix"
                     , Text
"cases"
                     , Text
"CD"
                     , Text
"eqnarray"
                     , Text
"eqnarray*"
                     , Text
"equation"
                     , Text
"equation*"
                     , Text
"gather"
                     , Text
"gather*"
                     , Text
"gathered"
                     , Text
"matrix"
                     , Text
"multline"
                     , Text
"multline*"
                     , Text
"pmatrix"
                     , Text
"smallmatrix"
                     , Text
"split"
                     , Text
"subarray"
                     , Text
"Vmatrix"
                     , Text
"vmatrix" ]

allowsMathEnvironments :: HTMLMathMethod -> Bool
allowsMathEnvironments :: HTMLMathMethod -> Bool
allowsMathEnvironments (MathJax Text
_) = Bool
True
allowsMathEnvironments HTMLMathMethod
MathML      = Bool
True
allowsMathEnvironments (WebTeX Text
_)  = Bool
True
allowsMathEnvironments HTMLMathMethod
_           = Bool
False

-- | List of intrinsic event attributes allowed on all elements in HTML4.
intrinsicEventsHTML4 :: [Text]
intrinsicEventsHTML4 :: [Text]
intrinsicEventsHTML4 =
  [ Text
"onclick", Text
"ondblclick", Text
"onmousedown", Text
"onmouseup", Text
"onmouseover"
  , Text
"onmouseout", Text
"onmouseout", Text
"onkeypress", Text
"onkeydown", Text
"onkeyup"]

isRawHtml :: PandocMonad m => Format -> StateT WriterState m Bool
isRawHtml :: Format -> StateT WriterState m Bool
isRawHtml Format
f = do
  Bool
html5 <- (WriterState -> Bool) -> StateT WriterState m Bool
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets WriterState -> Bool
stHtml5
  Bool -> StateT WriterState m Bool
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> StateT WriterState m Bool)
-> Bool -> StateT WriterState m Bool
forall a b. (a -> b) -> a -> b
$ Format
f Format -> Format -> Bool
forall a. Eq a => a -> a -> Bool
== Text -> Format
Format Text
"html" Bool -> Bool -> Bool
||
           ((Bool
html5 Bool -> Bool -> Bool
&& Format
f Format -> Format -> Bool
forall a. Eq a => a -> a -> Bool
== Text -> Format
Format Text
"html5") Bool -> Bool -> Bool
|| Format
f Format -> Format -> Bool
forall a. Eq a => a -> a -> Bool
== Text -> Format
Format Text
"html4")