{-# LANGUAGE ExtendedDefaultRules       #-}
{-# LANGUAGE FlexibleContexts           #-}
{-# LANGUAGE FlexibleInstances          #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MultiParamTypeClasses      #-}
{-# LANGUAGE OverloadedStrings          #-}
{-# LANGUAGE UndecidableInstances       #-}

module Commonmark.Pandoc
  ( Cm(..)
  )

where

import Data.Maybe (fromMaybe)
import qualified Data.Text as T
import qualified Data.Text.Read as TR
import Text.Pandoc.Definition
import Text.Pandoc.Walk
import qualified Text.Pandoc.Builder as B
import Commonmark.Types as C
import Commonmark.Entity (lookupEntity)
import Commonmark.Extensions.Math
import Commonmark.Extensions.Emoji
import Commonmark.Extensions.Wikilinks
import Commonmark.Extensions.PipeTable
import Commonmark.Extensions.Strikethrough
import Commonmark.Extensions.Superscript
import Commonmark.Extensions.Subscript
import Commonmark.Extensions.DefinitionList
import Commonmark.Extensions.Attributes
import Commonmark.Extensions.Footnote
import Commonmark.Extensions.TaskList
import Commonmark.Extensions.Alerts
import Commonmark.Extensions.Smart
import Data.Char (isSpace)
import Data.Coerce (coerce)

newtype Cm b a = Cm { forall b a. Cm b a -> a
unCm :: a }
  deriving (Int -> Cm b a -> ShowS
[Cm b a] -> ShowS
Cm b a -> String
(Int -> Cm b a -> ShowS)
-> (Cm b a -> String) -> ([Cm b a] -> ShowS) -> Show (Cm b a)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall b a. Show a => Int -> Cm b a -> ShowS
forall b a. Show a => [Cm b a] -> ShowS
forall b a. Show a => Cm b a -> String
$cshowsPrec :: forall b a. Show a => Int -> Cm b a -> ShowS
showsPrec :: Int -> Cm b a -> ShowS
$cshow :: forall b a. Show a => Cm b a -> String
show :: Cm b a -> String
$cshowList :: forall b a. Show a => [Cm b a] -> ShowS
showList :: [Cm b a] -> ShowS
Show, NonEmpty (Cm b a) -> Cm b a
Cm b a -> Cm b a -> Cm b a
(Cm b a -> Cm b a -> Cm b a)
-> (NonEmpty (Cm b a) -> Cm b a)
-> (forall b. Integral b => b -> Cm b a -> Cm b a)
-> Semigroup (Cm b a)
forall b. Integral b => b -> Cm b a -> Cm b a
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
forall b a. Semigroup a => NonEmpty (Cm b a) -> Cm b a
forall b a. Semigroup a => Cm b a -> Cm b a -> Cm b a
forall b a b. (Semigroup a, Integral b) => b -> Cm b a -> Cm b a
$c<> :: forall b a. Semigroup a => Cm b a -> Cm b a -> Cm b a
<> :: Cm b a -> Cm b a -> Cm b a
$csconcat :: forall b a. Semigroup a => NonEmpty (Cm b a) -> Cm b a
sconcat :: NonEmpty (Cm b a) -> Cm b a
$cstimes :: forall b a b. (Semigroup a, Integral b) => b -> Cm b a -> Cm b a
stimes :: forall b. Integral b => b -> Cm b a -> Cm b a
Semigroup, Semigroup (Cm b a)
Cm b a
Semigroup (Cm b a) =>
Cm b a
-> (Cm b a -> Cm b a -> Cm b a)
-> ([Cm b a] -> Cm b a)
-> Monoid (Cm b a)
[Cm b a] -> Cm b a
Cm b a -> Cm b a -> Cm b a
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall b a. Monoid a => Semigroup (Cm b a)
forall b a. Monoid a => Cm b a
forall b a. Monoid a => [Cm b a] -> Cm b a
forall b a. Monoid a => Cm b a -> Cm b a -> Cm b a
$cmempty :: forall b a. Monoid a => Cm b a
mempty :: Cm b a
$cmappend :: forall b a. Monoid a => Cm b a -> Cm b a -> Cm b a
mappend :: Cm b a -> Cm b a -> Cm b a
$cmconcat :: forall b a. Monoid a => [Cm b a] -> Cm b a
mconcat :: [Cm b a] -> Cm b a
Monoid)

instance Functor (Cm b) where
  fmap :: forall a b. (a -> b) -> Cm b a -> Cm b b
fmap a -> b
f (Cm a
x) = b -> Cm b b
forall b a. a -> Cm b a
Cm (a -> b
f a
x)

instance Rangeable (Cm b B.Inlines) => IsInline (Cm b B.Inlines) where
  lineBreak :: Cm b Inlines
lineBreak = Inlines -> Cm b Inlines
forall b a. a -> Cm b a
Cm Inlines
B.linebreak
  softBreak :: Cm b Inlines
softBreak = Inlines -> Cm b Inlines
forall b a. a -> Cm b a
Cm Inlines
B.softbreak
  str :: Text -> Cm b Inlines
str Text
t = Inlines -> Cm b Inlines
forall b a. a -> Cm b a
Cm (Inlines -> Cm b Inlines) -> Inlines -> Cm b Inlines
forall a b. (a -> b) -> a -> b
$ Text -> Inlines
B.text Text
t
  entity :: Text -> Cm b Inlines
entity Text
t
    | Text -> Bool
illegalCodePoint Text
t = Inlines -> Cm b Inlines
forall b a. a -> Cm b a
Cm (Inlines -> Cm b Inlines) -> Inlines -> Cm b Inlines
forall a b. (a -> b) -> a -> b
$ Text -> Inlines
B.str Text
"\xFFFD"
    | Bool
otherwise = Inlines -> Cm b Inlines
forall b a. a -> Cm b a
Cm (Inlines -> Cm b Inlines) -> Inlines -> Cm b Inlines
forall a b. (a -> b) -> a -> b
$ Text -> Inlines
B.str (Text -> Inlines) -> Text -> Inlines
forall a b. (a -> b) -> a -> b
$ Text -> Maybe Text -> Text
forall a. a -> Maybe a -> a
fromMaybe Text
t (Maybe Text -> Text) -> Maybe Text -> Text
forall a b. (a -> b) -> a -> b
$ Text -> Maybe Text
lookupEntity (Int -> Text -> Text
T.drop Int
1 Text
t)
  escapedChar :: Char -> Cm b Inlines
escapedChar Char
c = Inlines -> Cm b Inlines
forall b a. a -> Cm b a
Cm (Inlines -> Cm b Inlines) -> Inlines -> Cm b Inlines
forall a b. (a -> b) -> a -> b
$ Text -> Inlines
B.str (Text -> Inlines) -> Text -> Inlines
forall a b. (a -> b) -> a -> b
$ Char -> Text
T.singleton Char
c
  emph :: Cm b Inlines -> Cm b Inlines
emph Cm b Inlines
ils = Inlines -> Inlines
B.emph (Inlines -> Inlines) -> Cm b Inlines -> Cm b Inlines
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Cm b Inlines
ils
  strong :: Cm b Inlines -> Cm b Inlines
strong Cm b Inlines
ils = Inlines -> Inlines
B.strong (Inlines -> Inlines) -> Cm b Inlines -> Cm b Inlines
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Cm b Inlines
ils
  link :: Text -> Text -> Cm b Inlines -> Cm b Inlines
link Text
target Text
title Cm b Inlines
ils = Text -> Text -> Inlines -> Inlines
B.link Text
target Text
title (Inlines -> Inlines) -> Cm b Inlines -> Cm b Inlines
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Cm b Inlines
ils
  image :: Text -> Text -> Cm b Inlines -> Cm b Inlines
image Text
target Text
title Cm b Inlines
ils = Text -> Text -> Inlines -> Inlines
B.image Text
target Text
title (Inlines -> Inlines) -> Cm b Inlines -> Cm b Inlines
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Cm b Inlines
ils
  code :: Text -> Cm b Inlines
code Text
t = Inlines -> Cm b Inlines
forall b a. a -> Cm b a
Cm (Inlines -> Cm b Inlines) -> Inlines -> Cm b Inlines
forall a b. (a -> b) -> a -> b
$ Text -> Inlines
B.code Text
t
  rawInline :: Format -> Text -> Cm b Inlines
rawInline (C.Format Text
f) Text
t = Inlines -> Cm b Inlines
forall b a. a -> Cm b a
Cm (Inlines -> Cm b Inlines) -> Inlines -> Cm b Inlines
forall a b. (a -> b) -> a -> b
$ Text -> Text -> Inlines
B.rawInline Text
f Text
t

instance Rangeable (Cm () B.Inlines) where
  ranged :: SourceRange -> Cm () Inlines -> Cm () Inlines
ranged SourceRange
_r Cm () Inlines
x = Cm () Inlines
x

instance Rangeable (Cm SourceRange B.Inlines) where
  ranged :: SourceRange -> Cm SourceRange Inlines -> Cm SourceRange Inlines
ranged SourceRange
r = Attributes -> Cm SourceRange Inlines -> Cm SourceRange Inlines
forall a. HasAttributes a => Attributes -> a -> a
addAttributes [(Text
"data-pos", String -> Text
T.pack (SourceRange -> String
forall a. Show a => a -> String
show SourceRange
r))]

instance Walkable Inline b => ToPlainText (Cm a b) where
  toPlainText :: Cm a b -> Text
toPlainText = b -> Text
forall a. Walkable Inline a => a -> Text
stringify (b -> Text) -> (Cm a b -> b) -> Cm a b -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Inline -> Inline) -> b -> b
forall a b. Walkable a b => (a -> a) -> b -> b
walk Inline -> Inline
unemoji (b -> b) -> (Cm a b -> b) -> Cm a b -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Cm a b -> b
forall b a. Cm b a -> a
unCm

unemoji :: Inline -> Inline
unemoji :: Inline -> Inline
unemoji (Span (Text
"",[Text
"emoji"],[(Text
"data-emoji",Text
alias)]) [Inline]
_)
          = Text -> Inline
Str (Text
":" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
alias Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
":")
unemoji Inline
x = Inline
x

instance (Rangeable (Cm a B.Inlines),
          Rangeable (Cm a B.Blocks))
      => IsBlock (Cm a B.Inlines) (Cm a B.Blocks) where
  paragraph :: Cm a Inlines -> Cm a Blocks
paragraph Cm a Inlines
ils = Blocks -> Cm a Blocks
forall b a. a -> Cm b a
Cm (Blocks -> Cm a Blocks) -> Blocks -> Cm a Blocks
forall a b. (a -> b) -> a -> b
$ Inlines -> Blocks
B.para (Inlines -> Blocks) -> Inlines -> Blocks
forall a b. (a -> b) -> a -> b
$ Cm a Inlines -> Inlines
forall b a. Cm b a -> a
unCm Cm a Inlines
ils
  plain :: Cm a Inlines -> Cm a Blocks
plain Cm a Inlines
ils = Blocks -> Cm a Blocks
forall b a. a -> Cm b a
Cm (Blocks -> Cm a Blocks) -> Blocks -> Cm a Blocks
forall a b. (a -> b) -> a -> b
$ Inlines -> Blocks
B.plain (Inlines -> Blocks) -> Inlines -> Blocks
forall a b. (a -> b) -> a -> b
$ Cm a Inlines -> Inlines
forall b a. Cm b a -> a
unCm Cm a Inlines
ils
  thematicBreak :: Cm a Blocks
thematicBreak = Blocks -> Cm a Blocks
forall b a. a -> Cm b a
Cm Blocks
B.horizontalRule
  blockQuote :: Cm a Blocks -> Cm a Blocks
blockQuote Cm a Blocks
bs = Blocks -> Blocks
B.blockQuote (Blocks -> Blocks) -> Cm a Blocks -> Cm a Blocks
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Cm a Blocks
bs
  codeBlock :: Text -> Text -> Cm a Blocks
codeBlock Text
info Text
t =
    Blocks -> Cm a Blocks
forall b a. a -> Cm b a
Cm (Blocks -> Cm a Blocks) -> Blocks -> Cm a Blocks
forall a b. (a -> b) -> a -> b
$ (Text, [Text], Attributes) -> Text -> Blocks
B.codeBlockWith (Text, [Text], Attributes)
forall {a}. (Text, [Text], [a])
attr (Text -> Blocks) -> Text -> Blocks
forall a b. (a -> b) -> a -> b
$ Text -> Maybe Text -> Text
forall a. a -> Maybe a -> a
fromMaybe Text
t (Maybe Text -> Text) -> Maybe Text -> Text
forall a b. (a -> b) -> a -> b
$ Text -> Text -> Maybe Text
T.stripSuffix Text
"\n" Text
t
    where attr :: (Text, [Text], [a])
attr = (Text
"", [Text
lang | Bool -> Bool
not (Text -> Bool
T.null Text
lang)], [])
          lang :: Text
lang = (Char -> Bool) -> Text -> Text
T.takeWhile (Bool -> Bool
not (Bool -> Bool) -> (Char -> Bool) -> Char -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Bool
isSpace) Text
info
  heading :: Int -> Cm a Inlines -> Cm a Blocks
heading Int
level Cm a Inlines
ils = Blocks -> Cm a Blocks
forall b a. a -> Cm b a
Cm (Blocks -> Cm a Blocks) -> Blocks -> Cm a Blocks
forall a b. (a -> b) -> a -> b
$ Int -> Inlines -> Blocks
B.header Int
level (Inlines -> Blocks) -> Inlines -> Blocks
forall a b. (a -> b) -> a -> b
$ Cm a Inlines -> Inlines
forall b a. Cm b a -> a
unCm Cm a Inlines
ils
  rawBlock :: Format -> Text -> Cm a Blocks
rawBlock (C.Format Text
f) Text
t = Blocks -> Cm a Blocks
forall b a. a -> Cm b a
Cm (Blocks -> Cm a Blocks) -> Blocks -> Cm a Blocks
forall a b. (a -> b) -> a -> b
$ Text -> Text -> Blocks
B.rawBlock Text
f Text
t
  referenceLinkDefinition :: Text -> (Text, Text) -> Cm a Blocks
referenceLinkDefinition Text
_ (Text, Text)
_ = Blocks -> Cm a Blocks
forall b a. a -> Cm b a
Cm Blocks
forall a. Monoid a => a
mempty
  list :: ListType -> ListSpacing -> [Cm a Blocks] -> Cm a Blocks
list (C.BulletList Char
_) ListSpacing
lSpacing [Cm a Blocks]
items =
    Blocks -> Cm a Blocks
forall b a. a -> Cm b a
Cm (Blocks -> Cm a Blocks)
-> ([Cm a Blocks] -> Blocks) -> [Cm a Blocks] -> Cm a Blocks
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Blocks] -> Blocks
B.bulletList ([Blocks] -> Blocks)
-> ([Cm a Blocks] -> [Blocks]) -> [Cm a Blocks] -> Blocks
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ListSpacing -> [Blocks] -> [Blocks]
handleSpacing ListSpacing
lSpacing ([Blocks] -> [Blocks])
-> ([Cm a Blocks] -> [Blocks]) -> [Cm a Blocks] -> [Blocks]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Cm a Blocks -> Blocks) -> [Cm a Blocks] -> [Blocks]
forall a b. (a -> b) -> [a] -> [b]
map Cm a Blocks -> Blocks
forall b a. Cm b a -> a
unCm ([Cm a Blocks] -> Cm a Blocks) -> [Cm a Blocks] -> Cm a Blocks
forall a b. (a -> b) -> a -> b
$ [Cm a Blocks]
items
  list (C.OrderedList Int
startnum EnumeratorType
enumtype DelimiterType
delimtype) ListSpacing
lSpacing [Cm a Blocks]
items =
    Blocks -> Cm a Blocks
forall b a. a -> Cm b a
Cm (Blocks -> Cm a Blocks)
-> ([Cm a Blocks] -> Blocks) -> [Cm a Blocks] -> Cm a Blocks
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ListAttributes -> [Blocks] -> Blocks
B.orderedListWith ListAttributes
attr ([Blocks] -> Blocks)
-> ([Cm a Blocks] -> [Blocks]) -> [Cm a Blocks] -> Blocks
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ListSpacing -> [Blocks] -> [Blocks]
handleSpacing ListSpacing
lSpacing ([Blocks] -> [Blocks])
-> ([Cm a Blocks] -> [Blocks]) -> [Cm a Blocks] -> [Blocks]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Cm a Blocks -> Blocks) -> [Cm a Blocks] -> [Blocks]
forall a b. (a -> b) -> [a] -> [b]
map Cm a Blocks -> Blocks
forall b a. Cm b a -> a
unCm ([Cm a Blocks] -> Cm a Blocks) -> [Cm a Blocks] -> Cm a Blocks
forall a b. (a -> b) -> a -> b
$ [Cm a Blocks]
items
    where sty :: ListNumberStyle
sty = case EnumeratorType
enumtype of
                  EnumeratorType
C.Decimal    -> ListNumberStyle
B.Decimal
                  EnumeratorType
C.UpperAlpha -> ListNumberStyle
B.UpperAlpha
                  EnumeratorType
C.LowerAlpha -> ListNumberStyle
B.LowerAlpha
                  EnumeratorType
C.UpperRoman -> ListNumberStyle
B.UpperRoman
                  EnumeratorType
C.LowerRoman -> ListNumberStyle
B.LowerRoman
          delim :: ListNumberDelim
delim = case DelimiterType
delimtype of
                    DelimiterType
C.Period    -> ListNumberDelim
B.Period
                    DelimiterType
C.OneParen  -> ListNumberDelim
B.OneParen
                    DelimiterType
C.TwoParens -> ListNumberDelim
B.TwoParens
          attr :: ListAttributes
attr = (Int
startnum, ListNumberStyle
sty, ListNumberDelim
delim)

instance Rangeable (Cm () B.Blocks) where
  ranged :: SourceRange -> Cm () Blocks -> Cm () Blocks
ranged SourceRange
_r Cm () Blocks
x = Cm () Blocks
x

instance Rangeable (Cm SourceRange B.Blocks) where
  ranged :: SourceRange -> Cm SourceRange Blocks -> Cm SourceRange Blocks
ranged SourceRange
r = Attributes -> Cm SourceRange Blocks -> Cm SourceRange Blocks
forall a. HasAttributes a => Attributes -> a -> a
addAttributes [(Text
"data-pos", String -> Text
T.pack (SourceRange -> String
forall a. Show a => a -> String
show SourceRange
r))]

instance HasMath (Cm b B.Inlines) where
  inlineMath :: Text -> Cm b Inlines
inlineMath Text
t = Inlines -> Cm b Inlines
forall b a. a -> Cm b a
Cm (Inlines -> Cm b Inlines) -> Inlines -> Cm b Inlines
forall a b. (a -> b) -> a -> b
$ Text -> Inlines
B.math Text
t
  displayMath :: Text -> Cm b Inlines
displayMath Text
t = Inlines -> Cm b Inlines
forall b a. a -> Cm b a
Cm (Inlines -> Cm b Inlines) -> Inlines -> Cm b Inlines
forall a b. (a -> b) -> a -> b
$ Text -> Inlines
B.displayMath Text
t

instance Rangeable (Cm b B.Inlines) => HasQuoted (Cm b B.Inlines) where
  singleQuoted :: Cm b Inlines -> Cm b Inlines
singleQuoted Cm b Inlines
x = Inlines -> Inlines
B.singleQuoted (Inlines -> Inlines) -> Cm b Inlines -> Cm b Inlines
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Cm b Inlines
x
  doubleQuoted :: Cm b Inlines -> Cm b Inlines
doubleQuoted Cm b Inlines
x = Inlines -> Inlines
B.doubleQuoted (Inlines -> Inlines) -> Cm b Inlines -> Cm b Inlines
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Cm b Inlines
x

instance HasEmoji (Cm b B.Inlines) where
  emoji :: Text -> Text -> Cm b Inlines
emoji Text
kw Text
t = Inlines -> Cm b Inlines
forall b a. a -> Cm b a
Cm (Inlines -> Cm b Inlines) -> Inlines -> Cm b Inlines
forall a b. (a -> b) -> a -> b
$ (Text, [Text], Attributes) -> Inlines -> Inlines
B.spanWith (Text
"",[Text
"emoji"],[(Text
"data-emoji",Text
kw)])
                  (Inlines -> Inlines) -> Inlines -> Inlines
forall a b. (a -> b) -> a -> b
$ Text -> Inlines
B.text Text
t

instance HasWikilinks (Cm b B.Inlines) where
  wikilink :: Text -> Cm b Inlines -> Cm b Inlines
wikilink Text
t Cm b Inlines
il = Inlines -> Cm b Inlines
forall b a. a -> Cm b a
Cm (Inlines -> Cm b Inlines) -> Inlines -> Cm b Inlines
forall a b. (a -> b) -> a -> b
$ (Text, [Text], Attributes) -> Text -> Text -> Inlines -> Inlines
B.linkWith (Text
forall a. Monoid a => a
mempty, [Text
"wikilink"], Attributes
forall a. Monoid a => a
mempty) Text
t Text
"" (Inlines -> Inlines) -> Inlines -> Inlines
forall a b. (a -> b) -> a -> b
$ Cm b Inlines -> Inlines
forall b a. Cm b a -> a
unCm Cm b Inlines
il

instance HasPipeTable (Cm a B.Inlines) (Cm a B.Blocks) where
  pipeTable :: [ColAlignment] -> [Cm a Inlines] -> [[Cm a Inlines]] -> Cm a Blocks
pipeTable [ColAlignment]
aligns [Cm a Inlines]
headerCells [[Cm a Inlines]]
rows =
    Blocks -> Cm a Blocks
forall b a. a -> Cm b a
Cm (Blocks -> Cm a Blocks) -> Blocks -> Cm a Blocks
forall a b. (a -> b) -> a -> b
$ Caption
-> [ColSpec] -> TableHead -> [TableBody] -> TableFoot -> Blocks
B.table Caption
B.emptyCaption [ColSpec]
colspecs
           ((Text, [Text], Attributes) -> [Row] -> TableHead
TableHead (Text, [Text], Attributes)
nullAttr ([Cm a Inlines] -> [Row]
forall {b}. [Cm b Inlines] -> [Row]
toHeaderRow [Cm a Inlines]
headerCells))
           [(Text, [Text], Attributes)
-> RowHeadColumns -> [Row] -> [Row] -> TableBody
TableBody (Text, [Text], Attributes)
nullAttr RowHeadColumns
0 [] ([Row] -> TableBody) -> [Row] -> TableBody
forall a b. (a -> b) -> a -> b
$ ([Cm a Inlines] -> Row) -> [[Cm a Inlines]] -> [Row]
forall a b. (a -> b) -> [a] -> [b]
map [Cm a Inlines] -> Row
forall {b}. [Cm b Inlines] -> Row
toRow [[Cm a Inlines]]
rows]
           ((Text, [Text], Attributes) -> [Row] -> TableFoot
TableFoot (Text, [Text], Attributes)
nullAttr [])
    where
     toHeaderRow :: [Cm b Inlines] -> [Row]
toHeaderRow [Cm b Inlines]
cells
       | [Cm b Inlines] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Cm b Inlines]
