@@ -1,5 +1,6 @@
1{-# LANGUAGE RelaxedPolyRec #-} -- needed for inlinesBetween on GHC < 7
1{-# LANGUAGE RelaxedPolyRec #-} -- needed for inlinesBetween on GHC < 7
2{-# LANGUAGE ScopedTypeVariables #-}
2{-# LANGUAGE ScopedTypeVariables #-}
4Copyright (C) 2006-2015 John MacFarlane <jgm@berkeley.edu>
5Copyright (C) 2006-2015 John MacFarlane <jgm@berkeley.edu>
@@ -65,24 +66,31 @@ import qualified Data.Set as Set
65import Text.Printf (printf)
66import Text.Printf (printf)
66import Debug.Trace (trace)
67import Debug.Trace (trace)
67import Data.Monoid ((<>))
68import Data.Monoid ((<>))
68−import Text.Pandoc.Error
69+import Control.Monad.Trans (lift)
70+import Control.Monad.Except (throwError, catchError)
71+import Text.Pandoc.Class (PandocMonad, PandocExecutionError(..))
72+import qualified Text.Pandoc.Class as P
70−type MarkdownParser = Parser [Char] ParserState
74+type MarkdownParser m = ParserT [Char] ParserState m
72-- | Read markdown from an input string and return a Pandoc document.
76-- | Read markdown from an input string and return a Pandoc document.
77+readMarkdown :: PandocMonad m
73−readMarkdown :: ReaderOptions -- ^ Reader options
78+ => ReaderOptions -- ^ Reader options
74 -> String -- ^ String to parse (assuming @'\n'@ line endings)
79 -> String -- ^ String to parse (assuming @'\n'@ line endings)
75− -> Either PandocError Pandoc
80+ -> m Pandoc
76−readMarkdown opts s =
81+readMarkdown opts s = do
77− (readWith parseMarkdown) def{ stateOptions = opts } (s ++ "\n\n")
82+ parsed <- (readWithM parseMarkdown) def{ stateOptions = opts } (s ++ "\n\n")
84+ Right result -> return result
85+ Left _ -> throwError $ PandocParseError "markdown parse error"
79-- | Read markdown from an input string and return a pair of a Pandoc document
87-- | Read markdown from an input string and return a pair of a Pandoc document
80-- and a list of warnings.
88-- and a list of warnings.
89+readMarkdownWithWarnings :: PandocMonad m
81−readMarkdownWithWarnings :: ReaderOptions -- ^ Reader options
90+ => ReaderOptions -- ^ Reader options
82 -> String -- ^ String to parse (assuming @'\n'@ line endings)
91 -> String -- ^ String to parse (assuming @'\n'@ line endings)
83− -> Either PandocError (Pandoc, [String])
92+ -> m Pandoc
84−readMarkdownWithWarnings opts s =
93+readMarkdownWithWarnings = readMarkdown
85− (readWithWarnings parseMarkdown) def{ stateOptions = opts } (s ++ "\n\n")
87trimInlinesF :: F Inlines -> F Inlines
95trimInlinesF :: F Inlines -> F Inlines
88trimInlinesF = liftM trimInlines
96trimInlinesF = liftM trimInlines
@@ -117,25 +125,25 @@ isBlank _ = False
119-- | Succeeds when we're in list context.
127-- | Succeeds when we're in list context.
120−inList :: MarkdownParser ()
128+inList :: PandocMonad m => MarkdownParser m ()
121inList = do
129inList = do
122 ctx <- stateParserContext <$> getState
130 ctx <- stateParserContext <$> getState
123 guard (ctx == ListItemState)
131 guard (ctx == ListItemState)
125−spnl :: Parser [Char] st ()
133+spnl :: PandocMonad m => ParserT [Char] st m ()
126spnl = try $ do
134spnl = try $ do
127 skipSpaces
135 skipSpaces
128 optional newline
136 optional newline
129 skipSpaces
137 skipSpaces
130 notFollowedBy (char '\n')
138 notFollowedBy (char '\n')
132−indentSpaces :: MarkdownParser String
140+indentSpaces :: PandocMonad m => MarkdownParser m String
133indentSpaces = try $ do
141indentSpaces = try $ do
134 tabStop <- getOption readerTabStop
142 tabStop <- getOption readerTabStop
135 count tabStop (char ' ') <|>
143 count tabStop (char ' ') <|>
136 string "\t" <?> "indentation"
144 string "\t" <?> "indentation"
138−nonindentSpaces :: MarkdownParser String
146+nonindentSpaces :: PandocMonad m => MarkdownParser m String
139nonindentSpaces = do
147nonindentSpaces = do
140 tabStop <- getOption readerTabStop
148 tabStop <- getOption readerTabStop
141 sps <- many (char ' ')
149 sps <- many (char ' ')
@@ -144,17 +152,17 @@ nonindentSpaces = do
144 else unexpected "indented line"
152 else unexpected "indented line"
146-- returns number of spaces parsed
154-- returns number of spaces parsed
147−skipNonindentSpaces :: MarkdownParser Int
155+skipNonindentSpaces :: PandocMonad m => MarkdownParser m Int
148skipNonindentSpaces = do
156skipNonindentSpaces = do
149 tabStop <- getOption readerTabStop
157 tabStop <- getOption readerTabStop
150 atMostSpaces (tabStop - 1) <* notFollowedBy (char ' ')
158 atMostSpaces (tabStop - 1) <* notFollowedBy (char ' ')
152−atMostSpaces :: Int -> MarkdownParser Int
160+atMostSpaces :: PandocMonad m => Int -> MarkdownParser m Int
153atMostSpaces n
161atMostSpaces n
154 | n > 0 = (char ' ' >> (+1) <$> atMostSpaces (n-1)) <|> return 0
162 | n > 0 = (char ' ' >> (+1) <$> atMostSpaces (n-1)) <|> return 0
155 | otherwise = return 0
163 | otherwise = return 0
157−litChar :: MarkdownParser Char
165+litChar :: PandocMonad m => MarkdownParser m Char
158litChar = escapedChar'
166litChar = escapedChar'
159 <|> characterReference
167 <|> characterReference
160 <|> noneOf "\n"
168 <|> noneOf "\n"
@@ -162,14 +170,14 @@ litChar = escapedChar'
163-- | Parse a sequence of inline elements between square brackets,
171-- | Parse a sequence of inline elements between square brackets,
164-- including inlines between balanced pairs of square brackets.
172-- including inlines between balanced pairs of square brackets.
165−inlinesInBalancedBrackets :: MarkdownParser (F Inlines)
173+inlinesInBalancedBrackets :: PandocMonad m => MarkdownParser m (F Inlines)
166inlinesInBalancedBrackets = do
174inlinesInBalancedBrackets = do
168 (_, raw) <- withRaw $ charsInBalancedBrackets 1
176 (_, raw) <- withRaw $ charsInBalancedBrackets 1
169 guard $ not $ null raw
177 guard $ not $ null raw
170 parseFromString (trimInlinesF . mconcat <$> many inline) (init raw)
178 parseFromString (trimInlinesF . mconcat <$> many inline) (init raw)
172−charsInBalancedBrackets :: Int -> MarkdownParser ()
180+charsInBalancedBrackets :: PandocMonad m => Int -> MarkdownParser m ()
173charsInBalancedBrackets 0 = return ()
181charsInBalancedBrackets 0 = return ()
174charsInBalancedBrackets openBrackets =
182charsInBalancedBrackets openBrackets =
175 (char '[' >> charsInBalancedBrackets (openBrackets + 1))
183 (char '[' >> charsInBalancedBrackets (openBrackets + 1))
@@ -185,7 +193,7 @@ charsInBalancedBrackets openBrackets =
185-- document structure
193-- document structure
188−rawTitleBlockLine :: MarkdownParser String
196+rawTitleBlockLine :: PandocMonad m => MarkdownParser m String
189rawTitleBlockLine = do
197rawTitleBlockLine = do
191 skipSpaces
199 skipSpaces
@@ -196,13 +204,13 @@ rawTitleBlockLine = do
197 return $ trim $ unlines (first:rest)
205 return $ trim $ unlines (first:rest)
199−titleLine :: MarkdownParser (F Inlines)
207+titleLine :: PandocMonad m => MarkdownParser m (F Inlines)
200titleLine = try $ do
208titleLine = try $ do
201 raw <- rawTitleBlockLine
209 raw <- rawTitleBlockLine
202 res <- parseFromString (many inline) raw
210 res <- parseFromString (many inline) raw
203 return $ trimInlinesF $ mconcat res
211 return $ trimInlinesF $ mconcat res
205−authorsLine :: MarkdownParser (F [Inlines])
213+authorsLine :: PandocMonad m => MarkdownParser m (F [Inlines])
206authorsLine = try $ do
214authorsLine = try $ do
207 raw <- rawTitleBlockLine
215 raw <- rawTitleBlockLine
208 let sep = (char ';' <* spaces) <|> newline
216 let sep = (char ';' <* spaces) <|> newline
@@ -212,16 +220,16 @@ authorsLine = try $ do
213 sequence <$> parseFromString pAuthors raw
221 sequence <$> parseFromString pAuthors raw
215−dateLine :: MarkdownParser (F Inlines)
223+dateLine :: PandocMonad m => MarkdownParser m (F Inlines)
216dateLine = try $ do
224dateLine = try $ do
217 raw <- rawTitleBlockLine
225 raw <- rawTitleBlockLine
218 res <- parseFromString (many inline) raw
226 res <- parseFromString (many inline) raw
219 return $ trimInlinesF $ mconcat res
227 return $ trimInlinesF $ mconcat res
221−titleBlock :: MarkdownParser ()
229+titleBlock :: PandocMonad m => MarkdownParser m ()
222titleBlock = pandocTitleBlock <|> mmdTitleBlock
230titleBlock = pandocTitleBlock <|> mmdTitleBlock
224−pandocTitleBlock :: MarkdownParser ()
232+pandocTitleBlock :: PandocMonad m => MarkdownParser m ()
225pandocTitleBlock = try $ do
233pandocTitleBlock = try $ do
226 guardEnabled Ext_pandoc_title_block
234 guardEnabled Ext_pandoc_title_block
227 lookAhead (char '%')
235 lookAhead (char '%')
@@ -239,7 +247,15 @@ pandocTitleBlock = try $ do
239 $ nullMeta
247 $ nullMeta
240 updateState $ \st -> st{ stateMeta' = stateMeta' st <> meta' }
248 updateState $ \st -> st{ stateMeta' = stateMeta' st <> meta' }
251+-- Adapted from solution at
252+-- http://stackoverflow.com/a/29448764/1901888
253+foldrWithKeyM :: Monad m => (k -> b -> a -> m a) -> a -> H.HashMap k b -> m a
254+foldrWithKeyM f acc = H.foldrWithKey f' (return acc)
256+ f' k b ma = ma >>= \a -> f k b a
242−yamlMetaBlock :: MarkdownParser (F Blocks)
258+yamlMetaBlock :: PandocMonad m => MarkdownParser m (F Blocks)
243yamlMetaBlock = try $ do
259yamlMetaBlock = try $ do
244 guardEnabled Ext_yaml_metadata_block
260 guardEnabled Ext_yaml_metadata_block
245 pos <- getPosition
261 pos <- getPosition
@@ -252,18 +268,20 @@ yamlMetaBlock = try $ do
252 optional blanklines
268 optional blanklines
253 opts <- stateOptions <$> getState
269 opts <- stateOptions <$> getState
254 meta' <- case Yaml.decodeEither' $ UTF8.fromString rawYaml of
270 meta' <- case Yaml.decodeEither' $ UTF8.fromString rawYaml of
255− Right (Yaml.Object hashmap) -> return $ return $
271+ Right (Yaml.Object hashmap) ->
256− H.foldrWithKey (\k v m ->
272+ foldrWithKeyM
257− if ignorable k
274+ if ignorable k
258− then m
275+ then return m
259− else case yamlToMeta opts v of
276+ else (do v' <- lift $ yamlToMeta opts v
261− Right v' -> B.setMeta (T.unpack k) v' m)
277+ return $ B.setMeta (T.unpack k) v' m)
262− nullMeta hashmap
280+ ) nullMeta hashmap
263− Right Yaml.Null -> return $ return nullMeta
281+ Right Yaml.Null -> return nullMeta
264 Right _ -> do
282 Right _ -> do
265− addWarning (Just pos) "YAML header is not an object"
283+ P.addWarningWithPos (Just pos) "YAML header is not an object"
266− return $ return nullMeta
284+ return nullMeta
267 Left err' -> do
285 Left err' -> do
268 case err' of
286 case err' of
269 InvalidYaml (Just YamlParseException{
287 InvalidYaml (Just YamlParseException{
@@ -273,24 +291,24 @@ yamlMetaBlock = try $ do
273 yamlLine = yline
291 yamlLine = yline
274 , yamlColumn = ycol
292 , yamlColumn = ycol
276− addWarning (Just $ setSourceLine
294+ P.addWarningWithPos (Just $ setSourceLine
277 (setSourceColumn pos
295 (setSourceColumn pos
278 (sourceColumn pos + ycol))
296 (sourceColumn pos + ycol))
279 (sourceLine pos + 1 + yline))
297 (sourceLine pos + 1 + yline))
280 $ "Could not parse YAML header: " ++
298 $ "Could not parse YAML header: " ++
282− _ -> addWarning (Just pos)
300+ _ -> P.addWarningWithPos (Just pos)
283 $ "Could not parse YAML header: " ++
301 $ "Could not parse YAML header: " ++
284 show err'
302 show err'
285− return $ return nullMeta
303+ return nullMeta
286− updateState $ \st -> st{ stateMeta' = stateMeta' st <> meta' }
304+ updateState $ \st -> st{ stateMeta' = stateMeta' st <> (return meta') }
287 return mempty
305 return mempty
289-- ignore fields ending with _
307-- ignore fields ending with _
290ignorable :: Text -> Bool
308ignorable :: Text -> Bool
291ignorable t = (T.pack "_") `T.isSuffixOf` t
309ignorable t = (T.pack "_") `T.isSuffixOf` t
293−toMetaValue :: ReaderOptions -> Text -> Either PandocError MetaValue
311+toMetaValue :: PandocMonad m => ReaderOptions -> Text -> m MetaValue
294toMetaValue opts x = toMeta <$> readMarkdown opts' (T.unpack x)
312toMetaValue opts x = toMeta <$> readMarkdown opts' (T.unpack x)
296 toMeta p =
314 toMeta p =
@@ -307,7 +325,7 @@ toMetaValue opts x = toMeta <$> readMarkdown opts' (T.unpack x)
307 , Ext_yaml_metadata_block
325 , Ext_yaml_metadata_block
310−yamlToMeta :: ReaderOptions -> Yaml.Value -> Either PandocError MetaValue
328+yamlToMeta :: PandocMonad m => ReaderOptions -> Yaml.Value -> m MetaValue
311yamlToMeta opts (Yaml.String t) = toMetaValue opts t
329yamlToMeta opts (Yaml.String t) = toMetaValue opts t
312yamlToMeta _ (Yaml.Number n)
330yamlToMeta _ (Yaml.Number n)
313 -- avoid decimal points for numbers that don't need them:
331 -- avoid decimal points for numbers that don't need them:
@@ -327,10 +345,10 @@ yamlToMeta opts (Yaml.Object o) = MetaMap <$> H.foldrWithKey (\k v m ->
327 (return M.empty) o
345 (return M.empty) o
328yamlToMeta _ _ = return $ MetaString ""
346yamlToMeta _ _ = return $ MetaString ""
330−stopLine :: MarkdownParser ()
348+stopLine :: PandocMonad m => MarkdownParser m ()
331stopLine = try $ (string "---" <|> string "...") >> blankline >> return ()
349stopLine = try $ (string "---" <|> string "...") >> blankline >> return ()
333−mmdTitleBlock :: MarkdownParser ()
351+mmdTitleBlock :: PandocMonad m => MarkdownParser m ()
334mmdTitleBlock = try $ do
352mmdTitleBlock = try $ do
335 guardEnabled Ext_mmd_title_block
353 guardEnabled Ext_mmd_title_block
336 firstPair <- kvPair False
354 firstPair <- kvPair False
@@ -340,7 +358,7 @@ mmdTitleBlock = try $ do
340 updateState $ \st -> st{ stateMeta' = stateMeta' st <>
358 updateState $ \st -> st{ stateMeta' = stateMeta' st <>
341 return (Meta $ M.fromList kvPairs) }
359 return (Meta $ M.fromList kvPairs) }
343−kvPair :: Bool -> MarkdownParser (String, MetaValue)
361+kvPair :: PandocMonad m => Bool -> MarkdownParser m (String, MetaValue)
344kvPair allowEmpty = try $ do
362kvPair allowEmpty = try $ do
345 key <- many1Till (alphaNum <|> oneOf "_- ") (char ':')
363 key <- many1Till (alphaNum <|> oneOf "_- ") (char ':')
346 val <- trim <$> manyTill anyChar
364 val <- trim <$> manyTill anyChar
@@ -350,7 +368,7 @@ kvPair allowEmpty = try $ do
350 let val' = MetaBlocks $ B.toList $ B.plain $ B.text $ val
368 let val' = MetaBlocks $ B.toList $ B.plain $ B.text $ val
351 return (key',val')
369 return (key',val')
353−parseMarkdown :: MarkdownParser Pandoc
371+parseMarkdown :: PandocMonad m => MarkdownParser m Pandoc
354parseMarkdown = do
372parseMarkdown = do
355 -- markdown allows raw HTML
373 -- markdown allows raw HTML
356 updateState $ \state -> state { stateOptions =
374 updateState $ \state -> state { stateOptions =
@@ -375,7 +393,7 @@ softBreakFilter (x:SoftBreak:y:zs) =
375 _ -> x:SoftBreak:y:zs
393 _ -> x:SoftBreak:y:zs
376softBreakFilter xs = xs
394softBreakFilter xs = xs
378−referenceKey :: MarkdownParser (F Blocks)
396+referenceKey :: PandocMonad m => MarkdownParser m (F Blocks)
379referenceKey = try $ do
397referenceKey = try $ do
380 pos <- getPosition
398 pos <- getPosition
381 skipNonindentSpaces
399 skipNonindentSpaces
@@ -402,18 +420,18 @@ referenceKey = try $ do
402 let oldkeys = stateKeys st
420 let oldkeys = stateKeys st
403 let key = toKey raw
421 let key = toKey raw
404 case M.lookup key oldkeys of
422 case M.lookup key oldkeys of
405− Just _ -> addWarning (Just pos) $ "Duplicate link reference `" ++ raw ++ "'"
423+ Just _ -> P.addWarningWithPos (Just pos) $ "Duplicate link reference `" ++ raw ++ "'"
406 Nothing -> return ()
424 Nothing -> return ()
407 updateState $ \s -> s { stateKeys = M.insert key (target, attr') oldkeys }
425 updateState $ \s -> s { stateKeys = M.insert key (target, attr') oldkeys }
408 return $ return mempty
426 return $ return mempty
410−referenceTitle :: MarkdownParser String
428+referenceTitle :: PandocMonad m => MarkdownParser m String
411referenceTitle = try $ do
429referenceTitle = try $ do
412 skipSpaces >> optional newline >> skipSpaces
430 skipSpaces >> optional newline >> skipSpaces
413 quotedTitle '"' <|> quotedTitle '\'' <|> charsInBalanced '(' ')' litChar
431 quotedTitle '"' <|> quotedTitle '\'' <|> charsInBalanced '(' ')' litChar
415-- A link title in quotes
433-- A link title in quotes
416−quotedTitle :: Char -> MarkdownParser String
434+quotedTitle :: PandocMonad m => Char -> MarkdownParser m String
417quotedTitle c = try $ do
435quotedTitle c = try $ do
419 notFollowedBy spaces
437 notFollowedBy spaces
@@ -425,7 +443,7 @@ quotedTitle c = try $ do
425-- | PHP Markdown Extra style abbreviation key. Currently
443-- | PHP Markdown Extra style abbreviation key. Currently
426-- we just skip them, since Pandoc doesn't have an element for
444-- we just skip them, since Pandoc doesn't have an element for
427-- an abbreviation.
445-- an abbreviation.
428−abbrevKey :: MarkdownParser (F Blocks)
446+abbrevKey :: PandocMonad m => MarkdownParser m (F Blocks)
429abbrevKey = do
447abbrevKey = do
430 guardEnabled Ext_abbreviations
448 guardEnabled Ext_abbreviations
@@ -436,23 +454,23 @@ abbrevKey = do
436 blanklines
454 blanklines
437 return $ return mempty
455 return $ return mempty
439−noteMarker :: MarkdownParser String
457+noteMarker :: PandocMonad m => MarkdownParser m String
440noteMarker = string "[^" >> many1Till (satisfy $ not . isBlank) (char ']')
458noteMarker = string "[^" >> many1Till (satisfy $ not . isBlank) (char ']')
442−rawLine :: MarkdownParser String
460+rawLine :: PandocMonad m => MarkdownParser m String
443rawLine = try $ do
461rawLine = try $ do
444 notFollowedBy blankline
462 notFollowedBy blankline
445 notFollowedBy' $ try $ skipNonindentSpaces >> noteMarker
463 notFollowedBy' $ try $ skipNonindentSpaces >> noteMarker
446 optional indentSpaces
464 optional indentSpaces
449−rawLines :: MarkdownParser String
467+rawLines :: PandocMonad m => MarkdownParser m String
450rawLines = do
468rawLines = do
451 first <- anyLine
469 first <- anyLine
452 rest <- many rawLine
470 rest <- many rawLine
453 return $ unlines (first:rest)
471 return $ unlines (first:rest)
455−noteBlock :: MarkdownParser (F Blocks)
473+noteBlock :: PandocMonad m => MarkdownParser m (F Blocks)
456noteBlock = try $ do
474noteBlock = try $ do
457 pos <- getPosition
475 pos <- getPosition
458 skipNonindentSpaces
476 skipNonindentSpaces
@@ -468,7 +486,7 @@ noteBlock = try $ do
468 let newnote = (ref, parsed)
486 let newnote = (ref, parsed)
469 oldnotes <- stateNotes' <$> getState
487 oldnotes <- stateNotes' <$> getState
470 case lookup ref oldnotes of
488 case lookup ref oldnotes of
471− Just _ -> addWarning (Just pos) $ "Duplicate note reference `" ++ ref ++ "'"
489+ Just _ -> P.addWarningWithPos (Just pos) $ "Duplicate note reference `" ++ ref ++ "'"
472 Nothing -> return ()
490 Nothing -> return ()
473 updateState $ \s -> s { stateNotes' = newnote : oldnotes }
491 updateState $ \s -> s { stateNotes' = newnote : oldnotes }
474 return mempty
492 return mempty
@@ -477,10 +495,10 @@ noteBlock = try $ do
477-- parsing blocks
495-- parsing blocks
480−parseBlocks :: MarkdownParser (F Blocks)
498+parseBlocks :: PandocMonad m => MarkdownParser m (F Blocks)
481parseBlocks = mconcat <$> manyTill block eof
499parseBlocks = mconcat <$> manyTill block eof
483−block :: MarkdownParser (F Blocks)
501+block :: PandocMonad m => MarkdownParser m (F Blocks)
484block = do
502block = do
485 tr <- getOption readerTrace
503 tr <- getOption readerTrace
486 pos <- getPosition
504 pos <- getPosition
@@ -519,16 +537,16 @@ block = do
519-- header blocks
537-- header blocks
522−header :: MarkdownParser (F Blocks)
540+header :: PandocMonad m => MarkdownParser m (F Blocks)
523header = setextHeader <|> atxHeader <?> "header"
541header = setextHeader <|> atxHeader <?> "header"
525−atxChar :: MarkdownParser Char
543+atxChar :: PandocMonad m => MarkdownParser m Char
526atxChar = do
544atxChar = do
527 exts <- getOption readerExtensions
545 exts <- getOption readerExtensions
528 return $ if Set.member Ext_literate_haskell exts
546 return $ if Set.member Ext_literate_haskell exts
529 then '=' else '#'
547 then '=' else '#'
531−atxHeader :: MarkdownParser (F Blocks)
549+atxHeader :: PandocMonad m => MarkdownParser m (F Blocks)
532atxHeader = try $ do
550atxHeader = try $ do
533 level <- atxChar >>= many1 . char >>= return . length
551 level <- atxChar >>= many1 . char >>= return . length
534 notFollowedBy $ guardEnabled Ext_fancy_lists >>
552 notFollowedBy $ guardEnabled Ext_fancy_lists >>
@@ -542,7 +560,7 @@ atxHeader = try $ do
542 <|> registerImplicitHeader raw attr'
560 <|> registerImplicitHeader raw attr'
543 return $ B.headerWith attr' level <$> text
561 return $ B.headerWith attr' level <$> text
545−atxClosing :: MarkdownParser Attr
563+atxClosing :: PandocMonad m => MarkdownParser m Attr
546atxClosing = try $ do
564atxClosing = try $ do
547 attr' <- option nullAttr
565 attr' <- option nullAttr
548 (guardEnabled Ext_mmd_header_identifiers >> mmdHeaderIdentifier)
566 (guardEnabled Ext_mmd_header_identifiers >> mmdHeaderIdentifier)
@@ -553,7 +571,7 @@ atxClosing = try $ do
553 blanklines
571 blanklines
554 return attr
572 return attr
556−setextHeaderEnd :: MarkdownParser Attr
574+setextHeaderEnd :: PandocMonad m => MarkdownParser m Attr
557setextHeaderEnd = try $ do
575setextHeaderEnd = try $ do
558 attr <- option nullAttr
576 attr <- option nullAttr
559 $ (guardEnabled Ext_mmd_header_identifiers >> mmdHeaderIdentifier)
577 $ (guardEnabled Ext_mmd_header_identifiers >> mmdHeaderIdentifier)
@@ -561,13 +579,13 @@ setextHeaderEnd = try $ do
561 blanklines
579 blanklines
562 return attr
580 return attr
564−mmdHeaderIdentifier :: MarkdownParser Attr
582+mmdHeaderIdentifier :: PandocMonad m => MarkdownParser m Attr
565mmdHeaderIdentifier = do
583mmdHeaderIdentifier = do
566 ident <- stripFirstAndLast . snd <$> reference
584 ident <- stripFirstAndLast . snd <$> reference
567 skipSpaces
585 skipSpaces
568 return (ident,[],[])
586 return (ident,[],[])
570−setextHeader :: MarkdownParser (F Blocks)
588+setextHeader :: PandocMonad m => MarkdownParser m (F Blocks)
571setextHeader = try $ do
589setextHeader = try $ do
572 -- This lookahead prevents us from wasting time parsing Inlines
590 -- This lookahead prevents us from wasting time parsing Inlines
573 -- unless necessary -- it gives a significant performance boost.
591 -- unless necessary -- it gives a significant performance boost.
@@ -585,7 +603,7 @@ setextHeader = try $ do
585 <|> registerImplicitHeader raw attr'
603 <|> registerImplicitHeader raw attr'
586 return $ B.headerWith attr' level <$> text
604 return $ B.headerWith attr' level <$> text
588−registerImplicitHeader :: String -> Attr -> MarkdownParser ()
606+registerImplicitHeader :: PandocMonad m => String -> Attr -> MarkdownParser m ()
589registerImplicitHeader raw attr@(ident, _, _) = do
607registerImplicitHeader raw attr@(ident, _, _) = do
590 let key = toKey $ "[" ++ raw ++ "]"
608 let key = toKey $ "[" ++ raw ++ "]"
591 updateState (\s -> s { stateHeaderKeys =
609 updateState (\s -> s { stateHeaderKeys =
@@ -595,7 +613,7 @@ registerImplicitHeader raw attr@(ident, _, _) = do
595-- hrule block
613-- hrule block
598−hrule :: Parser [Char] st (F Blocks)
616+hrule :: PandocMonad m => ParserT [Char] st m (F Blocks)
599hrule = try $ do
617hrule = try $ do
600 skipSpaces
618 skipSpaces
601 start <- satisfy isHruleChar
619 start <- satisfy isHruleChar
@@ -609,12 +627,13 @@ hrule = try $ do
609-- code blocks
627-- code blocks
612−indentedLine :: MarkdownParser String
630+indentedLine :: PandocMonad m => MarkdownParser m String
613indentedLine = indentSpaces >> anyLine >>= return . (++ "\n")
631indentedLine = indentSpaces >> anyLine >>= return . (++ "\n")
615−blockDelimiter :: (Char -> Bool)
633+blockDelimiter :: PandocMonad m
616 -> Maybe Int
635 -> Maybe Int
617− -> Parser [Char] st Int
636+ -> ParserT [Char] st m Int
618blockDelimiter f len = try $ do
637blockDelimiter f len = try $ do
619 c <- lookAhead (satisfy f)
638 c <- lookAhead (satisfy f)
620 case len of
639 case len of
@@ -622,7 +641,7 @@ blockDelimiter f len = try $ do
622 Nothing -> count 3 (char c) >> many (char c) >>=
641 Nothing -> count 3 (char c) >> many (char c) >>=
623 return . (+ 3) . length
642 return . (+ 3) . length
625−attributes :: MarkdownParser Attr
644+attributes :: PandocMonad m => MarkdownParser m Attr
626attributes = try $ do
645attributes = try $ do
@@ -630,28 +649,28 @@ attributes = try $ do
631 return $ foldl (\x f -> f x) nullAttr attrs
650 return $ foldl (\x f -> f x) nullAttr attrs
633−attribute :: MarkdownParser (Attr -> Attr)
652+attribute :: PandocMonad m => MarkdownParser m (Attr -> Attr)
634attribute = identifierAttr <|> classAttr <|> keyValAttr <|> specialAttr
653attribute = identifierAttr <|> classAttr <|> keyValAttr <|> specialAttr
636−identifier :: MarkdownParser String
655+identifier :: PandocMonad m => MarkdownParser m String
637identifier = do
656identifier = do
638 first <- letter
657 first <- letter
639 rest <- many $ alphaNum <|> oneOf "-_:."
658 rest <- many $ alphaNum <|> oneOf "-_:."
640 return (first:rest)
659 return (first:rest)
642−identifierAttr :: MarkdownParser (Attr -> Attr)
661+identifierAttr :: PandocMonad m => MarkdownParser m (Attr -> Attr)
643identifierAttr = try $ do
662identifierAttr = try $ do
645 result <- identifier
664 result <- identifier
646 return $ \(_,cs,kvs) -> (result,cs,kvs)
665 return $ \(_,cs,kvs) -> (result,cs,kvs)
648−classAttr :: MarkdownParser (Attr -> Attr)
667+classAttr :: PandocMonad m => MarkdownParser m (Attr -> Attr)
649classAttr = try $ do
668classAttr = try $ do
651 result <- identifier
670 result <- identifier
652 return $ \(id',cs,kvs) -> (id',cs ++ [result],kvs)
671 return $ \(id',cs,kvs) -> (id',cs ++ [result],kvs)
654−keyValAttr :: MarkdownParser (Attr -> Attr)
673+keyValAttr :: PandocMonad m => MarkdownParser m (Attr -> Attr)
655keyValAttr = try $ do
674keyValAttr = try $ do
656 key <- identifier
675 key <- identifier
@@ -664,12 +683,12 @@ keyValAttr = try $ do
664 "class" -> (id',cs ++ words val,kvs)
683 "class" -> (id',cs ++ words val,kvs)
665 _ -> (id',cs,kvs ++ [(key,val)])
684 _ -> (id',cs,kvs ++ [(key,val)])
667−specialAttr :: MarkdownParser (Attr -> Attr)
686+specialAttr :: PandocMonad m => MarkdownParser m (Attr -> Attr)
668specialAttr = do
687specialAttr = do
670 return $ \(id',cs,kvs) -> (id',cs ++ ["unnumbered"],kvs)
689 return $ \(id',cs,kvs) -> (id',cs ++ ["unnumbered"],kvs)
672−codeBlockFenced :: MarkdownParser (F Blocks)
691+codeBlockFenced :: PandocMonad m => MarkdownParser m (F Blocks)
673codeBlockFenced = try $ do
692codeBlockFenced = try $ do
674 c <- try (guardEnabled Ext_fenced_code_blocks >> lookAhead (char '~'))
693 c <- try (guardEnabled Ext_fenced_code_blocks >> lookAhead (char '~'))
675 <|> (guardEnabled Ext_backtick_code_blocks >> lookAhead (char '`'))
694 <|> (guardEnabled Ext_backtick_code_blocks >> lookAhead (char '`'))
@@ -690,7 +709,7 @@ toLanguageId = map toLower . go
690 go "objective-c" = "objectivec"
709 go "objective-c" = "objectivec"
693−codeBlockIndented :: MarkdownParser (F Blocks)
712+codeBlockIndented :: PandocMonad m => MarkdownParser m (F Blocks)
694codeBlockIndented = do
713codeBlockIndented = do
695 contents <- many1 (indentedLine <|>
714 contents <- many1 (indentedLine <|>
696 try (do b <- blanklines
715 try (do b <- blanklines
@@ -701,7 +720,7 @@ codeBlockIndented = do
701 return $ return $ B.codeBlockWith ("", classes, []) $
720 return $ return $ B.codeBlockWith ("", classes, []) $
702 stripTrailingNewlines $ concat contents
721 stripTrailingNewlines $ concat contents
704−lhsCodeBlock :: MarkdownParser (F Blocks)
723+lhsCodeBlock :: PandocMonad m => MarkdownParser m (F Blocks)
705lhsCodeBlock = do
724lhsCodeBlock = do
706 guardEnabled Ext_literate_haskell
725 guardEnabled Ext_literate_haskell
707 (return . B.codeBlockWith ("",["sourceCode","literate","haskell"],[]) <$>
726 (return . B.codeBlockWith ("",["sourceCode","literate","haskell"],[]) <$>
@@ -709,7 +728,7 @@ lhsCodeBlock = do
709 <|> (return . B.codeBlockWith ("",["sourceCode","haskell"],[]) <$>
728 <|> (return . B.codeBlockWith ("",["sourceCode","haskell"],[]) <$>
710 lhsCodeBlockInverseBird)
729 lhsCodeBlockInverseBird)
712−lhsCodeBlockLaTeX :: MarkdownParser String
731+lhsCodeBlockLaTeX :: PandocMonad m => MarkdownParser m String
713lhsCodeBlockLaTeX = try $ do
732lhsCodeBlockLaTeX = try $ do
714 string "\\begin{code}"
733 string "\\begin{code}"
715 manyTill spaceChar newline
734 manyTill spaceChar newline
@@ -717,13 +736,13 @@ lhsCodeBlockLaTeX = try $ do
717 blanklines
736 blanklines
718 return $ stripTrailingNewlines contents
737 return $ stripTrailingNewlines contents
720−lhsCodeBlockBird :: MarkdownParser String
739+lhsCodeBlockBird :: PandocMonad m => MarkdownParser m String
721lhsCodeBlockBird = lhsCodeBlockBirdWith '>'
740lhsCodeBlockBird = lhsCodeBlockBirdWith '>'
723−lhsCodeBlockInverseBird :: MarkdownParser String
742+lhsCodeBlockInverseBird :: PandocMonad m => MarkdownParser m String
724lhsCodeBlockInverseBird = lhsCodeBlockBirdWith '<'
743lhsCodeBlockInverseBird = lhsCodeBlockBirdWith '<'
726−lhsCodeBlockBirdWith :: Char -> MarkdownParser String
745+lhsCodeBlockBirdWith :: PandocMonad m => Char -> MarkdownParser m String
727lhsCodeBlockBirdWith c = try $ do
746lhsCodeBlockBirdWith c = try $ do
728 pos <- getPosition
747 pos <- getPosition
729 when (sourceColumn pos /= 1) $ fail "Not in first column"
748 when (sourceColumn pos /= 1) $ fail "Not in first column"
@@ -735,7 +754,7 @@ lhsCodeBlockBirdWith c = try $ do
735 blanklines
754 blanklines
736 return $ intercalate "\n" lns'
755 return $ intercalate "\n" lns'
738−birdTrackLine :: Char -> Parser [Char] st String
757+birdTrackLine :: PandocMonad m => Char -> ParserT [Char] st m String
739birdTrackLine c = try $ do
758birdTrackLine c = try $ do
741 -- allow html tags on left margin:
760 -- allow html tags on left margin:
@@ -746,10 +765,10 @@ birdTrackLine c = try $ do
746-- block quotes
765-- block quotes
749−emailBlockQuoteStart :: MarkdownParser Char
768+emailBlockQuoteStart :: PandocMonad m => MarkdownParser m Char
750emailBlockQuoteStart = try $ skipNonindentSpaces >> char '>' <* optional (char ' ')
769emailBlockQuoteStart = try $ skipNonindentSpaces >> char '>' <* optional (char ' ')
752−emailBlockQuote :: MarkdownParser [String]
771+emailBlockQuote :: PandocMonad m => MarkdownParser m [String]
753emailBlockQuote = try $ do
772emailBlockQuote = try $ do
754 emailBlockQuoteStart
773 emailBlockQuoteStart
755 let emailLine = many $ nonEndline <|> try
774 let emailLine = many $ nonEndline <|> try
@@ -763,7 +782,7 @@ emailBlockQuote = try $ do
763 optional blanklines
782 optional blanklines
764 return raw
783 return raw
766−blockQuote :: MarkdownParser (F Blocks)
785+blockQuote :: PandocMonad m => MarkdownParser m (F Blocks)
767blockQuote = do
786blockQuote = do
768 raw <- emailBlockQuote
787 raw <- emailBlockQuote
769 -- parse the extracted block, which may contain various block elements:
788 -- parse the extracted block, which may contain various block elements:
@@ -774,7 +793,7 @@ blockQuote = do
774-- list blocks
793-- list blocks
777−bulletListStart :: MarkdownParser ()
796+bulletListStart :: PandocMonad m => MarkdownParser m ()
778bulletListStart = try $ do
797bulletListStart = try $ do
779 optional newline -- if preceded by a Plain block in a list context
798 optional newline -- if preceded by a Plain block in a list context
780 startpos <- sourceColumn <$> getPosition
799 startpos <- sourceColumn <$> getPosition
@@ -786,7 +805,7 @@ bulletListStart = try $ do
786 lookAhead (newline <|> spaceChar)
805 lookAhead (newline <|> spaceChar)
787 () <$ atMostSpaces (tabStop - (endpos - startpos))
806 () <$ atMostSpaces (tabStop - (endpos - startpos))
789−anyOrderedListStart :: MarkdownParser (Int, ListNumberStyle, ListNumberDelim)
808+anyOrderedListStart :: PandocMonad m => MarkdownParser m (Int, ListNumberStyle, ListNumberDelim)
790anyOrderedListStart = try $ do
809anyOrderedListStart = try $ do
791 optional newline -- if preceded by a Plain block in a list context
810 optional newline -- if preceded by a Plain block in a list context
792 startpos <- sourceColumn <$> getPosition
811 startpos <- sourceColumn <$> getPosition
@@ -810,10 +829,10 @@ anyOrderedListStart = try $ do
810 atMostSpaces (tabStop - (endpos - startpos))
829 atMostSpaces (tabStop - (endpos - startpos))
811 return res
830 return res
813−listStart :: MarkdownParser ()
832+listStart :: PandocMonad m => MarkdownParser m ()
814listStart = bulletListStart <|> (anyOrderedListStart >> return ())
833listStart = bulletListStart <|> (anyOrderedListStart >> return ())
816−listLine :: MarkdownParser String
835+listLine :: PandocMonad m => MarkdownParser m String
817listLine = try $ do
836listLine = try $ do
818 notFollowedBy' (do indentSpaces
837 notFollowedBy' (do indentSpaces
819 many spaceChar
838 many spaceChar
@@ -822,7 +841,7 @@ listLine = try $ do
822 optional (() <$ indentSpaces)
841 optional (() <$ indentSpaces)
823 listLineCommon
842 listLineCommon
825−listLineCommon :: MarkdownParser String
844+listLineCommon :: PandocMonad m => MarkdownParser m String
826listLineCommon = concat <$> manyTill
845listLineCommon = concat <$> manyTill
827 ( many1 (satisfy $ \c -> c /= '\n' && c /= '<')
846 ( many1 (satisfy $ \c -> c /= '\n' && c /= '<')
828 <|> liftM snd (htmlTag isCommentTag)
847 <|> liftM snd (htmlTag isCommentTag)
@@ -830,8 +849,9 @@ listLineCommon = concat <$> manyTill
830 ) newline
849 ) newline
832-- parse raw text for one list item, excluding start marker and continuations
851-- parse raw text for one list item, excluding start marker and continuations
852+rawListItem :: PandocMonad m
833−rawListItem :: MarkdownParser a
853+ => MarkdownParser m a
834− -> MarkdownParser String
854+ -> MarkdownParser m String
835rawListItem start = try $ do
855rawListItem start = try $ do
837 first <- listLineCommon
857 first <- listLineCommon
@@ -842,21 +862,21 @@ rawListItem start = try $ do
842-- continuation of a list item - indented and separated by blankline
862-- continuation of a list item - indented and separated by blankline
843-- or (in compact lists) endline.
863-- or (in compact lists) endline.
844-- note: nested lists are parsed as continuations
864-- note: nested lists are parsed as continuations
845−listContinuation :: MarkdownParser String
865+listContinuation :: PandocMonad m => MarkdownParser m String
846listContinuation = try $ do
866listContinuation = try $ do
847 lookAhead indentSpaces
867 lookAhead indentSpaces
848 result <- many1 listContinuationLine
868 result <- many1 listContinuationLine
849 blanks <- many blankline
869 blanks <- many blankline
850 return $ concat result ++ blanks
870 return $ concat result ++ blanks
852−notFollowedByHtmlCloser :: MarkdownParser ()
872+notFollowedByHtmlCloser :: PandocMonad m => MarkdownParser m ()
853notFollowedByHtmlCloser = do
873notFollowedByHtmlCloser = do
854 inHtmlBlock <- stateInHtmlBlock <$> getState
874 inHtmlBlock <- stateInHtmlBlock <$> getState
855 case inHtmlBlock of
875 case inHtmlBlock of
856 Just t -> notFollowedBy' $ htmlTag (~== TagClose t)
876 Just t -> notFollowedBy' $ htmlTag (~== TagClose t)
857 Nothing -> return ()
877 Nothing -> return ()
859−listContinuationLine :: MarkdownParser String
879+listContinuationLine :: PandocMonad m => MarkdownParser m String
860listContinuationLine = try $ do
880listContinuationLine = try $ do
861 notFollowedBy blankline
881 notFollowedBy blankline
862 notFollowedBy' listStart
882 notFollowedBy' listStart
@@ -865,8 +885,9 @@ listContinuationLine = try $ do
865 result <- anyLine
885 result <- anyLine
866 return $ result ++ "\n"
886 return $ result ++ "\n"
888+listItem :: PandocMonad m
868−listItem :: MarkdownParser a
889+ => MarkdownParser m a
869− -> MarkdownParser (F Blocks)
890+ -> MarkdownParser m (F Blocks)
870listItem start = try $ do
891listItem start = try $ do
871 first <- rawListItem start
892 first <- rawListItem start
872 continuations <- many listContinuation
893 continuations <- many listContinuation
@@ -882,7 +903,7 @@ listItem start = try $ do
882 updateState (\st -> st {stateParserContext = oldContext})
903 updateState (\st -> st {stateParserContext = oldContext})
883 return contents
904 return contents
885−orderedList :: MarkdownParser (F Blocks)
906+orderedList :: PandocMonad m => MarkdownParser m (F Blocks)
886orderedList = try $ do
907orderedList = try $ do
887 (start, style, delim) <- lookAhead anyOrderedListStart
908 (start, style, delim) <- lookAhead anyOrderedListStart
888 unless (style `elem` [DefaultStyle, Decimal, Example] &&
909 unless (style `elem` [DefaultStyle, Decimal, Example] &&
@@ -903,14 +924,14 @@ orderedList = try $ do
903 start' <- option 1 $ guardEnabled Ext_startnum >> return start
924 start' <- option 1 $ guardEnabled Ext_startnum >> return start
904 return $ B.orderedListWith (start', style, delim) <$> fmap compactify' items
925 return $ B.orderedListWith (start', style, delim) <$> fmap compactify' items
906−bulletList :: MarkdownParser (F Blocks)
927+bulletList :: PandocMonad m => MarkdownParser m (F Blocks)
907bulletList = do
928bulletList = do
908 items <- fmap sequence $ many1 $ listItem bulletListStart
929 items <- fmap sequence $ many1 $ listItem bulletListStart
909 return $ B.bulletList <$> fmap compactify' items
930 return $ B.bulletList <$> fmap compactify' items
911-- definition lists
932-- definition lists
913−defListMarker :: MarkdownParser ()
934+defListMarker :: PandocMonad m => MarkdownParser m ()
914defListMarker = do
935defListMarker = do
915 sps <- nonindentSpaces
936 sps <- nonindentSpaces
916 char ':' <|> char '~'
937 char ':' <|> char '~'
@@ -921,7 +942,7 @@ defListMarker = do
921 else mzero
942 else mzero
922 return ()
943 return ()
924−definitionListItem :: Bool -> MarkdownParser (F (Inlines, [Blocks]))
945+definitionListItem :: PandocMonad m => Bool -> MarkdownParser m (F (Inlines, [Blocks]))
925definitionListItem compact = try $ do
946definitionListItem compact = try $ do
926 rawLine' <- anyLine
947 rawLine' <- anyLine
927 raw <- many1 $ defRawBlock compact
948 raw <- many1 $ defRawBlock compact
@@ -930,7 +951,7 @@ definitionListItem compact = try $ do
930 optional blanklines
951 optional blanklines
931 return $ liftM2 (,) term (sequence contents)
952 return $ liftM2 (,) term (sequence contents)
933−defRawBlock :: Bool -> MarkdownParser String
954+defRawBlock :: PandocMonad m => Bool -> MarkdownParser m String
934defRawBlock compact = try $ do
955defRawBlock compact = try $ do
935 hasBlank <- option False $ blankline >> return True
956 hasBlank <- option False $ blankline >> return True
936 defListMarker
957 defListMarker
@@ -952,7 +973,7 @@ defRawBlock compact = try $ do
952 return $ trimr (firstline ++ "\n" ++ unlines rawlines ++ cont) ++
973 return $ trimr (firstline ++ "\n" ++ unlines rawlines ++ cont) ++
953 if hasBlank || not (null cont) then "\n\n" else ""
974 if hasBlank || not (null cont) then "\n\n" else ""
955−definitionList :: MarkdownParser (F Blocks)
976+definitionList :: PandocMonad m => MarkdownParser m (F Blocks)
956definitionList = try $ do
977definitionList = try $ do
957 lookAhead (anyLine >>
978 lookAhead (anyLine >>
958 optional (blankline >> notFollowedBy (table >> return ())) >>
979 optional (blankline >> notFollowedBy (table >> return ())) >>
@@ -960,13 +981,13 @@ definitionList = try $ do
960 defListMarker)
981 defListMarker)
961 compactDefinitionList <|> normalDefinitionList
982 compactDefinitionList <|> normalDefinitionList
963−compactDefinitionList :: MarkdownParser (F Blocks)
984+compactDefinitionList :: PandocMonad m => MarkdownParser m (F Blocks)
964compactDefinitionList = do
985compactDefinitionList = do
965 guardEnabled Ext_compact_definition_lists
986 guardEnabled Ext_compact_definition_lists
966 items <- fmap sequence $ many1 $ definitionListItem True
987 items <- fmap sequence $ many1 $ definitionListItem True
967 return $ B.definitionList <$> fmap compactify'DL items
988 return $ B.definitionList <$> fmap compactify'DL items
969−normalDefinitionList :: MarkdownParser (F Blocks)
990+normalDefinitionList :: PandocMonad m => MarkdownParser m (F Blocks)
970normalDefinitionList = do
991normalDefinitionList = do
971 guardEnabled Ext_definition_lists
992 guardEnabled Ext_definition_lists
972 items <- fmap sequence $ many1 $ definitionListItem False
993 items <- fmap sequence $ many1 $ definitionListItem False
@@ -976,7 +997,7 @@ normalDefinitionList = do
976-- paragraph block
997-- paragraph block
979−para :: MarkdownParser (F Blocks)
1000+para :: PandocMonad m => MarkdownParser m (F Blocks)
980para = try $ do
1001para = try $ do
981 exts <- getOption readerExtensions
1002 exts <- getOption readerExtensions
982 result <- trimInlinesF . mconcat <$> many1 inline
1003 result <- trimInlinesF . mconcat <$> many1 inline
@@ -1007,19 +1028,19 @@ para = try $ do
1007 $ Image attr alt (src,'f':'i':'g':':':tit)
1028 $ Image attr alt (src,'f':'i':'g':':':tit)
1008 _ -> return $ B.para result'
1029 _ -> return $ B.para result'
1010−plain :: MarkdownParser (F Blocks)
1031+plain :: PandocMonad m => MarkdownParser m (F Blocks)
1011plain = fmap B.plain . trimInlinesF . mconcat <$> many1 inline
1032plain = fmap B.plain . trimInlinesF . mconcat <$> many1 inline
1014-- raw html
1035-- raw html
1017−htmlElement :: MarkdownParser String
1038+htmlElement :: PandocMonad m => MarkdownParser m String
1018htmlElement = rawVerbatimBlock
1039htmlElement = rawVerbatimBlock
1019 <|> strictHtmlBlock
1040 <|> strictHtmlBlock
1020 <|> liftM snd (htmlTag isBlockTag)
1041 <|> liftM snd (htmlTag isBlockTag)
1022−htmlBlock :: MarkdownParser (F Blocks)
1043+htmlBlock :: PandocMonad m => MarkdownParser m (F Blocks)
1023htmlBlock = do
1044htmlBlock = do
1024 guardEnabled Ext_raw_html
1045 guardEnabled Ext_raw_html
@@ -1044,24 +1065,24 @@ htmlBlock = do
1044 <|> (guardEnabled Ext_markdown_in_html_blocks >> rawHtmlBlocks))
1065 <|> (guardEnabled Ext_markdown_in_html_blocks >> rawHtmlBlocks))
1045 <|> htmlBlock'
1066 <|> htmlBlock'
1047−htmlBlock' :: MarkdownParser (F Blocks)
1068+htmlBlock' :: PandocMonad m => MarkdownParser m (F Blocks)
1048htmlBlock' = try $ do
1069htmlBlock' = try $ do
1049 first <- htmlElement
1070 first <- htmlElement
1050 skipMany spaceChar
1071 skipMany spaceChar
1051 optional blanklines
1072 optional blanklines
1052 return $ return $ B.rawBlock "html" first
1073 return $ return $ B.rawBlock "html" first
1054−strictHtmlBlock :: MarkdownParser String
1075+strictHtmlBlock :: PandocMonad m => MarkdownParser m String
1055strictHtmlBlock = htmlInBalanced (not . isInlineTag)
1076strictHtmlBlock = htmlInBalanced (not . isInlineTag)
1057−rawVerbatimBlock :: MarkdownParser String
1078+rawVerbatimBlock :: PandocMonad m => MarkdownParser m String
1058rawVerbatimBlock = htmlInBalanced isVerbTag
1079rawVerbatimBlock = htmlInBalanced isVerbTag
1059 where isVerbTag (TagOpen "pre" _) = True
1080 where isVerbTag (TagOpen "pre" _) = True
1060 isVerbTag (TagOpen "style" _) = True
1081 isVerbTag (TagOpen "style" _) = True
1061 isVerbTag (TagOpen "script" _) = True
1082 isVerbTag (TagOpen "script" _) = True
1062 isVerbTag _ = False
1083 isVerbTag _ = False
1064−rawTeXBlock :: MarkdownParser (F Blocks)
1085+rawTeXBlock :: PandocMonad m => MarkdownParser m (F Blocks)
1065rawTeXBlock = do
1086rawTeXBlock = do
1066 guardEnabled Ext_raw_tex
1087 guardEnabled Ext_raw_tex
1067 result <- (B.rawBlock "latex" . concat <$>
1088 result <- (B.rawBlock "latex" . concat <$>
@@ -1071,7 +1092,7 @@ rawTeXBlock = do
1072 return $ return result
1093 return $ return result
1074−rawHtmlBlocks :: MarkdownParser (F Blocks)
1095+rawHtmlBlocks :: PandocMonad m => MarkdownParser m (F Blocks)
1075rawHtmlBlocks = do
1096rawHtmlBlocks = do
1076 (TagOpen tagtype _, raw) <- htmlTag isBlockTag
1097 (TagOpen tagtype _, raw) <- htmlTag isBlockTag
1077 -- try to find closing tag
1098 -- try to find closing tag
@@ -1101,7 +1122,7 @@ stripMarkdownAttribute s = renderTags' $ map filterAttrib $ parseTags s
1101-- line block
1122-- line block
1104−lineBlock :: MarkdownParser (F Blocks)
1125+lineBlock :: PandocMonad m => MarkdownParser m (F Blocks)
1105lineBlock = try $ do
1126lineBlock = try $ do
1106 guardEnabled Ext_line_blocks
1127 guardEnabled Ext_line_blocks
1107 lines' <- lineBlockLines >>=
1128 lines' <- lineBlockLines >>=
@@ -1114,8 +1135,9 @@ lineBlock = try $ do
1115-- Parse a dashed line with optional trailing spaces; return its length
1136-- Parse a dashed line with optional trailing spaces; return its length
1116-- and the length including trailing space.
1137-- and the length including trailing space.
1117−dashedLine :: Char
1138+dashedLine :: PandocMonad m
1118− -> Parser [Char] st (Int, Int)
1140+ -> ParserT [Char] st m (Int, Int)
1119dashedLine ch = do
1141dashedLine ch = do
1120 dashes <- many1 (char ch)
1142 dashes <- many1 (char ch)
1121 sp <- many spaceChar
1143 sp <- many spaceChar
@@ -1125,8 +1147,9 @@ dashedLine ch = do
1126-- Parse a table header with dashed lines of '-' preceded by
1148-- Parse a table header with dashed lines of '-' preceded by
1127-- one (or zero) line of text.
1149-- one (or zero) line of text.
1150+simpleTableHeader :: PandocMonad m
1128−simpleTableHeader :: Bool -- ^ Headerless table
1151+ => Bool -- ^ Headerless table
1129− -> MarkdownParser (F [Blocks], [Alignment], [Int])
1152+ -> MarkdownParser m (F [Blocks], [Alignment], [Int])
1130simpleTableHeader headless = try $ do
1153simpleTableHeader headless = try $ do
1131 rawContent <- if headless
1154 rawContent <- if headless
1132 then return ""
1155 then return ""
@@ -1170,16 +1193,17 @@ alignType strLst len =
1170 (False, False) -> AlignDefault
1193 (False, False) -> AlignDefault
1172-- Parse a table footer - dashed lines followed by blank line.
1195-- Parse a table footer - dashed lines followed by blank line.
1173−tableFooter :: MarkdownParser String
1196+tableFooter :: PandocMonad m => MarkdownParser m String
1174tableFooter = try $ skipNonindentSpaces >> many1 (dashedLine '-') >> blanklines
1197tableFooter = try $ skipNonindentSpaces >> many1 (dashedLine '-') >> blanklines
1176-- Parse a table separator - dashed line.
1199-- Parse a table separator - dashed line.
1177−tableSep :: MarkdownParser Char
1200+tableSep :: PandocMonad m => MarkdownParser m Char
1178tableSep = try $ skipNonindentSpaces >> many1 (dashedLine '-') >> char '\n'
1201tableSep = try $ skipNonindentSpaces >> many1 (dashedLine '-') >> char '\n'
1180-- Parse a raw line and split it into chunks by indices.
1203-- Parse a raw line and split it into chunks by indices.
1181−rawTableLine :: [Int]
1204+rawTableLine :: PandocMonad m
1182− -> MarkdownParser [String]
1206+ -> MarkdownParser m [String]
1183rawTableLine indices = do
1207rawTableLine indices = do
1184 notFollowedBy' (blanklines <|> tableFooter)
1208 notFollowedBy' (blanklines <|> tableFooter)
1185 line <- many1Till anyChar newline
1209 line <- many1Till anyChar newline
@@ -1187,14 +1211,16 @@ rawTableLine indices = do
1187 splitStringByIndices (init indices) line
1211 splitStringByIndices (init indices) line
1189-- Parse a table line and return a list of lists of blocks (columns).
1213-- Parse a table line and return a list of lists of blocks (columns).
1190−tableLine :: [Int]
1214+tableLine :: PandocMonad m
1191− -> MarkdownParser (F [Blocks])
1216+ -> MarkdownParser m (F [Blocks])
1192tableLine indices = rawTableLine indices >>=
1217tableLine indices = rawTableLine indices >>=
1193 fmap sequence . mapM (parseFromString (mconcat <$> many plain))
1218 fmap sequence . mapM (parseFromString (mconcat <$> many plain))
1195-- Parse a multiline table row and return a list of blocks (columns).
1220-- Parse a multiline table row and return a list of blocks (columns).
1196−multilineRow :: [Int]
1221+multilineRow :: PandocMonad m
1197− -> MarkdownParser (F [Blocks])
1223+ -> MarkdownParser m (F [Blocks])
1198multilineRow indices = do
1224multilineRow indices = do
1199 colLines <- many1 (rawTableLine indices)
1225 colLines <- many1 (rawTableLine indices)
1200 let cols = map unlines $ transpose colLines
1226 let cols = map unlines $ transpose colLines
@@ -1202,7 +1228,7 @@ multilineRow indices = do
1203-- Parses a table caption: inlines beginning with 'Table:'
1229-- Parses a table caption: inlines beginning with 'Table:'
1204-- and followed by blank lines.
1230-- and followed by blank lines.
1205−tableCaption :: MarkdownParser (F Inlines)
1231+tableCaption :: PandocMonad m => MarkdownParser m (F Inlines)
1206tableCaption = try $ do
1232tableCaption = try $ do
1207 guardEnabled Ext_table_captions
1233 guardEnabled Ext_table_captions
1208 skipNonindentSpaces
1234 skipNonindentSpaces
@@ -1210,8 +1236,9 @@ tableCaption = try $ do
1210 trimInlinesF . mconcat <$> many1 inline <* blanklines
1236 trimInlinesF . mconcat <$> many1 inline <* blanklines
1212-- Parse a simple table with '---' header and one line per row.
1238-- Parse a simple table with '---' header and one line per row.
1239+simpleTable :: PandocMonad m
1213−simpleTable :: Bool -- ^ Headerless table
1240+ => Bool -- ^ Headerless table
1214− -> MarkdownParser ([Alignment], [Double], F [Blocks], F [[Blocks]])
1241+ -> MarkdownParser m ([Alignment], [Double], F [Blocks], F [[Blocks]])
1215simpleTable headless = do
1242simpleTable headless = do
1216 (aligns, _widths, heads', lines') <-
1243 (aligns, _widths, heads', lines') <-
1217 tableWith (simpleTableHeader headless) tableLine
1244 tableWith (simpleTableHeader headless) tableLine
@@ -1224,13 +1251,15 @@ simpleTable headless = do
1224-- (which may be multiline), then the rows,
1251-- (which may be multiline), then the rows,
1225-- which may be multiline, separated by blank lines, and
1252-- which may be multiline, separated by blank lines, and
1226-- ending with a footer (dashed line followed by blank line).
1253-- ending with a footer (dashed line followed by blank line).
1254+multilineTable :: PandocMonad m
1227−multilineTable :: Bool -- ^ Headerless table
1255+ => Bool -- ^ Headerless table
1228− -> MarkdownParser ([Alignment], [Double], F [Blocks], F [[Blocks]])
1256+ -> MarkdownParser m ([Alignment], [Double], F [Blocks], F [[Blocks]])
1229multilineTable headless =
1257multilineTable headless =
1230 tableWith (multilineTableHeader headless) multilineRow blanklines tableFooter
1258 tableWith (multilineTableHeader headless) multilineRow blanklines tableFooter
1260+multilineTableHeader :: PandocMonad m
1232−multilineTableHeader :: Bool -- ^ Headerless table
1261+ => Bool -- ^ Headerless table
1233− -> MarkdownParser (F [Blocks], [Alignment], [Int])
1262+ -> MarkdownParser m (F [Blocks], [Alignment], [Int])
1234multilineTableHeader headless = try $ do
1263multilineTableHeader headless = try $ do
1235 unless headless $
1264 unless headless $
1236 tableSep >> notFollowedBy blankline
1265 tableSep >> notFollowedBy blankline
@@ -1261,8 +1290,8 @@ multilineTableHeader headless = try $ do
1261-- (which may be grid), then the rows,
1290-- (which may be grid), then the rows,
1262-- which may be grid, separated by blank lines, and
1291-- which may be grid, separated by blank lines, and
1263-- ending with a footer (dashed line followed by blank line).
1292-- ending with a footer (dashed line followed by blank line).
1264−gridTable :: Bool -- ^ Headerless table
1293+gridTable :: PandocMonad m => Bool -- ^ Headerless table
1265− -> MarkdownParser ([Alignment], [Double], F [Blocks], F [[Blocks]])
1294+ -> MarkdownParser m ([Alignment], [Double], F [Blocks], F [[Blocks]])
1266gridTable headless =
1295gridTable headless =
1267 tableWith (gridTableHeader headless) gridTableRow
1296 tableWith (gridTableHeader headless) gridTableRow
1268 (gridTableSep '-') gridTableFooter
1297 (gridTableSep '-') gridTableFooter
@@ -1271,7 +1300,7 @@ gridTableSplitLine :: [Int] -> String -> [String]
1271gridTableSplitLine indices line = map removeFinalBar $ tail $
1300gridTableSplitLine indices line = map removeFinalBar $ tail $
1272 splitStringByIndices (init indices) $ trimr line
1301 splitStringByIndices (init indices) $ trimr line
1274−gridPart :: Char -> Parser [Char] st ((Int, Int), Alignment)
1303+gridPart :: PandocMonad m => Char -> ParserT [Char] st m ((Int, Int), Alignment)
1275gridPart ch = do
1304gridPart ch = do
1276 leftColon <- option False (True <$ char ':')
1305 leftColon <- option False (True <$ char ':')
1277 dashes <- many1 (char ch)
1306 dashes <- many1 (char ch)
@@ -1286,7 +1315,7 @@ gridPart ch = do
1286 (False, False) -> AlignDefault
1315 (False, False) -> AlignDefault
1287 return ((lengthDashes, lengthDashes + 1), alignment)
1316 return ((lengthDashes, lengthDashes + 1), alignment)
1289−gridDashedLines :: Char -> Parser [Char] st [((Int, Int), Alignment)]
1318+gridDashedLines :: PandocMonad m => Char -> ParserT [Char] st m [((Int, Int), Alignment)]
1290gridDashedLines ch = try $ char '+' >> many1 (gridPart ch) <* blankline
1319gridDashedLines ch = try $ char '+' >> many1 (gridPart ch) <* blankline
1292removeFinalBar :: String -> String
1321removeFinalBar :: String -> String
@@ -1294,12 +1323,12 @@ removeFinalBar =
1294 reverse . dropWhile (`elem` " \t") . dropWhile (=='|') . reverse
1323 reverse . dropWhile (`elem` " \t") . dropWhile (=='|') . reverse
1296-- | Separator between rows of grid table.
1325-- | Separator between rows of grid table.
1297−gridTableSep :: Char -> MarkdownParser Char
1326+gridTableSep :: PandocMonad m => Char -> MarkdownParser m Char
1298gridTableSep ch = try $ gridDashedLines ch >> return '\n'
1327gridTableSep ch = try $ gridDashedLines ch >> return '\n'
1300-- | Parse header for a grid table.
1329-- | Parse header for a grid table.
1301−gridTableHeader :: Bool -- ^ Headerless table
1330+gridTableHeader :: PandocMonad m => Bool -- ^ Headerless table
1302− -> MarkdownParser (F [Blocks], [Alignment], [Int])
1331+ -> MarkdownParser m (F [Blocks], [Alignment], [Int])
1303gridTableHeader headless = try $ do
1332gridTableHeader headless = try $ do
1304 optional blanklines
1333 optional blanklines
1305 dashes <- gridDashedLines '-'
1334 dashes <- gridDashedLines '-'
@@ -1320,15 +1349,15 @@ gridTableHeader headless = try $ do
1320 heads <- fmap sequence $ mapM (parseFromString parseBlocks . trim) rawHeads
1349 heads <- fmap sequence $ mapM (parseFromString parseBlocks . trim) rawHeads
1321 return (heads, aligns, indices)
1350 return (heads, aligns, indices)
1323−gridTableRawLine :: [Int] -> MarkdownParser [String]
1352+gridTableRawLine :: PandocMonad m => [Int] -> MarkdownParser m [String]
1324gridTableRawLine indices = do
1353gridTableRawLine indices = do
1325 char '|'
1354 char '|'
1326 line <- anyLine
1355 line <- anyLine
1327 return (gridTableSplitLine indices line)
1356 return (gridTableSplitLine indices line)
1329-- | Parse row of grid table.
1358-- | Parse row of grid table.
1330−gridTableRow :: [Int]
1359+gridTableRow :: PandocMonad m => [Int]
1331− -> MarkdownParser (F [Blocks])
1360+ -> MarkdownParser m (F [Blocks])
1332gridTableRow indices = do
1361gridTableRow indices = do
1333 colLines <- many1 (gridTableRawLine indices)
1362 colLines <- many1 (gridTableRawLine indices)
1334 let cols = map ((++ "\n") . unlines . removeOneLeadingSpace) $
1363 let cols = map ((++ "\n") . unlines . removeOneLeadingSpace) $
@@ -1344,10 +1373,10 @@ removeOneLeadingSpace xs =
1344 startsWithSpace (y:_) = y == ' '
1373 startsWithSpace (y:_) = y == ' '
1346-- | Parse footer for a grid table.
1375-- | Parse footer for a grid table.
1347−gridTableFooter :: MarkdownParser [Char]
1376+gridTableFooter :: PandocMonad m => MarkdownParser m [Char]
1348gridTableFooter = blanklines
1377gridTableFooter = blanklines
1350−pipeBreak :: MarkdownParser ([Alignment], [Int])
1379+pipeBreak :: PandocMonad m => MarkdownParser m ([Alignment], [Int])
1351pipeBreak = try $ do
1380pipeBreak = try $ do
1352 nonindentSpaces
1381 nonindentSpaces
1353 openPipe <- (True <$ char '|') <|> return False
1382 openPipe <- (True <$ char '|') <|> return False
@@ -1359,7 +1388,7 @@ pipeBreak = try $ do
1359 blankline
1388 blankline
1360 return $ unzip (first:rest)
1389 return $ unzip (first:rest)
1362−pipeTable :: MarkdownParser ([Alignment], [Double], F [Blocks], F [[Blocks]])
1391+pipeTable :: PandocMonad m => MarkdownParser m ([Alignment], [Double], F [Blocks], F [[Blocks]])
1363pipeTable = try $ do
1392pipeTable = try $ do
1364 nonindentSpaces
1393 nonindentSpaces
1365 lookAhead nonspaceChar
1394 lookAhead nonspaceChar
@@ -1377,13 +1406,13 @@ pipeTable = try $ do
1377 else replicate (length aligns) 0.0
1406 else replicate (length aligns) 0.0
1378 return $ (aligns, widths, heads', sequence lines'')
1407 return $ (aligns, widths, heads', sequence lines'')
1380−sepPipe :: MarkdownParser ()
1409+sepPipe :: PandocMonad m => MarkdownParser m ()
1381sepPipe = try $ do
1410sepPipe = try $ do
1382 char '|' <|> char '+'
1411 char '|' <|> char '+'
1383 notFollowedBy blankline
1412 notFollowedBy blankline
1385-- parse a row, also returning probable alignments for org-table cells
1414-- parse a row, also returning probable alignments for org-table cells
1386−pipeTableRow :: MarkdownParser (F [Blocks])
1415+pipeTableRow :: PandocMonad m => MarkdownParser m (F [Blocks])
1387pipeTableRow = try $ do
1416pipeTableRow = try $ do
1388 scanForPipe
1417 scanForPipe
1389 skipMany spaceChar
1418 skipMany spaceChar
@@ -1399,14 +1428,14 @@ pipeTableRow = try $ do
1399 blankline
1428 blankline
1400 return $ sequence cells
1429 return $ sequence cells
1402−pipeTableCell :: MarkdownParser (F Blocks)
1431+pipeTableCell :: PandocMonad m => MarkdownParser m (F Blocks)
1403pipeTableCell = do
1432pipeTableCell = do
1404 result <- many inline
1433 result <- many inline
1405 if null result
1434 if null result
1406 then return mempty
1435 then return mempty
1407 else return $ B.plain . mconcat <$> sequence result
1436 else return $ B.plain . mconcat <$> sequence result
1409−pipeTableHeaderPart :: Parser [Char] st (Alignment, Int)
1438+pipeTableHeaderPart :: PandocMonad m => ParserT [Char] st m (Alignment, Int)
1410pipeTableHeaderPart = try $ do
1439pipeTableHeaderPart = try $ do
1411 skipMany spaceChar
1440 skipMany spaceChar
1412 left <- optionMaybe (char ':')
1441 left <- optionMaybe (char ':')
@@ -1422,7 +1451,7 @@ pipeTableHeaderPart = try $ do
1422 (Just _,Just _) -> AlignCenter), len)
1451 (Just _,Just _) -> AlignCenter), len)
1424-- Succeed only if current line contains a pipe.
1453-- Succeed only if current line contains a pipe.
1425−scanForPipe :: Parser [Char] st ()
1454+scanForPipe :: PandocMonad m => ParserT [Char] st m ()
1426scanForPipe = do
1455scanForPipe = do
1427 inp <- getInput
1456 inp <- getInput
1428 case break (\c -> c == '\n' || c == '|') inp of
1457 case break (\c -> c == '\n' || c == '|') inp of
@@ -1432,11 +1461,12 @@ scanForPipe = do
1432-- | Parse a table using 'headerParser', 'rowParser',
1461-- | Parse a table using 'headerParser', 'rowParser',
1433-- 'lineParser', and 'footerParser'. Variant of the version in
1462-- 'lineParser', and 'footerParser'. Variant of the version in
1434-- Text.Pandoc.Parsing.
1463-- Text.Pandoc.Parsing.
1464+tableWith :: PandocMonad m
1435−tableWith :: MarkdownParser (F [Blocks], [Alignment], [Int])
1465+ => MarkdownParser m (F [Blocks], [Alignment], [Int])
1436− -> ([Int] -> MarkdownParser (F [Blocks]))
1466+ -> ([Int] -> MarkdownParser m (F [Blocks]))
1437− -> MarkdownParser sep
1467+ -> MarkdownParser m sep
1438− -> MarkdownParser end
1468+ -> MarkdownParser m end
1439− -> MarkdownParser ([Alignment], [Double], F [Blocks], F [[Blocks]])
1469+ -> MarkdownParser m ([Alignment], [Double], F [Blocks], F [[Blocks]])
1440tableWith headerParser rowParser lineParser footerParser = try $ do
1470tableWith headerParser rowParser lineParser footerParser = try $ do
1441 (heads, aligns, indices) <- headerParser
1471 (heads, aligns, indices) <- headerParser
1442 lines' <- fmap sequence $ rowParser indices `sepEndBy1` lineParser
1472 lines' <- fmap sequence $ rowParser indices `sepEndBy1` lineParser
@@ -1447,7 +1477,7 @@ tableWith headerParser rowParser lineParser footerParser = try $ do
1447 else widthsFromIndices numColumns indices
1477 else widthsFromIndices numColumns indices
1448 return $ (aligns, widths, heads, lines')
1478 return $ (aligns, widths, heads, lines')
1450−table :: MarkdownParser (F Blocks)
1480+table :: PandocMonad m => MarkdownParser m (F Blocks)
1451table = try $ do
1481table = try $ do
1452 frontCaption <- option Nothing (Just <$> tableCaption)
1482 frontCaption <- option Nothing (Just <$> tableCaption)
1453 (aligns, widths, heads, lns) <-
1483 (aligns, widths, heads, lns) <-
@@ -1479,7 +1509,7 @@ table = try $ do
1479-- inline
1509-- inline
1482−inline :: MarkdownParser (F Inlines)
1512+inline :: PandocMonad m => MarkdownParser m (F Inlines)
1483inline = choice [ whitespace
1513inline = choice [ whitespace
1484 , bareURL
1514 , bareURL
@@ -1509,7 +1539,7 @@ inline = choice [ whitespace
1509 , ltSign
1539 , ltSign
1510 ] <?> "inline"
1540 ] <?> "inline"
1512−escapedChar' :: MarkdownParser Char
1542+escapedChar' :: PandocMonad m => MarkdownParser m Char
1513escapedChar' = try $ do
1543escapedChar' = try $ do
1514 char '\\'
1544 char '\\'
1515 (guardEnabled Ext_all_symbols_escapable >> satisfy (not . isAlphaNum))
1545 (guardEnabled Ext_all_symbols_escapable >> satisfy (not . isAlphaNum))
@@ -1518,7 +1548,7 @@ escapedChar' = try $ do
1518 <|> (guardEnabled Ext_escaped_line_breaks >> char '\n')
1548 <|> (guardEnabled Ext_escaped_line_breaks >> char '\n')
1519 <|> oneOf "\\`*_{}[]()>#+-.!~\""
1549 <|> oneOf "\\`*_{}[]()>#+-.!~\""
1521−escapedChar :: MarkdownParser (F Inlines)
1551+escapedChar :: PandocMonad m => MarkdownParser m (F Inlines)
1522escapedChar = do
1552escapedChar = do
1523 result <- escapedChar'
1553 result <- escapedChar'
1524 case result of
1554 case result of
@@ -1527,14 +1557,14 @@ escapedChar = do
1527 return (return B.linebreak) -- "\[newline]" is a linebreak
1557 return (return B.linebreak) -- "\[newline]" is a linebreak
1528 _ -> return $ return $ B.str [result]
1558 _ -> return $ return $ B.str [result]
1530−ltSign :: MarkdownParser (F Inlines)
1560+ltSign :: PandocMonad m => MarkdownParser m (F Inlines)
1531ltSign = do
1561ltSign = do
1532 guardDisabled Ext_raw_html
1562 guardDisabled Ext_raw_html
1533 <|> (notFollowedByHtmlCloser >> notFollowedBy' (htmlTag isBlockTag))
1563 <|> (notFollowedByHtmlCloser >> notFollowedBy' (htmlTag isBlockTag))
1534 char '<'
1564 char '<'
1535 return $ return $ B.str "<"
1565 return $ return $ B.str "<"
1537−exampleRef :: MarkdownParser (F Inlines)
1567+exampleRef :: PandocMonad m => MarkdownParser m (F Inlines)
1538exampleRef = try $ do
1568exampleRef = try $ do
1539 guardEnabled Ext_example_lists
1569 guardEnabled Ext_example_lists
1540 char '@'
1570 char '@'
@@ -1545,7 +1575,7 @@ exampleRef = try $ do
1545 Just n -> B.str (show n)
1575 Just n -> B.str (show n)
1546 Nothing -> B.str ('@':lab)
1576 Nothing -> B.str ('@':lab)
1548−symbol :: MarkdownParser (F Inlines)
1578+symbol :: PandocMonad m => MarkdownParser m (F Inlines)
1549symbol = do
1579symbol = do
1550 result <- noneOf "<\\\n\t "
1580 result <- noneOf "<\\\n\t "
1551 <|> try (do lookAhead $ char '\\'
1581 <|> try (do lookAhead $ char '\\'
@@ -1554,7 +1584,7 @@ symbol = do
1554 return $ return $ B.str [result]
1584 return $ return $ B.str [result]
1556-- parses inline code, between n `s and n `s
1586-- parses inline code, between n `s and n `s
1557−code :: MarkdownParser (F Inlines)
1587+code :: PandocMonad m => MarkdownParser m (F Inlines)
1558code = try $ do
1588code = try $ do
1559 starts <- many1 (char '`')
1589 starts <- many1 (char '`')
1560 skipSpaces
1590 skipSpaces
@@ -1566,7 +1596,7 @@ code = try $ do
1566 >> attributes)
1596 >> attributes)
1567 return $ return $ B.codeWith attr $ trim $ concat result
1597 return $ return $ B.codeWith attr $ trim $ concat result
1569−math :: MarkdownParser (F Inlines)
1599+math :: PandocMonad m => MarkdownParser m (F Inlines)
1570math = (return . B.displayMath <$> (mathDisplay >>= applyMacros'))
1600math = (return . B.displayMath <$> (mathDisplay >>= applyMacros'))
1571 <|> (return . B.math <$> (mathInline >>= applyMacros')) <+?>
1601 <|> (return . B.math <$> (mathInline >>= applyMacros')) <+?>
1572 ((getOption readerSmart >>= guard) *> (return <$> apostrophe)
1602 ((getOption readerSmart >>= guard) *> (return <$> apostrophe)
@@ -1574,8 +1604,9 @@ math = (return . B.displayMath <$> (mathDisplay >>= applyMacros'))
1575-- Parses material enclosed in *s, **s, _s, or __s.
1605-- Parses material enclosed in *s, **s, _s, or __s.
1576-- Designed to avoid backtracking.
1606-- Designed to avoid backtracking.
1577−enclosure :: Char
1607+enclosure :: PandocMonad m
1578− -> MarkdownParser (F Inlines)
1609+ -> MarkdownParser m (F Inlines)
1579enclosure c = do
1610enclosure c = do
1580 -- we can't start an enclosure with _ if after a string and
1611 -- we can't start an enclosure with _ if after a string and
1581 -- the intraword_underscores extension is enabled:
1612 -- the intraword_underscores extension is enabled:
@@ -1591,7 +1622,7 @@ enclosure c = do
1591 1 -> one c mempty
1622 1 -> one c mempty
1592 _ -> return (return $ B.str cs)
1623 _ -> return (return $ B.str cs)
1594−ender :: Char -> Int -> MarkdownParser ()
1625+ender :: PandocMonad m => Char -> Int -> MarkdownParser m ()
1595ender c n = try $ do
1626ender c n = try $ do
1596 count n (char c)
1627 count n (char c)
1597 guard (c == '*')
1628 guard (c == '*')
@@ -1602,7 +1633,7 @@ ender c n = try $ do
1602-- If one c, emit emph and then parse two.
1633-- If one c, emit emph and then parse two.
1603-- If two cs, emit strong and then parse one.
1634-- If two cs, emit strong and then parse one.
1604-- Otherwise, emit ccc then the results.
1635-- Otherwise, emit ccc then the results.
1605−three :: Char -> MarkdownParser (F Inlines)
1636+three :: PandocMonad m => Char -> MarkdownParser m (F Inlines)
1606three c = do
1637three c = do
1607 contents <- mconcat <$> many (notFollowedBy (ender c 1) >> inline)
1638 contents <- mconcat <$> many (notFollowedBy (ender c 1) >> inline)
1608 (ender c 3 >> return ((B.strong . B.emph) <$> contents))
1639 (ender c 3 >> return ((B.strong . B.emph) <$> contents))
@@ -1612,7 +1643,7 @@ three c = do
1613-- Parse inlines til you hit two c's, and emit strong.
1644-- Parse inlines til you hit two c's, and emit strong.
1614-- If you never do hit two cs, emit ** plus inlines parsed.
1645-- If you never do hit two cs, emit ** plus inlines parsed.
1615−two :: Char -> F Inlines -> MarkdownParser (F Inlines)
1646+two :: PandocMonad m => Char -> F Inlines -> MarkdownParser m (F Inlines)
1616two c prefix' = do
1647two c prefix' = do
1617 contents <- mconcat <$> many (try $ notFollowedBy (ender c 2) >> inline)
1648 contents <- mconcat <$> many (try $ notFollowedBy (ender c 2) >> inline)
1618 (ender c 2 >> return (B.strong <$> (prefix' <> contents)))
1649 (ender c 2 >> return (B.strong <$> (prefix' <> contents)))
@@ -1620,7 +1651,7 @@ two c prefix' = do
1621-- Parse inlines til you hit a c, and emit emph.
1652-- Parse inlines til you hit a c, and emit emph.
1622-- If you never hit a c, emit * plus inlines parsed.
1653-- If you never hit a c, emit * plus inlines parsed.
1623−one :: Char -> F Inlines -> MarkdownParser (F Inlines)
1654+one :: PandocMonad m => Char -> F Inlines -> MarkdownParser m (F Inlines)
1624one c prefix' = do
1655one c prefix' = do
1625 contents <- mconcat <$> many ( (notFollowedBy (ender c 1) >> inline)
1656 contents <- mconcat <$> many ( (notFollowedBy (ender c 1) >> inline)
1626 <|> try (string [c,c] >>
1657 <|> try (string [c,c] >>
@@ -1629,47 +1660,48 @@ one c prefix' = do
1629 (ender c 1 >> return (B.emph <$> (prefix' <> contents)))
1660 (ender c 1 >> return (B.emph <$> (prefix' <> contents)))
1630 <|> return (return (B.str [c]) <> (prefix' <> contents))
1661 <|> return (return (B.str [c]) <> (prefix' <> contents))
1632−strongOrEmph :: MarkdownParser (F Inlines)
1663+strongOrEmph :: PandocMonad m => MarkdownParser m (F Inlines)
1633strongOrEmph = enclosure '*' <|> enclosure '_'
1664strongOrEmph = enclosure '*' <|> enclosure '_'
1635-- | Parses a list of inlines between start and end delimiters.
1666-- | Parses a list of inlines between start and end delimiters.
1636−inlinesBetween :: (Show b)
1667+inlinesBetween :: PandocMonad m
1637− => MarkdownParser a
1669+ => MarkdownParser m a
1638− -> MarkdownParser b
1670+ -> MarkdownParser m b
1639− -> MarkdownParser (F Inlines)
1671+ -> MarkdownParser m (F Inlines)
1640inlinesBetween start end =
1672inlinesBetween start end =
1641 (trimInlinesF . mconcat) <$> try (start >> many1Till inner end)
1673 (trimInlinesF . mconcat) <$> try (start >> many1Till inner end)
1642 where inner = innerSpace <|> (notFollowedBy' (() <$ whitespace) >> inline)
1674 where inner = innerSpace <|> (notFollowedBy' (() <$ whitespace) >> inline)
1643 innerSpace = try $ whitespace <* notFollowedBy' end
1675 innerSpace = try $ whitespace <* notFollowedBy' end
1645−strikeout :: MarkdownParser (F Inlines)
1677+strikeout :: PandocMonad m => MarkdownParser m (F Inlines)
1646strikeout = fmap B.strikeout <$>
1678strikeout = fmap B.strikeout <$>
1647 (guardEnabled Ext_strikeout >> inlinesBetween strikeStart strikeEnd)
1679 (guardEnabled Ext_strikeout >> inlinesBetween strikeStart strikeEnd)
1648 where strikeStart = string "~~" >> lookAhead nonspaceChar
1680 where strikeStart = string "~~" >> lookAhead nonspaceChar
1649 >> notFollowedBy (char '~')
1681 >> notFollowedBy (char '~')
1650 strikeEnd = try $ string "~~"
1682 strikeEnd = try $ string "~~"
1652−superscript :: MarkdownParser (F Inlines)
1684+superscript :: PandocMonad m => MarkdownParser m (F Inlines)
1653superscript = fmap B.superscript <$> try (do
1685superscript = fmap B.superscript <$> try (do
1654 guardEnabled Ext_superscript
1686 guardEnabled Ext_superscript
1655 char '^'
1687 char '^'
1656 mconcat <$> many1Till (notFollowedBy spaceChar >> inline) (char '^'))
1688 mconcat <$> many1Till (notFollowedBy spaceChar >> inline) (char '^'))
1658−subscript :: MarkdownParser (F Inlines)
1690+subscript :: PandocMonad m => MarkdownParser m (F Inlines)
1659subscript = fmap B.subscript <$> try (do
1691subscript = fmap B.subscript <$> try (do
1660 guardEnabled Ext_subscript
1692 guardEnabled Ext_subscript
1661 char '~'
1693 char '~'
1662 mconcat <$> many1Till (notFollowedBy spaceChar >> inline) (char '~'))
1694 mconcat <$> many1Till (notFollowedBy spaceChar >> inline) (char '~'))
1664−whitespace :: MarkdownParser (F Inlines)
1696+whitespace :: PandocMonad m => MarkdownParser m (F Inlines)
1665whitespace = spaceChar >> return <$> (lb <|> regsp) <?> "whitespace"
1697whitespace = spaceChar >> return <$> (lb <|> regsp) <?> "whitespace"
1666 where lb = spaceChar >> skipMany spaceChar >> option B.space (endline >> return B.linebreak)
1698 where lb = spaceChar >> skipMany spaceChar >> option B.space (endline >> return B.linebreak)
1667 regsp = skipMany spaceChar >> return B.space
1699 regsp = skipMany spaceChar >> return B.space
1669−nonEndline :: Parser [Char] st Char
1701+nonEndline :: PandocMonad m => ParserT [Char] st m Char
1670nonEndline = satisfy (/='\n')
1702nonEndline = satisfy (/='\n')
1672−str :: MarkdownParser (F Inlines)
1704+str :: PandocMonad m => MarkdownParser m (F Inlines)
1674 result <- many1 alphaNum
1706 result <- many1 alphaNum
1675 updateLastStrPos
1707 updateLastStrPos
@@ -1699,7 +1731,7 @@ likelyAbbrev x =
1699 in map snd $ filter (\(y,_) -> y == x) abbrPairs
1731 in map snd $ filter (\(y,_) -> y == x) abbrPairs
1701-- an endline character that can be treated as a space, not a structural break
1733-- an endline character that can be treated as a space, not a structural break
1702−endline :: MarkdownParser (F Inlines)
1734+endline :: PandocMonad m => MarkdownParser m (F Inlines)
1703endline = try $ do
1735endline = try $ do
1705 notFollowedBy blankline
1737 notFollowedBy blankline
@@ -1721,17 +1753,17 @@ endline = try $ do
1723-- a reference label for a link
1755-- a reference label for a link
1724−reference :: MarkdownParser (F Inlines, String)
1756+reference :: PandocMonad m => MarkdownParser m (F Inlines, String)
1725reference = do notFollowedBy' (string "[^") -- footnote reference
1757reference = do notFollowedBy' (string "[^") -- footnote reference
1726 withRaw $ trimInlinesF <$> inlinesInBalancedBrackets
1758 withRaw $ trimInlinesF <$> inlinesInBalancedBrackets
1728−parenthesizedChars :: MarkdownParser [Char]
1760+parenthesizedChars :: PandocMonad m => MarkdownParser m [Char]
1729parenthesizedChars = do
1761parenthesizedChars = do
1730 result <- charsInBalanced '(' ')' litChar
1762 result <- charsInBalanced '(' ')' litChar
1731 return $ '(' : result ++ ")"
1763 return $ '(' : result ++ ")"
1733-- source for a link, with optional title
1765-- source for a link, with optional title
1734−source :: MarkdownParser (String, String)
1766+source :: PandocMonad m => MarkdownParser m (String, String)
1735source = do
1767source = do
1736 char '('
1768 char '('
1737 skipSpaces
1769 skipSpaces
@@ -1748,10 +1780,10 @@ source = do
1748 char ')'
1780 char ')'
1749 return (escapeURI $ trimr src, tit)
1781 return (escapeURI $ trimr src, tit)
1751−linkTitle :: MarkdownParser String
1783+linkTitle :: PandocMonad m => MarkdownParser m String
1752linkTitle = quotedTitle '"' <|> quotedTitle '\''
1784linkTitle = quotedTitle '"' <|> quotedTitle '\''
1754−link :: MarkdownParser (F Inlines)
1786+link :: PandocMonad m => MarkdownParser m (F Inlines)
1755link = try $ do
1787link = try $ do
1756 st <- getState
1788 st <- getState
1757 guard $ stateAllowLinks st
1789 guard $ stateAllowLinks st
@@ -1760,7 +1792,7 @@ link = try $ do
1760 setState $ st{ stateAllowLinks = True }
1792 setState $ st{ stateAllowLinks = True }
1761 regLink B.linkWith lab <|> referenceLink B.linkWith (lab,raw)
1793 regLink B.linkWith lab <|> referenceLink B.linkWith (lab,raw)
1763−bracketedSpan :: MarkdownParser (F Inlines)
1795+bracketedSpan :: PandocMonad m => MarkdownParser m (F Inlines)
1764bracketedSpan = try $ do
1796bracketedSpan = try $ do
1765 guardEnabled Ext_bracketed_spans
1797 guardEnabled Ext_bracketed_spans
1766 (lab,_) <- reference
1798 (lab,_) <- reference
@@ -1773,8 +1805,10 @@ bracketedSpan = try $ do
1773 -> return $ B.smallcaps <$> lab
1805 -> return $ B.smallcaps <$> lab
1774 _ -> return $ B.spanWith attr <$> lab
1806 _ -> return $ B.spanWith attr <$> lab
1808+regLink :: PandocMonad m
1776−regLink :: (Attr -> String -> String -> Inlines -> Inlines)
1809+ => (Attr -> String -> String -> Inlines -> Inlines)
1777− -> F Inlines -> MarkdownParser (F Inlines)
1811+ -> MarkdownParser m (F Inlines)
1778regLink constructor lab = try $ do
1812regLink constructor lab = try $ do
1779 (src, tit) <- source
1813 (src, tit) <- source
1780 attr <- option nullAttr $
1814 attr <- option nullAttr $
@@ -1782,8 +1816,10 @@ regLink constructor lab = try $ do
1782 return $ constructor attr src tit <$> lab
1816 return $ constructor attr src tit <$> lab
1784-- a link like [this][ref] or [this][] or [this]
1818-- a link like [this][ref] or [this][] or [this]
1819+referenceLink :: PandocMonad m
1785−referenceLink :: (Attr -> String -> String -> Inlines -> Inlines)
1820+ => (Attr -> String -> String -> Inlines -> Inlines)
1821+ -> (F Inlines, String)
1786− -> (F Inlines, String) -> MarkdownParser (F Inlines)
1822+ -> MarkdownParser m (F Inlines)
1787referenceLink constructor (lab, raw) = do
1823referenceLink constructor (lab, raw) = do
1788 sp <- (True <$ lookAhead (char ' ')) <|> return False
1824 sp <- (True <$ lookAhead (char ' ')) <|> return False
1789 (_,raw') <- option (mempty, "") $
1825 (_,raw') <- option (mempty, "") $
@@ -1824,7 +1860,7 @@ dropBrackets = reverse . dropRB . reverse . dropLB
1824 dropLB ('[':xs) = xs
1860 dropLB ('[':xs) = xs
1825 dropLB xs = xs
1861 dropLB xs = xs
1827−bareURL :: MarkdownParser (F Inlines)
1863+bareURL :: PandocMonad m => MarkdownParser m (F Inlines)
1828bareURL = try $ do
1864bareURL = try $ do
1829 guardEnabled Ext_autolink_bare_uris
1865 guardEnabled Ext_autolink_bare_uris
1830 getState >>= guard . stateAllowLinks
1866 getState >>= guard . stateAllowLinks
@@ -1832,7 +1868,7 @@ bareURL = try $ do
1832 notFollowedBy $ try $ spaces >> htmlTag (~== TagClose "a")
1868 notFollowedBy $ try $ spaces >> htmlTag (~== TagClose "a")
1833 return $ return $ B.link src "" (B.str orig)
1869 return $ return $ B.link src "" (B.str orig)
1835−autoLink :: MarkdownParser (F Inlines)
1871+autoLink :: PandocMonad m => MarkdownParser m (F Inlines)
1836autoLink = try $ do
1872autoLink = try $ do
1837 getState >>= guard . stateAllowLinks
1873 getState >>= guard . stateAllowLinks
1838 char '<'
1874 char '<'
@@ -1846,7 +1882,7 @@ autoLink = try $ do
1846 guardEnabled Ext_link_attributes >> attributes
1882 guardEnabled Ext_link_attributes >> attributes
1847 return $ return $ B.linkWith attr (src ++ escapeURI extra) "" (B.str $ orig ++ extra)
1883 return $ return $ B.linkWith attr (src ++ escapeURI extra) "" (B.str $ orig ++ extra)
1849−image :: MarkdownParser (F Inlines)
1885+image :: PandocMonad m => MarkdownParser m (F Inlines)
1850image = try $ do
1886image = try $ do
1851 char '!'
1887 char '!'
1852 (lab,raw) <- reference
1888 (lab,raw) <- reference
@@ -1856,7 +1892,7 @@ image = try $ do
1856 _ -> B.imageWith attr' src
1892 _ -> B.imageWith attr' src
1857 regLink constructor lab <|> referenceLink constructor (lab,raw)
1893 regLink constructor lab <|> referenceLink constructor (lab,raw)
1859−note :: MarkdownParser (F Inlines)
1895+note :: PandocMonad m => MarkdownParser m (F Inlines)
1860note = try $ do
1896note = try $ do
1861 guardEnabled Ext_footnotes
1897 guardEnabled Ext_footnotes
1862 ref <- noteMarker
1898 ref <- noteMarker
@@ -1872,14 +1908,14 @@ note = try $ do
1872 let contents' = runF contents st{ stateNotes' = [] }
1908 let contents' = runF contents st{ stateNotes' = [] }
1873 return $ B.note contents'
1909 return $ B.note contents'
1875−inlineNote :: MarkdownParser (F Inlines)
1911+inlineNote :: PandocMonad m => MarkdownParser m (F Inlines)
1876inlineNote = try $ do
1912inlineNote = try $ do
1877 guardEnabled Ext_inline_notes
1913 guardEnabled Ext_inline_notes
1878 char '^'
1914 char '^'
1879 contents <- inlinesInBalancedBrackets
1915 contents <- inlinesInBalancedBrackets
1880 return $ B.note . B.para <$> contents
1916 return $ B.note . B.para <$> contents
1882−rawLaTeXInline' :: MarkdownParser (F Inlines)
1918+rawLaTeXInline' :: PandocMonad m => MarkdownParser m (F Inlines)
1883rawLaTeXInline' = try $ do
1919rawLaTeXInline' = try $ do
1884 guardEnabled Ext_raw_tex
1920 guardEnabled Ext_raw_tex
1885 lookAhead $ char '\\' >> notFollowedBy' (string "start") -- context env
1921 lookAhead $ char '\\' >> notFollowedBy' (string "start") -- context env
@@ -1887,7 +1923,7 @@ rawLaTeXInline' = try $ do
1887 return $ return $ B.rawInline "tex" s
1923 return $ return $ B.rawInline "tex" s
1888 -- "tex" because it might be context or latex
1924 -- "tex" because it might be context or latex
1890−rawConTeXtEnvironment :: Parser [Char] st String
1926+rawConTeXtEnvironment :: PandocMonad m => ParserT [Char] st m String
1891rawConTeXtEnvironment = try $ do
1927rawConTeXtEnvironment = try $ do
1892 string "\\start"
1928 string "\\start"
1893 completion <- inBrackets (letter <|> digit <|> spaceChar)
1929 completion <- inBrackets (letter <|> digit <|> spaceChar)
@@ -1896,14 +1932,14 @@ rawConTeXtEnvironment = try $ do
1896 (try $ string "\\stop" >> string completion)
1932 (try $ string "\\stop" >> string completion)
1897 return $ "\\start" ++ completion ++ concat contents ++ "\\stop" ++ completion
1933 return $ "\\start" ++ completion ++ concat contents ++ "\\stop" ++ completion
1899−inBrackets :: (Parser [Char] st Char) -> Parser [Char] st String
1935+inBrackets :: PandocMonad m => (ParserT [Char] st m Char) -> ParserT [Char] st m String
1900inBrackets parser = do
1936inBrackets parser = do
1901 char '['
1937 char '['
1902 contents <- many parser
1938 contents <- many parser
1903 char ']'
1939 char ']'
1904 return $ "[" ++ contents ++ "]"
1940 return $ "[" ++ contents ++ "]"
1906−spanHtml :: MarkdownParser (F Inlines)
1942+spanHtml :: PandocMonad m => MarkdownParser m (F Inlines)
1907spanHtml = try $ do
1943spanHtml = try $ do
1908 guardEnabled Ext_native_spans
1944 guardEnabled Ext_native_spans
1909 (TagOpen _ attrs, _) <- htmlTag (~== TagOpen "span" [])
1945 (TagOpen _ attrs, _) <- htmlTag (~== TagOpen "span" [])
@@ -1918,7 +1954,7 @@ spanHtml = try $ do
1918 -> return $ B.smallcaps <$> contents
1954 -> return $ B.smallcaps <$> contents
1919 _ -> return $ B.spanWith (ident, classes, keyvals) <$> contents
1955 _ -> return $ B.spanWith (ident, classes, keyvals) <$> contents
1921−divHtml :: MarkdownParser (F Blocks)
1957+divHtml :: PandocMonad m => MarkdownParser m (F Blocks)
1922divHtml = try $ do
1958divHtml = try $ do
1923 guardEnabled Ext_native_divs
1959 guardEnabled Ext_native_divs
1924 (TagOpen _ attrs, rawtag) <- htmlTag (~== TagOpen "div" [])
1960 (TagOpen _ attrs, rawtag) <- htmlTag (~== TagOpen "div" [])
@@ -1940,7 +1976,7 @@ divHtml = try $ do
1940 else -- avoid backtracing
1976 else -- avoid backtracing
1941 return $ return (B.rawBlock "html" (rawtag <> bls)) <> contents
1977 return $ return (B.rawBlock "html" (rawtag <> bls)) <> contents
1943−rawHtmlInline :: MarkdownParser (F Inlines)
1979+rawHtmlInline :: PandocMonad m => MarkdownParser m (F Inlines)
1944rawHtmlInline = do
1980rawHtmlInline = do
1945 guardEnabled Ext_raw_html
1981 guardEnabled Ext_raw_html
1946 inHtmlBlock <- stateInHtmlBlock <$> getState
1982 inHtmlBlock <- stateInHtmlBlock <$> getState
@@ -1962,7 +1998,7 @@ rawHtmlInline = do
1962emojiChars :: [Char]
1998emojiChars :: [Char]
1963emojiChars = ['a'..'z'] ++ ['0'..'9'] ++ ['_','+','-']
1999emojiChars = ['a'..'z'] ++ ['0'..'9'] ++ ['_','+','-']
1965−emoji :: MarkdownParser (F Inlines)
2001+emoji :: PandocMonad m => MarkdownParser m (F Inlines)
1966emoji = try $ do
2002emoji = try $ do
1967 guardEnabled Ext_emoji
2003 guardEnabled Ext_emoji
1968 char ':'
2004 char ':'
@@ -1974,7 +2010,7 @@ emoji = try $ do
1975-- Citations
2011-- Citations
1977−cite :: MarkdownParser (F Inlines)
2013+cite :: PandocMonad m => MarkdownParser m (F Inlines)
1978cite = do
2014cite = do
1979 guardEnabled Ext_citations
2015 guardEnabled Ext_citations
1980 citations <- textualCite
2016 citations <- textualCite
@@ -1982,7 +2018,7 @@ cite = do
1982 return $ (flip B.cite (B.text raw)) <$> cs
2018 return $ (flip B.cite (B.text raw)) <$> cs
1983 return citations
2019 return citations
1985−textualCite :: MarkdownParser (F Inlines)
2021+textualCite :: PandocMonad m => MarkdownParser m (F Inlines)
1986textualCite = try $ do
2022textualCite = try $ do
1987 (_, key) <- citeKey
2023 (_, key) <- citeKey
1988 let first = Citation{ citationId = key
2024 let first = Citation{ citationId = key
@@ -2017,7 +2053,7 @@ textualCite = try $ do
2017 Just n -> B.str (show n)
2053 Just n -> B.str (show n)
2018 _ -> B.cite [first] $ B.str $ '@':key)
2054 _ -> B.cite [first] $ B.str $ '@':key)
2020−bareloc :: Citation -> MarkdownParser (F [Citation])
2056+bareloc :: PandocMonad m => Citation -> MarkdownParser m (F [Citation])
2021bareloc c = try $ do
2057bareloc c = try $ do
2023 char '['
2059 char '['
@@ -2032,7 +2068,7 @@ bareloc c = try $ do
2032 rest' <- rest
2068 rest' <- rest
2033 return $ c{ citationSuffix = B.toList suff' } : rest'
2069 return $ c{ citationSuffix = B.toList suff' } : rest'
2035−normalCite :: MarkdownParser (F [Citation])
2071+normalCite :: PandocMonad m => MarkdownParser m (F [Citation])
2036normalCite = try $ do
2072normalCite = try $ do
2037 char '['
2073 char '['
@@ -2041,7 +2077,7 @@ normalCite = try $ do
2041 char ']'
2077 char ']'
2042 return citations
2078 return citations
2044−suffix :: MarkdownParser (F Inlines)
2080+suffix :: PandocMonad m => MarkdownParser m (F Inlines)
2045suffix = try $ do
2081suffix = try $ do
2046 hasSpace <- option False (notFollowedBy nonspaceChar >> return True)
2082 hasSpace <- option False (notFollowedBy nonspaceChar >> return True)
@@ -2050,14 +2086,14 @@ suffix = try $ do
2050 then (B.space <>) <$> rest
2086 then (B.space <>) <$> rest
2051 else rest
2087 else rest
2053−prefix :: MarkdownParser (F Inlines)
2089+prefix :: PandocMonad m => MarkdownParser m (F Inlines)
2054prefix = trimInlinesF . mconcat <$>
2090prefix = trimInlinesF . mconcat <$>
2055 manyTill inline (char ']' <|> liftM (const ']') (lookAhead citeKey))
2091 manyTill inline (char ']' <|> liftM (const ']') (lookAhead citeKey))
2057−citeList :: MarkdownParser (F [Citation])
2093+citeList :: PandocMonad m => MarkdownParser m (F [Citation])
2058citeList = fmap sequence $ sepBy1 citation (try $ char ';' >> spnl)
2094citeList = fmap sequence $ sepBy1 citation (try $ char ';' >> spnl)
2060−citation :: MarkdownParser (F Citation)
2096+citation :: PandocMonad m => MarkdownParser m (F Citation)
2061citation = try $ do
2097citation = try $ do
2062 pref <- prefix
2098 pref <- prefix
2063 (suppress_author, key) <- citeKey
2099 (suppress_author, key) <- citeKey
@@ -2075,13 +2111,13 @@ citation = try $ do
2075 , citationHash = 0
2111 , citationHash = 0
2078−smart :: MarkdownParser (F Inlines)
2114+smart :: PandocMonad m => MarkdownParser m (F Inlines)
2079smart = do
2115smart = do
2080 getOption readerSmart >>= guard
2116 getOption readerSmart >>= guard
2081 doubleQuoted <|> singleQuoted <|>
2117 doubleQuoted <|> singleQuoted <|>
2082 choice (map (return <$>) [apostrophe, dash, ellipses])
2118 choice (map (return <$>) [apostrophe, dash, ellipses])
2084−singleQuoted :: MarkdownParser (F Inlines)
2120+singleQuoted :: PandocMonad m => MarkdownParser m (F Inlines)
2085singleQuoted = try $ do
2121singleQuoted = try $ do
2086 singleQuoteStart
2122 singleQuoteStart
2087 withQuoteContext InSingleQuote $
2123 withQuoteContext InSingleQuote $
@@ -2091,7 +2127,7 @@ singleQuoted = try $ do
2091-- doubleQuoted will handle regular double-quoted sections, as well
2127-- doubleQuoted will handle regular double-quoted sections, as well
2092-- as dialogues with an open double-quote without a close double-quote
2128-- as dialogues with an open double-quote without a close double-quote
2093-- in the same paragraph.
2129-- in the same paragraph.
2094−doubleQuoted :: MarkdownParser (F Inlines)
2130+doubleQuoted :: PandocMonad m => MarkdownParser m (F Inlines)
2095doubleQuoted = try $ do
2131doubleQuoted = try $ do
2096 doubleQuoteStart
2132 doubleQuoteStart
2097 contents <- mconcat <$> many (try $ notFollowedBy doubleQuoteEnd >> inline)
2133 contents <- mconcat <$> many (try $ notFollowedBy doubleQuoteEnd >> inline)