@@ -247,51 +247,60 @@ titleBlock :: PandocMonad m => MarkdownParser m ()
247247titleBlock = pandocTitleBlock <|> mmdTitleBlock
248248
249249pandocTitleBlock :: PandocMonad m => MarkdownParser m ()
250−pandocTitleBlock = try $ do
250+pandocTitleBlock = do
251251 guardEnabled Ext_pandoc_title_block
252252 lookAhead (char '%')
253− title <- option mempty titleLine
254− author <- option (return []) authorsLine
255− date <- option mempty dateLine
256− optional blanklines
257− let meta' = do title' <- title
258− author' <- author
259− date' <- date
260− return $
261− (if null title' then id else B.setMeta "title" title')
262− . (if null author' then id else B.setMeta "author" author')
263− . (if null date' then id else B.setMeta "date" date')
264− $ nullMeta
265− updateState $ \st -> st{ stateMeta' = stateMeta' st <> meta' }
253+ try $ do
254+ title <- option mempty titleLine
255+ author <- option (return []) authorsLine
256+ date <- option mempty dateLine
257+ optional blanklines
258+ let meta' = do title' <- title
259+ author' <- author
260+ date' <- date
261+ return $
262+ (if null title'
263+ then id
264+ else B.setMeta "title" title')
265+ . (if null author'
266+ then id
267+ else B.setMeta "author" author')
268+ . (if null date'
269+ then id
270+ else B.setMeta "date" date')
271+ $ nullMeta
272+ updateState $ \st -> st{ stateMeta' = stateMeta' st <> meta' }
266273
267274yamlMetaBlock :: PandocMonad m => MarkdownParser m (F Blocks)
268−yamlMetaBlock = try $ do
275+yamlMetaBlock = do
269276 guardEnabled Ext_yaml_metadata_block
270− string "---"
271− blankline
272− notFollowedBy blankline -- if --- is followed by a blank it's an HRULE
273− rawYamlLines <- manyTill anyLine stopLine
274− -- by including --- and ..., we allow yaml blocks with just comments:
275− let rawYaml = T.unlines ("---" : (rawYamlLines ++ ["..."]))
276− optional blanklines
277− newMetaF <- yamlBsToMeta (fmap B.toMetaValue <$> parseBlocks)
278− $ UTF8.fromTextLazy $ TL.fromStrict rawYaml
279− -- Since `<>` is left-biased, existing values are not touched:
280− updateState $ \st -> st{ stateMeta' = stateMeta' st <> newMetaF }
281− return mempty
277+ try $ do
278+ string "---"
279+ blankline
280+ notFollowedBy blankline -- if --- is followed by a blank it's an HRULE
281+ rawYamlLines <- manyTill anyLine stopLine
282+ -- by including --- and ..., we allow yaml blocks with just comments:
283+ let rawYaml = T.unlines ("---" : (rawYamlLines ++ ["..."]))
284+ optional blanklines
285+ newMetaF <- yamlBsToMeta (fmap B.toMetaValue <$> parseBlocks)
286+ $ UTF8.fromTextLazy $ TL.fromStrict rawYaml
287+ -- Since `<>` is left-biased, existing values are not touched:
288+ updateState $ \st -> st{ stateMeta' = stateMeta' st <> newMetaF }
289+ return mempty
282290
283291stopLine :: PandocMonad m => MarkdownParser m ()
284292stopLine = try $ (string "---" <|> string "...") >> blankline >> return ()
285293
286294mmdTitleBlock :: PandocMonad m => MarkdownParser m ()
287−mmdTitleBlock = try $ do
295+mmdTitleBlock = do
288296 guardEnabled Ext_mmd_title_block
289− firstPair <- kvPair False
290− restPairs <- many (kvPair True)
291− let kvPairs = firstPair : restPairs
292− blanklines
293− updateState $ \st -> st{ stateMeta' = stateMeta' st <>
294− return (Meta $ M.fromList kvPairs) }
297+ try $ do
298+ firstPair <- kvPair False
299+ restPairs <- many (kvPair True)
300+ let kvPairs = firstPair : restPairs
301+ blanklines
302+ updateState $ \st -> st{ stateMeta' = stateMeta' st <>
303+ return (Meta $ M.fromList kvPairs) }
295304
296305kvPair :: PandocMonad m => Bool -> MarkdownParser m (Text, MetaValue)
297306kvPair allowEmpty = try $ do
@@ -661,15 +670,15 @@ codeBlockFenced :: PandocMonad m => MarkdownParser m (F Blocks)
661670codeBlockFenced = try $ do
662671 indentchars <- nonindentSpaces
663672 let indentLevel = T.length indentchars
664− c <- try (guardEnabled Ext_fenced_code_blocks >> lookAhead (char '~'))
673+ c <- (guardEnabled Ext_fenced_code_blocks >> lookAhead (char '~'))
665674 <|> (guardEnabled Ext_backtick_code_blocks >> lookAhead (char '`'))
666675 size <- blockDelimiter (== c) Nothing
667676 skipMany spaceChar
668677 rawattr <-
669− (Left <$> try (guardEnabled Ext_raw_attribute >> rawAttribute))
678+ (Left <$> (guardEnabled Ext_raw_attribute >> try rawAttribute))
670679 <|>
671680 (Right <$> option ("",[],[])
672− (try (guardEnabled Ext_fenced_code_attributes >> attributes)
681+ ((guardEnabled Ext_fenced_code_attributes >> try attributes)
673682 <|> ((\x -> ("",[toLanguageId x],[])) <$> many1Char nonspaceChar)))
674683 blankline
675684 contents <- T.intercalate "\n" <$>
@@ -1157,11 +1166,12 @@ stripMarkdownAttribute s = renderTags' $ map filterAttrib $ parseTags s
11571166--
11581167
11591168lineBlock :: PandocMonad m => MarkdownParser m (F Blocks)
1160−lineBlock = try $ do
1169+lineBlock = do
11611170 guardEnabled Ext_line_blocks
1162− lines' <- lineBlockLines >>=
1163− mapM (parseFromString' (trimInlinesF <$> inlines))
1164− return $ B.lineBlock <$> sequence lines'
1171+ try $ do
1172+ lines' <- lineBlockLines >>=
1173+ mapM (parseFromString' (trimInlinesF <$> inlines))
1174+ return $ B.lineBlock <$> sequence lines'
11651175
11661176--
11671177-- Tables
@@ -1263,11 +1273,12 @@ multilineRow indices = do
12631273-- Parses a table caption: inlines beginning with 'Table:'
12641274-- and followed by blank lines.
12651275tableCaption :: PandocMonad m => MarkdownParser m (F Inlines)
1266−tableCaption = try $ do
1276+tableCaption = do
12671277 guardEnabled Ext_table_captions
1268− skipNonindentSpaces
1269− (string ":" <* notFollowedBy (satisfy isPunctuation)) <|> string "Table:"
1270− trimInlinesF <$> inlines1 <* blanklines
1278+ try $ do
1279+ skipNonindentSpaces
1280+ (string ":" <* notFollowedBy (satisfy isPunctuation)) <|> string "Table:"
1281+ trimInlinesF <$> inlines1 <* blanklines
12711282
12721283-- Parse a simple table with '---' header and one line per row.
12731284simpleTable :: PandocMonad m
@@ -1436,15 +1447,14 @@ table :: PandocMonad m => MarkdownParser m (F Blocks)
14361447table = try $ do
14371448 frontCaption <- option Nothing (Just <$> tableCaption)
14381449 (aligns, widths, heads, lns) <-
1439− try (guardEnabled Ext_pipe_tables >> scanForPipe >> pipeTable) <|>
1440− try (guardEnabled Ext_multiline_tables >>
1441− multilineTable False) <|>
1442− try (guardEnabled Ext_simple_tables >>
1443− (simpleTable True <|> simpleTable False)) <|>
1444− try (guardEnabled Ext_multiline_tables >>
1445− multilineTable True) <|>
1446− try (guardEnabled Ext_grid_tables >>
1447− (gridTable False <|> gridTable True)) <?> "table"
1450+ (guardEnabled Ext_pipe_tables >> try (scanForPipe >> pipeTable)) <|>
1451+ (guardEnabled Ext_multiline_tables >> try (multilineTable False)) <|>
1452+ (guardEnabled Ext_simple_tables >>
1453+ try (simpleTable True <|> simpleTable False)) <|>
1454+ (guardEnabled Ext_multiline_tables >>
1455+ try (multilineTable True)) <|>
1456+ (guardEnabled Ext_grid_tables >>
1457+ try (gridTable False <|> gridTable True)) <?> "table"
14481458 optional blanklines
14491459 caption <- case frontCaption of
14501460 Nothing -> option (return mempty) tableCaption
@@ -1478,35 +1488,37 @@ inlines1 :: PandocMonad m => MarkdownParser m (F Inlines)
14781488inlines1 = mconcat <$> many1 inline
14791489
14801490inline :: PandocMonad m => MarkdownParser m (F Inlines)
1481−inline = choice [ whitespace
1482− , bareURL
1483− , str
1484− , endline
1485− , code
1486− , strongOrEmph
1487− , note
1488− , cite
1489− , bracketedSpan
1490− , link
1491− , image
1492− , math
1493− , strikeout
1494− , subscript
1495− , superscript
1496− , inlineNote -- after superscript because of ^[link](/foo)^
1497− , autoLink
1498− , spanHtml
1499− , rawHtmlInline
1500− , escapedNewline
1501− , escapedChar
1502− , rawLaTeXInline'
1503− , exampleRef
1504− , smart
1505− , return . B.singleton <$> charRef
1506− , emoji
1507− , symbol
1508− , ltSign
1509− ] <?> "inline"
1491+inline = do
1492+ c <- lookAhead anyChar
1493+ ((case c of
1494+ ' ' -> whitespace
1495+ '\t' -> whitespace
1496+ '\n' -> endline
1497+ '`' -> code
1498+ '_' -> strongOrEmph
1499+ '*' -> strongOrEmph
1500+ '^' -> superscript <|> inlineNote -- in this order bc ^[link](/foo)^
1501+ '[' -> note <|> cite <|> bracketedSpan <|> link
1502+ '!' -> image
1503+ '$' -> math
1504+ '~' -> strikeout <|> subscript
1505+ '<' -> autoLink <|> spanHtml <|> rawHtmlInline <|> ltSign
1506+ '\\' -> escapedNewline <|> escapedChar <|> rawLaTeXInline'
1507+ '@' -> exampleRef
1508+ '"' -> smart
1509+ '\'' -> smart
1510+ '\8216' -> smart
1511+ '\145' -> smart
1512+ '\8220' -> smart
1513+ '\147' -> smart
1514+ '-' -> smart
1515+ '.' -> smart
1516+ '&' -> return . B.singleton <$> charRef
1517+ ':' -> emoji
1518+ _ -> mzero)
1519+ <|> bareURL
1520+ <|> str
1521+ <|> symbol) <?> "inline"
15101522
15111523escapedChar' :: PandocMonad m => MarkdownParser m Char
15121524escapedChar' = try $ do
@@ -1517,11 +1529,12 @@ escapedChar' = try $ do
15171529 <|> oneOf "\\`*_{}[]()>#+-.!~\""
15181530
15191531escapedNewline :: PandocMonad m => MarkdownParser m (F Inlines)
1520−escapedNewline = try $ do
1532+escapedNewline = do
15211533 guardEnabled Ext_escaped_line_breaks
1522− char '\\'
1523− lookAhead (char '\n') -- don't consume the newline (see #3730)
1524− return $ return B.linebreak
1534+ try $ do
1535+ char '\\'
1536+ lookAhead (char '\n') -- don't consume the newline (see #3730)
1537+ return $ return B.linebreak
15251538
15261539escapedChar :: PandocMonad m => MarkdownParser m (F Inlines)
15271540escapedChar = do
@@ -1543,19 +1556,20 @@ ltSign = do
15431556-- whole document has been parsed. But we need this parser
15441557-- here in case citations is disabled.
15451558exampleRef :: PandocMonad m => MarkdownParser m (F Inlines)
1546−exampleRef = try $ do
1559+exampleRef = do
15471560 guardEnabled Ext_example_lists
1548− char '@'
1549− lab <- mconcat . map T.pack <$>
1550− many (many1 alphaNum <|>
1551− try (do c <- char '_' <|> char '-'
1552− cs <- many1 alphaNum
1553− return (c:cs)))
1554− return $ do
1555− st <- askF
1556− return $ case M.lookup lab (stateExamples st) of
1557− Just n -> B.str $ tshow n
1558− Nothing -> B.str $ "@" <> lab
1561+ try $ do
1562+ char '@'
1563+ lab <- mconcat . map T.pack <$>
1564+ many (many1 alphaNum <|>
1565+ try (do c <- char '_' <|> char '-'
1566+ cs <- many1 alphaNum
1567+ return (c:cs)))
1568+ return $ do
1569+ st <- askF
1570+ return $ case M.lookup lab (stateExamples st) of
1571+ Just n -> B.str $ tshow n
1572+ Nothing -> B.str $ "@" <> lab
15591573
15601574symbol :: PandocMonad m => MarkdownParser m (F Inlines)
15611575symbol = do
@@ -1582,10 +1596,10 @@ code = try $ do
15821596 >> count (length starts) (char '`')
15831597 >> notFollowedBy (char '`'))
15841598 rawattr <-
1585− (Left <$> try (guardEnabled Ext_raw_attribute >> rawAttribute))
1599+ (Left <$> (guardEnabled Ext_raw_attribute >> try rawAttribute))
15861600 <|>
15871601 (Right <$> option ("",[],[])
1588− (try (guardEnabled Ext_inline_code_attributes >> attributes)))
1602+ (guardEnabled Ext_inline_code_attributes >> try attributes))
15891603 return $ return $
15901604 case rawattr of
15911605 Left syn -> B.rawInline syn result
@@ -1678,20 +1692,22 @@ strikeout = fmap B.strikeout <$>
16781692 strikeEnd = try $ string "~~"
16791693
16801694superscript :: PandocMonad m => MarkdownParser m (F Inlines)
1681−superscript = fmap B.superscript <$> try (do
1695+superscript = do
16821696 guardEnabled Ext_superscript
1683− char '^'
1684− mconcat <$> many1Till (do notFollowedBy spaceChar
1685− notFollowedBy newline
1686− inline) (char '^'))
1697+ fmap B.superscript <$> try (do
1698+ char '^'
1699+ mconcat <$> many1Till (do notFollowedBy spaceChar
1700+ notFollowedBy newline
1701+ inline) (char '^'))
16871702
16881703subscript :: PandocMonad m => MarkdownParser m (F Inlines)
1689−subscript = fmap B.subscript <$> try (do
1704+subscript = do
16901705 guardEnabled Ext_subscript
1691− char '~'
1692− mconcat <$> many1Till (do notFollowedBy spaceChar
1693− notFollowedBy newline
1694− inline) (char '~'))
1706+ fmap B.subscript <$> try (do
1707+ char '~'
1708+ mconcat <$> many1Till (do notFollowedBy spaceChar
1709+ notFollowedBy newline
1710+ inline) (char '~'))
16951711
16961712whitespace :: PandocMonad m => MarkdownParser m (F Inlines)
16971713whitespace = spaceChar >> return <$> (lb <|> regsp) <?> "whitespace"
@@ -1792,15 +1808,16 @@ link = try $ do
17921808 regLink B.linkWith lab <|> referenceLink B.linkWith (lab,raw)
17931809
17941810bracketedSpan :: PandocMonad m => MarkdownParser m (F Inlines)
1795−bracketedSpan = try $ do
1811+bracketedSpan = do
17961812 guardEnabled Ext_bracketed_spans
1797− (lab,_) <- reference
1798− attr <- attributes
1799− return $ if isSmallCaps attr
1800− then B.smallcaps <$> lab
1801− else if isUnderline attr
1802− then B.underline <$> lab
1803− else B.spanWith attr <$> lab
1813+ try $ do
1814+ (lab,_) <- reference
1815+ attr <- attributes
1816+ return $ if isSmallCaps attr
1817+ then B.smallcaps <$> lab
1818+ else if isUnderline attr
1819+ then B.underline <$> lab
1820+ else B.spanWith attr <$> lab
18041821
18051822-- | We treat a span as SmallCaps if class is "smallcaps" (and
18061823-- no other attributes are set or if style is "font-variant:small-caps"
@@ -1879,12 +1896,13 @@ dropBrackets = dropRB . dropLB
18791896 dropLB xs = xs
18801897
18811898bareURL :: PandocMonad m => MarkdownParser m (F Inlines)
1882−bareURL = try $ do
1899+bareURL = do
18831900 guardEnabled Ext_autolink_bare_uris
18841901 getState >>= guard . stateAllowLinks
1885− (cls, (orig, src)) <- (("uri",) <$> uri) <|> (("email",) <$> emailAddress)
1886− notFollowedBy $ try $ spaces >> htmlTag (~== TagClose ("a" :: Text))
1887− return $ return $ B.linkWith ("",[cls],[]) src "" (B.str orig)
1902+ try $ do
1903+ (cls, (orig, src)) <- (("uri",) <$> uri) <|> (("email",) <$> emailAddress)
1904+ notFollowedBy $ try $ spaces >> htmlTag (~== TagClose ("a" :: Text))
1905+ return $ return $ B.linkWith ("",[cls],[]) src "" (B.str orig)
18881906
18891907autoLink :: PandocMonad m => MarkdownParser m (F Inlines)
18901908autoLink = try $ do
@@ -1937,21 +1955,23 @@ note = try $ do
19371955 return $ B.note $ walk adjustCite contents'
19381956
19391957inlineNote :: PandocMonad m => MarkdownParser m (F Inlines)
1940−inlineNote = try $ do
1958+inlineNote = do
19411959 guardEnabled Ext_inline_notes
1942− char '^'
1943− updateState $ \st -> st{ stateInNote = True
1944− , stateNoteNumber = stateNoteNumber st + 1 }
1945− contents <- inlinesInBalancedBrackets
1946− updateState $ \st -> st{ stateInNote = False }
1947− return $ B.note . B.para <$> contents
1960+ try $ do
1961+ char '^'
1962+ updateState $ \st -> st{ stateInNote = True
1963+ , stateNoteNumber = stateNoteNumber st + 1 }
1964+ contents <- inlinesInBalancedBrackets
1965+ updateState $ \st -> st{ stateInNote = False }
1966+ return $ B.note . B.para <$> contents
19481967
19491968rawLaTeXInline' :: PandocMonad m => MarkdownParser m (F Inlines)
1950−rawLaTeXInline' = try $ do
1969+rawLaTeXInline' = do
19511970 guardEnabled Ext_raw_tex
19521971 notFollowedBy' rawConTeXtEnvironment
1953− s <- rawLaTeXInline
1954− return $ return $ B.rawInline "tex" s -- "tex" because it might be context
1972+ try $ do
1973+ s <- rawLaTeXInline
1974+ return $ return $ B.rawInline "tex" s -- "tex" because it might be context
19551975
19561976rawConTeXtEnvironment :: PandocMonad m => ParserT Text st m Text
19571977rawConTeXtEnvironment = try $ do
@@ -1970,55 +1990,60 @@ inBrackets parser = do
19701990 return $ "[" <> contents <> "]"
19711991
19721992spanHtml :: PandocMonad m => MarkdownParser m (F Inlines)
1973−spanHtml = try $ do
1993+spanHtml = do
19741994 guardEnabled Ext_native_spans
1975− (TagOpen _ attrs, _) <- htmlTag (~== TagOpen ("span" :: Text) [])
1976− contents <- mconcat <$> manyTill inline (htmlTag (~== TagClose ("span" :: Text)))
1977− let ident = fromMaybe "" $ lookup "id" attrs
1978− let classes = maybe [] T.words $ lookup "class" attrs
1979− let keyvals = [(k,v) | (k,v) <- attrs, k /= "id" && k /= "class"]
1980− return $ if isSmallCaps (ident, classes, keyvals)
1981− then B.smallcaps <$> contents
1982− else if isUnderline (ident, classes, keyvals)
1983− then B.underline <$> contents
1984− else B.spanWith (ident, classes, keyvals) <$> contents
1995+ try $ do
1996+ (TagOpen _ attrs, _) <- htmlTag (~== TagOpen ("span" :: Text) [])
1997+ contents <- mconcat <$> manyTill inline (htmlTag (~== TagClose ("span" :: Text)))
1998+ let ident = fromMaybe "" $ lookup "id" attrs
1999+ let classes = maybe [] T.words $ lookup "class" attrs
2000+ let keyvals = [(k,v) | (k,v) <- attrs, k /= "id" && k /= "class"]
2001+ return $ if isSmallCaps (ident, classes, keyvals)
2002+ then B.smallcaps <$> contents
2003+ else if isUnderline (ident, classes, keyvals)
2004+ then B.underline <$> contents
2005+ else B.spanWith (ident, classes, keyvals) <$> contents
19852006
19862007divHtml :: PandocMonad m => MarkdownParser m (F Blocks)
1987−divHtml = try $ do
2008+divHtml = do
19882009 guardEnabled Ext_native_divs
1989− (TagOpen _ attrs, rawtag) <- htmlTag (~== TagOpen ("div" :: Text) [])
1990− -- we set stateInHtmlBlock so that closing tags that can be either block or
1991− -- inline will not be parsed as inline tags
1992− oldInHtmlBlock <- stateInHtmlBlock <$> getState
1993− updateState $ \st -> st{ stateInHtmlBlock = Just "div" }
1994− bls <- option "" (blankline >> option "" blanklines)
1995− contents <- mconcat <$>
1996− many (notFollowedBy' (htmlTag (~== TagClose ("div" :: Text))) >> block)
1997− closed <- option False (True <$ htmlTag (~== TagClose ("div" :: Text)))
1998− if closed
1999− then do
2000− updateState $ \st -> st{ stateInHtmlBlock = oldInHtmlBlock }
2001− let ident = fromMaybe "" $ lookup "id" attrs
2002− let classes = maybe [] T.words $ lookup "class" attrs
2003− let keyvals = [(k,v) | (k,v) <- attrs, k /= "id" && k /= "class"]
2004− return $ B.divWith (ident, classes, keyvals) <$> contents
2005− else -- avoid backtracing
2006− return $ return (B.rawBlock "html" (rawtag <> bls)) <> contents
2010+ try $ do
2011+ (TagOpen _ attrs, rawtag) <- htmlTag (~== TagOpen ("div" :: Text) [])
2012+ -- we set stateInHtmlBlock so that closing tags that can be either block
2013+ -- or inline will not be parsed as inline tags
2014+ oldInHtmlBlock <- stateInHtmlBlock <$> getState
2015+ updateState $ \st -> st{ stateInHtmlBlock = Just "div" }
2016+ bls <- option "" (blankline >> option "" blanklines)
2017+ contents <- mconcat <$>
2018+ many (notFollowedBy' (htmlTag (~== TagClose ("div" :: Text))) >> block)
2019+ closed <- option False (True <$ htmlTag (~== TagClose ("div" :: Text)))
2020+ if closed
2021+ then do
2022+ updateState $ \st -> st{ stateInHtmlBlock = oldInHtmlBlock }
2023+ let ident = fromMaybe "" $ lookup "id" attrs
2024+ let classes = maybe [] T.words $ lookup "class" attrs
2025+ let keyvals = [(k,v) | (k,v) <- attrs, k /= "id" && k /= "class"]
2026+ return $ B.divWith (ident, classes, keyvals) <$> contents
2027+ else -- avoid backtracing
2028+ return $ return (B.rawBlock "html" (rawtag <> bls)) <> contents
20072029
20082030divFenced :: PandocMonad m => MarkdownParser m (F Blocks)
2009−divFenced = try $ do
2031+divFenced = do
20102032 guardEnabled Ext_fenced_divs
2011− string ":::"
2012− skipMany (char ':')
2013− skipMany spaceChar
2014− attribs <- attributes <|> ((\x -> ("",[x],[])) <$> many1Char nonspaceChar)
2015− skipMany spaceChar
2016− skipMany (char ':')
2017− blankline
2018− updateState $ \st -> st{ stateFencedDivLevel = stateFencedDivLevel st + 1 }
2019− bs <- mconcat <$> manyTill block divFenceEnd
2020− updateState $ \st -> st{ stateFencedDivLevel = stateFencedDivLevel st - 1 }
2021− return $ B.divWith attribs <$> bs
2033+ try $ do
2034+ string ":::"
2035+ skipMany (char ':')
2036+ skipMany spaceChar
2037+ attribs <- attributes <|> ((\x -> ("",[x],[])) <$> many1Char nonspaceChar)
2038+ skipMany spaceChar
2039+ skipMany (char ':')
2040+ blankline
2041+ updateState $ \st ->
2042+ st{ stateFencedDivLevel = stateFencedDivLevel st + 1 }
2043+ bs <- mconcat <$> manyTill block divFenceEnd
2044+ updateState $ \st ->
2045+ st{ stateFencedDivLevel = stateFencedDivLevel st - 1 }
2046+ return $ B.divWith attribs <$> bs
20222047
20232048divFenceEnd :: PandocMonad m => MarkdownParser m ()
20242049divFenceEnd = try $ do
@@ -2050,14 +2075,15 @@ emojiChars :: [Char]
20502075emojiChars = ['a'..'z'] ++ ['0'..'9'] ++ ['_','+','-']
20512076
20522077emoji :: PandocMonad m => MarkdownParser m (F Inlines)
2053−emoji = try $ do
2078+emoji = do
20542079 guardEnabled Ext_emoji
2055− char ':'
2056− emojikey <- many1Char (oneOf emojiChars)
2057− char ':'
2058− case emojiToInline emojikey of
2059− Just i -> return (return $ B.singleton i)
2060− Nothing -> mzero
2080+ try $ do
2081+ char ':'
2082+ emojikey <- many1Char (oneOf emojiChars)
2083+ char ':'
2084+ case emojiToInline emojikey of
2085+ Just i -> return (return $ B.singleton i)
2086+ Nothing -> mzero
20612087
20622088-- Citations
20632089