cells  = []
       | Bool
otherwise   = [[Cm b Inlines] -> Row
forall {b}. [Cm b Inlines] -> Row
toRow [Cm b Inlines]
cells]
     toRow :: [Cm b Inlines] -> Row
toRow = (Text, [Text], Attributes) -> [Cell] -> Row
Row (Text, [Text], Attributes)
nullAttr ([Cell] -> Row)
-> ([Cm b Inlines] -> [Cell]) -> [Cm b Inlines] -> Row
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Cm b Inlines -> Cell) -> [Cm b Inlines] -> [Cell]
forall a b. (a -> b) -> [a] -> [b]
map (Blocks -> Cell
B.simpleCell (Blocks -> Cell)
-> (Cm b Inlines -> Blocks) -> Cm b Inlines -> Cell
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Inlines -> Blocks
B.plain (Inlines -> Blocks)
-> (Cm b Inlines -> Inlines) -> Cm b Inlines -> Blocks
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Cm b Inlines -> Inlines
forall b a. Cm b a -> a
unCm)
     toPandocAlignment :: ColAlignment -> Alignment
toPandocAlignment ColAlignment
LeftAlignedCol = Alignment
AlignLeft
     toPandocAlignment ColAlignment
CenterAlignedCol = Alignment
AlignCenter
     toPandocAlignment ColAlignment
