    {- |
       Module      : Text.Pandoc.Writers.Markdown.Types
       Copyright   : Copyright (C) 2006-2024 John MacFarlane
       License     : GNU GPL, version 2 or above

       Maintainer  : John MacFarlane <jgm@berkeley.edu>
       Stability   : alpha
       Portability : portable
    -}
    module Text.Pandoc.Writers.Markdown.Types (
      MarkdownVariant(..),
      WriterState(..),
      WriterEnv(..),
      Notes,
      Ref,
      Refs,
      MD,
      evalMD
      ) where
    import Control.Monad.Reader
    import Control.Monad.State.Strict
    import Data.Default
    import qualified Data.Map as M
    import qualified Data.Set as Set
    import Data.Text (Text)
    import Text.Pandoc.Parsing (Key)
    import Text.Pandoc.Class.PandocMonad (PandocMonad)
    import Text.Pandoc.Definition

    type Notes = [[Block]]
    type Ref   = (Text, Target, Attr)
    type Refs  = [Ref]

    type MD m = ReaderT WriterEnv (StateT WriterState m)

    evalMD :: PandocMonad m => MD m a -> WriterEnv -> WriterState -> m a
    evalMD :: forall (m :: * -> *) a.
    PandocMonad m =>
    MD m a -> WriterEnv -> WriterState -> m a
    evalMD MD m a
    md WriterEnv
    env WriterState
    st = StateT WriterState m a -> WriterState -> m a
    forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
    evalStateT (MD m a -> WriterEnv -> StateT WriterState m a
    forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
    runReaderT MD m a
    md WriterEnv
    env) WriterState
    st

    data WriterEnv = WriterEnv { WriterEnv -> Bool
    envInList          :: Bool
                               , WriterEnv -> MarkdownVariant
    envVariant         :: MarkdownVariant
                               , WriterEnv -> Bool
    envRefShortcutable :: Bool
                               , WriterEnv -> Int
    envBlockLevel      :: Int
                               , WriterEnv -> Bool
    envEscapeSpaces    :: Bool
                               }

    data MarkdownVariant =
          Markua
        | PlainText
        | Commonmark
        | Markdown
        deriving (Int -> MarkdownVariant -> ShowS
    [MarkdownVariant] -> ShowS
    MarkdownVariant -> String
    (Int -> MarkdownVariant -> ShowS)
    -> (MarkdownVariant -> String)
    -> ([MarkdownVariant] -> ShowS)
    -> Show MarkdownVariant
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> MarkdownVariant -> ShowS
    showsPrec :: Int -> MarkdownVariant -> ShowS
    $cshow :: MarkdownVariant -> String
    show :: MarkdownVariant -> String
    $cshowList :: [MarkdownVariant] -> ShowS
    showList :: [MarkdownVariant] -> ShowS
    Show, MarkdownVariant -> MarkdownVariant -> Bool
    (MarkdownVariant -> MarkdownVariant -> Bool)
    -> (MarkdownVariant -> MarkdownVariant -> Bool)
    -> Eq MarkdownVariant
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: MarkdownVariant -> MarkdownVariant -> Bool
    == :: MarkdownVariant -> MarkdownVariant -> Bool
    $c/= :: MarkdownVariant -> MarkdownVariant -> Bool
    /= :: MarkdownVariant -> MarkdownVariant -> Bool
    Eq)

    instance Default WriterEnv
      where def :: WriterEnv
    def = WriterEnv { envInList :: Bool
    envInList          = Bool
    False
                            , envVariant :: MarkdownVariant
    envVariant         = MarkdownVariant
    Markdown
                            , envRefShortcutable :: Bool
    envRefShortcutable = Bool
    True
                            , envBlockLevel :: Int
    envBlockLevel      = Int
    0
                            , envEscapeSpaces :: Bool
    envEscapeSpaces    = Bool
    False
                            }

    data WriterState = WriterState { WriterState -> Notes
    stNotes   :: Notes
                                   , WriterState -> Refs
    stPrevRefs :: Refs
                                   , WriterState -> Refs
    stRefs    :: Refs
                                   , WriterState -> Map Key (Map (Target, Attr) Int)
    stKeys    :: M.Map Key
                                                    (M.Map (Target, Attr) Int)
                                   , WriterState -> Int
    stLastIdx  :: Int
                                   , WriterState -> Set Text
    stIds     :: Set.Set Text
                                   , WriterState -> Int
    stNoteNum :: Int
                                   }

    instance Default WriterState
      where def :: WriterState
    def = WriterState{ stNotes :: Notes
    stNotes = []
                             , stPrevRefs :: Refs
    stPrevRefs = []
                             , stRefs :: Refs
    stRefs = []
                             , stKeys :: Map Key (Map (Target, Attr) Int)
    stKeys = Map Key (Map (Target, Attr) Int)
    forall k a. Map k a
    M.empty
                             , stLastIdx :: Int
    stLastIdx = Int
    0
                             , stIds :: Set Text
    stIds = Set Text
    forall a. Set a
    Set.empty
                             , stNoteNum :: Int
    stNoteNum = Int
    1
                             }