    {-# LANGUAGE FlexibleContexts  #-}
    {-# LANGUAGE OverloadedStrings #-}
    {-# LANGUAGE TupleSections     #-}
    {- |
       Module      : Text.Pandoc.Readers.Org.DocumentTree
       Copyright   : Copyright (C) 2014-2020 Albert Krewinkel
       License     : GNU GPL, version 2 or above

       Maintainer  : Albert Krewinkel <tarleb+pandoc@moltkeplatz.de>

    Parsers for org-mode headlines and document subtrees
    -}
    module Text.Pandoc.Readers.Org.DocumentTree
      ( documentTree
      , unprunedHeadlineToBlocks
      ) where

    import Control.Arrow ((***), first)
    import Control.Monad (guard)
    import Data.List (intersperse)
    import Data.Maybe (mapMaybe)
    import Data.Text (Text)
    import Text.Pandoc.Builder (Blocks, Inlines)
    import Text.Pandoc.Class.PandocMonad (PandocMonad)
    import Text.Pandoc.Definition
    import Text.Pandoc.Readers.Org.BlockStarts
    import Text.Pandoc.Readers.Org.ParserState
    import Text.Pandoc.Readers.Org.Parsing

    import qualified Data.Set as Set
    import qualified Data.Text as T
    import qualified Text.Pandoc.Builder as B

    --
    -- Org headers
    --

    -- | Parse input as org document tree.
    documentTree :: PandocMonad m
                 => OrgParser m (F Blocks)
                 -> OrgParser m (F Inlines)
                 -> OrgParser m (F Headline)
    documentTree :: OrgParser m (F Blocks)
    -> OrgParser m (F Inlines) -> OrgParser m (F Headline)
    documentTree blocks :: OrgParser m (F Blocks)
    blocks inline :: OrgParser m (F Inlines)
    inline = do
      F Blocks
    initialBlocks <- OrgParser m (F Blocks)
    blocks
      Future OrgParserState [Headline]
    headlines <- [F Headline] -> Future OrgParserState [Headline]
    forall (t :: * -> *) (m :: * -> *) a.
    (Traversable t, Monad m) =>
    t (m a) -> m (t a)
    sequence ([F Headline] -> Future OrgParserState [Headline])
    -> ParsecT
         Text OrgParserState (ReaderT OrgParserLocal m) [F Headline]
    -> ParsecT
         Text
         OrgParserState
         (ReaderT OrgParserLocal m)
         (Future OrgParserState [Headline])
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> OrgParser m (F Headline)
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) ()
    -> ParsecT
         Text OrgParserState (ReaderT OrgParserLocal m) [F Headline]
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    manyTill (OrgParser m (F Blocks)
    -> OrgParser m (F Inlines) -> Int -> OrgParser m (F Headline)
    forall (m :: * -> *).
    PandocMonad m =>
    OrgParser m (F Blocks)
    -> OrgParser m (F Inlines) -> Int -> OrgParser m (F Headline)
    headline OrgParser m (F Blocks)
    blocks OrgParser m (F Inlines)
    inline 1) ParsecT Text OrgParserState (ReaderT OrgParserLocal m) ()
    forall s (m :: * -> *) t u.
    (Stream s m t, Show t) =>
    ParsecT s u m ()
    eof
      Future OrgParserState [Inline]
    title <- (Meta -> [Inline])
    -> Future OrgParserState Meta -> Future OrgParserState [Inline]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Meta -> [Inline]
    docTitle (Future OrgParserState Meta -> Future OrgParserState [Inline])
    -> (OrgParserState -> Future OrgParserState Meta)
    -> OrgParserState
    -> Future OrgParserState [Inline]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . OrgParserState -> Future OrgParserState Meta
    orgStateMeta (OrgParserState -> Future OrgParserState [Inline])
    -> ParsecT
         Text OrgParserState (ReaderT OrgParserLocal m) OrgParserState
    -> ParsecT
         Text
         OrgParserState
         (ReaderT OrgParserLocal m)
         (Future OrgParserState [Inline])
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT
      Text OrgParserState (ReaderT OrgParserLocal m) OrgParserState
    forall (m :: * -> *) s u. Monad m => ParsecT s u m u
    getState
      F Headline -> OrgParser m (F Headline)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (F Headline -> OrgParser m (F Headline))
    -> F Headline -> OrgParser m (F Headline)
    forall a b. (a -> b) -> a -> b
    $ do
        [Headline]
    headlines' <- Future OrgParserState [Headline]
    headlines
        Blocks
    initialBlocks' <- F Blocks
    initialBlocks
        [Inline]
    title' <- Future OrgParserState [Inline]
    title
        Headline -> F Headline
    forall (m :: * -> *) a. Monad m => a -> m a
    return Headline :: Int
    -> Maybe TodoMarker
    -> Inlines
    -> [Tag]
    -> PlanningInfo
    -> Properties
    -> Blocks
    -> [Headline]
    -> Headline
    Headline
          { headlineLevel :: Int
    headlineLevel = 0
          , headlineTodoMarker :: Maybe TodoMarker
    headlineTodoMarker = Maybe TodoMarker
    forall a. Maybe a
    Nothing
          , headlineText :: Inlines
    headlineText = [Inline] -> Inlines
    forall a. [a] -> Many a
    B.fromList [Inline]
    title'
          , headlineTags :: [Tag]
    headlineTags = [Tag]
    forall a. Monoid a => a
    mempty
          , headlinePlanning :: PlanningInfo
    headlinePlanning = PlanningInfo
    emptyPlanning
          , headlineProperties :: Properties
    headlineProperties = Properties
    forall a. Monoid a => a
    mempty
          , headlineContents :: Blocks
    headlineContents = Blocks
    initialBlocks'
          , headlineChildren :: [Headline]
    headlineChildren = [Headline]
    headlines'
          }

    -- | Create a tag containing the given string.
    toTag :: Text -> Tag
    toTag :: Text -> Tag
    toTag = Text -> Tag
    Tag

    -- | The key (also called name or type) of a property.
    newtype PropertyKey = PropertyKey { PropertyKey -> Text
    fromKey :: Text }
      deriving (Int -> PropertyKey -> ShowS
    [PropertyKey] -> ShowS
    PropertyKey -> String
    (Int -> PropertyKey -> ShowS)
    -> (PropertyKey -> String)
    -> ([PropertyKey] -> ShowS)
    -> Show PropertyKey
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [PropertyKey] -> ShowS
    $cshowList :: [PropertyKey] -> ShowS
    show :: PropertyKey -> String
    $cshow :: PropertyKey -> String
    showsPrec :: Int -> PropertyKey -> ShowS
    $cshowsPrec :: Int -> PropertyKey -> ShowS
    Show, PropertyKey -> PropertyKey -> Bool
    (PropertyKey -> PropertyKey -> Bool)
    -> (PropertyKey -> PropertyKey -> Bool) -> Eq PropertyKey
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: PropertyKey -> PropertyKey -> Bool
    $c/= :: PropertyKey -> PropertyKey -> Bool
    == :: PropertyKey -> PropertyKey -> Bool
    $c== :: PropertyKey -> PropertyKey -> Bool
    Eq, Eq PropertyKey
    Eq PropertyKey =>
    (PropertyKey -> PropertyKey -> Ordering)
    -> (PropertyKey -> PropertyKey -> Bool)
    -> (PropertyKey -> PropertyKey -> Bool)
    -> (PropertyKey -> PropertyKey -> Bool)
    -> (PropertyKey -> PropertyKey -> Bool)
    -> (PropertyKey -> PropertyKey -> PropertyKey)
    -> (PropertyKey -> PropertyKey -> PropertyKey)
    -> Ord PropertyKey
    PropertyKey -> PropertyKey -> Bool
    PropertyKey -> PropertyKey -> Ordering
    PropertyKey -> PropertyKey -> PropertyKey
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    min :: PropertyKey -> PropertyKey -> PropertyKey
    $cmin :: PropertyKey -> PropertyKey -> PropertyKey
    max :: PropertyKey -> PropertyKey -> PropertyKey
    $cmax :: PropertyKey -> PropertyKey -> PropertyKey
    >= :: PropertyKey -> PropertyKey -> Bool
    $c>= :: PropertyKey -> PropertyKey -> Bool
    > :: PropertyKey -> PropertyKey -> Bool
    $c> :: PropertyKey -> PropertyKey -> Bool
    <= :: PropertyKey -> PropertyKey -> Bool
    $c<= :: PropertyKey -> PropertyKey -> Bool
    < :: PropertyKey -> PropertyKey -> Bool
    $c< :: PropertyKey -> PropertyKey -> Bool
    compare :: PropertyKey -> PropertyKey -> Ordering
    $ccompare :: PropertyKey -> PropertyKey -> Ordering
    $cp1Ord :: Eq PropertyKey
    Ord)

    -- | Create a property key containing the given string.  Org mode keys are
    -- case insensitive and are hence converted to lower case.
    toPropertyKey :: Text -> PropertyKey
    toPropertyKey :: Text -> PropertyKey
    toPropertyKey = Text -> PropertyKey
    PropertyKey (Text -> PropertyKey) -> (Text -> Text) -> Text -> PropertyKey
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Text
    T.toLower

    -- | The value assigned to a property.
    newtype PropertyValue = PropertyValue { PropertyValue -> Text
    fromValue :: Text }

    -- | Create a property value containing the given string.
    toPropertyValue :: Text -> PropertyValue
    toPropertyValue :: Text -> PropertyValue
    toPropertyValue = Text -> PropertyValue
    PropertyValue

    -- | Check whether the property value is non-nil (i.e. truish).
    isNonNil :: PropertyValue -> Bool
    isNonNil :: PropertyValue -> Bool
    isNonNil p :: PropertyValue
    p = Text -> Text
    T.toLower (PropertyValue -> Text
    fromValue PropertyValue
    p) Text -> [Text] -> Bool
    forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
    `notElem` ["()", "{}", "nil"]

    -- | Key/value pairs from a PROPERTIES drawer
    type Properties = [(PropertyKey, PropertyValue)]

    -- | Org mode headline (i.e. a document subtree).
    data Headline = Headline
      { Headline -> Int
    headlineLevel      :: Int
      , Headline -> Maybe TodoMarker
    headlineTodoMarker :: Maybe TodoMarker
      , Headline -> Inlines
    headlineText       :: Inlines
      , Headline -> [Tag]
    headlineTags       :: [Tag]
      , Headline -> PlanningInfo
    headlinePlanning   :: PlanningInfo -- ^ subtree planning information
      , Headline -> Properties
    headlineProperties :: Properties
      , Headline -> Blocks
    headlineContents   :: Blocks
      , Headline -> [Headline]
    headlineChildren   :: [Headline]
      }

    -- | Read an Org mode headline and its contents (i.e. a document subtree).
    -- @lvl@ gives the minimum acceptable level of the tree.
    headline :: PandocMonad m
             => OrgParser m (F Blocks)
             -> OrgParser m (F Inlines)
             -> Int
             -> OrgParser m (F Headline)
    headline :: OrgParser m (F Blocks)
    -> OrgParser m (F Inlines) -> Int -> OrgParser m (F Headline)
    headline blocks :: OrgParser m (F Blocks)
    blocks inline :: OrgParser m (F Inlines)
    inline lvl :: Int
    lvl = OrgParser m (F Headline) -> OrgParser m (F Headline)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (OrgParser m (F Headline) -> OrgParser m (F Headline))
    -> OrgParser m (F Headline) -> OrgParser m (F Headline)
    forall a b. (a -> b) -> a -> b
    $ do
      Int
    level <- OrgParser m Int
    forall (m :: * -> *). Monad m => OrgParser m Int
    headerStart
      Bool -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) ()
    forall (f :: * -> *). Alternative f => Bool -> f ()
    guard (Int
    lvl Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Int
    level)
      Maybe TodoMarker
    todoKw <- ParsecT Text OrgParserState (ReaderT OrgParserLocal m) TodoMarker
    -> ParsecT
         Text OrgParserState (ReaderT OrgParserLocal m) (Maybe TodoMarker)
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m (Maybe a)
    optionMaybe ParsecT Text OrgParserState (ReaderT OrgParserLocal m) TodoMarker
    forall (m :: * -> *). Monad m => OrgParser m TodoMarker
    todoKeyword
      (title :: [F Inlines]
    title, tags :: [Tag]
    tags) <- OrgParser m (F Inlines)
    -> OrgParser m [Tag] -> OrgParser m ([F Inlines], [Tag])
    forall (m :: * -> *) a b.
    Monad m =>
    OrgParser m a -> OrgParser m b -> OrgParser m ([a], b)
    manyThen OrgParser m (F Inlines)
    inline OrgParser m [Tag]
    forall (m :: * -> *). Monad m => OrgParser m [Tag]
    endOfTitle
      PlanningInfo
    planning   <- PlanningInfo
    -> ParsecT
         Text OrgParserState (ReaderT OrgParserLocal m) PlanningInfo
    -> ParsecT
         Text OrgParserState (ReaderT OrgParserLocal m) PlanningInfo
    forall s (m :: * -> *) t a u.
    Stream s m t =>
    a -> ParsecT s u m a -> ParsecT s u m a
    option PlanningInfo
    emptyPlanning ParsecT Text OrgParserState (ReaderT OrgParserLocal m) PlanningInfo
    forall (m :: * -> *). Monad m => OrgParser m PlanningInfo
    planningInfo
      Properties
    properties <- Properties
    -> ParsecT
         Text OrgParserState (ReaderT OrgParserLocal m) Properties
    -> ParsecT
         Text OrgParserState (ReaderT OrgParserLocal m) Properties
    forall s (m :: * -> *) t a u.
    Stream s m t =>
    a -> ParsecT s u m a -> ParsecT s u m a
    option Properties
    forall a. Monoid a => a
    mempty ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Properties
    forall (m :: * -> *). Monad m => OrgParser m Properties
    propertiesDrawer
      F Blocks
    contents   <- OrgParser m (F Blocks)
    blocks
      [F Headline]
    children   <- OrgParser m (F Headline)
    -> ParsecT
         Text OrgParserState (ReaderT OrgParserLocal m) [F Headline]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many (OrgParser m (F Blocks)
    -> OrgParser m (F Inlines) -> Int -> OrgParser m (F Headline)
    forall (m :: * -> *).
    PandocMonad m =>
    OrgParser m (F Blocks)
    -> OrgParser m (F Inlines) -> Int -> OrgParser m (F Headline)
    headline OrgParser m (F Blocks)
    blocks OrgParser m (F Inlines)
    inline (Int
    level Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + 1))
      F Headline -> OrgParser m (F Headline)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (F Headline -> OrgParser m (F Headline))
    -> F Headline -> OrgParser m (F Headline)
    forall a b. (a -> b) -> a -> b
    $ do
        Inlines
    title'    <- F Inlines -> F Inlines
    forall s. Future s Inlines -> Future s Inlines
    trimInlinesF ([F Inlines] -> F Inlines
    forall a. Monoid a => [a] -> a
    mconcat [F Inlines]
    title)
        Blocks
    contents' <- F Blocks
    contents
        [Headline]
    children' <- [F Headline] -> Future OrgParserState [Headline]
    forall (t :: * -> *) (m :: * -> *) a.
    (Traversable t, Monad m) =>
    t (m a) -> m (t a)
    sequence [F Headline]
    children
        Headline -> F Headline
    forall (m :: * -> *) a. Monad m => a -> m a
    return Headline :: Int
    -> Maybe TodoMarker
    -> Inlines
    -> [Tag]
    -> PlanningInfo
    -> Properties
    -> Blocks
    -> [Headline]
    -> Headline
    Headline
          { headlineLevel :: Int
    headlineLevel = Int
    level
          , headlineTodoMarker :: Maybe TodoMarker
    headlineTodoMarker = Maybe TodoMarker
    todoKw
          , headlineText :: Inlines
    headlineText = Inlines
    title'
          , headlineTags :: [Tag]
    headlineTags = [Tag]
    tags
          , headlinePlanning :: PlanningInfo
    headlinePlanning = PlanningInfo
    planning
          , headlineProperties :: Properties
    headlineProperties = Properties
    properties
          , headlineContents :: Blocks
    headlineContents = Blocks
    contents'
          , headlineChildren :: [Headline]
    headlineChildren = [Headline]
    children'
          }
     where
       endOfTitle :: Monad m => OrgParser m [Tag]
       endOfTitle :: OrgParser m [Tag]
    endOfTitle = OrgParser m [Tag] -> OrgParser m [Tag]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (OrgParser m [Tag] -> OrgParser m [Tag])
    -> OrgParser m [Tag] -> OrgParser m [Tag]
    forall a b. (a -> b) -> a -> b
    $ do
         ParserT Text OrgParserState (ReaderT OrgParserLocal m) ()
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m ()
    skipSpaces
         [Tag]
    tags <- [Tag] -> OrgParser m [Tag] -> OrgParser m [Tag]
    forall s (m :: * -> *) t a u.
    Stream s m t =>
    a -> ParsecT s u m a -> ParsecT s u m a
    option [] (OrgParser m [Tag]
    forall (m :: * -> *). Monad m => OrgParser m [Tag]
    headerTags OrgParser m [Tag]
    -> ParserT Text OrgParserState (ReaderT OrgParserLocal m) ()
    -> OrgParser m [Tag]
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParserT Text OrgParserState (ReaderT OrgParserLocal m) ()
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m ()
    skipSpaces)
         OrgParser m Char
    forall (m :: * -> *). Monad m => OrgParser m Char
    newline
         [Tag] -> OrgParser m [Tag]
    forall (m :: * -> *) a. Monad m => a -> m a
    return [Tag]
    tags

       headerTags :: Monad m => OrgParser m [Tag]
       headerTags :: OrgParser m [Tag]
    headerTags = OrgParser m [Tag] -> OrgParser m [Tag]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (OrgParser m [Tag] -> OrgParser m [Tag])
    -> OrgParser m [Tag] -> OrgParser m [Tag]
    forall a b. (a -> b) -> a -> b
    $ do
         Char -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char ':'
         ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Tag
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Char
    -> OrgParser m [Tag]
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    endBy1 (Text -> Tag
    toTag (Text -> Tag)
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Text
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Tag
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Text
    forall (m :: * -> *). Monad m => OrgParser m Text
    orgTagWord) (Char -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char ':')

       manyThen :: Monad m
                => OrgParser m a
                -> OrgParser m b
                -> OrgParser m ([a], b)
       manyThen :: OrgParser m a -> OrgParser m b -> OrgParser m ([a], b)
    manyThen p :: OrgParser m a
    p end :: OrgParser m b
    end = (([],) (b -> ([a], b)) -> OrgParser m b -> OrgParser m ([a], b)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> OrgParser m b -> OrgParser m b
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try OrgParser m b
    end) OrgParser m ([a], b)
    -> OrgParser m ([a], b) -> OrgParser m ([a], b)
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> do
         a
    x <- OrgParser m a
    p
         ([a] -> [a]) -> ([a], b) -> ([a], b)
    forall (a :: * -> * -> *) b c d.
    Arrow a =>
    a b c -> a (b, d) (c, d)
    first (a
    xa -> [a] -> [a]
    forall a. a -> [a] -> [a]
    :) (([a], b) -> ([a], b))
    -> OrgParser m ([a], b) -> OrgParser m ([a], b)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> OrgParser m a -> OrgParser m b -> OrgParser m ([a], b)
    forall (m :: * -> *) a b.
    Monad m =>
    OrgParser m a -> OrgParser m b -> OrgParser m ([a], b)
    manyThen OrgParser m a
    p OrgParser m b
    end

       -- titleFollowedByTags :: Monad m => OrgParser m (Inlines, [Tag])
       -- titleFollowedByTags = do

    unprunedHeadlineToBlocks :: Monad m => Headline -> OrgParserState -> OrgParser m [Block]
    unprunedHeadlineToBlocks :: Headline -> OrgParserState -> OrgParser m [Block]
    unprunedHeadlineToBlocks hdln :: Headline
    hdln st :: OrgParserState
    st =
      let usingSelectedTags :: Bool
    usingSelectedTags = Headline -> OrgParserState -> Bool
    docContainsSelectTags Headline
    hdln OrgParserState
    st
          rootNode :: Headline
    rootNode = if Bool -> Bool
    not Bool
    usingSelectedTags
                       then Headline
    hdln
                       else Headline -> OrgParserState -> Headline
    includeRootAndSelected Headline
    hdln OrgParserState
    st
          rootNode' :: Headline
    rootNode' = Headline -> OrgParserState -> Headline
    removeExplicitlyExcludedNodes Headline
    rootNode OrgParserState
    st
      in if Bool -> Bool
    not Bool
    usingSelectedTags Bool -> Bool -> Bool
    ||
            (Tag -> Bool) -> [Tag] -> Bool
    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
    any (Tag -> Set Tag -> Bool
    forall a. Ord a => a -> Set a -> Bool
    `Set.member` OrgParserState -> Set Tag
    orgStateSelectTags OrgParserState
    st) (Headline -> [Tag]
    headlineTags Headline
    rootNode')
            then do Blocks
    headlineBlocks <- Headline -> OrgParser m Blocks
    forall (m :: * -> *). Monad m => Headline -> OrgParser m Blocks
    headlineToBlocks Headline
    rootNode'
                    -- ignore first headline, it's the document's title
                    [Block] -> OrgParser m [Block]
    forall (m :: * -> *) a. Monad m => a -> m a
    return ([Block] -> OrgParser m [Block])
    -> (Blocks -> [Block]) -> Blocks -> OrgParser m [Block]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> [Block] -> [Block]
    forall a. Int -> [a] -> [a]
    drop 1 ([Block] -> [Block]) -> (Blocks -> [Block]) -> Blocks -> [Block]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Blocks -> [Block]
    forall a. Many a -> [a]
    B.toList (Blocks -> OrgParser m [Block]) -> Blocks -> OrgParser m [Block]
    forall a b. (a -> b) -> a -> b
    $ Blocks
    headlineBlocks
            else do Blocks
    headlineBlocks <- [Blocks] -> Blocks
    forall a. Monoid a => [a] -> a
    mconcat ([Blocks] -> Blocks)
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) [Blocks]
    -> OrgParser m Blocks
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Headline -> OrgParser m Blocks)
    -> [Headline]
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) [Blocks]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    mapM Headline -> OrgParser m Blocks
    forall (m :: * -> *). Monad m => Headline -> OrgParser m Blocks
    headlineToBlocks
                                                       (Headline -> [Headline]
    headlineChildren Headline
    rootNode')
                    [Block] -> OrgParser m [Block]
    forall (m :: * -> *) a. Monad m => a -> m a
    return ([Block] -> OrgParser m [Block])
    -> (Blocks -> [Block]) -> Blocks -> OrgParser m [Block]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Blocks -> [Block]
    forall a. Many a -> [a]
    B.toList (Blocks -> OrgParser m [Block]) -> Blocks -> OrgParser m [Block]
    forall a b. (a -> b) -> a -> b
    $ Blocks
    headlineBlocks

    -- | Convert an Org mode headline (i.e. a document tree) into pandoc's Blocks
    headlineToBlocks :: Monad m => Headline -> OrgParser m Blocks
    headlineToBlocks :: Headline -> OrgParser m Blocks
    headlineToBlocks hdln :: Headline
    hdln = do
      Int
    maxLevel <- (ExportSettings -> Int) -> OrgParser m Int
    forall (m :: * -> *) a.
    Monad m =>
    (ExportSettings -> a) -> OrgParser m a
    getExportSetting ExportSettings -> Int
    exportHeadlineLevels
      let tags :: [Tag]
    tags = Headline -> [Tag]
    headlineTags Headline
    hdln
      let text :: Inlines
    text = Headline -> Inlines
    headlineText Headline
    hdln
      let level :: Int
    level = Headline -> Int
    headlineLevel Headline
    hdln
      case () of
        _ | (Tag -> Bool) -> [Tag] -> Bool
    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
    any Tag -> Bool
    isArchiveTag  [Tag]
    tags -> Headline -> OrgParser m Blocks
    forall (m :: * -> *). Monad m => Headline -> OrgParser m Blocks
    archivedHeadlineToBlocks Headline
    hdln
        _ | Inlines -> Bool
    isCommentTitle Inlines
    text    -> Blocks -> OrgParser m Blocks
    forall (m :: * -> *) a. Monad m => a -> m a
    return Blocks
    forall a. Monoid a => a
    mempty
        _ | Int
    maxLevel Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Int
    level      -> Headline -> OrgParser m Blocks
    forall (m :: * -> *). Monad m => Headline -> OrgParser m Blocks
    headlineToHeaderWithList Headline
    hdln
        _ | Bool
    otherwise              -> Headline -> OrgParser m Blocks
    forall (m :: * -> *). Monad m => Headline -> OrgParser m Blocks
    headlineToHeaderWithContents Headline
    hdln

    removeExplicitlyExcludedNodes :: Headline -> OrgParserState -> Headline
    removeExplicitlyExcludedNodes :: Headline -> OrgParserState -> Headline
    removeExplicitlyExcludedNodes hdln :: Headline
    hdln st :: OrgParserState
    st =
      Headline
    hdln { headlineChildren :: [Headline]
    headlineChildren =
               [Headline -> OrgParserState -> Headline
    removeExplicitlyExcludedNodes Headline
    childHdln OrgParserState
    st |
                  Headline
    childHdln <- Headline -> [Headline]
    headlineChildren Headline
    hdln,
                  Bool -> Bool
    not (Bool -> Bool) -> Bool -> Bool
    forall a b. (a -> b) -> a -> b
    $ Headline -> OrgParserState -> Bool
    headlineContainsExcludeTags Headline
    childHdln OrgParserState
    st] }

    includeRootAndSelected :: Headline -> OrgParserState -> Headline
    includeRootAndSelected :: Headline -> OrgParserState -> Headline
    includeRootAndSelected hdln :: Headline
    hdln st :: OrgParserState
    st =
      Headline
    hdln { headlineChildren :: [Headline]
    headlineChildren = (Headline -> Maybe Headline) -> [Headline] -> [Headline]
    forall a b. (a -> Maybe b) -> [a] -> [b]
    mapMaybe (Headline -> OrgParserState -> Maybe Headline
    `includeAncestorsAndSelected` OrgParserState
    st)
                                         (Headline -> [Headline]
    headlineChildren Headline
    hdln)}

    docContainsSelectTags :: Headline -> OrgParserState -> Bool
    docContainsSelectTags :: Headline -> OrgParserState -> Bool
    docContainsSelectTags hdln :: Headline
    hdln st :: OrgParserState
    st =
      Headline -> OrgParserState -> Bool
    headlineContainsSelectTags Headline
    hdln OrgParserState
    st Bool -> Bool -> Bool
    ||
      (Headline -> Bool) -> [Headline] -> Bool
    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
    any (Headline -> OrgParserState -> Bool
    `docContainsSelectTags` OrgParserState
    st) (Headline -> [Headline]
    headlineChildren Headline
    hdln)

    includeAncestorsAndSelected :: Headline -> OrgParserState -> Maybe Headline
    includeAncestorsAndSelected :: Headline -> OrgParserState -> Maybe Headline
    includeAncestorsAndSelected hdln :: Headline
    hdln st :: OrgParserState
    st =
      if Headline -> OrgParserState -> Bool
    headlineContainsSelectTags Headline
    hdln OrgParserState
    st
        then Headline -> Maybe Headline
    forall a. a -> Maybe a
    Just Headline
    hdln
        else let children :: [Headline]
    children = (Headline -> Maybe Headline) -> [Headline] -> [Headline]
    forall a b. (a -> Maybe b) -> [a] -> [b]
    mapMaybe (Headline -> OrgParserState -> Maybe Headline
    `includeAncestorsAndSelected` OrgParserState
    st)
                                     (Headline -> [Headline]
    headlineChildren Headline
    hdln)
             in case [Headline]
    children of
                  [] -> Maybe Headline
    forall a. Maybe a
    Nothing
                  _ -> Headline -> Maybe Headline
    forall a. a -> Maybe a
    Just (Headline -> Maybe Headline) -> Headline -> Maybe Headline
    forall a b. (a -> b) -> a -> b
    $ Headline
    hdln { headlineChildren :: [Headline]
    headlineChildren = [Headline]
    children }

    headlineContainsSelectTags :: Headline -> OrgParserState -> Bool
    headlineContainsSelectTags :: Headline -> OrgParserState -> Bool
    headlineContainsSelectTags hdln :: Headline
    hdln st :: OrgParserState
    st =
      (Tag -> Bool) -> [Tag] -> Bool
    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
    any (Tag -> Set Tag -> Bool
    forall a. Ord a => a -> Set a -> Bool
    `Set.member` OrgParserState -> Set Tag
    orgStateSelectTags OrgParserState
    st) (Headline -> [Tag]
    headlineTags Headline
    hdln)

    headlineContainsExcludeTags :: Headline -> OrgParserState -> Bool
    headlineContainsExcludeTags :: Headline -> OrgParserState -> Bool
    headlineContainsExcludeTags hdln :: Headline
    hdln st :: OrgParserState
    st =
      (Tag -> Bool) -> [Tag] -> Bool
    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
    any (Tag -> Set Tag -> Bool
    forall a. Ord a => a -> Set a -> Bool
    `Set.member` OrgParserState -> Set Tag
    orgStateExcludeTags OrgParserState
    st) (Headline -> [Tag]
    headlineTags Headline
    hdln)

    isArchiveTag :: Tag -> Bool
    isArchiveTag :: Tag -> Bool
    isArchiveTag = (Tag -> Tag -> Bool
    forall a. Eq a => a -> a -> Bool
    == Text -> Tag
    toTag "ARCHIVE")

    -- | Check if the title starts with COMMENT.
    -- FIXME: This accesses builder internals not intended for use in situations
    -- like these.  Replace once keyword parsing is supported.
    isCommentTitle :: Inlines -> Bool
    isCommentTitle :: Inlines -> Bool
    isCommentTitle inlns :: Inlines
    inlns = case Inlines -> [Inline]
    forall a. Many a -> [a]
    B.toList Inlines
    inlns of
      (Str "COMMENT":_) -> Bool
    True
      _ -> Bool
    False

    archivedHeadlineToBlocks :: Monad m => Headline -> OrgParser m Blocks
    archivedHeadlineToBlocks :: Headline -> OrgParser m Blocks
    archivedHeadlineToBlocks hdln :: Headline
    hdln = do
      ArchivedTreesOption
    archivedTreesOption <- (ExportSettings -> ArchivedTreesOption)
    -> OrgParser m ArchivedTreesOption
    forall (m :: * -> *) a.
    Monad m =>
    (ExportSettings -> a) -> OrgParser m a
    getExportSetting ExportSettings -> ArchivedTreesOption
    exportArchivedTrees
      case ArchivedTreesOption
    archivedTreesOption of
        ArchivedTreesNoExport     -> Blocks -> OrgParser m Blocks
    forall (m :: * -> *) a. Monad m => a -> m a
    return Blocks
    forall a. Monoid a => a
    mempty
        ArchivedTreesExport       -> Headline -> OrgParser m Blocks
    forall (m :: * -> *). Monad m => Headline -> OrgParser m Blocks
    headlineToHeaderWithContents Headline
    hdln
        ArchivedTreesHeadlineOnly -> Headline -> OrgParser m Blocks
    forall (m :: * -> *). Monad m => Headline -> OrgParser m Blocks
    headlineToHeader Headline
    hdln

    headlineToHeaderWithList :: Monad m => Headline -> OrgParser m Blocks
    headlineToHeaderWithList :: Headline -> OrgParser m Blocks
    headlineToHeaderWithList hdln :: Headline
    hdln = do
      Int
    maxHeadlineLevels <- (ExportSettings -> Int) -> OrgParser m Int
    forall (m :: * -> *) a.
    Monad m =>
    (ExportSettings -> a) -> OrgParser m a
    getExportSetting ExportSettings -> Int
    exportHeadlineLevels
      Blocks
    header        <- Headline -> OrgParser m Blocks
    forall (m :: * -> *). Monad m => Headline -> OrgParser m Blocks
    headlineToHeader Headline
    hdln
      [Blocks]
    listElements  <- (Headline -> OrgParser m Blocks)
    -> [Headline]
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) [Blocks]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    mapM Headline -> OrgParser m Blocks
    forall (m :: * -> *). Monad m => Headline -> OrgParser m Blocks
    headlineToBlocks (Headline -> [Headline]
    headlineChildren Headline
    hdln)
      Blocks
    planningBlock <- PlanningInfo -> OrgParser m Blocks
    forall (m :: * -> *). Monad m => PlanningInfo -> OrgParser m Blocks
    planningToBlock (Headline -> PlanningInfo
    headlinePlanning Headline
    hdln)
      let listBlock :: Blocks
    listBlock  = if [Blocks] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null [Blocks]
    listElements
                       then Blocks
    forall a. Monoid a => a
    mempty
                       else [Blocks] -> Blocks
    B.orderedList [Blocks]
    listElements
      let headerText :: Blocks
    headerText = if Int
    maxHeadlineLevels Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Headline -> Int
    headlineLevel Headline
    hdln
                       then Blocks
    header
                       else Blocks -> Blocks
    flattenHeader Blocks
    header
      Blocks -> OrgParser m Blocks
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Blocks -> OrgParser m Blocks)
    -> ([Blocks] -> Blocks) -> [Blocks] -> OrgParser m Blocks
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [Blocks] -> Blocks
    forall a. Monoid a => [a] -> a
    mconcat ([Blocks] -> OrgParser m Blocks) -> [Blocks] -> OrgParser m Blocks
    forall a b. (a -> b) -> a -> b
    $
        [ Blocks
    headerText
        , Blocks
    planningBlock
        , Headline -> Blocks
    headlineContents Headline
    hdln
        , Blocks
    listBlock
        ]
     where
       flattenHeader :: Blocks -> Blocks
       flattenHeader :: Blocks -> Blocks
    flattenHeader blks :: Blocks
    blks =
         case Blocks -> [Block]
    forall a. Many a -> [a]
    B.toList Blocks
    blks of
           (Header _ _ inlns :: [Inline]
    inlns:_) -> Inlines -> Blocks
    B.para ([Inline] -> Inlines
    forall a. [a] -> Many a
    B.fromList [Inline]
    inlns)
           _                    -> Blocks
    forall a. Monoid a => a
    mempty

    headlineToHeaderWithContents :: Monad m => Headline -> OrgParser m Blocks
    headlineToHeaderWithContents :: Headline -> OrgParser m Blocks
    headlineToHeaderWithContents hdln :: Headline
    hdln = do
      Blocks
    header         <- Headline -> OrgParser m Blocks
    forall (m :: * -> *). Monad m => Headline -> OrgParser m Blocks
    headlineToHeader Headline
    hdln
      Blocks
    planningBlock <- PlanningInfo -> OrgParser m Blocks
    forall (m :: * -> *). Monad m => PlanningInfo -> OrgParser m Blocks
    planningToBlock (Headline -> PlanningInfo
    headlinePlanning Headline
    hdln)
      Blocks
    childrenBlocks <- [Blocks] -> Blocks
    forall a. Monoid a => [a] -> a
    mconcat ([Blocks] -> Blocks)
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) [Blocks]
    -> OrgParser m Blocks
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Headline -> OrgParser m Blocks)
    -> [Headline]
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) [Blocks]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    mapM Headline -> OrgParser m Blocks
    forall (m :: * -> *). Monad m => Headline -> OrgParser m Blocks
    headlineToBlocks (Headline -> [Headline]
    headlineChildren Headline
    hdln)
      Blocks -> OrgParser m Blocks
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Blocks -> OrgParser m Blocks) -> Blocks -> OrgParser m Blocks
    forall a b. (a -> b) -> a -> b
    $ Blocks
    header Blocks -> Blocks -> Blocks
    forall a. Semigroup a => a -> a -> a
    <> Blocks
    planningBlock Blocks -> Blocks -> Blocks
    forall a. Semigroup a => a -> a -> a
    <> Headline -> Blocks
    headlineContents Headline
    hdln Blocks -> Blocks -> Blocks
    forall a. Semigroup a => a -> a -> a
    <> Blocks
    childrenBlocks

    headlineToHeader :: Monad m => Headline -> OrgParser m Blocks
    headlineToHeader :: Headline -> OrgParser m Blocks
    headlineToHeader hdln :: Headline
    hdln = do
      Bool
    exportTodoKeyword <- (ExportSettings -> Bool) -> OrgParser m Bool
    forall (m :: * -> *) a.
    Monad m =>
    (ExportSettings -> a) -> OrgParser m a
    getExportSetting ExportSettings -> Bool
    exportWithTodoKeywords
      Bool
    exportTags        <- (ExportSettings -> Bool) -> OrgParser m Bool
    forall (m :: * -> *) a.
    Monad m =>
    (ExportSettings -> a) -> OrgParser m a
    getExportSetting ExportSettings -> Bool
    exportWithTags
      let todoText :: Inlines
    todoText    = if Bool
    exportTodoKeyword
                        then case Headline -> Maybe TodoMarker
    headlineTodoMarker Headline
    hdln of
                          Just kw :: TodoMarker
    kw -> TodoMarker -> Inlines
    todoKeywordToInlines TodoMarker
    kw Inlines -> Inlines -> Inlines
    forall a. Semigroup a => a -> a -> a
    <> Inlines
    B.space
                          Nothing -> Inlines
    forall a. Monoid a => a
    mempty
                        else Inlines
    forall a. Monoid a => a
    mempty
      let text :: Inlines
    text        = Inlines
    todoText Inlines -> Inlines -> Inlines
    forall a. Semigroup a => a -> a -> a
    <> Headline -> Inlines
    headlineText Headline
    hdln Inlines -> Inlines -> Inlines
    forall a. Semigroup a => a -> a -> a
    <>
                        if Bool
    exportTags
                        then [Tag] -> Inlines
    tagsToInlines (Headline -> [Tag]
    headlineTags Headline
    hdln)
                        else Inlines
    forall a. Monoid a => a
    mempty
      let propAttr :: Attr
    propAttr    = Properties -> Attr
    propertiesToAttr (Headline -> Properties
    headlineProperties Headline
    hdln)
      Attr
    attr           <- Attr
    -> Inlines
    -> ParserT Text OrgParserState (ReaderT OrgParserLocal m) Attr
    forall s (m :: * -> *) a st.
    (Stream s m a, HasReaderOptions st, HasLogMessages st,
     HasIdentifierList st) =>
    Attr -> Inlines -> ParserT s st m Attr
    registerHeader Attr
    propAttr (Headline -> Inlines
    headlineText Headline
    hdln)
      Blocks -> OrgParser m Blocks
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Blocks -> OrgParser m Blocks) -> Blocks -> OrgParser m Blocks
    forall a b. (a -> b) -> a -> b
    $ Attr -> Int -> Inlines -> Blocks
    B.headerWith Attr
    attr (Headline -> Int
    headlineLevel Headline
    hdln) Inlines
    text

    todoKeyword :: Monad m => OrgParser m TodoMarker
    todoKeyword :: OrgParser m TodoMarker
    todoKeyword = OrgParser m TodoMarker -> OrgParser m TodoMarker
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (OrgParser m TodoMarker -> OrgParser m TodoMarker)
    -> OrgParser m TodoMarker -> OrgParser m TodoMarker
    forall a b. (a -> b) -> a -> b
    $ do
      TodoSequence
    taskStates <- OrgParserState -> TodoSequence
    activeTodoMarkers (OrgParserState -> TodoSequence)
    -> ParsecT
         Text OrgParserState (ReaderT OrgParserLocal m) OrgParserState
    -> ParsecT
         Text OrgParserState (ReaderT OrgParserLocal m) TodoSequence
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT
      Text OrgParserState (ReaderT OrgParserLocal m) OrgParserState
    forall (m :: * -> *) s u. Monad m => ParsecT s u m u
    getState
      let kwParser :: TodoMarker
    -> ParsecT
         Text OrgParserState (ReaderT OrgParserLocal m) TodoMarker
    kwParser tdm :: TodoMarker
    tdm = ParsecT Text OrgParserState (ReaderT OrgParserLocal m) TodoMarker
    -> ParsecT
         Text OrgParserState (ReaderT OrgParserLocal m) TodoMarker
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (TodoMarker
    tdm TodoMarker
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Text
    -> ParsecT
         Text OrgParserState (ReaderT OrgParserLocal m) TodoMarker
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ Text -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Text
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Text -> ParsecT s u m Text
    textStr (TodoMarker -> Text
    todoMarkerName TodoMarker
    tdm)
                                  ParsecT Text OrgParserState (ReaderT OrgParserLocal m) TodoMarker
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Char
    -> ParsecT
         Text OrgParserState (ReaderT OrgParserLocal m) TodoMarker
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    spaceChar
                                  ParsecT Text OrgParserState (ReaderT OrgParserLocal m) TodoMarker
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) ()
    -> ParsecT
         Text OrgParserState (ReaderT OrgParserLocal m) TodoMarker
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT Text OrgParserState (ReaderT OrgParserLocal m) ()
    forall (m :: * -> *). Monad m => OrgParser m ()
    updateLastPreCharPos)
      [OrgParser m TodoMarker] -> OrgParser m TodoMarker
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    [ParsecT s u m a] -> ParsecT s u m a
    choice ((TodoMarker -> OrgParser m TodoMarker)
    -> TodoSequence -> [OrgParser m TodoMarker]
    forall a b. (a -> b) -> [a] -> [b]
    map TodoMarker -> OrgParser m TodoMarker
    forall (m :: * -> *).
    Monad m =>
    TodoMarker
    -> ParsecT
         Text OrgParserState (ReaderT OrgParserLocal m) TodoMarker
    kwParser TodoSequence
    taskStates)

    todoKeywordToInlines :: TodoMarker -> Inlines
    todoKeywordToInlines :: TodoMarker -> Inlines
    todoKeywordToInlines tdm :: TodoMarker
    tdm =
      let todoText :: Text
    todoText  = TodoMarker -> Text
    todoMarkerName TodoMarker
    tdm
          todoState :: Text
    todoState = Text -> Text
    T.toLower (Text -> Text) -> (TodoState -> Text) -> TodoState -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . String -> Text
    T.pack (String -> Text) -> (TodoState -> String) -> TodoState -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . TodoState -> String
    forall a. Show a => a -> String
    show (TodoState -> Text) -> TodoState -> Text
    forall a b. (a -> b) -> a -> b
    $ TodoMarker -> TodoState
    todoMarkerState TodoMarker
    tdm
          classes :: [Text]
    classes = [Text
    todoState, Text
    todoText]
      in Attr -> Inlines -> Inlines
    B.spanWith (Text
    forall a. Monoid a => a
    mempty, [Text]
    classes, [(Text, Text)]
    forall a. Monoid a => a
    mempty) (Text -> Inlines
    B.str Text
    todoText)

    propertiesToAttr :: Properties -> Attr
    propertiesToAttr :: Properties -> Attr
    propertiesToAttr properties :: Properties
    properties =
      let
        toTextPair :: (PropertyKey, PropertyValue) -> (Text, Text)
    toTextPair = PropertyKey -> Text
    fromKey (PropertyKey -> Text)
    -> (PropertyValue -> Text)
    -> (PropertyKey, PropertyValue)
    -> (Text, Text)
    forall (a :: * -> * -> *) b c b' c'.
    Arrow a =>
    a b c -> a b' c' -> a (b, b') (c, c')
    *** PropertyValue -> Text
    fromValue
        customIdKey :: PropertyKey
    customIdKey = Text -> PropertyKey
    toPropertyKey "custom_id"
        classKey :: PropertyKey
    classKey    = Text -> PropertyKey
    toPropertyKey "class"
        unnumberedKey :: PropertyKey
    unnumberedKey = Text -> PropertyKey
    toPropertyKey "unnumbered"
        specialProperties :: [PropertyKey]
    specialProperties = [PropertyKey
    customIdKey, PropertyKey
    classKey, PropertyKey
    unnumberedKey]
        id' :: Text
    id'  = Text -> (PropertyValue -> Text) -> Maybe PropertyValue -> Text
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe Text
    forall a. Monoid a => a
    mempty PropertyValue -> Text
    fromValue (Maybe PropertyValue -> Text)
    -> (Properties -> Maybe PropertyValue) -> Properties -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . PropertyKey -> Properties -> Maybe PropertyValue
    forall a b. Eq a => a -> [(a, b)] -> Maybe b
    lookup PropertyKey
    customIdKey (Properties -> Text) -> Properties -> Text
    forall a b. (a -> b) -> a -> b
    $ Properties
    properties
        cls :: Text
    cls  = Text -> (PropertyValue -> Text) -> Maybe PropertyValue -> Text
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe Text
    forall a. Monoid a => a
    mempty PropertyValue -> Text
    fromValue (Maybe PropertyValue -> Text)
    -> (Properties -> Maybe PropertyValue) -> Properties -> Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . PropertyKey -> Properties -> Maybe PropertyValue
    forall a b. Eq a => a -> [(a, b)] -> Maybe b
    lookup PropertyKey
    classKey    (Properties -> Text) -> Properties -> Text
    forall a b. (a -> b) -> a -> b
    $ Properties
    properties
        kvs' :: [(Text, Text)]
    kvs' = ((PropertyKey, PropertyValue) -> (Text, Text))
    -> Properties -> [(Text, Text)]
    forall a b. (a -> b) -> [a] -> [b]
    map (PropertyKey, PropertyValue) -> (Text, Text)
    toTextPair (Properties -> [(Text, Text)])
    -> (Properties -> Properties) -> Properties -> [(Text, Text)]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ((PropertyKey, PropertyValue) -> Bool) -> Properties -> Properties
    forall a. (a -> Bool) -> [a] -> [a]
    filter ((PropertyKey -> [PropertyKey] -> Bool
    forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
    `notElem` [PropertyKey]
    specialProperties) (PropertyKey -> Bool)
    -> ((PropertyKey, PropertyValue) -> PropertyKey)
    -> (PropertyKey, PropertyValue)
    -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (PropertyKey, PropertyValue) -> PropertyKey
    forall a b. (a, b) -> a
    fst)
               (Properties -> [(Text, Text)]) -> Properties -> [(Text, Text)]
    forall a b. (a -> b) -> a -> b
    $ Properties
    properties
        isUnnumbered :: Bool
    isUnnumbered =
          Bool -> (PropertyValue -> Bool) -> Maybe PropertyValue -> Bool
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe Bool
    False PropertyValue -> Bool
    isNonNil (Maybe PropertyValue -> Bool)
    -> (Properties -> Maybe PropertyValue) -> Properties -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . PropertyKey -> Properties -> Maybe PropertyValue
    forall a b. Eq a => a -> [(a, b)] -> Maybe b
    lookup PropertyKey
    unnumberedKey (Properties -> Bool) -> Properties -> Bool
    forall a b. (a -> b) -> a -> b
    $ Properties
    properties
      in
        (Text
    id', Text -> [Text]
    T.words Text
    cls [Text] -> [Text] -> [Text]
    forall a. [a] -> [a] -> [a]
    ++ ["unnumbered" | Bool
    isUnnumbered], [(Text, Text)]
    kvs')

    tagsToInlines :: [Tag] -> Inlines
    tagsToInlines :: [Tag] -> Inlines
    tagsToInlines [] = Inlines
    forall a. Monoid a => a
    mempty
    tagsToInlines tags :: [Tag]
    tags =
      (Inlines
    B.space Inlines -> Inlines -> Inlines
    forall a. Semigroup a => a -> a -> a
    <>) (Inlines -> Inlines) -> ([Tag] -> Inlines) -> [Tag] -> Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [Inlines] -> Inlines
    forall a. Monoid a => [a] -> a
    mconcat ([Inlines] -> Inlines) -> ([Tag] -> [Inlines]) -> [Tag] -> Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Inlines -> [Inlines] -> [Inlines]
    forall a. a -> [a] -> [a]
    intersperse (Text -> Inlines
    B.str "\160") ([Inlines] -> [Inlines])
    -> ([Tag] -> [Inlines]) -> [Tag] -> [Inlines]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Tag -> Inlines) -> [Tag] -> [Inlines]
    forall a b. (a -> b) -> [a] -> [b]
    map Tag -> Inlines
    tagToInline ([Tag] -> Inlines) -> [Tag] -> Inlines
    forall a b. (a -> b) -> a -> b
    $ [Tag]
    tags
     where
      tagToInline :: Tag -> Inlines
      tagToInline :: Tag -> Inlines
    tagToInline t :: Tag
    t = Tag -> Inlines -> Inlines
    tagSpan Tag
    t (Inlines -> Inlines) -> (Text -> Inlines) -> Text -> Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Inlines -> Inlines
    B.smallcaps (Inlines -> Inlines) -> (Text -> Inlines) -> Text -> Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Inlines
    B.str (Text -> Inlines) -> Text -> Inlines
    forall a b. (a -> b) -> a -> b
    $ Tag -> Text
    fromTag Tag
    t

    -- | Wrap the given inline in a span, marking it as a tag.
    tagSpan :: Tag -> Inlines -> Inlines
    tagSpan :: Tag -> Inlines -> Inlines
    tagSpan t :: Tag
    t = Attr -> Inlines -> Inlines
    B.spanWith ("", ["tag"], [("tag-name", Tag -> Text
    fromTag Tag
    t)])

    -- | Render planning info as a block iff the respective export setting is
    -- enabled.
    planningToBlock :: Monad m => PlanningInfo -> OrgParser m Blocks
    planningToBlock :: PlanningInfo -> OrgParser m Blocks
    planningToBlock planning :: PlanningInfo
    planning = do
      Bool
    includePlanning <- (ExportSettings -> Bool) -> OrgParser m Bool
    forall (m :: * -> *) a.
    Monad m =>
    (ExportSettings -> a) -> OrgParser m a
    getExportSetting ExportSettings -> Bool
    exportWithPlanning
      Blocks -> OrgParser m Blocks
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Blocks -> OrgParser m Blocks) -> Blocks -> OrgParser m Blocks
    forall a b. (a -> b) -> a -> b
    $
        if Bool
    includePlanning
        then Inlines -> Blocks
    B.plain (Inlines -> Blocks)
    -> ([Inlines] -> Inlines) -> [Inlines] -> Blocks
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [Inlines] -> Inlines
    forall a. Monoid a => [a] -> a
    mconcat ([Inlines] -> Inlines)
    -> ([Inlines] -> [Inlines]) -> [Inlines] -> Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Inlines -> [Inlines] -> [Inlines]
    forall a. a -> [a] -> [a]
    intersperse Inlines
    B.space ([Inlines] -> [Inlines])
    -> ([Inlines] -> [Inlines]) -> [Inlines] -> [Inlines]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Inlines -> Bool) -> [Inlines] -> [Inlines]
    forall a. (a -> Bool) -> [a] -> [a]
    filter (Inlines -> Inlines -> Bool
    forall a. Eq a => a -> a -> Bool
    /= Inlines
    forall a. Monoid a => a
    mempty) ([Inlines] -> Blocks) -> [Inlines] -> Blocks
    forall a b. (a -> b) -> a -> b
    $
             [ (PlanningInfo -> Maybe Text) -> Text -> Inlines
    datumInlines PlanningInfo -> Maybe Text
    planningClosed "CLOSED"
             , (PlanningInfo -> Maybe Text) -> Text -> Inlines
    datumInlines PlanningInfo -> Maybe Text
    planningDeadline "DEADLINE"
             , (PlanningInfo -> Maybe Text) -> Text -> Inlines
    datumInlines PlanningInfo -> Maybe Text
    planningScheduled "SCHEDULED"
             ]
        else Blocks
    forall a. Monoid a => a
    mempty
     where
      datumInlines :: (PlanningInfo -> Maybe Text) -> Text -> Inlines
    datumInlines field :: PlanningInfo -> Maybe Text
    field name :: Text
    name =
        case PlanningInfo -> Maybe Text
    field PlanningInfo
    planning of
          Nothing -> Inlines
    forall a. Monoid a => a
    mempty
          Just time :: Text
    time ->   Inlines -> Inlines
    B.strong (Text -> Inlines
    B.str Text
    name Inlines -> Inlines -> Inlines
    forall a. Semigroup a => a -> a -> a
    <> Text -> Inlines
    B.str ":")
                      Inlines -> Inlines -> Inlines
    forall a. Semigroup a => a -> a -> a
    <> Inlines
    B.space
                      Inlines -> Inlines -> Inlines
    forall a. Semigroup a => a -> a -> a
    <> Inlines -> Inlines
    B.emph (Text -> Inlines
    B.str Text
    time)

    -- | An Org timestamp, including repetition marks. TODO: improve
    type Timestamp = Text

    timestamp :: Monad m => OrgParser m Timestamp
    timestamp :: OrgParser m Text
    timestamp = OrgParser m Text -> OrgParser m Text
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (OrgParser m Text -> OrgParser m Text)
    -> OrgParser m Text -> OrgParser m Text
    forall a b. (a -> b) -> a -> b
    $ do
      Char
    openChar <- String
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    String -> ParsecT s u m Char
    oneOf "<["
      let isActive :: Bool
    isActive = Char
    openChar Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    == '<'
      let closeChar :: Char
    closeChar = if Bool
    isActive then '>' else ']'
      Text
    content <- ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Char
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Char
    -> OrgParser m Text
    forall end s (m :: * -> *) t st.
    (Show end, Stream s m t) =>
    ParserT s st m Char -> ParserT s st m end -> ParserT s st m Text
    many1TillChar ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    anyChar (Char -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char Char
    closeChar)
      Text -> OrgParser m Text
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Text -> OrgParser m Text) -> Text -> OrgParser m Text
    forall a b. (a -> b) -> a -> b
    $ Char -> Text -> Text
    T.cons Char
    openChar (Text -> Text) -> Text -> Text
    forall a b. (a -> b) -> a -> b
    $ Text
    content Text -> Char -> Text
    `T.snoc` Char
    closeChar

    -- | Planning information for a subtree/headline.
    data PlanningInfo = PlanningInfo
      { PlanningInfo -> Maybe Text
    planningClosed :: Maybe Timestamp
      , PlanningInfo -> Maybe Text
    planningDeadline :: Maybe Timestamp
      , PlanningInfo -> Maybe Text
    planningScheduled :: Maybe Timestamp
      }

    emptyPlanning :: PlanningInfo
    emptyPlanning :: PlanningInfo
    emptyPlanning = Maybe Text -> Maybe Text -> Maybe Text -> PlanningInfo
    PlanningInfo Maybe Text
    forall a. Maybe a
    Nothing Maybe Text
    forall a. Maybe a
    Nothing Maybe Text
    forall a. Maybe a
    Nothing

    -- | Read a single planning-related and timestamped line.
    planningInfo :: Monad m => OrgParser m PlanningInfo
    planningInfo :: OrgParser m PlanningInfo
    planningInfo = OrgParser m PlanningInfo -> OrgParser m PlanningInfo
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (OrgParser m PlanningInfo -> OrgParser m PlanningInfo)
    -> OrgParser m PlanningInfo -> OrgParser m PlanningInfo
    forall a b. (a -> b) -> a -> b
    $ do
      [PlanningInfo -> PlanningInfo]
    updaters <- ParsecT
      Text
      OrgParserState
      (ReaderT OrgParserLocal m)
      (PlanningInfo -> PlanningInfo)
    -> ParsecT
         Text
         OrgParserState
         (ReaderT OrgParserLocal m)
         [PlanningInfo -> PlanningInfo]
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m [a]
    many1 ParsecT
      Text
      OrgParserState
      (ReaderT OrgParserLocal m)
      (PlanningInfo -> PlanningInfo)
    planningDatum ParsecT
      Text
      OrgParserState
      (ReaderT OrgParserLocal m)
      [PlanningInfo -> PlanningInfo]
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) ()
    -> ParsecT
         Text
         OrgParserState
         (ReaderT OrgParserLocal m)
         [PlanningInfo -> PlanningInfo]
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT Text OrgParserState (ReaderT OrgParserLocal m) ()
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m ()
    skipSpaces ParsecT
      Text
      OrgParserState
      (ReaderT OrgParserLocal m)
      [PlanningInfo -> PlanningInfo]
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Char
    -> ParsecT
         Text
         OrgParserState
         (ReaderT OrgParserLocal m)
         [PlanningInfo -> PlanningInfo]
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Char
    forall (m :: * -> *). Monad m => OrgParser m Char
    newline
      PlanningInfo -> OrgParser m PlanningInfo
    forall (m :: * -> *) a. Monad m => a -> m a
    return (PlanningInfo -> OrgParser m PlanningInfo)
    -> PlanningInfo -> OrgParser m PlanningInfo
    forall a b. (a -> b) -> a -> b
    $ ((PlanningInfo -> PlanningInfo) -> PlanningInfo -> PlanningInfo)
    -> PlanningInfo -> [PlanningInfo -> PlanningInfo] -> PlanningInfo
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    foldr (PlanningInfo -> PlanningInfo) -> PlanningInfo -> PlanningInfo
    forall a b. (a -> b) -> a -> b
    ($) PlanningInfo
    emptyPlanning [PlanningInfo -> PlanningInfo]
    updaters
     where
      planningDatum :: ParsecT
      Text
      OrgParserState
      (ReaderT OrgParserLocal m)
      (PlanningInfo -> PlanningInfo)
    planningDatum = ParsecT Text OrgParserState (ReaderT OrgParserLocal m) ()
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m ()
    skipSpaces ParsecT Text OrgParserState (ReaderT OrgParserLocal m) ()
    -> ParsecT
         Text
         OrgParserState
         (ReaderT OrgParserLocal m)
         (PlanningInfo -> PlanningInfo)
    -> ParsecT
         Text
         OrgParserState
         (ReaderT OrgParserLocal m)
         (PlanningInfo -> PlanningInfo)
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> [ParsecT
       Text
       OrgParserState
       (ReaderT OrgParserLocal m)
       (PlanningInfo -> PlanningInfo)]
    -> ParsecT
         Text
         OrgParserState
         (ReaderT OrgParserLocal m)
         (PlanningInfo -> PlanningInfo)
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    [ParsecT s u m a] -> ParsecT s u m a
    choice
        [ (Text -> PlanningInfo -> PlanningInfo)
    -> String
    -> ParsecT
         Text
         OrgParserState
         (ReaderT OrgParserLocal m)
         (PlanningInfo -> PlanningInfo)
    forall (m :: * -> *) b.
    Monad m =>
    (Text -> b)
    -> String
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) b
    updateWith (\s :: Text
    s p :: PlanningInfo
    p -> PlanningInfo
    p { planningScheduled :: Maybe Text
    planningScheduled = Text -> Maybe Text
    forall a. a -> Maybe a
    Just Text
    s}) "SCHEDULED"
        , (Text -> PlanningInfo -> PlanningInfo)
    -> String
    -> ParsecT
         Text
         OrgParserState
         (ReaderT OrgParserLocal m)
         (PlanningInfo -> PlanningInfo)
    forall (m :: * -> *) b.
    Monad m =>
    (Text -> b)
    -> String
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) b
    updateWith (\d :: Text
    d p :: PlanningInfo
    p -> PlanningInfo
    p { planningDeadline :: Maybe Text
    planningDeadline = Text -> Maybe Text
    forall a. a -> Maybe a
    Just Text
    d}) "DEADLINE"
        , (Text -> PlanningInfo -> PlanningInfo)
    -> String
    -> ParsecT
         Text
         OrgParserState
         (ReaderT OrgParserLocal m)
         (PlanningInfo -> PlanningInfo)
    forall (m :: * -> *) b.
    Monad m =>
    (Text -> b)
    -> String
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) b
    updateWith (\c :: Text
    c p :: PlanningInfo
    p -> PlanningInfo
    p { planningClosed :: Maybe Text
    planningClosed = Text -> Maybe Text
    forall a. a -> Maybe a
    Just Text
    c}) "CLOSED"
        ]
      updateWith :: (Text -> b)
    -> String
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) b
    updateWith fn :: Text -> b
    fn cs :: String
    cs = Text -> b
    fn (Text -> b)
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Text
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (String
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) String
    forall s (m :: * -> *) u.
    Stream s m Char =>
    String -> ParsecT s u m String
    string String
    cs ParsecT Text OrgParserState (ReaderT OrgParserLocal m) String
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Char
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Char
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> Char -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char ':' ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Char
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) ()
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) ()
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) ()
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m ()
    skipSpaces ParsecT Text OrgParserState (ReaderT OrgParserLocal m) ()
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Text
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Text
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Text
    forall (m :: * -> *). Monad m => OrgParser m Text
    timestamp)

    -- | Read a :PROPERTIES: drawer and return the key/value pairs contained
    -- within.
    propertiesDrawer :: Monad m => OrgParser m Properties
    propertiesDrawer :: OrgParser m Properties
    propertiesDrawer = OrgParser m Properties -> OrgParser m Properties
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (OrgParser m Properties -> OrgParser m Properties)
    -> OrgParser m Properties -> OrgParser m Properties
    forall a b. (a -> b) -> a -> b
    $ do
      Text
    drawerType <- OrgParser m Text
    forall (m :: * -> *). Monad m => OrgParser m Text
    drawerStart
      Bool -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) ()
    forall (f :: * -> *). Alternative f => Bool -> f ()
    guard (Bool -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) ())
    -> Bool
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) ()
    forall a b. (a -> b) -> a -> b
    $ Text -> Text
    T.toUpper Text
    drawerType Text -> Text -> Bool
    forall a. Eq a => a -> a -> Bool
    == "PROPERTIES"
      ParsecT
      Text
      OrgParserState
      (ReaderT OrgParserLocal m)
      (PropertyKey, PropertyValue)
    -> OrgParser m Text -> OrgParser m Properties
    forall s (m :: * -> *) t u a end.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    manyTill ParsecT
      Text
      OrgParserState
      (ReaderT OrgParserLocal m)
      (PropertyKey, PropertyValue)
    forall (m :: * -> *).
    Monad m =>
    OrgParser m (PropertyKey, PropertyValue)
    property (OrgParser m Text -> OrgParser m Text
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try OrgParser m Text
    forall (m :: * -> *). Monad m => OrgParser m Text
    endOfDrawer)
     where
       property :: Monad m => OrgParser m (PropertyKey, PropertyValue)
       property :: OrgParser m (PropertyKey, PropertyValue)
    property = OrgParser m (PropertyKey, PropertyValue)
    -> OrgParser m (PropertyKey, PropertyValue)
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (OrgParser m (PropertyKey, PropertyValue)
     -> OrgParser m (PropertyKey, PropertyValue))
    -> OrgParser m (PropertyKey, PropertyValue)
    -> OrgParser m (PropertyKey, PropertyValue)
    forall a b. (a -> b) -> a -> b
    $ (,) (PropertyKey -> PropertyValue -> (PropertyKey, PropertyValue))
    -> ParsecT
         Text OrgParserState (ReaderT OrgParserLocal m) PropertyKey
    -> ParsecT
         Text
         OrgParserState
         (ReaderT OrgParserLocal m)
         (PropertyValue -> (PropertyKey, PropertyValue))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) PropertyKey
    forall (m :: * -> *). Monad m => OrgParser m PropertyKey
    key ParsecT
      Text
      OrgParserState
      (ReaderT OrgParserLocal m)
      (PropertyValue -> (PropertyKey, PropertyValue))
    -> ParsecT
         Text OrgParserState (ReaderT OrgParserLocal m) PropertyValue
    -> OrgParser m (PropertyKey, PropertyValue)
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ParsecT
      Text OrgParserState (ReaderT OrgParserLocal m) PropertyValue
    forall (m :: * -> *). Monad m => OrgParser m PropertyValue
    value

       key :: Monad m => OrgParser m PropertyKey
       key :: OrgParser m PropertyKey
    key = (Text -> PropertyKey)
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Text
    -> OrgParser m PropertyKey
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Text -> PropertyKey
    toPropertyKey (ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Text
     -> OrgParser m PropertyKey)
    -> (ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Text
        -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Text)
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Text
    -> OrgParser m PropertyKey
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Text
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Text
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Text
     -> OrgParser m PropertyKey)
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Text
    -> OrgParser m PropertyKey
    forall a b. (a -> b) -> a -> b
    $
             ParserT Text OrgParserState (ReaderT OrgParserLocal m) ()
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m ()
    skipSpaces ParserT Text OrgParserState (ReaderT OrgParserLocal m) ()
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Char
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Char
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> Char -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char ':' ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Char
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Text
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Text
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Char
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Char
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Text
    forall end s (m :: * -> *) t st.
    (Show end, Stream s m t) =>
    ParserT s st m Char -> ParserT s st m end -> ParserT s st m Text
    many1TillChar ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    nonspaceChar (Char -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char ':')

       value :: Monad m => OrgParser m PropertyValue
       value :: OrgParser m PropertyValue
    value = (Text -> PropertyValue)
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Text
    -> OrgParser m PropertyValue
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Text -> PropertyValue
    toPropertyValue (ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Text
     -> OrgParser m PropertyValue)
    -> (ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Text
        -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Text)
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Text
    -> OrgParser m PropertyValue
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Text
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Text
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Text
     -> OrgParser m PropertyValue)
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Text
    -> OrgParser m PropertyValue
    forall a b. (a -> b) -> a -> b
    $
               ParserT Text OrgParserState (ReaderT OrgParserLocal m) ()
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m ()
    skipSpaces ParserT Text OrgParserState (ReaderT OrgParserLocal m) ()
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Text
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Text
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> ParserT Text OrgParserState (ReaderT OrgParserLocal m) Char
    -> ParserT Text OrgParserState (ReaderT OrgParserLocal m) Char
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Text
    forall s (m :: * -> *) t st a.
    Stream s m t =>
    ParserT s st m Char -> ParserT s st m a -> ParserT s st m Text
    manyTillChar ParserT Text OrgParserState (ReaderT OrgParserLocal m) Char
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m Char
    anyChar (ParserT Text OrgParserState (ReaderT OrgParserLocal m) Char
    -> ParserT Text OrgParserState (ReaderT OrgParserLocal m) Char
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParserT Text OrgParserState (ReaderT OrgParserLocal m) Char
     -> ParserT Text OrgParserState (ReaderT OrgParserLocal m) Char)
    -> ParserT Text OrgParserState (ReaderT OrgParserLocal m) Char
    -> ParserT Text OrgParserState (ReaderT OrgParserLocal m) Char
    forall a b. (a -> b) -> a -> b
    $ ParserT Text OrgParserState (ReaderT OrgParserLocal m) ()
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m ()
    skipSpaces ParserT Text OrgParserState (ReaderT OrgParserLocal m) ()
    -> ParserT Text OrgParserState (ReaderT OrgParserLocal m) Char
    -> ParserT Text OrgParserState (ReaderT OrgParserLocal m) Char
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> ParserT Text OrgParserState (ReaderT OrgParserLocal m) Char
    forall (m :: * -> *). Monad m => OrgParser m Char
    newline)

       endOfDrawer :: Monad m => OrgParser m Text
       endOfDrawer :: OrgParser m Text
    endOfDrawer = OrgParser m Text -> OrgParser m Text
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (OrgParser m Text -> OrgParser m Text)
    -> OrgParser m Text -> OrgParser m Text
    forall a b. (a -> b) -> a -> b
    $
         ParserT Text OrgParserState (ReaderT OrgParserLocal m) ()
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m ()
    skipSpaces ParserT Text OrgParserState (ReaderT OrgParserLocal m) ()
    -> OrgParser m Text -> OrgParser m Text
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> Text -> OrgParser m Text
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Text -> ParsecT s u m Text
    stringAnyCase ":END:" OrgParser m Text
    -> ParserT Text OrgParserState (ReaderT OrgParserLocal m) ()
    -> OrgParser m Text
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParserT Text OrgParserState (ReaderT OrgParserLocal m) ()
    forall s (m :: * -> *) st. Stream s m Char => ParserT s st m ()
    skipSpaces OrgParser m Text
    -> ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Char
    -> OrgParser m Text
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* ParsecT Text OrgParserState (ReaderT OrgParserLocal m) Char
    forall (m :: * -> *). Monad m => OrgParser m Char
    newline