RightAlignedCol = Alignment
AlignRight
     toPandocAlignment ColAlignment
DefaultAlignedCol = Alignment
AlignDefault
     colspecs :: [ColSpec]
colspecs = (ColAlignment -> ColSpec) -> [ColAlignment] -> [ColSpec]
forall a b. (a -> b) -> [a] -> [b]
map (\ColAlignment
al -> (ColAlignment -> Alignment
toPandocAlignment ColAlignment
al, ColWidth
ColWidthDefault))
                 [ColAlignment]
aligns

instance (Rangeable (Cm a B.Inlines), Rangeable (Cm a B.Blocks))
  => HasDefinitionList (Cm a B.Inlines) (Cm a B.Blocks) where
  definitionList :: ListSpacing -> [(Cm a Inlines, [Cm a Blocks])] -> Cm a Blocks
definitionList ListSpacing
_ [(Cm a Inlines, [Cm a Blocks])]
items =
    Blocks -> Cm a Blocks
forall b a. a -> Cm b a
Cm (Blocks -> Cm a Blocks) -> Blocks -> Cm a Blocks
forall a b. (a -> b) -> a -> b
$ [(Inlines, [Blocks])] -> Blocks
B.definitionList ([(Inlines, [Blocks])] -> Blocks)
-> [(Inlines, [Blocks])] -> Blocks
forall a b. (a -> b) -> a -> b
$ ((Cm a Inlines, [Cm a Blocks]) -> (Inlines, [Blocks]))
-> [(Cm a Inlines, [Cm a Blocks])] -> [(Inlines, [Blocks])]
forall a b. (a -> b) -> [a] -> [b]
map (Cm a Inlines, [Cm a Blocks]) -> (Inlines, [Blocks])
forall a b. Coercible a b => a -> b
coerce [(Cm a Inlines, [Cm a Blocks])]
items

