{-# LANGUAGE OverloadedStrings    #-}
{- |
   Module      : Text.Pandoc.Readers.Docx.Combine
   Copyright   : © 2014-2020 Jesse Rosenthal <jrosenthal@jhu.edu>,
                   2014-2024 John MacFarlane <jgm@berkeley.edu>,
                   2020 Nikolay Yakimov <root@livid.pp.ru>
   License     : GNU GPL, version 2 or above

   Maintainer  : Jesse Rosenthal <jrosenthal@jhu.edu>
   Stability   : alpha
   Portability : portable

Flatten sequences of elements.
-}

{-
The purpose of this module is to combine the formatting of separate
runs, which have *non-nesting* formatting. Because the formatting
doesn't nest, you can't actually tell the nesting order until you
combine with the runs that follow.

For example, say you have a something like `<em><strong>foo</strong>
bar</em>`. Then in ooxml, you'll get these two runs:

~~~
<w:r>
 <w:rPr>
  <w:b />
  <w:i />
 </w:rPr>
 <w:t>Foo</w:t>
</w:r>
<w:r>
 <w:rPr>
  <w:i />
 </w:rPr>
 <w:t> Bar</w:t>
</w:r>
~~~

Note that this is an ideal situation. In practice, it will probably be
more---if, for example, the user turned italics
off and then on.

So, when you get the first run, which is marked as both bold and italic,
you have no idea whether it's `Strong [Emph [Str "Foo"]]` or `Emph
[Strong [Str "Foo"]]`.

We combine two runs, then, by taking off the formatting that modifies an
inline, seeing what is shared between them, and rebuilding an inline. We
fold this to combine the inlines.

-}

module Text.Pandoc.Readers.Docx.Combine ( combineBlocks
                                        , smushInlines
                                        , smushBlocks
                                        )
       where

import qualified Data.List as L
import Data.Bifunctor
import Data.Sequence ( ViewL (..), ViewR (..), viewl, viewr, spanr, spanl
                     , (><), (|>) )
import Text.Pandoc.Builder as B

data Modifier a = Modifier (a -> a)
                | AttrModifier (Attr -> a -> a) Attr

spaceOutInlinesL :: Inlines -> (Inlines, Inlines)
spaceOutInlinesL :: Many Inline -> (Many Inline, Many Inline)
spaceOutInlinesL Many Inline
ms = (Many Inline
l, [Modifier (Many Inline)] -> Many Inline -> Many Inline
stackInlines [Modifier (Many Inline)]
fs (Many Inline
m' Many Inline -> Many Inline -> Many Inline
forall a. Semigroup a => a -> a -> a
<> Many Inline
r))
  where (Many Inline
l, ([Modifier (Many Inline)]
fs, Many Inline
m'), Many Inline
r) = Many Inline
-> (Many Inline, ([Modifier (Many Inline)], Many Inline),
    Many Inline)
spaceOutInlines Many Inline
ms

spaceOutInlinesR :: Inlines -> (Inlines, Inlines)
spaceOutInlinesR :: Many Inline -> (Many Inline, Many Inline)
spaceOutInlinesR Many Inline
ms = ([Modifier (Many Inline)] -> Many Inline -> Many Inline
stackInlines [Modifier (Many Inline)]
fs (Many Inline
l Many Inline -> Many Inline -> Many Inline
forall a. Semigroup a => a -> a -> a
<> Many Inline
m'), Many Inline
r)
  where (Many Inline
l, ([Modifier (Many Inline)]
fs, Many Inline
m'), Many Inline
r) = Many Inline
-> (Many Inline, ([Modifier (Many Inline)], Many Inline),
    Many Inline)
spaceOutInlines Many Inline
ms

spaceOutInlines :: Inlines -> (Inlines, ([Modifier Inlines], Inlines), Inlines)
spaceOutInlines :: Many Inline
-> (Many Inline, ([Modifier (Many Inline)], Many Inline),
    Many Inline)
spaceOutInlines Many Inline
ils =
  let ([Modifier (Many Inline)]
fs, Many Inline
ils') = Many Inline -> ([Modifier (Many Inline)], Many Inline)
unstackInlines Many Inline
ils
      (Seq Inline
left, (Seq Inline
right, Seq Inline
contents')) = (Seq Inline -> (Seq Inline, Seq Inline))
-> (Seq Inline, Seq Inline)
-> (Seq Inline, (Seq Inline, Seq Inline))
forall b c a. (b -> c) -> (a, b) -> (a, c)
forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second ((Inline -> Bool) -> Seq Inline -> (Seq Inline, Seq Inline)
forall a. (a -> Bool) -> Seq a -> (Seq a, Seq a)
spanr Inline -> Bool
isSpace) ((Seq Inline, Seq Inline)
 -> (Seq Inline, (Seq Inline, Seq Inline)))
-> (Seq Inline, Seq Inline)
-> (Seq Inline, (Seq Inline, Seq Inline))
forall a b. (a -> b) -> a -> b
$ (Inline -> Bool) -> Seq Inline -> (Seq Inline, Seq Inline)
forall a. (a -> Bool) -> Seq a -> (Seq a, Seq a)
spanl Inline -> Bool
isSpace (Seq Inline -> (Seq Inline, Seq Inline))
-> Seq Inline -> (Seq Inline, Seq Inline)
forall a b. (a -> b) -> a -> b
$ Many Inline -> Seq Inline
forall a. Many a -> Seq a
unMany Many Inline
ils'
      -- NOTE: spanr counterintuitively returns suffix as the FIRST tuple element
  in (Seq Inline -> Many Inline
forall a. Seq a -> Many a
Many Seq Inline
left, ([Modifier (Many Inline)]
fs, Seq Inline -> Many Inline
forall a. Seq a -> Many a
Many Seq Inline
contents'), Seq Inline -> Many Inline
forall a. Seq a -> Many a
Many Seq Inline
right)

isSpace :: Inline -> Bool
isSpace :: Inline -> Bool
isSpace Inline
Space = Bool
True
isSpace Inline
SoftBreak = Bool
True
isSpace Inline
_ = Bool
False

stackInlines :: [Modifier Inlines] -> Inlines -> Inlines
stackInlines :: [Modifier (Many Inline)] -> Many Inline -> Many Inline
stackInlines [] Many Inline
ms = Many Inline
ms
stackInlines (Modifier Many Inline -> Many Inline
f : [Modifier (Many Inline)]
fs) Many Inline
ms =
  if Many Inline -> Bool
forall a. Many a -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null Many Inline
ms
  then [Modifier (Many Inline)] -> Many Inline -> Many Inline
stackInlines [Modifier (Many Inline)]
fs Many Inline
ms
  else Many Inline -> Many Inline
f (Many Inline -> Many Inline) -> Many Inline -> Many Inline
forall a b. (a -> b) -> a -> b
$ [Modifier (Many Inline)] -> Many Inline -> Many Inline
stackInlines [Modifier (Many Inline)]
fs Many Inline
ms
stackInlines (AttrModifier (Text, [Text], [(Text, Text)]) -> Many Inline -> Many Inline
f (Text, [Text], [(Text, Text)])
attr : [Modifier (Many Inline)]
fs) Many Inline
ms = (Text, [Text], [(Text, Text)]) -> Many Inline -> Many Inline
f (Text, [Text], [(Text, Text)])
attr (Many Inline -> Many Inline) -> Many Inline -> Many Inline
forall a b. (a -> b) -> a -> b
$ [Modifier (Many Inline)] -> Many Inline -> Many Inline
stackInlines [Modifier (Many Inline)]
fs Many Inline
ms

unstackInlines :: Inlines -> ([Modifier Inlines], Inlines)
unstackInlines :: Many Inline -> ([Modifier (Many Inline)], Many Inline)
unstackInlines Many Inline
ms = case Many Inline -> Maybe (Modifier (Many Inline), Many Inline)
ilModifierAndInnards Many Inline
ms of
  Maybe (Modifier (Many Inline), Many Inline)
Nothing         -> ([], Many Inline
ms)
  Just (Modifier (Many Inline)
f, Many Inline
inner) -> ([Modifier (Many Inline)] -> [Modifier (Many Inline)])
-> ([Modifier (Many Inline)], Many Inline)
-> ([Modifier (Many Inline)], Many Inline)
forall a b c. (a -> b) -> (a, c) -> (b, c)
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first (Modifier (Many Inline)
f Modifier (Many Inline)
-> [Modifier (Many Inline)] -> [Modifier (Many Inline)]
forall a. a -> [a] -> [a]
:) (([Modifier (Many Inline)], Many Inline)
 -> ([Modifier (Many Inline)], Many Inline))
-> ([Modifier (Many Inline)], Many Inline)
-> ([Modifier (Many Inline)], Many Inline)
forall a b. (a -> b) -> a -> b
$ Many Inline -> ([Modifier (Many Inline)], Many Inline)
unstackInlines Many Inline
inner

ilModifierAndInnards :: Inlines -> Maybe (Modifier Inlines, Inlines)
ilModifierAndInnards :: Many Inline -> Maybe (Modifier (Many Inline), Many Inline)
ilModifierAndInnards Many Inline
ils = case Seq Inline -> ViewL Inline
forall a. Seq a -> ViewL a
viewl (Seq Inline -> ViewL Inline) -> Seq Inline -> ViewL Inline
forall a b. (a -> b) -> a -> b
$ Many Inline -> Seq Inline
forall a. Many a -> Seq a
unMany Many Inline
ils of
  Inline
x :< Seq Inline
xs | Seq Inline -> Bool
forall a. Seq a -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null Seq Inline
xs -> ([Inline] -> Many Inline)
-> (Modifier (Many Inline), [Inline])
-> (Modifier (Many Inline), Many Inline)
forall b c a. (b -> c) -> (a, b) -> (a, c)
forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second [Inline] -> Many Inline
forall a. [a] -> Many a
fromList ((Modifier (Many Inline), [Inline])
 -> (Modifier (Many Inline), Many Inline))
-> Maybe (Modifier (Many Inline), [Inline])
-> Maybe (Modifier (Many Inline), Many Inline)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> case Inline
x of
    Emph [Inline]
lst          -> (Modifier (Many Inline), [Inline])
-> Maybe (Modifier (Many Inline), [Inline])
forall a. a -> Maybe a
Just ((Many Inline -> Many Inline) -> Modifier (Many Inline)
forall a. (a -> a) -> Modifier a
Modifier Many Inline -> Many Inline
emph, [Inline]
lst)
    Strong [Inline]
lst        -> (Modifier (Many Inline), [Inline])
-> Maybe (Modifier (Many Inline), [Inline])
forall a. a -> Maybe a
Just ((Many Inline -> Many Inline) -> Modifier (Many Inline)
forall a. (a -> a) -> Modifier a
Modifier Many Inline -> Many Inline
strong, [Inline]
lst)
    SmallCaps [Inline]
lst     -> (Modifier (Many Inline), [Inline])
-> Maybe (Modifier (Many Inline), [Inline])
forall a. a -> Maybe a
Just ((Many Inline -> Many Inline) -> Modifier (Many Inline)
forall a. (a -> a) -> Modifier a
Modifier Many Inline -> Many Inline
smallcaps, [Inline]
lst)
    Strikeout [Inline]
lst     -> (Modifier (Many Inline), [Inline])
-> Maybe (Modifier (Many Inline), [Inline])
forall a. a -> Maybe a
Just ((Many Inline -> Many Inline) -> Modifier (Many Inline)
forall a. (a -> a) -> Modifier a
Modifier Many Inline -> Many Inline
strikeout, [Inline]
lst)
    Underline [Inline]
lst     -> (Modifier (Many Inline), [Inline])
-> Maybe (Modifier (Many Inline), [Inline])
forall a. a -> Maybe a
Just ((Many Inline -> Many Inline) -> Modifier (Many Inline)
forall a. (a -> a) -> Modifier a
Modifier Many Inline -> Many Inline
underline, [Inline]
lst)
    Superscript [Inline]
lst   -> (Modifier (Many Inline), [Inline])
-> Maybe (Modifier (Many Inline), [Inline])
forall a. a -> Maybe a
Just ((Many Inline -> Many Inline) -> Modifier (Many Inline)
forall a. (a -> a) -> Modifier a
Modifier Many Inline -> Many Inline
superscript, [Inline]
lst)
    Subscript [Inline]
lst     -> (Modifier (Many Inline), [Inline])
-> Maybe (Modifier (Many Inline), [Inline])
forall a. a -> Maybe a
Just ((Many Inline -> Many Inline) -> Modifier (Many Inline)
forall a. (a -> a) -> Modifier a
Modifier Many Inline -> Many Inline
subscript, [Inline]
lst)
    Link (Text, [Text], [(Text, Text)])
attr [Inline]
lst (Text, Text)
tgt -> (Modifier (Many Inline), [Inline])
-> Maybe (Modifier (Many Inline), [Inline])
forall a. a -> Maybe a
Just ((Many Inline -> Many Inline) -> Modifier (Many Inline)
forall a. (a -> a) -> Modifier a
Modifier ((Many Inline -> Many Inline) -> Modifier (Many Inline))
-> (Many Inline -> Many Inline) -> Modifier (Many Inline)
forall a b. (a -> b) -> a -> b
$ (Text -> Text -> Many Inline -> Many Inline)
-> (Text, Text) -> Many Inline -> Many Inline
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry ((Text, [Text], [(Text, Text)])
-> Text -> Text -> Many Inline -> Many Inline
linkWith (Text, [Text], [(Text, Text)])
attr) (Text, Text)
tgt, [Inline]
lst)
    Span (Text, [Text], [(Text, Text)])
attr [Inline]
lst     -> (Modifier (Many Inline), [Inline])
-> Maybe (Modifier (Many Inline), [Inline])
forall a. a -> Maybe a
Just (((Text, [Text], [(Text, Text)]) -> Many Inline -> Many Inline)
-> (Text, [Text], [(Text, Text)]) -> Modifier (Many Inline)
forall a.
((Text, [Text], [(Text, Text)]) -> a -> a)
-> (Text, [Text], [(Text, Text)]) -> Modifier a
AttrModifier (Text, [Text], [(Text, Text)]) -> Many Inline -> Many Inline
spanWith (Text, [Text], [(Text, Text)])
attr, [Inline]
lst)
    Inline
_                 -> Maybe (Modifier (Many Inline), [Inline])
forall a. Maybe a
Nothing
  ViewL Inline
_ -> Maybe (Modifier (Many Inline), Many Inline)
forall a. Maybe a
Nothing

inlinesL :: Inlines -> (Inlines, Inlines)
inlinesL :: Many Inline -> (Many Inline, Many Inline)
inlinesL Many Inline
ils = case Seq Inline -> ViewL Inline
forall a. Seq a -> ViewL a
viewl (Seq Inline -> ViewL Inline) -> Seq Inline -> ViewL Inline
forall a b. (a -> b) -> a -> b
$ Many Inline -> Seq Inline
forall a. Many a -> Seq a
unMany Many Inline
ils of
  (Inline
s :< Seq Inline
sq) -> (Inline -> Many Inline
forall a. a -> Many a
B.singleton Inline
s, Seq Inline -> Many Inline
forall a. Seq a -> Many a
Many Seq Inline
sq)
  ViewL Inline
_         -> (Many Inline
forall a. Monoid a => a
mempty, Many Inline
ils)

inlinesR :: Inlines -> (Inlines, Inlines)
inlinesR :: Many Inline -> (Many Inline, Many Inline)
inlinesR Many Inline
ils = case Seq Inline -> ViewR Inline
forall a. Seq a -> ViewR a
viewr (Seq Inline -> ViewR Inline) -> Seq Inline -> ViewR Inline
forall a b. (a -> b) -> a -> b
$ Many Inline -> Seq Inline
forall a. Many a -> Seq a
unMany Many Inline
ils of
  (Seq Inline
sq :> Inline
s) -> (Seq Inline -> Many Inline
forall a. Seq a -> Many a
Many Seq Inline
sq, Inline -> Many Inline
forall a. a -> Many a
B.singleton Inline
s)
  ViewR Inline
_         -> (Many Inline
ils, Many Inline
forall a. Monoid a => a
mempty)

combineInlines :: Inlines -> Inlines -> Inlines
combineInlines :: Many Inline -> Many Inline -> Many Inline
combineInlines Many Inline
x Many Inline
y =
  let (Many Inline
xs', Many Inline
x') = Many Inline -> (Many Inline, Many Inline)
inlinesR Many Inline
x
      (Many Inline
y', Many Inline
ys') = Many Inline -> (Many Inline, Many Inline)
inlinesL Many Inline
y
  in
   Many Inline
xs' Many Inline -> Many Inline -> Many Inline
forall a. Semigroup a => a -> a -> a
<> Many Inline -> Many Inline -> Many Inline
combineSingletonInlines Many Inline
x' Many Inline
y' Many Inline -> Many Inline -> Many Inline
forall a. Semigroup a => a -> a -> a
<> Many Inline
ys'

combineSingletonInlines :: Inlines -> Inlines -> Inlines
combineSingletonInlines :: Many Inline -> Many Inline -> Many Inline
combineSingletonInlines Many Inline
x Many Inline
y =
  let ([Modifier (Many Inline)]
xfs, Many Inline
xs) = Many Inline -> ([Modifier (Many Inline)], Many Inline)
unstackInlines Many Inline
x
      ([Modifier (Many Inline)]
yfs, Many Inline
ys) = Many Inline -> ([Modifier (Many Inline)], Many Inline)
unstackInlines Many Inline
y
      shared :: [Modifier (Many Inline)]
shared = [Modifier (Many Inline)]
xfs [Modifier (Many Inline)]
-> [Modifier (Many Inline)] -> [Modifier (Many Inline)]
forall a. Eq a => [a] -> [a] -> [a]
`L.intersect` [Modifier (Many Inline)]
yfs
      x_remaining :: [Modifier (Many Inline)]
x_remaining = [Modifier (Many Inline)]
xfs [Modifier (Many Inline)]
-> [Modifier (Many Inline)] -> [Modifier (Many Inline)]
forall a. Eq a => [a] -> [a] -> [a]
L.\\ [Modifier (Many Inline)]
shared
      y_remaining :: [Modifier (Many Inline)]
y_remaining = [Modifier (Many Inline)]
yfs [Modifier (Many Inline)]
-> [Modifier (Many Inline)] -> [Modifier (Many Inline)]
forall a. Eq a => [a] -> [a] -> [a]
L.\\ [Modifier (Many Inline)]
shared
      x_rem_attr :: [Modifier (Many Inline)]
x_rem_attr = (Modifier (Many Inline) -> Bool)
-> [Modifier (Many Inline)] -> [Modifier (Many Inline)]
forall a. (a -> Bool) -> [a] -> [a]
filter Modifier (Many Inline) -> Bool
forall a. Modifier a -> Bool
isAttrModifier [Modifier (Many Inline)]
x_remaining
      y_rem_attr :: [Modifier (Many Inline)]
y_rem_attr = (Modifier (Many Inline) -> Bool)
-> [Modifier (Many Inline)] -> [Modifier (Many Inline)]
forall a. (a -> Bool) -> [a] -> [a]
filter Modifier (Many Inline) -> Bool
forall a. Modifier a -> Bool
isAttrModifier [Modifier (Many Inline)]
y_remaining
  in
   case [Modifier (Many Inline)] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Modifier (Many Inline)]
shared of
     Bool
True | Many Inline -> Bool
forall a. Many a -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null Many Inline
xs Bool -> Bool -> Bool
&& Many Inline -> Bool
forall a. Many a -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null Many Inline
ys ->
            [Modifier (Many Inline)] -> Many Inline -> Many Inline
stackInlines ([Modifier (Many Inline)]
x_rem_attr [Modifier (Many Inline)]
-> [Modifier (Many Inline)] -> [Modifier (Many Inline)]
forall a. Semigroup a => a -> a -> a
<> [Modifier (Many Inline)]
y_rem_attr) Many Inline
forall a. Monoid a => a
mempty
          | Many Inline -> Bool
forall a. Many a -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null Many Inline
xs ->
            let (Many Inline
sp, Many Inline
y') = Many Inline -> (Many Inline, Many Inline)
spaceOutInlinesL Many Inline
y in
            [Modifier (Many Inline)] -> Many Inline -> Many Inline
stackInlines [Modifier (Many Inline)]
x_rem_attr Many Inline
forall a. Monoid a => a
mempty Many Inline -> Many Inline -> Many Inline
forall a. Semigroup a => a -> a -> a
<> Many Inline
sp Many Inline -> Many Inline -> Many Inline
forall a. Semigroup a => a -> a -> a
<> Many Inline
y'
          | Many Inline -> Bool
forall a. Many a -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null Many Inline
ys ->
            let (Many Inline
x', Many Inline
sp) = Many Inline -> (Many Inline, Many Inline)
spaceOutInlinesR Many Inline
x in
            Many Inline
x' Many Inline -> Many Inline -> Many Inline
forall a. Semigroup a => a -> a -> a
<> Many Inline
sp Many Inline -> Many Inline -> Many Inline
forall a. Semigroup a => a -> a -> a
<> [Modifier (Many Inline)] -> Many Inline -> Many Inline
stackInlines [Modifier (Many Inline)]
y_rem_attr Many Inline
forall a. Monoid a => a
mempty
          | Bool
otherwise ->
              let (Many Inline
x', Many Inline
xsp) = Many Inline -> (Many Inline, Many Inline)
spaceOutInlinesR Many Inline
x
                  (Many Inline
ysp, Many Inline
y') = Many Inline -> (Many Inline, Many Inline)
spaceOutInlinesL Many Inline
y
              in
               Many Inline
x' Many Inline -> Many Inline -> Many Inline
forall a. Semigroup a => a -> a -> a
<> Many Inline
xsp Many Inline -> Many Inline -> Many Inline
forall a. Semigroup a => a -> a -> a
<> Many Inline
ysp Many Inline -> Many Inline -> Many Inline
forall a. Semigroup a => a -> a -> a
<> Many Inline
y'
     Bool
False -> [Modifier (Many Inline)] -> Many Inline -> Many Inline
stackInlines [Modifier (Many Inline)]
shared (Many Inline -> Many Inline) -> Many Inline -> Many Inline
forall a b. (a -> b) -> a -> b
$
              Many Inline -> Many Inline -> Many Inline
combineInlines
              ([Modifier (Many Inline)] -> Many Inline -> Many Inline
stackInlines [Modifier (Many Inline)]
x_remaining Many Inline
xs)
              ([Modifier (Many Inline)] -> Many Inline -> Many Inline
stackInlines [Modifier (Many Inline)]
y_remaining Many Inline
ys)

combineBlocks :: Blocks -> Blocks -> Blocks
combineBlocks :: Many Block -> Many Block -> Many Block
combineBlocks Many Block
bs Many Block
cs
  | Seq Block
bs' :> BlockQuote [Block]
bs'' <- Seq Block -> ViewR Block
forall a. Seq a -> ViewR a
viewr (Many Block -> Seq Block
forall a. Many a -> Seq a
unMany Many Block
bs)
  , BlockQuote [Block]
cs'' :< Seq Block
cs' <- Seq Block -> ViewL Block
forall a. Seq a -> ViewL a
viewl (Many Block -> Seq Block
forall a. Many a -> Seq a
unMany Many Block
cs) =
      Seq Block -> Many Block
forall a. Seq a -> Many a
Many (Seq Block -> Many Block) -> Seq Block -> Many Block
forall a b. (a -> b) -> a -> b
$ (Seq Block
bs' Seq Block -> Block -> Seq Block
forall a. Seq a -> a -> Seq a
|> [Block] -> Block
BlockQuote ([Block]
bs'' [Block] -> [Block] -> [Block]
forall a. Semigroup a => a -> a -> a
<> [Block]
cs'')) Seq Block -> Seq Block -> Seq Block
forall a. Seq a -> Seq a -> Seq a
>< Seq Block
cs'
  | Seq Block
bs' :> CodeBlock (Text, [Text], [(Text, Text)])
attr Text
codeStr <- Seq Block -> ViewR Block
forall a. Seq a -> ViewR a
viewr (Many Block -> Seq Block
forall a. Many a -> Seq a
unMany Many Block
bs)
  , CodeBlock (Text, [Text], [(Text, Text)])
attr' Text
codeStr' :< Seq Block
cs' <- Seq Block -> ViewL Block
forall a. Seq a -> ViewL a
viewl (Many Block -> Seq Block
forall a. Many a -> Seq a
unMany Many Block
cs)
  , (Text, [Text], [(Text, Text)])
attr (Text, [Text], [(Text, Text)])
-> (Text, [Text], [(Text, Text)]) -> Bool
forall a. Eq a => a -> a -> Bool
== (Text, [Text], [(Text, Text)])
attr' =
      Seq Block -> Many Block
forall a. Seq a -> Many a
Many (Seq Block -> Many Block) -> Seq Block -> Many Block
forall a b. (a -> b) -> a -> b
$ (Seq Block
bs' Seq Block -> Block -> Seq Block
forall a. Seq a -> a -> Seq a
|> (Text, [Text], [(Text, Text)]) -> Text -> Block
CodeBlock (Text, [Text], [(Text, Text)])
attr (Text
codeStr Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"\n" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
codeStr')) Seq Block -> Seq Block -> Seq Block
forall a. Seq a -> Seq a -> Seq a
>< Seq Block
cs'
combineBlocks Many Block
bs Many Block
cs = Many Block
bs Many Block -> Many Block -> Many Block
forall a. Semigroup a => a -> a -> a
<> Many Block
cs

instance (Monoid a, Eq a) => Eq (Modifier a) where
  (Modifier a -> a
f) == :: Modifier a -> Modifier a -> Bool
== (Modifier a -> a
g) = a -> a
f a
forall a. Monoid a => a
mempty a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a -> a
g a
forall a. Monoid a => a
mempty
  (AttrModifier (Text, [Text], [(Text, Text)]) -> a -> a
f (Text, [Text], [(Text, Text)])
attr) == (AttrModifier (Text, [Text], [(Text, Text)]) -> a -> a
g (Text, [Text], [(Text, Text)])
attr') = (Text, [Text], [(Text, Text)]) -> a -> a
f (Text, [Text], [(Text, Text)])
attr a
forall a. Monoid a => a
mempty a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== (Text, [Text], [(Text, Text)]) -> a -> a
g (Text, [Text], [(Text, Text)])
attr' a
forall a. Monoid a => a
mempty
  Modifier a
_ == Modifier a
_ = Bool
False

isAttrModifier :: Modifier a -> Bool
isAttrModifier :: forall a. Modifier a -> Bool
isAttrModifier (AttrModifier (Text, [Text], [(Text, Text)]) -> a -> a
_ (Text, [Text], [(Text, Text)])
_) = Bool
True
isAttrModifier Modifier a
_                  = Bool
False

smushInlines :: [Inlines] -> Inlines
smushInlines :: [Many Inline] -> Many Inline
smushInlines [Many Inline]
xs = Many Inline -> Many Inline -> Many Inline
combineInlines Many Inline
xs' Many Inline
forall a. Monoid a => a
mempty
  where xs' :: Many Inline
xs' = (Many Inline -> Many Inline -> Many Inline)
-> Many Inline -> [Many Inline] -> Many Inline
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
L.foldl' Many Inline -> Many Inline -> Many Inline
combineInlines Many Inline
forall a. Monoid a => a
mempty [Many Inline]
xs

smushBlocks :: [Blocks] -> Blocks
smushBlocks :: [Many Block] -> Many Block
smushBlocks [Many Block]
xs = (Many Block -> Many Block -> Many Block)
-> Many Block -> [Many Block] -> Many Block
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
L.foldl' Many Block -> Many Block -> Many Block
combineBlocks Many Block
forall a. Monoid a => a
mempty [Many Block]
xs