instance (Rangeable (Cm a B.Inlines), Rangeable (Cm a B.Blocks))
  => HasAlerts (Cm a B.Inlines) (Cm a B.Blocks) where
  alert :: AlertType -> Cm a Blocks -> Cm a Blocks
alert AlertType
alertType Cm a Blocks
bs =
    Blocks -> Cm a Blocks
forall b a. a -> Cm b a
Cm (Blocks -> Cm a Blocks) -> Blocks -> Cm a Blocks
forall a b. (a -> b) -> a -> b
$ (Text, [Text], Attributes) -> Blocks -> Blocks
B.divWith (Text
"",[Text -> Text
T.toLower (Text -> Text) -> Text -> Text
forall a b. (a -> b) -> a -> b
$ AlertType -> Text
alertName AlertType
alertType],[])
       (Blocks -> Blocks) -> Blocks -> Blocks
forall a b. (a -> b) -> a -> b
$ (Text, [Text], Attributes) -> Blocks -> Blocks
B.divWith (Text
"",[Text
"title"],[])
           (Inlines -> Blocks
B.para (Text -> Inlines
B.str (AlertType -> Text
alertName AlertType
alertType)))
         Blocks -> Blocks -> Blocks
forall a. Semigroup a => a -> a -> a
<> Cm a Blocks -> Blocks
forall a b. Coercible a b => a -> b
coerce Cm a Blocks
bs

instance (Rangeable (Cm a B.Inlines), Rangeable (Cm a B.Blocks))
  => HasTaskList (Cm a B.Inlines) (Cm a B.Blocks) where
  taskList :: ListType -> ListSpacing -> [(Bool, Cm a Blocks)] -> Cm a Blocks
taskList ListType
_ ListSpacing
spacing [(Bool, Cm a Blocks)]
items =
    Blocks -> Cm a Blocks
forall b a. a -> Cm b a
Cm (Blocks -> Cm a Blocks) -> Blocks -> Cm a Blocks
forall a b. (a -> b) -> a -> b
$ [Blocks] -> Blocks
B.bulletList ([Blocks] -> Blocks) -> [Blocks] -> Blocks
forall a b. (a -> b) -> a -> b
$ ListSpacing -> [Blocks] -> [Blocks]
handleSpacing ListSpacing
spacing ([Blocks] -> [Blocks]) -> [Blocks] -> [Blocks]
forall a b. (a -> b) -> a -> b
$ ((Bool, Cm a Blocks) -> Blocks)
-> [(Bool, Cm a Blocks)] -> [Blocks]
forall a b. (a -> b) -> [a] -> [b]
map (Bool, Cm a Blocks) -> Blocks
forall a. (Bool, Cm a Blocks) -> Blocks
toTaskListItem [(Bool, Cm a Blocks)]
items

handleSpacing :: ListSpacing -> [B.Blocks] -> [B.Blocks]
handleSpacing :: ListSpacing -> [Blocks] -> [Blocks]
handleSpacing ListSpacing
TightList = (Blocks -> Blocks) -> [Blocks] -> [Blocks]
forall a b. (a -> b) -> [a] -> [b]
map ([Block] -> Blocks
forall a. [a] -> Many a
B.fromList ([Block] -> Blocks) -> (Blocks -> [Block]) -> Blocks -> Blocks
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Block -> Block) -> [Block] -> [Block]
forall a b. (a -> b) -> [a] -> [b]
map Block -> Block
paraToPlain ([Block] -> [Block]) -> (Blocks -> [Block]) -> Blocks -> [Block]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Blocks -> [Block]
forall a. Many a -> [a]
B.toList)
handleSpacing ListSpacing
LooseList = [Blocks] -> [Blocks]
forall a. a -> a
id

paraToPlain :: Block -> Block
paraToPlain :: Block -> Block
paraToPlain (Para [Inline]
xs) = [Inline] -> Block
Plain [Inline]
xs
paraToPlain Block
x = Block
x

toTaskListItem :: (Bool, Cm a B.Blocks) -> B.Blocks
toTaskListItem :: forall a. (Bool, Cm a Blocks) -> Blocks
toTaskListItem (Bool
checked, Cm a Blocks
item) = [Block] -> Blocks
forall a. [a] -> Many a
B.fromList ([Block] -> Blocks) -> [Block] -> Blocks
forall a b. (a -> b) -> a -> b
$
  case Blocks -> [Block]
forall a. Many a -> [a]
B.toList (Blocks -> [Block]) -> Blocks -> [Block]
forall a b. (a -> b) -> a -> b
$ Cm a Blocks -> Blocks
forall a b. Coercible a b => a -> b
coerce Cm a Blocks
item of
    (Plain [Inline]
ils : [Block]
rest) -> [Inline] -> Block
Plain (Inline
checkbox Inline -> [Inline] -> [Inline]
forall a. a -> [a] -> [a]
: Inline
Space Inline -> [Inline] -> [Inline]
forall a. a -> [a] -> [a]
: [Inline]
ils) Block -> [Block] -> [Block]
forall a. a -> [a] -> [a]
: [Block]
rest
    (Para  [Inline]
ils : [Block]
rest) -> [Inline] -> Block
Para  (Inline
checkbox Inline -> [Inline] -> [Inline]
forall a. a -> [a] -> [a]
: Inline
Space Inline -> [Inline] -> [Inline]
forall a. a -> [a] -> [a]
: [Inline]
ils) Block -> [Block] -> [Block]
forall a. a -> [a] -> [a]
: [Block]
rest
    [Block]
bs                 -> [Inline] -> Block
Plain [Inline
checkbox] Block -> [Block] -> [Block]
forall a. a -> [a] -> [a]
: [Block]
bs
    where checkbox :: Inline
checkbox = Text -> Inline
Str (if Bool
checked then Text
"\9746" else Text
"\9744")

instance Rangeable (Cm a B.Blocks)
  => HasDiv (Cm a B.Blocks) where
  div_ :: Cm a Blocks -> Cm a Blocks
div_ Cm a Blocks
bs = (Text, [Text], Attributes) -> Blocks -> Blocks
B.divWith (Text, [Text], Attributes)
nullAttr (Blocks -> Blocks) -> Cm a Blocks -> Cm a Blocks
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Cm a Blocks
bs

instance HasStrikethrough (Cm a B.Inlines) where
  strikethrough :: Cm a Inlines -> Cm a Inlines
strikethrough Cm a Inlines
ils = Inlines -> Inlines
B.strikeout (Inlines -> Inlines) -> Cm a Inlines -> Cm a Inlines
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Cm a Inlines
ils

instance HasSuperscript (Cm a B.Inlines) where
  superscript :: Cm a Inlines -> Cm a Inlines
superscript Cm a Inlines
ils = Inlines -> Inlines
B.superscript (Inlines -> Inlines) -> Cm a Inlines -> Cm a Inlines
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Cm a Inlines
ils

instance HasSubscript (Cm a B.Inlines) where
  subscript :: Cm a Inlines -> Cm a Inlines
subscript Cm a Inlines
ils = Inlines -> Inlines
B.subscript (Inlines -> Inlines) -> Cm a Inlines -> Cm a Inlines
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Cm a Inlines
ils

instance Rangeable (Cm a B.Inlines) => HasSpan (Cm a B.Inlines) where
  spanWith :: Attributes -> Cm a Inlines -> Cm a Inlines
spanWith Attributes
attrs Cm a Inlines
ils =
    (Text, [Text], Attributes) -> Inlines -> Inlines
B.spanWith (Attributes
-> (Text, [Text], Attributes) -> (Text, [Text], Attributes)
addToPandocAttr Attributes
attrs (Text, [Text], Attributes)
nullAttr) (Inlines -> Inlines) -> Cm a Inlines -> Cm a Inlines
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Cm a Inlines
ils

instance HasAttributes (Cm a B.Blocks) where
  addAttributes :: Attributes -> Cm a Blocks -> Cm a Blocks
addAttributes Attributes
attrs Cm a Blocks
b = (Block -> Block) -> Blocks -> Blocks
forall a b. (a -> b) -> Many a -> Many b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Attributes -> Block -> Block
addBlockAttrs Attributes
attrs) (Blocks -> Blocks) -> Cm a Blocks -> Cm a Blocks
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Cm a Blocks
b

instance HasAttributes (Cm a B.Inlines) where
  addAttributes :: Attributes -> Cm a Inlines -> Cm a Inlines
addAttributes Attributes
attrs Cm a Inlines
il = (Inline -> Inline) -> Inlines -> Inlines
forall a b. (a -> b) -> Many a -> Many b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Attributes -> Inline -> Inline
addInlineAttrs Attributes
attrs) (Inlines -> Inlines) -> Cm a Inlines -> Cm a Inlines
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Cm a Inlines
il

addBlockAttrs :: [(T.Text, T.Text)] -> Block -> Block
addBlockAttrs :: Attributes -> Block -> Block
addBlockAttrs Attributes
attrs (Header Int
n (Text, [Text], Attributes)
curattrs [Inline]
ils) =
  Int -> (Text, [Text], Attributes) -> [Inline] -> Block
Header Int
n (Attributes
-> (Text, [Text], Attributes) -> (Text, [Text], Attributes)
addToPandocAttr Attributes
attrs (Text, [Text], Attributes)
curattrs) [Inline]
ils
addBlockAttrs Attributes
attrs (CodeBlock (Text, [Text], Attributes)
curattrs Text
s) =
  (Text, [Text], Attributes) -> Text -> Block
CodeBlock (Attributes
-> (Text, [Text], Attributes) -> (Text, [Text], Attributes)
addToPandocAttr Attributes
attrs (Text, [Text], Attributes)
curattrs) Text
s
addBlockAttrs Attributes
attrs (Table (Text, [Text], Attributes)
curattrs Caption
capt [ColSpec]
colspecs TableHead
thead [TableBody]
tbody TableFoot
tfoot) =
  (Text, [Text], Attributes)
-> Caption
-> [ColSpec]
-> TableHead
-> [TableBody]
-> TableFoot
-> Block
Table (Attributes
-> (Text, [Text], Attributes) -> (Text, [Text], Attributes)
addToPandocAttr Attributes
attrs (Text, [Text], Attributes)
curattrs) Caption
capt [ColSpec]
colspecs TableHead
thead [TableBody]
tbody TableFoot
tfoot
addBlockAttrs Attributes
attrs (Div (Text, [Text], Attributes)
curattrs [Block]
bs) =
  (Text, [Text], Attributes) -> [Block] -> Block
Div (Attributes
-> (Text, [Text], Attributes) -> (Text, [Text], Attributes)
addToPandocAttr Attributes
attrs (Text, [Text], Attributes)
curattrs) [Block]
bs
addBlockAttrs Attributes
attrs Block
x = -- add wrapper="1" if we needed to add a Div
  (Text, [Text], Attributes) -> [Block] -> Block
Div (Attributes
-> (Text, [Text], Attributes) -> (Text, [Text], Attributes)
addToPandocAttr ((Text
"wrapper",Text
"1")(Text, Text) -> Attributes -> Attributes
forall a. a -> [a] -> [a]
:Attributes
attrs) (Text, [Text], Attributes)
nullAttr) [Block
x]

addInlineAttrs :: [(T.Text, T.Text)] -> Inline -> Inline
addInlineAttrs :: Attributes -> Inline -> Inline
addInlineAttrs Attributes
attrs (Link (Text, [Text], Attributes)
curattrs [Inline]
ils (Text, Text)
target) =
  (Text, [Text], Attributes) -> [Inline] -> (Text, Text) -> Inline
Link (Attributes
-> (Text, [Text], Attributes) -> (Text, [Text], Attributes)
addToPandocAttr Attributes
attrs (Text, [Text], Attributes)
curattrs) [Inline]
ils (Text, Text)
target
addInlineAttrs Attributes
attrs (Image (Text, [Text], Attributes)
curattrs [Inline]
ils (Text, Text)
target) =
  (Text, [Text], Attributes) -> [Inline] -> (Text, Text) -> Inline
Image (Attributes
-> (Text, [Text], Attributes) -> (Text, [Text], Attributes)
addToPandocAttr Attributes
attrs (Text, [Text], Attributes)
curattrs) [Inline]
ils (Text, Text)
target
addInlineAttrs Attributes
attrs (Span (Text, [Text], Attributes)
curattrs [Inline]
ils) =
  (Text, [Text], Attributes) -> [Inline] -> Inline
Span (Attributes
-> (Text, [Text], Attributes) -> (Text, [Text], Attributes)
addToPandocAttr Attributes
attrs (Text, [Text], Attributes)
curattrs) [Inline]
ils
addInlineAttrs Attributes
attrs (Code (Text, [Text], Attributes)
curattrs Text
s) =
  (Text, [Text], Attributes) -> Text -> Inline
Code (Attributes
-> (Text, [Text], Attributes) -> (Text, [Text], Attributes)
addToPandocAttr Attributes
attrs (Text, [Text], Attributes)
curattrs) Text
s
addInlineAttrs Attributes
attrs Inline
x = -- add wrapper="1" if we needed to add a Span
  (Text, [Text], Attributes) -> [Inline] -> Inline
Span (Attributes
-> (Text, [Text], Attributes) -> (Text, [Text], Attributes)
addToPandocAttr ((Text
"wrapper",Text
"1")(Text, Text) -> Attributes -> Attributes
forall a. a -> [a] -> [a]
:Attributes
attrs) (Text, [Text], Attributes)
nullAttr) [Inline
x]

addToPandocAttr :: Attributes -> Attr -> Attr
-- avoid adding spurious extra data-pos to wrapper div (#159):
addToPandocAttr :: Attributes
-> (Text, [Text], Attributes) -> (Text, [Text], Attributes)
addToPandocAttr [(Text
"data-pos", Text
_)] attrs :: (Text, [Text], Attributes)
attrs@(Text
_,[Text]
_,(Text
"wrapper",Text
"1"):Attributes
_)  = (Text, [Text], Attributes)
attrs
addToPandocAttr Attributes
attrs (Text, [Text], Attributes)
attr = ((Text, Text)
 -> (Text, [Text], Attributes) -> (Text, [Text], Attributes))
-> (Text, [Text], Attributes)
-> Attributes
-> (Text, [Text], Attributes)
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (Text, Text)
-> (Text, [Text], Attributes) -> (Text, [Text], Attributes)
forall {a} {b}.
(Eq a, IsString a) =>
(a, b) -> (b, [b], [(a, b)]) -> (b, [b], [(a, b)])
go (Text, [Text], Attributes)
attr Attributes
attrs
 where
  go :: (a, b) -> (b, [b], [(a, b)]) -> (b, [b], [(a, b)])
go (a
"id", b
v) (b
_, [b]
cls, [(a, b)]
kvs) = (b
v, [b]
cls, [(a, b)]
kvs)
  go (a
"class", b
v) (b
ident, [b]
cls, [(a, b)]
kvs) = (b
ident, b
vb -> [b] -> [b]
forall a. a -> [a] -> [a]
:[b]
cls, [(a, b)]
kvs)
  go (a
k, b
v) (b
ident, [b]
cls, [(a, b)]
kvs) = (b
ident, [b]
cls, (a
k,b
v)(a, b) -> [(a, b)] -> [(a, b)]
forall a. a -> [a] -> [a]
:[(a, b)]
kvs)

instance (Rangeable (Cm a B.Inlines), Rangeable (Cm a B.Blocks))
     => HasFootnote (Cm a B.Inlines) (Cm a B.Blocks) where
  footnote :: Int -> Text -> Cm a Blocks -> Cm a Blocks
footnote Int
_num Text
_lab Cm a Blocks
_x = Cm a Blocks
forall a. Monoid a => a
mempty
  footnoteList :: [Cm a Blocks] -> Cm a Blocks
footnoteList [Cm a Blocks]
_xs = Cm a Blocks
forall a. Monoid a => a
mempty
  footnoteRef :: Text -> Text -> Cm a Blocks -> Cm a Inlines
footnoteRef Text
_num Text
_lab Cm a Blocks
contents = Blocks -> Inlines
B.note (Blocks -> Inlines) -> (Blocks -> Blocks) -> Blocks -> Inlines
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Inline -> Inline) -> Blocks -> Blocks
forall a b. Walkable a b => (a -> a) -> b -> b
walk Inline -> Inline
deNote (Blocks -> Inlines) -> Cm a Blocks -> Cm a Inlines
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Cm a Blocks
contents

illegalCodePoint :: T.Text -> Bool
illegalCodePoint :: Text -> Bool
illegalCodePoint Text
t =
  Text
"&#" Text -> Text -> Bool
`T.isPrefixOf` Text
t Bool -> Bool -> Bool
&&
  let t' :: Text
t' = Int -> Text -> Text
T.drop Int
2 (Text -> Text) -> Text -> Text
forall a b. (a -> b) -> a -> b
$ (Char -> Bool) -> Text -> Text
T.filter (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/=Char
';') Text
t
      badvalue :: (Integer, Text) -> Bool
badvalue (Integer
n, Text
r) = Bool -> Bool
not (Text -> Bool
T.null Text
r) Bool -> Bool -> Bool
||
                        Integer
n Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
< Integer
1 Bool -> Bool -> Bool
||
                        Integer
n Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
> (Integer
0x10FFFF :: Integer)
  in
  case Text -> Maybe (Char, Text)
T.uncons Text
t' of
       Maybe (Char, Text)
Nothing -> Bool
True
       Just (Char
x, Text
rest)
         | Char
x Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'x' Bool -> Bool -> Bool
|| Char
x Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'X'
           -> (String -> Bool)
-> ((Integer, Text) -> Bool)
-> Either String (Integer, Text)
-> Bool
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (Bool -> String -> Bool
forall a b. a -> b -> a
const Bool
True) (Integer, Text) -> Bool
badvalue (Reader Integer
forall a. Integral a => Reader a
TR.hexadecimal Text
rest)
         | Bool
otherwise
           -> (String -> Bool)
-> ((Integer, Text) -> Bool)
-> Either String (Integer, Text)
-> Bool
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (Bool -> String -> Bool
forall a b. a -> b -> a
const Bool
True) (Integer, Text) -> Bool
badvalue (Reader Integer
forall a. Integral a => Reader a
TR.decimal Text
t')

stringify :: Walkable Inline a => a -> T.Text
stringify :: forall a. Walkable Inline a => a -> Text
stringify = (Inline -> Text) -> a -> Text
forall c. Monoid c => (Inline -> c) -> a -> c
forall a b c. (Walkable a b, Monoid c) => (a -> c) -> b -> c
query Inline -> Text
go (a -> Text) -> (a -> a) -> a -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Inline -> Inline) -> a -> a
forall a b. Walkable a b => (a -> a) -> b -> b
walk (Inline -> Inline
deNote (Inline -> Inline) -> (Inline -> Inline) -> Inline -> Inline
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Inline -> Inline
deQuote)
  where go :: Inline -> T.Text
        go :: Inline -> Text
go Inline
Space                                         = Text
" "
        go Inline
SoftBreak                                     = Text
" "
        go (Str Text
x)                                       = Text
x
        go (Code (Text, [Text], Attributes)
_ Text
x)                                    = Text
x
        go (Math MathType
_ Text
x)                                    = Text
x
        go (RawInline (B.Format Text
"html") Text
t)
           | Text
"<br" Text -> Text -> Bool
`T.isPrefixOf` Text
t                      = Text
" "
        go Inline
LineBreak                                     = Text
" "
        go Inline
_                                             = Text
forall a. Monoid a => a
mempty

deNote :: Inline -> Inline
deNote :: Inline -> Inline
deNote (Note [Block]
_) = Text -> Inline
Str Text
""
deNote Inline
x        = Inline
x

deQuote :: Inline -> Inline
deQuote :: Inline -> Inline
deQuote (Quoted QuoteType
SingleQuote [Inline]
xs) =
  (Text, [Text], Attributes) -> [Inline] -> Inline
Span (Text
"",[],[]) (Text -> Inline
Str Text
"\8216" Inline -> [Inline] -> [Inline]
forall a. a -> [a] -> [a]
: [Inline]
xs [Inline] -> [Inline] -> [Inline]
forall a. [a] -> [a] -> [a]
++ [Text -> Inline
Str Text
"\8217"])
deQuote (Quoted QuoteType
DoubleQuote [Inline]
xs) =
  (Text, [Text], Attributes) -> [Inline] -> Inline
Span (Text
"",[],[]) (Text -> Inline
Str Text
"\8220" Inline -> [Inline] -> [Inline]
forall a. a -> [a] -> [a]
: [Inline]
xs [Inline] -> [Inline] -> [Inline]
forall a. [a] -> [a] -> [a]
++ [Text -> Inline
Str Text
"\8221"])
deQuote Inline
x = Inline
x