    {-# LANGUAGE Arrows            #-}
    {-# LANGUAGE DeriveFoldable    #-}
    {-# LANGUAGE GeneralizedNewtypeDeriving #-}
    {-# LANGUAGE PatternGuards     #-}
    {-# LANGUAGE RecordWildCards   #-}
    {-# LANGUAGE TupleSections     #-}
    {-# LANGUAGE ViewPatterns      #-}
    {-# LANGUAGE OverloadedStrings #-}
    {- |
       Module      : Text.Pandoc.Readers.Odt.ContentReader
       Copyright   : Copyright (C) 2015 Martin Linnemann
       License     : GNU GPL, version 2 or above

       Maintainer  : Martin Linnemann <theCodingMarlin@googlemail.com>
       Stability   : alpha
       Portability : portable

    The core of the odt reader that converts odt features into Pandoc types.
    -}

    module Text.Pandoc.Readers.Odt.ContentReader
    ( readerState
    , read_body
    ) where

    import Control.Applicative hiding (liftA, liftA2, liftA3)
    import Control.Arrow

    import qualified Data.ByteString.Lazy as B
    import Data.Foldable (fold)
    import Data.List (find, stripPrefix)
    import qualified Data.Map as M
    import qualified Data.Text as T
    import Data.Maybe
    import Data.Semigroup (First(..), Option(..))

    import Text.TeXMath (readMathML, writeTeX)
    import qualified Text.XML.Light as XML

    import Text.Pandoc.Builder
    import Text.Pandoc.MediaBag (MediaBag, insertMedia)
    import Text.Pandoc.Shared
    import Text.Pandoc.Extensions (extensionsFromList, Extension(..))
    import qualified Text.Pandoc.UTF8 as UTF8

    import Text.Pandoc.Readers.Odt.Base
    import Text.Pandoc.Readers.Odt.Namespaces
    import Text.Pandoc.Readers.Odt.StyleReader

    import Text.Pandoc.Readers.Odt.Arrows.State (foldS)
    import Text.Pandoc.Readers.Odt.Arrows.Utils
    import Text.Pandoc.Readers.Odt.Generic.Fallible
    import Text.Pandoc.Readers.Odt.Generic.Utils
    import Text.Pandoc.Readers.Odt.Generic.XMLConverter

    import qualified Data.Set as Set

    --------------------------------------------------------------------------------
    -- State
    --------------------------------------------------------------------------------

    type Anchor = T.Text
    type Media = [(FilePath, B.ByteString)]

    data ReaderState
       = ReaderState { -- | A collection of styles read somewhere else.
                       -- It is only queried here, not modified.
                       ReaderState -> Styles
    styleSet         :: Styles
                       -- | A stack of the styles of parent elements.
                       -- Used to look up inherited style properties.
                     , ReaderState -> [Style]
    styleTrace       :: [Style]
                       -- | Keeps track of the current depth in nested lists
                     , ReaderState -> ListLevel
    currentListLevel :: ListLevel
                       -- | Lists may provide their own style, but they don't have
                       -- to. If they do not, the style of a parent list may be used
                       -- or even a default list style from the paragraph style.
                       -- This value keeps track of the closest list style there
                       -- currently is.
                     , ReaderState -> Maybe ListStyle
    currentListStyle :: Maybe ListStyle
                       -- | A map from internal anchor names to "pretty" ones.
                       -- The mapping is a purely cosmetic one.
                     , ReaderState -> Map Anchor Anchor
    bookmarkAnchors  :: M.Map Anchor Anchor
                       -- | A map of files / binary data from the archive
                     , ReaderState -> Media
    envMedia         :: Media
                       -- | Hold binary resources used in the document
                     , ReaderState -> MediaBag
    odtMediaBag      :: MediaBag
                     }
      deriving ( ListLevel -> ReaderState -> ShowS
    [ReaderState] -> ShowS
    ReaderState -> String
    (ListLevel -> ReaderState -> ShowS)
    -> (ReaderState -> String)
    -> ([ReaderState] -> ShowS)
    -> Show ReaderState
    forall a.
    (ListLevel -> a -> ShowS)
    -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [ReaderState] -> ShowS
    $cshowList :: [ReaderState] -> ShowS
    show :: ReaderState -> String
    $cshow :: ReaderState -> String
    showsPrec :: ListLevel -> ReaderState -> ShowS
    $cshowsPrec :: ListLevel -> ReaderState -> ShowS
    Show )

    readerState :: Styles -> Media -> ReaderState
    readerState :: Styles -> Media -> ReaderState
    readerState styles :: Styles
    styles media :: Media
    media = Styles
    -> [Style]
    -> ListLevel
    -> Maybe ListStyle
    -> Map Anchor Anchor
    -> Media
    -> MediaBag
    -> ReaderState
    ReaderState Styles
    styles [] 0 Maybe ListStyle
    forall a. Maybe a
    Nothing Map Anchor Anchor
    forall k a. Map k a
    M.empty Media
    media MediaBag
    forall a. Monoid a => a
    mempty

    --
    pushStyle'  :: Style -> ReaderState -> ReaderState
    pushStyle' :: Style -> ReaderState -> ReaderState
    pushStyle' style :: Style
    style state :: ReaderState
    state = ReaderState
    state { styleTrace :: [Style]
    styleTrace = Style
    style Style -> [Style] -> [Style]
    forall a. a -> [a] -> [a]
    : ReaderState -> [Style]
    styleTrace ReaderState
    state }

    --
    popStyle'   :: ReaderState -> ReaderState
    popStyle' :: ReaderState -> ReaderState
    popStyle' state :: ReaderState
    state = case ReaderState -> [Style]
    styleTrace ReaderState
    state of
                       _:trace :: [Style]
    trace -> ReaderState
    state  { styleTrace :: [Style]
    styleTrace = [Style]
    trace  }
                       _       -> ReaderState
    state

    --
    modifyListLevel :: (ListLevel -> ListLevel) -> (ReaderState -> ReaderState)
    modifyListLevel :: (ListLevel -> ListLevel) -> ReaderState -> ReaderState
    modifyListLevel f :: ListLevel -> ListLevel
    f state :: ReaderState
    state = ReaderState
    state { currentListLevel :: ListLevel
    currentListLevel = ListLevel -> ListLevel
    f (ReaderState -> ListLevel
    currentListLevel ReaderState
    state) }

    --
    shiftListLevel :: ListLevel -> (ReaderState -> ReaderState)
    shiftListLevel :: ListLevel -> ReaderState -> ReaderState
    shiftListLevel diff :: ListLevel
    diff = (ListLevel -> ListLevel) -> ReaderState -> ReaderState
    modifyListLevel (ListLevel -> ListLevel -> ListLevel
    forall a. Num a => a -> a -> a
    + ListLevel
    diff)

    --
    swapCurrentListStyle :: Maybe ListStyle -> ReaderState
                         -> (ReaderState, Maybe ListStyle)
    swapCurrentListStyle :: Maybe ListStyle -> ReaderState -> (ReaderState, Maybe ListStyle)
    swapCurrentListStyle mListStyle :: Maybe ListStyle
    mListStyle state :: ReaderState
    state = ( ReaderState
    state { currentListStyle :: Maybe ListStyle
    currentListStyle = Maybe ListStyle
    mListStyle }
                                            ,  ReaderState -> Maybe ListStyle
    currentListStyle ReaderState
    state
                                            )

    --
    lookupPrettyAnchor :: Anchor -> ReaderState -> Maybe Anchor
    lookupPrettyAnchor :: Anchor -> ReaderState -> Maybe Anchor
    lookupPrettyAnchor anchor :: Anchor
    anchor ReaderState{..} = Anchor -> Map Anchor Anchor -> Maybe Anchor
    forall k a. Ord k => k -> Map k a -> Maybe a
    M.lookup Anchor
    anchor Map Anchor Anchor
    bookmarkAnchors

    --
    putPrettyAnchor :: Anchor -> Anchor -> ReaderState -> ReaderState
    putPrettyAnchor :: Anchor -> Anchor -> ReaderState -> ReaderState
    putPrettyAnchor ugly :: Anchor
    ugly pretty :: Anchor
    pretty state :: ReaderState
    state@ReaderState{..}
      = ReaderState
    state { bookmarkAnchors :: Map Anchor Anchor
    bookmarkAnchors = Anchor -> Anchor -> Map Anchor Anchor -> Map Anchor Anchor
    forall k a. Ord k => k -> a -> Map k a -> Map k a
    M.insert Anchor
    ugly Anchor
    pretty Map Anchor Anchor
    bookmarkAnchors }

    --
    usedAnchors :: ReaderState -> [Anchor]
    usedAnchors :: ReaderState -> [Anchor]
    usedAnchors ReaderState{..} = Map Anchor Anchor -> [Anchor]
    forall k a. Map k a -> [a]
    M.elems Map Anchor Anchor
    bookmarkAnchors

    getMediaBag :: ReaderState -> MediaBag
    getMediaBag :: ReaderState -> MediaBag
    getMediaBag ReaderState{..} = MediaBag
    odtMediaBag

    getMediaEnv :: ReaderState -> Media
    getMediaEnv :: ReaderState -> Media
    getMediaEnv ReaderState{..} = Media
    envMedia

    insertMedia' :: (FilePath, B.ByteString) -> ReaderState ->  ReaderState
    insertMedia' :: (String, ByteString) -> ReaderState -> ReaderState
    insertMedia' (fp :: String
    fp, bs :: ByteString
    bs) state :: ReaderState
    state@ReaderState{..}
      = ReaderState
    state { odtMediaBag :: MediaBag
    odtMediaBag = String -> Maybe Anchor -> ByteString -> MediaBag -> MediaBag
    insertMedia String
    fp Maybe Anchor
    forall a. Maybe a
    Nothing ByteString
    bs MediaBag
    odtMediaBag }

    --------------------------------------------------------------------------------
    -- Reader type and associated tools
    --------------------------------------------------------------------------------

    type OdtReader      a b = XMLReader     ReaderState a b

    type OdtReaderSafe  a b = XMLReaderSafe ReaderState a b

    -- | Extract something from the styles
    fromStyles :: (a -> Styles -> b) -> OdtReaderSafe a b
    fromStyles :: (a -> Styles -> b) -> OdtReaderSafe a b
    fromStyles f :: a -> Styles -> b
    f =     ArrowState (XMLConverterState Namespace ReaderState) a Styles
    -> ArrowState
         (XMLConverterState Namespace ReaderState) a (a, Styles)
    forall (a :: * -> * -> *) b c. Arrow a => a b c -> a b (b, c)
    keepingTheValue
                         (XMLConverter Namespace ReaderState a ReaderState
    forall nsID extraState x. XMLConverter nsID extraState x extraState
    getExtraState XMLConverter Namespace ReaderState a ReaderState
    -> (ReaderState -> Styles)
    -> ArrowState (XMLConverterState Namespace ReaderState) a Styles
    forall (a :: * -> * -> *) b c d.
    Arrow a =>
    a b c -> (c -> d) -> a b d
    >>^ ReaderState -> Styles
    styleSet)
                   ArrowState (XMLConverterState Namespace ReaderState) a (a, Styles)
    -> (a -> Styles -> b) -> OdtReaderSafe a b
    forall (a :: * -> * -> *) x b c d.
    Arrow a =>
    a x (b, c) -> (b -> c -> d) -> a x d
    >>% a -> Styles -> b
    f

    --
    getStyleByName :: OdtReader StyleName Style
    getStyleByName :: OdtReader String Style
    getStyleByName = (String -> Styles -> Maybe Style)
    -> OdtReaderSafe String (Maybe Style)
    forall a b. (a -> Styles -> b) -> OdtReaderSafe a b
    fromStyles String -> Styles -> Maybe Style
    lookupStyle OdtReaderSafe String (Maybe Style)
    -> (Maybe Style -> Fallible Style) -> OdtReader String Style
    forall (a :: * -> * -> *) b c d.
    Arrow a =>
    a b c -> (c -> d) -> a b d
    >>^ Maybe Style -> Fallible Style
    forall (a :: * -> * -> *) b.
    ArrowChoice a =>
    a (Maybe b) (Fallible b)
    maybeToChoice

    --
    findStyleFamily :: OdtReader Style StyleFamily
    findStyleFamily :: OdtReader Style StyleFamily
    findStyleFamily = (Style -> Styles -> Maybe StyleFamily)
    -> OdtReaderSafe Style (Maybe StyleFamily)
    forall a b. (a -> Styles -> b) -> OdtReaderSafe a b
    fromStyles Style -> Styles -> Maybe StyleFamily
    getStyleFamily OdtReaderSafe Style (Maybe StyleFamily)
    -> (Maybe StyleFamily -> Fallible StyleFamily)
    -> OdtReader Style StyleFamily
    forall (a :: * -> * -> *) b c d.
    Arrow a =>
    a b c -> (c -> d) -> a b d
    >>^ Maybe StyleFamily -> Fallible StyleFamily
    forall (a :: * -> * -> *) b.
    ArrowChoice a =>
    a (Maybe b) (Fallible b)
    maybeToChoice

    --
    lookupListStyle :: OdtReader StyleName ListStyle
    lookupListStyle :: OdtReader String ListStyle
    lookupListStyle = (String -> Styles -> Maybe ListStyle)
    -> OdtReaderSafe String (Maybe ListStyle)
    forall a b. (a -> Styles -> b) -> OdtReaderSafe a b
    fromStyles String -> Styles -> Maybe ListStyle
    lookupListStyleByName OdtReaderSafe String (Maybe ListStyle)
    -> (Maybe ListStyle -> Fallible ListStyle)
    -> OdtReader String ListStyle
    forall (a :: * -> * -> *) b c d.
    Arrow a =>
    a b c -> (c -> d) -> a b d
    >>^ Maybe ListStyle -> Fallible ListStyle
    forall (a :: * -> * -> *) b.
    ArrowChoice a =>
    a (Maybe b) (Fallible b)
    maybeToChoice

    --
    switchCurrentListStyle :: OdtReaderSafe (Maybe ListStyle) (Maybe ListStyle)
    switchCurrentListStyle :: OdtReaderSafe (Maybe ListStyle) (Maybe ListStyle)
    switchCurrentListStyle =     ArrowState
      (XMLConverterState Namespace ReaderState)
      (Maybe ListStyle)
      ReaderState
    -> ArrowState
         (XMLConverterState Namespace ReaderState)
         (Maybe ListStyle)
         (Maybe ListStyle, ReaderState)
    forall (a :: * -> * -> *) b c. Arrow a => a b c -> a b (b, c)
    keepingTheValue ArrowState
      (XMLConverterState Namespace ReaderState)
      (Maybe ListStyle)
      ReaderState
    forall nsID extraState x. XMLConverter nsID extraState x extraState
    getExtraState
                             ArrowState
      (XMLConverterState Namespace ReaderState)
      (Maybe ListStyle)
      (Maybe ListStyle, ReaderState)
    -> (Maybe ListStyle
        -> ReaderState -> (ReaderState, Maybe ListStyle))
    -> ArrowState
         (XMLConverterState Namespace ReaderState)
         (Maybe ListStyle)
         (ReaderState, Maybe ListStyle)
    forall (a :: * -> * -> *) x b c d.
    Arrow a =>
    a x (b, c) -> (b -> c -> d) -> a x d
    >>% Maybe ListStyle -> ReaderState -> (ReaderState, Maybe ListStyle)
    swapCurrentListStyle
                             ArrowState
      (XMLConverterState Namespace ReaderState)
      (Maybe ListStyle)
      (ReaderState, Maybe ListStyle)
    -> ArrowState
         (XMLConverterState Namespace ReaderState)
         (ReaderState, Maybe ListStyle)
         (Maybe ListStyle)
    -> OdtReaderSafe (Maybe ListStyle) (Maybe ListStyle)
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>> ArrowState
      (XMLConverterState Namespace ReaderState) ReaderState ReaderState
    -> ArrowState
         (XMLConverterState Namespace ReaderState)
         (ReaderState, Maybe ListStyle)
         (ReaderState, Maybe ListStyle)
    forall (a :: * -> * -> *) b c d.
    Arrow a =>
    a b c -> a (b, d) (c, d)
    first ArrowState
      (XMLConverterState Namespace ReaderState) ReaderState ReaderState
    forall nsID extraState.
    XMLConverter nsID extraState extraState extraState
    setExtraState
                             ArrowState
      (XMLConverterState Namespace ReaderState)
      (ReaderState, Maybe ListStyle)
      (ReaderState, Maybe ListStyle)
    -> ((ReaderState, Maybe ListStyle) -> Maybe ListStyle)
    -> ArrowState
         (XMLConverterState Namespace ReaderState)
         (ReaderState, Maybe ListStyle)
         (Maybe ListStyle)
    forall (a :: * -> * -> *) b c d.
    Arrow a =>
    a b c -> (c -> d) -> a b d
    >>^ (ReaderState, Maybe ListStyle) -> Maybe ListStyle
    forall a b. (a, b) -> b
    snd

    --
    pushStyle :: OdtReaderSafe Style Style
    pushStyle :: OdtReaderSafe Style Style
    pushStyle =     ArrowState
      (XMLConverterState Namespace ReaderState) Style ReaderState
    -> ArrowState
         (XMLConverterState Namespace ReaderState)
         Style
         (Style, ReaderState)
    forall (a :: * -> * -> *) b c. Arrow a => a b c -> a b (b, c)
    keepingTheValue (
                      (     ArrowState
      (XMLConverterState Namespace ReaderState) Style ReaderState
    -> ArrowState
         (XMLConverterState Namespace ReaderState)
         Style
         (Style, ReaderState)
    forall (a :: * -> * -> *) b c. Arrow a => a b c -> a b (b, c)
    keepingTheValue ArrowState
      (XMLConverterState Namespace ReaderState) Style ReaderState
    forall nsID extraState x. XMLConverter nsID extraState x extraState
    getExtraState
                        ArrowState
      (XMLConverterState Namespace ReaderState)
      Style
      (Style, ReaderState)
    -> (Style -> ReaderState -> ReaderState)
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Style ReaderState
    forall (a :: * -> * -> *) x b c d.
    Arrow a =>
    a x (b, c) -> (b -> c -> d) -> a x d
    >>% Style -> ReaderState -> ReaderState
    pushStyle'
                      )
                      ArrowState
      (XMLConverterState Namespace ReaderState) Style ReaderState
    -> ArrowState
         (XMLConverterState Namespace ReaderState) ReaderState ReaderState
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Style ReaderState
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>> ArrowState
      (XMLConverterState Namespace ReaderState) ReaderState ReaderState
    forall nsID extraState.
    XMLConverter nsID extraState extraState extraState
    setExtraState
                    )
                ArrowState
      (XMLConverterState Namespace ReaderState)
      Style
      (Style, ReaderState)
    -> ((Style, ReaderState) -> Style) -> OdtReaderSafe Style Style
    forall (a :: * -> * -> *) b c d.
    Arrow a =>
    a b c -> (c -> d) -> a b d
    >>^ (Style, ReaderState) -> Style
    forall a b. (a, b) -> a
    fst

    --
    popStyle :: OdtReaderSafe x x
    popStyle :: OdtReaderSafe x x
    popStyle =     ArrowState (XMLConverterState Namespace ReaderState) x ReaderState
    -> ArrowState
         (XMLConverterState Namespace ReaderState) x (x, ReaderState)
    forall (a :: * -> * -> *) b c. Arrow a => a b c -> a b (b, c)
    keepingTheValue (
                         ArrowState (XMLConverterState Namespace ReaderState) x ReaderState
    forall nsID extraState x. XMLConverter nsID extraState x extraState
    getExtraState
                     ArrowState (XMLConverterState Namespace ReaderState) x ReaderState
    -> ArrowState
         (XMLConverterState Namespace ReaderState) ReaderState ReaderState
    -> ArrowState
         (XMLConverterState Namespace ReaderState) x ReaderState
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>> (ReaderState -> ReaderState)
    -> ArrowState
         (XMLConverterState Namespace ReaderState) ReaderState ReaderState
    forall (a :: * -> * -> *) b c. Arrow a => (b -> c) -> a b c
    arr ReaderState -> ReaderState
    popStyle'
                     ArrowState
      (XMLConverterState Namespace ReaderState) ReaderState ReaderState
    -> ArrowState
         (XMLConverterState Namespace ReaderState) ReaderState ReaderState
    -> ArrowState
         (XMLConverterState Namespace ReaderState) ReaderState ReaderState
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>> ArrowState
      (XMLConverterState Namespace ReaderState) ReaderState ReaderState
    forall nsID extraState.
    XMLConverter nsID extraState extraState extraState
    setExtraState
                   )
               ArrowState
      (XMLConverterState Namespace ReaderState) x (x, ReaderState)
    -> ((x, ReaderState) -> x) -> OdtReaderSafe x x
    forall (a :: * -> * -> *) b c d.
    Arrow a =>
    a b c -> (c -> d) -> a b d
    >>^ (x, ReaderState) -> x
    forall a b. (a, b) -> a
    fst

    --
    getCurrentListLevel :: OdtReaderSafe _x ListLevel
    getCurrentListLevel :: OdtReaderSafe _x ListLevel
    getCurrentListLevel = XMLConverter Namespace ReaderState _x ReaderState
    forall nsID extraState x. XMLConverter nsID extraState x extraState
    getExtraState XMLConverter Namespace ReaderState _x ReaderState
    -> (ReaderState -> ListLevel) -> OdtReaderSafe _x ListLevel
    forall (a :: * -> * -> *) b c d.
    Arrow a =>
    a b c -> (c -> d) -> a b d
    >>^ ReaderState -> ListLevel
    currentListLevel

    --
    updateMediaWithResource :: OdtReaderSafe (FilePath, B.ByteString) (FilePath, B.ByteString)
    updateMediaWithResource :: OdtReaderSafe (String, ByteString) (String, ByteString)
    updateMediaWithResource = ArrowState
      (XMLConverterState Namespace ReaderState)
      (String, ByteString)
      ReaderState
    -> ArrowState
         (XMLConverterState Namespace ReaderState)
         (String, ByteString)
         ((String, ByteString), ReaderState)
    forall (a :: * -> * -> *) b c. Arrow a => a b c -> a b (b, c)
    keepingTheValue (
                     (ArrowState
      (XMLConverterState Namespace ReaderState)
      (String, ByteString)
      ReaderState
    -> ArrowState
         (XMLConverterState Namespace ReaderState)
         (String, ByteString)
         ((String, ByteString), ReaderState)
    forall (a :: * -> * -> *) b c. Arrow a => a b c -> a b (b, c)
    keepingTheValue ArrowState
      (XMLConverterState Namespace ReaderState)
      (String, ByteString)
      ReaderState
    forall nsID extraState x. XMLConverter nsID extraState x extraState
    getExtraState
                      ArrowState
      (XMLConverterState Namespace ReaderState)
      (String, ByteString)
      ((String, ByteString), ReaderState)
    -> ((String, ByteString) -> ReaderState -> ReaderState)
    -> ArrowState
         (XMLConverterState Namespace ReaderState)
         (String, ByteString)
         ReaderState
    forall (a :: * -> * -> *) x b c d.
    Arrow a =>
    a x (b, c) -> (b -> c -> d) -> a x d
    >>% (String, ByteString) -> ReaderState -> ReaderState
    insertMedia'
                      )
                     ArrowState
      (XMLConverterState Namespace ReaderState)
      (String, ByteString)
      ReaderState
    -> ArrowState
         (XMLConverterState Namespace ReaderState) ReaderState ReaderState
    -> ArrowState
         (XMLConverterState Namespace ReaderState)
         (String, ByteString)
         ReaderState
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>> ArrowState
      (XMLConverterState Namespace ReaderState) ReaderState ReaderState
    forall nsID extraState.
    XMLConverter nsID extraState extraState extraState
    setExtraState
                   )
               ArrowState
      (XMLConverterState Namespace ReaderState)
      (String, ByteString)
      ((String, ByteString), ReaderState)
    -> (((String, ByteString), ReaderState) -> (String, ByteString))
    -> OdtReaderSafe (String, ByteString) (String, ByteString)
    forall (a :: * -> * -> *) b c d.
    Arrow a =>
    a b c -> (c -> d) -> a b d
    >>^ ((String, ByteString), ReaderState) -> (String, ByteString)
    forall a b. (a, b) -> a
    fst

    lookupResource :: OdtReaderSafe FilePath (FilePath, B.ByteString)
    lookupResource :: OdtReaderSafe String (String, ByteString)
    lookupResource = proc String
    target -> do
        ReaderState
    state <- XMLConverter Namespace ReaderState () ReaderState
    forall nsID extraState x. XMLConverter nsID extraState x extraState
    getExtraState -< ()
        case String -> Media -> Maybe ByteString
    forall a b. Eq a => a -> [(a, b)] -> Maybe b
    lookup String
    target (ReaderState -> Media
    getMediaEnv ReaderState
    state) of
          Just bs :: ByteString
    bs -> (String, ByteString)
    -> ArrowState
         (XMLConverterState Namespace ReaderState) () (String, ByteString)
    forall (a :: * -> * -> *) c x. Arrow a => c -> a x c
    returnV (String
    target, ByteString
    bs) -<< ()
          Nothing -> (String, ByteString)
    -> ArrowState
         (XMLConverterState Namespace ReaderState) () (String, ByteString)
    forall (a :: * -> * -> *) c x. Arrow a => c -> a x c
    returnV ("", ByteString
    B.empty) -< ()

    type AnchorPrefix = T.Text

    -- | An adaptation of 'uniqueIdent' from "Text.Pandoc.Shared" that generates a
    -- unique identifier but without assuming that the id should be for a header.
    -- Second argument is a list of already used identifiers.
    uniqueIdentFrom :: AnchorPrefix -> [Anchor] -> Anchor
    uniqueIdentFrom :: Anchor -> [Anchor] -> Anchor
    uniqueIdentFrom baseIdent :: Anchor
    baseIdent usedIdents :: [Anchor]
    usedIdents =
      let  numIdent :: a -> Anchor
    numIdent n :: a
    n = Anchor
    baseIdent Anchor -> Anchor -> Anchor
    forall a. Semigroup a => a -> a -> a
    <> "-" Anchor -> Anchor -> Anchor
    forall a. Semigroup a => a -> a -> a
    <> String -> Anchor
    T.pack (a -> String
    forall a. Show a => a -> String
    show a
    n)
      in  if Anchor
    baseIdent Anchor -> [Anchor] -> Bool
    forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
    `elem` [Anchor]
    usedIdents
            then case (ListLevel -> Bool) -> [ListLevel] -> Maybe ListLevel
    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
    find (\x :: ListLevel
    x -> ListLevel -> Anchor
    forall a. Show a => a -> Anchor
    numIdent ListLevel
    x Anchor -> [Anchor] -> Bool
    forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
    `notElem` [Anchor]
    usedIdents) ([1..60000] :: [Int]) of
                      Just x :: ListLevel
    x  -> ListLevel -> Anchor
    forall a. Show a => a -> Anchor
    numIdent ListLevel
    x
                      Nothing -> Anchor
    baseIdent   -- if we have more than 60,000, allow repeats
            else Anchor
    baseIdent

    -- | First argument: basis for a new "pretty" anchor if none exists yet
    -- Second argument: a key ("ugly" anchor)
    -- Returns: saved "pretty" anchor or created new one
    getPrettyAnchor :: OdtReaderSafe (AnchorPrefix, Anchor) Anchor
    getPrettyAnchor :: OdtReaderSafe (Anchor, Anchor) Anchor
    getPrettyAnchor = proc (baseIdent :: Anchor
    baseIdent, uglyAnchor :: Anchor
    uglyAnchor) -> do
      ReaderState
    state <- XMLConverter Namespace ReaderState () ReaderState
    forall nsID extraState x. XMLConverter nsID extraState x extraState
    getExtraState -< ()
      case Anchor -> ReaderState -> Maybe Anchor
    lookupPrettyAnchor Anchor
    uglyAnchor ReaderState
    state of
        Just prettyAnchor :: Anchor
    prettyAnchor -> ArrowState (XMLConverterState Namespace ReaderState) Anchor Anchor
    forall (a :: * -> * -> *) b. Arrow a => a b b
    returnA -< Anchor
    prettyAnchor
        Nothing           -> do
          let newPretty :: Anchor
    newPretty = Anchor -> [Anchor] -> Anchor
    uniqueIdentFrom Anchor
    baseIdent (ReaderState -> [Anchor]
    usedAnchors ReaderState
    state)
          (ReaderState -> ReaderState)
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Anchor Anchor
    forall extraState nsID x.
    (extraState -> extraState) -> XMLConverter nsID extraState x x
    modifyExtraState (Anchor -> Anchor -> ReaderState -> ReaderState
    putPrettyAnchor Anchor
    uglyAnchor Anchor
    newPretty) -<< Anchor
    newPretty

    -- | Input: basis for a new header anchor
    -- Output: saved new anchor
    getHeaderAnchor :: OdtReaderSafe Inlines Anchor
    getHeaderAnchor :: OdtReaderSafe Inlines Anchor
    getHeaderAnchor = proc Inlines
    title -> do
      ReaderState
    state <- XMLConverter Namespace ReaderState () ReaderState
    forall nsID extraState x. XMLConverter nsID extraState x extraState
    getExtraState -< ()
      let exts :: Extensions
    exts = [Extension] -> Extensions
    extensionsFromList [Extension
    Ext_auto_identifiers]
      let anchor :: Anchor
    anchor = Extensions -> [Inline] -> Set Anchor -> Anchor
    uniqueIdent Extensions
    exts (Inlines -> [Inline]
    forall a. Many a -> [a]
    toList Inlines
    title)
                    ([Anchor] -> Set Anchor
    forall a. Ord a => [a] -> Set a
    Set.fromList ([Anchor] -> Set Anchor) -> [Anchor] -> Set Anchor
    forall a b. (a -> b) -> a -> b
    $ ReaderState -> [Anchor]
    usedAnchors ReaderState
    state)
      (ReaderState -> ReaderState)
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Anchor Anchor
    forall extraState nsID x.
    (extraState -> extraState) -> XMLConverter nsID extraState x x
    modifyExtraState (Anchor -> Anchor -> ReaderState -> ReaderState
    putPrettyAnchor Anchor
    anchor Anchor
    anchor) -<< Anchor
    anchor

    --------------------------------------------------------------------------------
    -- Working with styles
    --------------------------------------------------------------------------------

    --
    readStyleByName :: OdtReader _x (StyleName, Style)
    readStyleByName :: OdtReader _x (String, Style)
    readStyleByName =
      Namespace
    -> String -> FallibleXMLConverter Namespace ReaderState _x String
    forall nsID extraState x.
    NameSpaceID nsID =>
    nsID -> String -> FallibleXMLConverter nsID extraState x String
    findAttr Namespace
    NsText "style-name" FallibleXMLConverter Namespace ReaderState _x String
    -> FallibleArrow
         (ArrowState (XMLConverterState Namespace ReaderState))
         String
         ()
         (String, Style)
    -> OdtReader _x (String, Style)
    forall (a :: * -> * -> *) x failure success success'.
    ArrowChoice a =>
    FallibleArrow a x failure success
    -> FallibleArrow a success failure success'
    -> FallibleArrow a x failure success'
    >>? OdtReader String Style
    -> ArrowState
         (XMLConverterState Namespace ReaderState)
         String
         (String, Fallible Style)
    forall (a :: * -> * -> *) b c. Arrow a => a b c -> a b (b, c)
    keepingTheValue OdtReader String Style
    getStyleByName ArrowState
      (XMLConverterState Namespace ReaderState)
      String
      (String, Fallible Style)
    -> ((String, Fallible Style) -> Fallible (String, Style))
    -> FallibleArrow
         (ArrowState (XMLConverterState Namespace ReaderState))
         String
         ()
         (String, Style)
    forall (a :: * -> * -> *) b c d.
    Arrow a =>
    a b c -> (c -> d) -> a b d
    >>^ (String, Fallible Style) -> Fallible (String, Style)
    liftE
      where
        liftE :: (StyleName, Fallible Style) -> Fallible (StyleName, Style)
        liftE :: (String, Fallible Style) -> Fallible (String, Style)
    liftE (name :: String
    name, Right v :: Style
    v) = (String, Style) -> Fallible (String, Style)
    forall a b. b -> Either a b
    Right (String
    name, Style
    v)
        liftE (_, Left v :: ()
    v)     = () -> Fallible (String, Style)
    forall a b. a -> Either a b
    Left ()
    v

    --
    isStyleToTrace :: OdtReader Style Bool
    isStyleToTrace :: OdtReader Style Bool
    isStyleToTrace = OdtReader Style StyleFamily
    findStyleFamily OdtReader Style StyleFamily
    -> (StyleFamily -> Bool) -> OdtReader Style Bool
    forall (a :: * -> * -> *) x failure success success'.
    ArrowChoice a =>
    FallibleArrow a x failure success
    -> (success -> success') -> FallibleArrow a x failure success'
    >>?^ (StyleFamily -> StyleFamily -> Bool
    forall a. Eq a => a -> a -> Bool
    ==StyleFamily
    FaText)

    --
    withNewStyle :: OdtReaderSafe x Inlines -> OdtReaderSafe x Inlines
    withNewStyle :: OdtReaderSafe x Inlines -> OdtReaderSafe x Inlines
    withNewStyle a :: OdtReaderSafe x Inlines
    a = proc x
    x -> do
      Fallible (String, Style)
    fStyle <- OdtReader () (String, Style)
    forall _x. OdtReader _x (String, Style)
    readStyleByName -< ()
      case Fallible (String, Style)
    fStyle of
        Right (styleName :: String
    styleName, _) | String -> Bool
    isCodeStyle String
    styleName -> do
          Inlines
    inlines <- OdtReaderSafe x Inlines
    a -< x
    x
          (Inlines -> Inlines)
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    forall (a :: * -> * -> *) b c. Arrow a => (b -> c) -> a b c
    arr Inlines -> Inlines
    inlineCode -<< Inlines
    inlines
        Right (_, style :: Style
    style) -> do
          Maybe StyleFamily
    mFamily    <- (Style -> Maybe StyleFamily)
    -> OdtReaderSafe Style (Maybe StyleFamily)
    forall (a :: * -> * -> *) b c. Arrow a => (b -> c) -> a b c
    arr Style -> Maybe StyleFamily
    styleFamily -< Style
    style
          Either () TextProperties
    fTextProps <- (Style -> Either () TextProperties)
    -> ArrowState
         (XMLConverterState Namespace ReaderState)
         Style
         (Either () TextProperties)
    forall (a :: * -> * -> *) b c. Arrow a => (b -> c) -> a b c
    arr ( Maybe TextProperties -> Either () TextProperties
    forall (a :: * -> * -> *) b.
    ArrowChoice a =>
    a (Maybe b) (Fallible b)
    maybeToChoice
                            (Maybe TextProperties -> Either () TextProperties)
    -> (Style -> Maybe TextProperties)
    -> Style
    -> Either () TextProperties
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . StyleProperties -> Maybe TextProperties
    textProperties
                            (StyleProperties -> Maybe TextProperties)
    -> (Style -> StyleProperties) -> Style -> Maybe TextProperties
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Style -> StyleProperties
    styleProperties
                            )           -< Style
    style
          case Either () TextProperties
    fTextProps of
            Right textProps :: TextProperties
    textProps -> do
              ReaderState
    state        <- XMLConverter Namespace ReaderState () ReaderState
    forall nsID extraState x. XMLConverter nsID extraState x extraState
    getExtraState             -< ()
              let triple :: (ReaderState, TextProperties, Maybe StyleFamily)
    triple = (ReaderState
    state, TextProperties
    textProps, Maybe StyleFamily
    mFamily)
              Inlines -> Inlines
    modifier     <- ((ReaderState, TextProperties, Maybe StyleFamily)
     -> Inlines -> Inlines)
    -> ArrowState
         (XMLConverterState Namespace ReaderState)
         (ReaderState, TextProperties, Maybe StyleFamily)
         (Inlines -> Inlines)
    forall (a :: * -> * -> *) b c. Arrow a => (b -> c) -> a b c
    arr (ReaderState, TextProperties, Maybe StyleFamily)
    -> Inlines -> Inlines
    modifierFromStyleDiff -< (ReaderState, TextProperties, Maybe StyleFamily)
    triple
              Fallible Bool
    fShouldTrace <- OdtReader Style Bool
    isStyleToTrace            -< Style
    style
              case Fallible Bool
    fShouldTrace of
                Right shouldTrace :: Bool
    shouldTrace ->
                  if Bool
    shouldTrace
                    then do
                      OdtReaderSafe Style Style
    pushStyle      -< Style
    style
                      Inlines
    inlines   <- OdtReaderSafe x Inlines
    a -< x
    x
                      OdtReaderSafe () ()
    forall x. OdtReaderSafe x x
    popStyle       -< ()
                      (Inlines -> Inlines)
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    forall (a :: * -> * -> *) b c. Arrow a => (b -> c) -> a b c
    arr Inlines -> Inlines
    modifier   -<< Inlines
    inlines
                    else
        -- In case anything goes wrong
                          OdtReaderSafe x Inlines
    a -< x
    x
                Left _ -> OdtReaderSafe x Inlines
    a -< x
    x
            Left _     -> OdtReaderSafe x Inlines
    a -< x
    x
        Left _         -> OdtReaderSafe x Inlines
    a -< x
    x
      where
        isCodeStyle :: StyleName -> Bool
        isCodeStyle :: String -> Bool
    isCodeStyle "Source_Text" = Bool
    True
        isCodeStyle _             = Bool
    False

        inlineCode :: Inlines -> Inlines
        inlineCode :: Inlines -> Inlines
    inlineCode = Anchor -> Inlines
    code (Anchor -> Inlines) -> (Inlines -> Anchor) -> Inlines -> Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [Anchor] -> Anchor
    T.concat ([Anchor] -> Anchor) -> (Inlines -> [Anchor]) -> Inlines -> Anchor
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Inline -> Anchor) -> [Inline] -> [Anchor]
    forall a b. (a -> b) -> [a] -> [b]
    map Inline -> Anchor
    forall a. Walkable Inline a => a -> Anchor
    stringify ([Inline] -> [Anchor])
    -> (Inlines -> [Inline]) -> Inlines -> [Anchor]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Inlines -> [Inline]
    forall a. Many a -> [a]
    toList

    type PropertyTriple = (ReaderState, TextProperties, Maybe StyleFamily)
    type InlineModifier = Inlines -> Inlines

    -- | Given data about the local style changes, calculates how to modify
    -- an instance of 'Inlines'
    modifierFromStyleDiff :: PropertyTriple -> InlineModifier
    modifierFromStyleDiff :: (ReaderState, TextProperties, Maybe StyleFamily)
    -> Inlines -> Inlines
    modifierFromStyleDiff propertyTriple :: (ReaderState, TextProperties, Maybe StyleFamily)
    propertyTriple  =
      [Inlines -> Inlines] -> Inlines -> Inlines
    forall (cat :: * -> * -> *) (f :: * -> *) a.
    (Category cat, Foldable f) =>
    f (cat a a) -> cat a a
    composition ([Inlines -> Inlines] -> Inlines -> Inlines)
    -> [Inlines -> Inlines] -> Inlines -> Inlines
    forall a b. (a -> b) -> a -> b
    $
      (ReaderState, TextProperties, Maybe StyleFamily)
    -> Inlines -> Inlines
    getVPosModifier (ReaderState, TextProperties, Maybe StyleFamily)
    propertyTriple
      (Inlines -> Inlines)
    -> [Inlines -> Inlines] -> [Inlines -> Inlines]
    forall a. a -> [a] -> [a]
    : (((ReaderState, TextProperties, Maybe StyleFamily) -> Bool,
      Inlines -> Inlines)
     -> Inlines -> Inlines)
    -> [((ReaderState, TextProperties, Maybe StyleFamily) -> Bool,
         Inlines -> Inlines)]
    -> [Inlines -> Inlines]
    forall a b. (a -> b) -> [a] -> [b]
    map ((((ReaderState, TextProperties, Maybe StyleFamily) -> Bool)
     -> Bool)
    -> ((ReaderState, TextProperties, Maybe StyleFamily) -> Bool,
        Inlines -> Inlines)
    -> (Bool, Inlines -> Inlines)
    forall (a :: * -> * -> *) b c d.
    Arrow a =>
    a b c -> a (b, d) (c, d)
    first (((ReaderState, TextProperties, Maybe StyleFamily) -> Bool)
    -> (ReaderState, TextProperties, Maybe StyleFamily) -> Bool
    forall a b. (a -> b) -> a -> b
    $ (ReaderState, TextProperties, Maybe StyleFamily)
    propertyTriple) (((ReaderState, TextProperties, Maybe StyleFamily) -> Bool,
      Inlines -> Inlines)
     -> (Bool, Inlines -> Inlines))
    -> ((Bool, Inlines -> Inlines) -> Inlines -> Inlines)
    -> ((ReaderState, TextProperties, Maybe StyleFamily) -> Bool,
        Inlines -> Inlines)
    -> Inlines
    -> Inlines
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>> (Inlines -> Inlines)
    -> (Bool, Inlines -> Inlines) -> Inlines -> Inlines
    forall p. p -> (Bool, p) -> p
    ifThen_else Inlines -> Inlines
    ignore)
            [ ((ReaderState, TextProperties, Maybe StyleFamily) -> Bool
    hasEmphChanged           , Inlines -> Inlines
    emph      )
            , ((TextProperties -> Bool)
    -> (ReaderState, TextProperties, Maybe StyleFamily) -> Bool
    forall b.
    Eq b =>
    (TextProperties -> b)
    -> (ReaderState, TextProperties, Maybe StyleFamily) -> Bool
    hasChanged TextProperties -> Bool
    isStrong      , Inlines -> Inlines
    strong    )
            , ((TextProperties -> Maybe UnderlineMode)
    -> (ReaderState, TextProperties, Maybe StyleFamily) -> Bool
    forall b.
    Eq b =>
    (TextProperties -> b)
    -> (ReaderState, TextProperties, Maybe StyleFamily) -> Bool
    hasChanged TextProperties -> Maybe UnderlineMode
    strikethrough , Inlines -> Inlines
    strikeout )
            ]
      where
        ifThen_else :: p -> (Bool, p) -> p
    ifThen_else else' :: p
    else' (if' :: Bool
    if',then' :: p
    then') = if Bool
    if' then p
    then' else p
    else'

        ignore :: Inlines -> Inlines
    ignore = Inlines -> Inlines
    forall a. a -> a
    id :: InlineModifier

        getVPosModifier :: PropertyTriple -> InlineModifier
        getVPosModifier :: (ReaderState, TextProperties, Maybe StyleFamily)
    -> Inlines -> Inlines
    getVPosModifier triple :: (ReaderState, TextProperties, Maybe StyleFamily)
    triple@(_,textProps :: TextProperties
    textProps,_) =
            let getVPos :: TextProperties -> Maybe VerticalTextPosition
    getVPos = VerticalTextPosition -> Maybe VerticalTextPosition
    forall a. a -> Maybe a
    Just (VerticalTextPosition -> Maybe VerticalTextPosition)
    -> (TextProperties -> VerticalTextPosition)
    -> TextProperties
    -> Maybe VerticalTextPosition
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . TextProperties -> VerticalTextPosition
    verticalPosition
            in  case (TextProperties -> Maybe VerticalTextPosition)
    -> (ReaderState, TextProperties, Maybe StyleFamily)
    -> Maybe VerticalTextPosition
    forall b b.
    (TextProperties -> Maybe b)
    -> (ReaderState, b, Maybe StyleFamily) -> Maybe b
    lookupPreviousValueM TextProperties -> Maybe VerticalTextPosition
    getVPos (ReaderState, TextProperties, Maybe StyleFamily)
    triple of
                  Nothing      -> Inlines -> Inlines
    ignore
                  Just oldVPos :: VerticalTextPosition
    oldVPos -> (VerticalTextPosition, VerticalTextPosition) -> Inlines -> Inlines
    getVPosModifier' (VerticalTextPosition
    oldVPos, TextProperties -> VerticalTextPosition
    verticalPosition TextProperties
    textProps)

        getVPosModifier' :: (VerticalTextPosition, VerticalTextPosition) -> Inlines -> Inlines
    getVPosModifier' (oldVPos :: VerticalTextPosition
    oldVPos , newVPos :: VerticalTextPosition
    newVPos   ) | VerticalTextPosition
    oldVPos VerticalTextPosition -> VerticalTextPosition -> Bool
    forall a. Eq a => a -> a -> Bool
    == VerticalTextPosition
    newVPos = Inlines -> Inlines
    ignore
        getVPosModifier' ( _      , VPosSub   ) = Inlines -> Inlines
    subscript
        getVPosModifier' ( _      , VPosSuper ) = Inlines -> Inlines
    superscript
        getVPosModifier' ( _      ,  _        ) = Inlines -> Inlines
    ignore

        hasEmphChanged :: PropertyTriple -> Bool
        hasEmphChanged :: (ReaderState, TextProperties, Maybe StyleFamily) -> Bool
    hasEmphChanged = ((((ReaderState, TextProperties, Maybe StyleFamily) -> Bool)
      -> Bool)
     -> [(ReaderState, TextProperties, Maybe StyleFamily) -> Bool]
     -> Bool)
    -> [(ReaderState, TextProperties, Maybe StyleFamily) -> Bool]
    -> (ReaderState, TextProperties, Maybe StyleFamily)
    -> Bool
    forall a b c d. (((a -> b) -> b) -> c -> d) -> c -> a -> d
    swing (((ReaderState, TextProperties, Maybe StyleFamily) -> Bool)
     -> Bool)
    -> [(ReaderState, TextProperties, Maybe StyleFamily) -> Bool]
    -> Bool
    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
    any [ (TextProperties -> Bool)
    -> (ReaderState, TextProperties, Maybe StyleFamily) -> Bool
    forall b.
    Eq b =>
    (TextProperties -> b)
    -> (ReaderState, TextProperties, Maybe StyleFamily) -> Bool
    hasChanged  TextProperties -> Bool
    isEmphasised
                                   , (TextProperties -> Maybe FontPitch)
    -> (ReaderState, TextProperties, Maybe StyleFamily) -> Bool
    forall b.
    Eq b =>
    (TextProperties -> Maybe b)
    -> (ReaderState, TextProperties, Maybe StyleFamily) -> Bool
    hasChangedM TextProperties -> Maybe FontPitch
    pitch
                                   , (TextProperties -> Maybe UnderlineMode)
    -> (ReaderState, TextProperties, Maybe StyleFamily) -> Bool
    forall b.
    Eq b =>
    (TextProperties -> b)
    -> (ReaderState, TextProperties, Maybe StyleFamily) -> Bool
    hasChanged  TextProperties -> Maybe UnderlineMode
    underline
                                   ]

        hasChanged :: (TextProperties -> b)
    -> (ReaderState, TextProperties, Maybe StyleFamily) -> Bool
    hasChanged property :: TextProperties -> b
    property triple :: (ReaderState, TextProperties, Maybe StyleFamily)
    triple@(_, TextProperties -> b
    property -> b
    newProperty, _) =
            (Maybe b -> Maybe b -> Bool
    forall a. Eq a => a -> a -> Bool
    /= b -> Maybe b
    forall a. a -> Maybe a
    Just b
    newProperty) ((TextProperties -> b)
    -> (ReaderState, TextProperties, Maybe StyleFamily) -> Maybe b
    forall b b.
    (TextProperties -> b)
    -> (ReaderState, b, Maybe StyleFamily) -> Maybe b
    lookupPreviousValue TextProperties -> b
    property (ReaderState, TextProperties, Maybe StyleFamily)
    triple)

        hasChangedM :: (TextProperties -> Maybe b)
    -> (ReaderState, TextProperties, Maybe StyleFamily) -> Bool
    hasChangedM property :: TextProperties -> Maybe b
    property triple :: (ReaderState, TextProperties, Maybe StyleFamily)
    triple@(_, textProps :: TextProperties
    textProps,_) =
          Bool -> Maybe Bool -> Bool
    forall a. a -> Maybe a -> a
    fromMaybe Bool
    False (Maybe Bool -> Bool) -> Maybe Bool -> Bool
    forall a b. (a -> b) -> a -> b
    $ b -> b -> Bool
    forall a. Eq a => a -> a -> Bool
    (/=) (b -> b -> Bool) -> Maybe b -> Maybe (b -> Bool)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> TextProperties -> Maybe b
    property TextProperties
    textProps Maybe (b -> Bool) -> Maybe b -> Maybe Bool
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (TextProperties -> Maybe b)
    -> (ReaderState, TextProperties, Maybe StyleFamily) -> Maybe b
    forall b b.
    (TextProperties -> Maybe b)
    -> (ReaderState, b, Maybe StyleFamily) -> Maybe b
    lookupPreviousValueM TextProperties -> Maybe b
    property (ReaderState, TextProperties, Maybe StyleFamily)
    triple

        lookupPreviousValue :: (TextProperties -> b)
    -> (ReaderState, b, Maybe StyleFamily) -> Maybe b
    lookupPreviousValue f :: TextProperties -> b
    f = (StyleProperties -> Maybe b)
    -> (ReaderState, b, Maybe StyleFamily) -> Maybe b
    forall b b.
    (StyleProperties -> Maybe b)
    -> (ReaderState, b, Maybe StyleFamily) -> Maybe b
    lookupPreviousStyleValue ((TextProperties -> b) -> Maybe TextProperties -> Maybe b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap TextProperties -> b
    f (Maybe TextProperties -> Maybe b)
    -> (StyleProperties -> Maybe TextProperties)
    -> StyleProperties
    -> Maybe b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . StyleProperties -> Maybe TextProperties
    textProperties)

        lookupPreviousValueM :: (TextProperties -> Maybe b)
    -> (ReaderState, b, Maybe StyleFamily) -> Maybe b
    lookupPreviousValueM f :: TextProperties -> Maybe b
    f = (StyleProperties -> Maybe b)
    -> (ReaderState, b, Maybe StyleFamily) -> Maybe b
    forall b b.
    (StyleProperties -> Maybe b)
    -> (ReaderState, b, Maybe StyleFamily) -> Maybe b
    lookupPreviousStyleValue ((TextProperties -> Maybe b
    f (TextProperties -> Maybe b) -> Maybe TextProperties -> Maybe b
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<<)(Maybe TextProperties -> Maybe b)
    -> (StyleProperties -> Maybe TextProperties)
    -> StyleProperties
    -> Maybe b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .StyleProperties -> Maybe TextProperties
    textProperties)

        lookupPreviousStyleValue :: (StyleProperties -> Maybe b)
    -> (ReaderState, b, Maybe StyleFamily) -> Maybe b
    lookupPreviousStyleValue f :: StyleProperties -> Maybe b
    f (ReaderState{..},_,mFamily :: Maybe StyleFamily
    mFamily)
          =     (StyleProperties -> Maybe b) -> [StyleProperties] -> Maybe b
    forall a b. (a -> Maybe b) -> [a] -> Maybe b
    findBy StyleProperties -> Maybe b
    f ([Style] -> Styles -> [StyleProperties]
    extendedStylePropertyChain [Style]
    styleTrace Styles
    styleSet)
            Maybe b -> Maybe b -> Maybe b
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> ( StyleProperties -> Maybe b
    f (StyleProperties -> Maybe b) -> Maybe StyleProperties -> Maybe b
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< (StyleFamily -> StyleProperties)
    -> Maybe StyleFamily -> Maybe StyleProperties
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (Styles -> StyleFamily -> StyleProperties
    lookupDefaultStyle' Styles
    styleSet) Maybe StyleFamily
    mFamily         )

    type ParaModifier = Blocks -> Blocks

    _MINIMUM_INDENTATION_FOR_BLOCKQUOTES_IN_MM_      :: Int
    _MINIMUM_INDENTATION_FOR_BLOCKQUOTES_IN_PERCENT_ :: Int
    _MINIMUM_INDENTATION_FOR_BLOCKQUOTES_IN_MM_ :: ListLevel
    _MINIMUM_INDENTATION_FOR_BLOCKQUOTES_IN_MM_      = 5
    _MINIMUM_INDENTATION_FOR_BLOCKQUOTES_IN_PERCENT_ :: ListLevel
    _MINIMUM_INDENTATION_FOR_BLOCKQUOTES_IN_PERCENT_ = 5

    -- | Returns either 'id' or 'blockQuote' depending on the current indentation
    getParaModifier :: Style -> ParaModifier
    getParaModifier :: Style -> ParaModifier
    getParaModifier Style{..} | Just props :: ParaProperties
    props <- StyleProperties -> Maybe ParaProperties
    paraProperties StyleProperties
    styleProperties
                              , LengthOrPercent -> LengthOrPercent -> Bool
    isBlockQuote (ParaProperties -> LengthOrPercent
    indentation ParaProperties
    props)
                                             (ParaProperties -> LengthOrPercent
    margin_left ParaProperties
    props)
                              = ParaModifier
    blockQuote
                              | Bool
    otherwise
                              = ParaModifier
    forall a. a -> a
    id
      where
      isBlockQuote :: LengthOrPercent -> LengthOrPercent -> Bool
    isBlockQuote mIndent :: LengthOrPercent
    mIndent mMargin :: LengthOrPercent
    mMargin
        | LengthValueMM indent :: ListLevel
    indent <- LengthOrPercent
    mIndent
        ,  ListLevel
    indent          ListLevel -> ListLevel -> Bool
    forall a. Ord a => a -> a -> Bool
    > ListLevel
    _MINIMUM_INDENTATION_FOR_BLOCKQUOTES_IN_MM_
         = Bool
    True
        | LengthValueMM margin :: ListLevel
    margin <- LengthOrPercent
    mMargin
        ,           ListLevel
    margin ListLevel -> ListLevel -> Bool
    forall a. Ord a => a -> a -> Bool
    > ListLevel
    _MINIMUM_INDENTATION_FOR_BLOCKQUOTES_IN_MM_
         = Bool
    True
        | LengthValueMM indent :: ListLevel
    indent <- LengthOrPercent
    mIndent
        , LengthValueMM margin :: ListLevel
    margin <- LengthOrPercent
    mMargin
         = ListLevel
    indent ListLevel -> ListLevel -> ListLevel
    forall a. Num a => a -> a -> a
    + ListLevel
    margin ListLevel -> ListLevel -> Bool
    forall a. Ord a => a -> a -> Bool
    > ListLevel
    _MINIMUM_INDENTATION_FOR_BLOCKQUOTES_IN_MM_

        | PercentValue  indent :: ListLevel
    indent <- LengthOrPercent
    mIndent
        ,  ListLevel
    indent          ListLevel -> ListLevel -> Bool
    forall a. Ord a => a -> a -> Bool
    > ListLevel
    _MINIMUM_INDENTATION_FOR_BLOCKQUOTES_IN_PERCENT_
         = Bool
    True
        | PercentValue  margin :: ListLevel
    margin <- LengthOrPercent
    mMargin
        ,           ListLevel
    margin ListLevel -> ListLevel -> Bool
    forall a. Ord a => a -> a -> Bool
    > ListLevel
    _MINIMUM_INDENTATION_FOR_BLOCKQUOTES_IN_PERCENT_
         = Bool
    True
        | PercentValue  indent :: ListLevel
    indent <- LengthOrPercent
    mIndent
        , PercentValue  margin :: ListLevel
    margin <- LengthOrPercent
    mMargin
         = ListLevel
    indent ListLevel -> ListLevel -> ListLevel
    forall a. Num a => a -> a -> a
    + ListLevel
    margin ListLevel -> ListLevel -> Bool
    forall a. Ord a => a -> a -> Bool
    > ListLevel
    _MINIMUM_INDENTATION_FOR_BLOCKQUOTES_IN_PERCENT_

        | Bool
    otherwise
         = Bool
    False

    --
    constructPara :: OdtReaderSafe Blocks Blocks -> OdtReaderSafe Blocks Blocks
    constructPara :: OdtReaderSafe Blocks Blocks -> OdtReaderSafe Blocks Blocks
    constructPara reader :: OdtReaderSafe Blocks Blocks
    reader = proc Blocks
    blocks -> do
      Fallible (String, Style)
    fStyle <- OdtReader Blocks (String, Style)
    forall _x. OdtReader _x (String, Style)
    readStyleByName -< Blocks
    blocks
      case Fallible (String, Style)
    fStyle of
        Left   _    -> OdtReaderSafe Blocks Blocks
    reader -< Blocks
    blocks
        Right (styleName :: String
    styleName, _) | String -> Bool
    isTableCaptionStyle String
    styleName -> do
          Blocks
    blocks' <- OdtReaderSafe Blocks Blocks
    reader   -< Blocks
    blocks
          ParaModifier -> OdtReaderSafe Blocks Blocks
    forall (a :: * -> * -> *) b c. Arrow a => (b -> c) -> a b c
    arr ParaModifier
    tableCaptionP  -< Blocks
    blocks'
        Right (_, style :: Style
    style) -> do
          let modifier :: ParaModifier
    modifier = Style -> ParaModifier
    getParaModifier Style
    style
          Blocks
    blocks' <- OdtReaderSafe Blocks Blocks
    reader   -<  Blocks
    blocks
          ParaModifier -> OdtReaderSafe Blocks Blocks
    forall (a :: * -> * -> *) b c. Arrow a => (b -> c) -> a b c
    arr ParaModifier
    modifier        -<< Blocks
    blocks'
      where
        isTableCaptionStyle :: StyleName -> Bool
        isTableCaptionStyle :: String -> Bool
    isTableCaptionStyle "Table" = Bool
    True
        isTableCaptionStyle _       = Bool
    False
        tableCaptionP :: ParaModifier
    tableCaptionP b :: Blocks
    b = Attr -> ParaModifier
    divWith ("", ["caption"], []) Blocks
    b

    type ListConstructor = [Blocks] -> Blocks

    getListConstructor :: ListLevelStyle -> ListConstructor
    getListConstructor :: ListLevelStyle -> ListConstructor
    getListConstructor ListLevelStyle{..} =
      case ListLevelType
    listLevelType of
        LltBullet   -> ListConstructor
    bulletList
        LltImage    -> ListConstructor
    bulletList
        LltNumbered -> let listNumberStyle :: ListNumberStyle
    listNumberStyle = ListItemNumberFormat -> ListNumberStyle
    toListNumberStyle ListItemNumberFormat
    listItemFormat
                           listNumberDelim :: ListNumberDelim
    listNumberDelim = Maybe String -> Maybe String -> ListNumberDelim
    forall a a.
    (Eq a, Eq a, IsString a, IsString a) =>
    Maybe a -> Maybe a -> ListNumberDelim
    toListNumberDelim Maybe String
    listItemPrefix
                                                               Maybe String
    listItemSuffix
                       in  ListAttributes -> ListConstructor
    orderedListWith (ListLevel
    listItemStart, ListNumberStyle
    listNumberStyle, ListNumberDelim
    listNumberDelim)
      where
        toListNumberStyle :: ListItemNumberFormat -> ListNumberStyle
    toListNumberStyle  LinfNone      = ListNumberStyle
    DefaultStyle
        toListNumberStyle  LinfNumber    = ListNumberStyle
    Decimal
        toListNumberStyle  LinfRomanLC   = ListNumberStyle
    LowerRoman
        toListNumberStyle  LinfRomanUC   = ListNumberStyle
    UpperRoman
        toListNumberStyle  LinfAlphaLC   = ListNumberStyle
    LowerAlpha
        toListNumberStyle  LinfAlphaUC   = ListNumberStyle
    UpperAlpha
        toListNumberStyle (LinfString _) = ListNumberStyle
    Example

        toListNumberDelim :: Maybe a -> Maybe a -> ListNumberDelim
    toListNumberDelim  Nothing   (Just ".") = ListNumberDelim
    Period
        toListNumberDelim (Just "" ) (Just ".") = ListNumberDelim
    Period
        toListNumberDelim  Nothing   (Just ")") = ListNumberDelim
    OneParen
        toListNumberDelim (Just "" ) (Just ")") = ListNumberDelim
    OneParen
        toListNumberDelim (Just "(") (Just ")") = ListNumberDelim
    TwoParens
        toListNumberDelim     _          _      = ListNumberDelim
    DefaultDelim

    -- | Determines which style to use for a list, which level to use of that
    -- style, and which type of list to create as a result of this information.
    -- Then prepares the state for eventual child lists and constructs the list from
    -- the results.
    -- Two main cases are handled: The list may provide its own style or it may
    -- rely on a parent list's style. I the former case the current style in the
    -- state must be switched before and after the call to the child converter
    -- while in the latter the child converter can be called directly.
    -- If anything goes wrong, a default ordered-list-constructor is used.
    constructList :: OdtReaderSafe x [Blocks] -> OdtReaderSafe x Blocks
    constructList :: OdtReaderSafe x [Blocks] -> OdtReaderSafe x Blocks
    constructList reader :: OdtReaderSafe x [Blocks]
    reader = proc x
    x -> do
      (ReaderState -> ReaderState) -> OdtReaderSafe () ()
    forall extraState nsID x.
    (extraState -> extraState) -> XMLConverter nsID extraState x x
    modifyExtraState (ListLevel -> ReaderState -> ReaderState
    shiftListLevel 1)        -< ()
      ListLevel
    listLevel  <- OdtReaderSafe () ListLevel
    forall _x. OdtReaderSafe _x ListLevel
    getCurrentListLevel          -< ()
      Fallible String
    fStyleName <- Namespace
    -> String -> FallibleXMLConverter Namespace ReaderState () String
    forall nsID extraState x.
    NameSpaceID nsID =>
    nsID -> String -> FallibleXMLConverter nsID extraState x String
    findAttr Namespace
    NsText "style-name" -< ()
      case Fallible String
    fStyleName of
        Right styleName :: String
    styleName -> do
          Fallible ListStyle
    fListStyle <- OdtReader String ListStyle
    lookupListStyle -< String
    styleName
          case Fallible ListStyle
    fListStyle of
            Right listStyle :: ListStyle
    listStyle -> do
              Maybe ListLevelStyle
    fLLS <- ((ListLevel, ListStyle) -> Maybe ListLevelStyle)
    -> ArrowState
         (XMLConverterState Namespace ReaderState)
         (ListLevel, ListStyle)
         (Maybe ListLevelStyle)
    forall (a :: * -> * -> *) b c. Arrow a => (b -> c) -> a b c
    arr ((ListLevel -> ListStyle -> Maybe ListLevelStyle)
    -> (ListLevel, ListStyle) -> Maybe ListLevelStyle
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry ListLevel -> ListStyle -> Maybe ListLevelStyle
    getListLevelStyle) -< (ListLevel
    listLevel,ListStyle
    listStyle)
              case Maybe ListLevelStyle
    fLLS of
                Just listLevelStyle :: ListLevelStyle
    listLevelStyle -> do
                  Maybe ListStyle
    oldListStyle <- OdtReaderSafe (Maybe ListStyle) (Maybe ListStyle)
    switchCurrentListStyle           -<  ListStyle -> Maybe ListStyle
    forall a. a -> Maybe a
    Just ListStyle
    listStyle
                  Blocks
    blocks       <- ListLevelStyle -> OdtReaderSafe x Blocks
    constructListWith ListLevelStyle
    listLevelStyle -<< x
    x
                  OdtReaderSafe (Maybe ListStyle) (Maybe ListStyle)
    switchCurrentListStyle                           -<  Maybe ListStyle
    oldListStyle
                  OdtReaderSafe Blocks Blocks
    forall (a :: * -> * -> *) b. Arrow a => a b b
    returnA                                          -<  Blocks
    blocks
                Nothing             -> OdtReaderSafe x Blocks
    constructOrderedList        -< x
    x
            Left _                  -> OdtReaderSafe x Blocks
    constructOrderedList        -< x
    x
        Left _ -> do
          ReaderState
    state      <- XMLConverter Namespace ReaderState () ReaderState
    forall nsID extraState x. XMLConverter nsID extraState x extraState
    getExtraState        -< ()
          Maybe ListStyle
    mListStyle <- (ReaderState -> Maybe ListStyle)
    -> ArrowState
         (XMLConverterState Namespace ReaderState)
         ReaderState
         (Maybe ListStyle)
    forall (a :: * -> * -> *) b c. Arrow a => (b -> c) -> a b c
    arr ReaderState -> Maybe ListStyle
    currentListStyle -< ReaderState
    state
          case Maybe ListStyle
    mListStyle of
            Just listStyle :: ListStyle
    listStyle -> do
              Maybe ListLevelStyle
    fLLS <- ((ListLevel, ListStyle) -> Maybe ListLevelStyle)
    -> ArrowState
         (XMLConverterState Namespace ReaderState)
         (ListLevel, ListStyle)
         (Maybe ListLevelStyle)
    forall (a :: * -> * -> *) b c. Arrow a => (b -> c) -> a b c
    arr ((ListLevel -> ListStyle -> Maybe ListLevelStyle)
    -> (ListLevel, ListStyle) -> Maybe ListLevelStyle
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry ListLevel -> ListStyle -> Maybe ListLevelStyle
    getListLevelStyle) -< (ListLevel
    listLevel,ListStyle
    listStyle)
              case Maybe ListLevelStyle
    fLLS of
                Just listLevelStyle :: ListLevelStyle
    listLevelStyle -> ListLevelStyle -> OdtReaderSafe x Blocks
    constructListWith ListLevelStyle
    listLevelStyle -<< x
    x
                Nothing             -> OdtReaderSafe x Blocks
    constructOrderedList             -<  x
    x
            Nothing                 -> OdtReaderSafe x Blocks
    constructOrderedList             -<  x
    x
      where
        constructOrderedList :: OdtReaderSafe x Blocks
    constructOrderedList =
              OdtReaderSafe x [Blocks]
    reader
          OdtReaderSafe x [Blocks]
    -> ArrowState
         (XMLConverterState Namespace ReaderState) [Blocks] Blocks
    -> OdtReaderSafe x Blocks
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>> (ReaderState -> ReaderState)
    -> XMLConverter Namespace ReaderState [Blocks] [Blocks]
    forall extraState nsID x.
    (extraState -> extraState) -> XMLConverter nsID extraState x x
    modifyExtraState (ListLevel -> ReaderState -> ReaderState
    shiftListLevel (-1))
          XMLConverter Namespace ReaderState [Blocks] [Blocks]
    -> ListConstructor
    -> ArrowState
         (XMLConverterState Namespace ReaderState) [Blocks] Blocks
    forall (a :: * -> * -> *) b c d.
    Arrow a =>
    a b c -> (c -> d) -> a b d
    >>^ ListConstructor
    orderedList
        constructListWith :: ListLevelStyle -> OdtReaderSafe x Blocks
    constructListWith listLevelStyle :: ListLevelStyle
    listLevelStyle =
              OdtReaderSafe x [Blocks]
    reader
          OdtReaderSafe x [Blocks]
    -> ArrowState
         (XMLConverterState Namespace ReaderState) [Blocks] Blocks
    -> OdtReaderSafe x Blocks
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>> ListLevelStyle -> ListConstructor
    getListConstructor ListLevelStyle
    listLevelStyle
          ListConstructor
    -> OdtReaderSafe Blocks Blocks
    -> ArrowState
         (XMLConverterState Namespace ReaderState) [Blocks] Blocks
    forall (a :: * -> * -> *) b c d.
    Arrow a =>
    (b -> c) -> a c d -> a b d
    ^>> (ReaderState -> ReaderState) -> OdtReaderSafe Blocks Blocks
    forall extraState nsID x.
    (extraState -> extraState) -> XMLConverter nsID extraState x x
    modifyExtraState (ListLevel -> ReaderState -> ReaderState
    shiftListLevel (-1))

    --------------------------------------------------------------------------------
    -- Readers
    --------------------------------------------------------------------------------

    type ElementMatcher result = (Namespace, ElementName, OdtReader result result)

    type InlineMatcher = ElementMatcher Inlines

    type BlockMatcher  = ElementMatcher Blocks

    newtype FirstMatch a = FirstMatch (Option (First a))
                         deriving (FirstMatch a -> Bool
    (a -> m) -> FirstMatch a -> m
    (a -> b -> b) -> b -> FirstMatch a -> b
    (forall m. Monoid m => FirstMatch m -> m)
    -> (forall m a. Monoid m => (a -> m) -> FirstMatch a -> m)
    -> (forall m a. Monoid m => (a -> m) -> FirstMatch a -> m)
    -> (forall a b. (a -> b -> b) -> b -> FirstMatch a -> b)
    -> (forall a b. (a -> b -> b) -> b -> FirstMatch a -> b)
    -> (forall b a. (b -> a -> b) -> b -> FirstMatch a -> b)
    -> (forall b a. (b -> a -> b) -> b -> FirstMatch a -> b)
    -> (forall a. (a -> a -> a) -> FirstMatch a -> a)
    -> (forall a. (a -> a -> a) -> FirstMatch a -> a)
    -> (forall a. FirstMatch a -> [a])
    -> (forall a. FirstMatch a -> Bool)
    -> (forall a. FirstMatch a -> ListLevel)
    -> (forall a. Eq a => a -> FirstMatch a -> Bool)
    -> (forall a. Ord a => FirstMatch a -> a)
    -> (forall a. Ord a => FirstMatch a -> a)
    -> (forall a. Num a => FirstMatch a -> a)
    -> (forall a. Num a => FirstMatch a -> a)
    -> Foldable FirstMatch
    forall a. Eq a => a -> FirstMatch a -> Bool
    forall a. Num a => FirstMatch a -> a
    forall a. Ord a => FirstMatch a -> a
    forall m. Monoid m => FirstMatch m -> m
    forall a. FirstMatch a -> Bool
    forall a. FirstMatch a -> ListLevel
    forall a. FirstMatch a -> [a]
    forall a. (a -> a -> a) -> FirstMatch a -> a
    forall m a. Monoid m => (a -> m) -> FirstMatch a -> m
    forall b a. (b -> a -> b) -> b -> FirstMatch a -> b
    forall a b. (a -> b -> b) -> b -> FirstMatch a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> ListLevel)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    product :: FirstMatch a -> a
    $cproduct :: forall a. Num a => FirstMatch a -> a
    sum :: FirstMatch a -> a
    $csum :: forall a. Num a => FirstMatch a -> a
    minimum :: FirstMatch a -> a
    $cminimum :: forall a. Ord a => FirstMatch a -> a
    maximum :: FirstMatch a -> a
    $cmaximum :: forall a. Ord a => FirstMatch a -> a
    elem :: a -> FirstMatch a -> Bool
    $celem :: forall a. Eq a => a -> FirstMatch a -> Bool
    length :: FirstMatch a -> ListLevel
    $clength :: forall a. FirstMatch a -> ListLevel
    null :: FirstMatch a -> Bool
    $cnull :: forall a. FirstMatch a -> Bool
    toList :: FirstMatch a -> [a]
    $ctoList :: forall a. FirstMatch a -> [a]
    foldl1 :: (a -> a -> a) -> FirstMatch a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> FirstMatch a -> a
    foldr1 :: (a -> a -> a) -> FirstMatch a -> a
    $cfoldr1 :: forall a. (a -> a -> a) -> FirstMatch a -> a
    foldl' :: (b -> a -> b) -> b -> FirstMatch a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> FirstMatch a -> b
    foldl :: (b -> a -> b) -> b -> FirstMatch a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> FirstMatch a -> b
    foldr' :: (a -> b -> b) -> b -> FirstMatch a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> FirstMatch a -> b
    foldr :: (a -> b -> b) -> b -> FirstMatch a -> b
    $cfoldr :: forall a b. (a -> b -> b) -> b -> FirstMatch a -> b
    foldMap' :: (a -> m) -> FirstMatch a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> FirstMatch a -> m
    foldMap :: (a -> m) -> FirstMatch a -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> FirstMatch a -> m
    fold :: FirstMatch m -> m
    $cfold :: forall m. Monoid m => FirstMatch m -> m
    Foldable, Semigroup (FirstMatch a)
    FirstMatch a
    Semigroup (FirstMatch a) =>
    FirstMatch a
    -> (FirstMatch a -> FirstMatch a -> FirstMatch a)
    -> ([FirstMatch a] -> FirstMatch a)
    -> Monoid (FirstMatch a)
    [FirstMatch a] -> FirstMatch a
    FirstMatch a -> FirstMatch a -> FirstMatch a
    forall a. Semigroup (FirstMatch a)
    forall a. FirstMatch a
    forall a.
    Semigroup a =>
    a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
    forall a. [FirstMatch a] -> FirstMatch a
    forall a. FirstMatch a -> FirstMatch a -> FirstMatch a
    mconcat :: [FirstMatch a] -> FirstMatch a
    $cmconcat :: forall a. [FirstMatch a] -> FirstMatch a
    mappend :: FirstMatch a -> FirstMatch a -> FirstMatch a
    $cmappend :: forall a. FirstMatch a -> FirstMatch a -> FirstMatch a
    mempty :: FirstMatch a
    $cmempty :: forall a. FirstMatch a
    $cp1Monoid :: forall a. Semigroup (FirstMatch a)
    Monoid, b -> FirstMatch a -> FirstMatch a
    NonEmpty (FirstMatch a) -> FirstMatch a
    FirstMatch a -> FirstMatch a -> FirstMatch a
    (FirstMatch a -> FirstMatch a -> FirstMatch a)
    -> (NonEmpty (FirstMatch a) -> FirstMatch a)
    -> (forall b. Integral b => b -> FirstMatch a -> FirstMatch a)
    -> Semigroup (FirstMatch a)
    forall b. Integral b => b -> FirstMatch a -> FirstMatch a
    forall a. NonEmpty (FirstMatch a) -> FirstMatch a
    forall a. FirstMatch a -> FirstMatch a -> FirstMatch a
    forall a.
    (a -> a -> a)
    -> (NonEmpty a -> a)
    -> (forall b. Integral b => b -> a -> a)
    -> Semigroup a
    forall a b. Integral b => b -> FirstMatch a -> FirstMatch a
    stimes :: b -> FirstMatch a -> FirstMatch a
    $cstimes :: forall a b. Integral b => b -> FirstMatch a -> FirstMatch a
    sconcat :: NonEmpty (FirstMatch a) -> FirstMatch a
    $csconcat :: forall a. NonEmpty (FirstMatch a) -> FirstMatch a
    <> :: FirstMatch a -> FirstMatch a -> FirstMatch a
    $c<> :: forall a. FirstMatch a -> FirstMatch a -> FirstMatch a
    Semigroup)

    firstMatch :: a -> FirstMatch a
    firstMatch :: a -> FirstMatch a
    firstMatch = Option (First a) -> FirstMatch a
    forall a. Option (First a) -> FirstMatch a
    FirstMatch (Option (First a) -> FirstMatch a)
    -> (a -> Option (First a)) -> a -> FirstMatch a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Maybe (First a) -> Option (First a)
    forall a. Maybe a -> Option a
    Option (Maybe (First a) -> Option (First a))
    -> (a -> Maybe (First a)) -> a -> Option (First a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . First a -> Maybe (First a)
    forall a. a -> Maybe a
    Just (First a -> Maybe (First a))
    -> (a -> First a) -> a -> Maybe (First a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> First a
    forall a. a -> First a
    First

    --
    matchingElement :: (Monoid e)
                    => Namespace -> ElementName
                    -> OdtReaderSafe  e e
                    -> ElementMatcher e
    matchingElement :: Namespace -> String -> OdtReaderSafe e e -> ElementMatcher e
    matchingElement ns :: Namespace
    ns name :: String
    name reader :: OdtReaderSafe e e
    reader = (Namespace
    ns, String
    name, OdtReaderSafe e e
    -> ArrowState
         (XMLConverterState Namespace ReaderState) e (Fallible e)
    forall (a :: * -> * -> *) m.
    (ArrowChoice a, Monoid m) =>
    a m m -> a m (Fallible m)
    asResultAccumulator OdtReaderSafe e e
    reader)
      where
       asResultAccumulator :: (ArrowChoice a, Monoid m) => a m m -> a m (Fallible m)
       asResultAccumulator :: a m m -> a m (Fallible m)
    asResultAccumulator a :: a m m
    a = a m m -> a m (Fallible m)
    forall (a :: * -> * -> *) x success failure.
    ArrowChoice a =>
    a x success -> FallibleArrow a x failure success
    liftAsSuccess (a m m -> a m (Fallible m)) -> a m m -> a m (Fallible m)
    forall a b. (a -> b) -> a -> b
    $ a m m -> a m (m, m)
    forall (a :: * -> * -> *) b c. Arrow a => a b c -> a b (b, c)
    keepingTheValue a m m
    a a m (m, m) -> (m -> m -> m) -> a m m
    forall (a :: * -> * -> *) x b c d.
    Arrow a =>
    a x (b, c) -> (b -> c -> d) -> a x d
    >>% m -> m -> m
    forall a. Monoid a => a -> a -> a
    mappend

    --
    matchChildContent'   :: (Monoid result)
                         => [ElementMatcher result]
                         ->  OdtReaderSafe _x result
    matchChildContent' :: [ElementMatcher result] -> OdtReaderSafe _x result
    matchChildContent' ls :: [ElementMatcher result]
    ls = result -> OdtReaderSafe _x result
    forall (a :: * -> * -> *) c x. Arrow a => c -> a x c
    returnV result
    forall a. Monoid a => a
    mempty OdtReaderSafe _x result
    -> ArrowState
         (XMLConverterState Namespace ReaderState) result result
    -> OdtReaderSafe _x result
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>> [ElementMatcher result]
    -> ArrowState
         (XMLConverterState Namespace ReaderState) result result
    forall nsID extraState a.
    NameSpaceID nsID =>
    [(nsID, String, FallibleXMLConverter nsID extraState a a)]
    -> XMLConverter nsID extraState a a
    matchContent' [ElementMatcher result]
    ls

    --
    matchChildContent    :: (Monoid result)
                         => [ElementMatcher result]
                         ->  OdtReaderSafe  (result, XML.Content) result
                         ->  OdtReaderSafe _x result
    matchChildContent :: [ElementMatcher result]
    -> OdtReaderSafe (result, Content) result
    -> OdtReaderSafe _x result
    matchChildContent ls :: [ElementMatcher result]
    ls fallback :: OdtReaderSafe (result, Content) result
    fallback = result -> OdtReaderSafe _x result
    forall (a :: * -> * -> *) c x. Arrow a => c -> a x c
    returnV result
    forall a. Monoid a => a
    mempty OdtReaderSafe _x result
    -> ArrowState
         (XMLConverterState Namespace ReaderState) result result
    -> OdtReaderSafe _x result
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>> [ElementMatcher result]
    -> OdtReaderSafe (result, Content) result
    -> ArrowState
         (XMLConverterState Namespace ReaderState) result result
    forall nsID extraState a.
    NameSpaceID nsID =>
    [(nsID, String, FallibleXMLConverter nsID extraState a a)]
    -> XMLConverter nsID extraState (a, Content) a
    -> XMLConverter nsID extraState a a
    matchContent [ElementMatcher result]
    ls OdtReaderSafe (result, Content) result
    fallback

    --------------------------------------------
    -- Matchers
    --------------------------------------------

    ----------------------
    -- Basics
    ----------------------

    --
    -- | Open Document allows several consecutive spaces if they are marked up
    read_plain_text :: OdtReaderSafe (Inlines, XML.Content) Inlines
    read_plain_text :: OdtReaderSafe (Inlines, Content) Inlines
    read_plain_text =  (Inlines, Content) -> Inlines
    forall a b. (a, b) -> a
    fst ((Inlines, Content) -> Inlines)
    -> ArrowState
         (XMLConverterState Namespace ReaderState)
         (Inlines, Content)
         (Fallible Inlines)
    -> ArrowState
         (XMLConverterState Namespace ReaderState)
         (Inlines, Content)
         (Inlines, Fallible Inlines)
    forall (a :: * -> * -> *) b c c'.
    Arrow a =>
    (b -> c) -> a b c' -> a b (c, c')
    ^&&& ArrowState
      (XMLConverterState Namespace ReaderState)
      (Inlines, Content)
      (Fallible Inlines)
    read_plain_text' ArrowState
      (XMLConverterState Namespace ReaderState)
      (Inlines, Content)
      (Inlines, Fallible Inlines)
    -> (Inlines -> Fallible Inlines -> Inlines)
    -> OdtReaderSafe (Inlines, Content) Inlines
    forall (a :: * -> * -> *) x b c d.
    Arrow a =>
    a x (b, c) -> (b -> c -> d) -> a x d
    >>% Inlines -> Fallible Inlines -> Inlines
    forall a _f. a -> Either _f a -> a
    recover
      where
        -- fallible version
        read_plain_text' :: OdtReader (Inlines, XML.Content) Inlines
        read_plain_text' :: ArrowState
      (XMLConverterState Namespace ReaderState)
      (Inlines, Content)
      (Fallible Inlines)
    read_plain_text' =      (     ArrowState
      (XMLConverterState Namespace ReaderState) Content (Fallible Anchor)
    -> ArrowState
         (XMLConverterState Namespace ReaderState)
         (Inlines, Content)
         (Inlines, Fallible Anchor)
    forall (a :: * -> * -> *) b c d.
    Arrow a =>
    a b c -> a (d, b) (d, c)
    second ( (Content -> Fallible Anchor)
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Content (Fallible Anchor)
    forall (a :: * -> * -> *) b c. Arrow a => (b -> c) -> a b c
    arr Content -> Fallible Anchor
    extractText )
                                  ArrowState
      (XMLConverterState Namespace ReaderState)
      (Inlines, Content)
      (Inlines, Fallible Anchor)
    -> ((Inlines, Fallible Anchor) -> Either () (Inlines, Inlines))
    -> ArrowState
         (XMLConverterState Namespace ReaderState)
         (Inlines, Content)
         (Either () (Inlines, Inlines))
    forall (a :: * -> * -> *) b c d.
    Arrow a =>
    a b c -> (c -> d) -> a b d
    >>^ (Inlines, Fallible Anchor) -> Either () (Inlines, Anchor)
    forall (v :: * -> *) f a.
    ChoiceVector v =>
    v (Either f a) -> Either f (v a)
    spreadChoice ((Inlines, Fallible Anchor) -> Either () (Inlines, Anchor))
    -> ((Inlines, Anchor) -> (Inlines, Inlines))
    -> (Inlines, Fallible Anchor)
    -> Either () (Inlines, Inlines)
    forall (a :: * -> * -> *) x failure success success'.
    ArrowChoice a =>
    FallibleArrow a x failure success
    -> a success success' -> FallibleArrow a x failure success'
    >>?! (Anchor -> Inlines) -> (Inlines, Anchor) -> (Inlines, Inlines)
    forall (a :: * -> * -> *) b c d.
    Arrow a =>
    a b c -> a (d, b) (d, c)
    second Anchor -> Inlines
    text
                                )
                           ArrowState
      (XMLConverterState Namespace ReaderState)
      (Inlines, Content)
      (Either () (Inlines, Inlines))
    -> (Inlines -> Inlines -> Inlines)
    -> ArrowState
         (XMLConverterState Namespace ReaderState)
         (Inlines, Content)
         (Fallible Inlines)
    forall (a :: * -> * -> *) x f b b' c.
    ArrowChoice a =>
    FallibleArrow a x f (b, b')
    -> (b -> b' -> c) -> FallibleArrow a x f c
    >>?% Inlines -> Inlines -> Inlines
    forall a. Monoid a => a -> a -> a
    mappend
        --
        extractText     :: XML.Content -> Fallible T.Text
        extractText :: Content -> Fallible Anchor
    extractText (XML.Text cData :: CData
    cData) = Anchor -> Fallible Anchor
    forall a _x. a -> Either _x a
    succeedWith (String -> Anchor
    T.pack (String -> Anchor) -> String -> Anchor
    forall a b. (a -> b) -> a -> b
    $ CData -> String
    XML.cdData CData
    cData)
        extractText         _        = Fallible Anchor
    forall failure _x. Monoid failure => Either failure _x
    failEmpty

    read_text_seq :: InlineMatcher
    read_text_seq :: InlineMatcher
    read_text_seq  = Namespace
    -> String
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    -> InlineMatcher
    forall e.
    Monoid e =>
    Namespace -> String -> OdtReaderSafe e e -> ElementMatcher e
    matchingElement Namespace
    NsText "sequence"
                     (ArrowState
       (XMLConverterState Namespace ReaderState) Inlines Inlines
     -> InlineMatcher)
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    -> InlineMatcher
    forall a b. (a -> b) -> a -> b
    $ [InlineMatcher]
    -> OdtReaderSafe (Inlines, Content) Inlines
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    forall result _x.
    Monoid result =>
    [ElementMatcher result]
    -> OdtReaderSafe (result, Content) result
    -> OdtReaderSafe _x result
    matchChildContent [] OdtReaderSafe (Inlines, Content) Inlines
    read_plain_text

    -- specifically. I honor that, although the current implementation of 'mappend'
    -- for 'Inlines' in "Text.Pandoc.Builder" will collapse them again.
    -- The rational is to be prepared for future modifications.
    read_spaces      :: InlineMatcher
    read_spaces :: InlineMatcher
    read_spaces       = Namespace
    -> String
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    -> InlineMatcher
    forall e.
    Monoid e =>
    Namespace -> String -> OdtReaderSafe e e -> ElementMatcher e
    matchingElement Namespace
    NsText "s" (
                              Namespace
    -> String
    -> ListLevel
    -> XMLConverter Namespace ReaderState Inlines ListLevel
    forall nsID attrValue extraState x.
    (NameSpaceID nsID, Read attrValue) =>
    nsID
    -> String -> attrValue -> XMLConverter nsID extraState x attrValue
    readAttrWithDefault Namespace
    NsText "c" 1 -- how many spaces?
                          XMLConverter Namespace ReaderState Inlines ListLevel
    -> (ListLevel -> Inlines)
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    forall (a :: * -> * -> *) b c d.
    Arrow a =>
    a b c -> (c -> d) -> a b d
    >>^ [Inline] -> Inlines
    forall a. [a] -> Many a
    fromList([Inline] -> Inlines)
    -> (ListLevel -> [Inline]) -> ListLevel -> Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .(ListLevel -> Inline -> [Inline]
    forall a. ListLevel -> a -> [a]
    `replicate` Inline
    Space)
                        )
    --
    read_line_break  :: InlineMatcher
    read_line_break :: InlineMatcher
    read_line_break   = Namespace
    -> String
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    -> InlineMatcher
    forall e.
    Monoid e =>
    Namespace -> String -> OdtReaderSafe e e -> ElementMatcher e
    matchingElement Namespace
    NsText "line-break"
                        (ArrowState
       (XMLConverterState Namespace ReaderState) Inlines Inlines
     -> InlineMatcher)
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    -> InlineMatcher
    forall a b. (a -> b) -> a -> b
    $ Inlines
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    forall (a :: * -> * -> *) c x. Arrow a => c -> a x c
    returnV Inlines
    linebreak

    --
    read_span        :: InlineMatcher
    read_span :: InlineMatcher
    read_span         = Namespace
    -> String
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    -> InlineMatcher
    forall e.
    Monoid e =>
    Namespace -> String -> OdtReaderSafe e e -> ElementMatcher e
    matchingElement Namespace
    NsText "span"
                        (ArrowState
       (XMLConverterState Namespace ReaderState) Inlines Inlines
     -> InlineMatcher)
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    -> InlineMatcher
    forall a b. (a -> b) -> a -> b
    $ ArrowState
      (XMLConverterState Namespace ReaderState) Inlines Inlines
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    forall x. OdtReaderSafe x Inlines -> OdtReaderSafe x Inlines
    withNewStyle
                        (ArrowState
       (XMLConverterState Namespace ReaderState) Inlines Inlines
     -> ArrowState
          (XMLConverterState Namespace ReaderState) Inlines Inlines)
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    forall a b. (a -> b) -> a -> b
    $ [InlineMatcher]
    -> OdtReaderSafe (Inlines, Content) Inlines
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    forall result _x.
    Monoid result =>
    [ElementMatcher result]
    -> OdtReaderSafe (result, Content) result
    -> OdtReaderSafe _x result
    matchChildContent [ InlineMatcher
    read_span
                                            , InlineMatcher
    read_spaces
                                            , InlineMatcher
    read_line_break
                                            , InlineMatcher
    read_link
                                            , InlineMatcher
    read_note
                                            , InlineMatcher
    read_citation
                                            , InlineMatcher
    read_bookmark
                                            , InlineMatcher
    read_bookmark_start
                                            , InlineMatcher
    read_reference_start
                                            , InlineMatcher
    read_bookmark_ref
                                            , InlineMatcher
    read_reference_ref
                                            ] OdtReaderSafe (Inlines, Content) Inlines
    read_plain_text

    --
    read_paragraph   :: BlockMatcher
    read_paragraph :: BlockMatcher
    read_paragraph    = Namespace -> String -> OdtReaderSafe Blocks Blocks -> BlockMatcher
    forall e.
    Monoid e =>
    Namespace -> String -> OdtReaderSafe e e -> ElementMatcher e
    matchingElement Namespace
    NsText "p"
                        (OdtReaderSafe Blocks Blocks -> BlockMatcher)
    -> OdtReaderSafe Blocks Blocks -> BlockMatcher
    forall a b. (a -> b) -> a -> b
    $ OdtReaderSafe Blocks Blocks -> OdtReaderSafe Blocks Blocks
    constructPara
                        (OdtReaderSafe Blocks Blocks -> OdtReaderSafe Blocks Blocks)
    -> OdtReaderSafe Blocks Blocks -> OdtReaderSafe Blocks Blocks
    forall a b. (a -> b) -> a -> b
    $ (Inlines -> Blocks)
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Blocks Inlines
    -> OdtReaderSafe Blocks Blocks
    forall (a :: * -> * -> *) y z b.
    Arrow a =>
    (y -> z) -> a b y -> a b z
    liftA Inlines -> Blocks
    para
                        (ArrowState
       (XMLConverterState Namespace ReaderState) Blocks Inlines
     -> OdtReaderSafe Blocks Blocks)
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Blocks Inlines
    -> OdtReaderSafe Blocks Blocks
    forall a b. (a -> b) -> a -> b
    $ ArrowState (XMLConverterState Namespace ReaderState) Blocks Inlines
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Blocks Inlines
    forall x. OdtReaderSafe x Inlines -> OdtReaderSafe x Inlines
    withNewStyle
                        (ArrowState
       (XMLConverterState Namespace ReaderState) Blocks Inlines
     -> ArrowState
          (XMLConverterState Namespace ReaderState) Blocks Inlines)
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Blocks Inlines
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Blocks Inlines
    forall a b. (a -> b) -> a -> b
    $ [InlineMatcher]
    -> OdtReaderSafe (Inlines, Content) Inlines
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Blocks Inlines
    forall result _x.
    Monoid result =>
    [ElementMatcher result]
    -> OdtReaderSafe (result, Content) result
    -> OdtReaderSafe _x result
    matchChildContent [ InlineMatcher
    read_span
                                            , InlineMatcher
    read_spaces
                                            , InlineMatcher
    read_line_break
                                            , InlineMatcher
    read_link
                                            , InlineMatcher
    read_note
                                            , InlineMatcher
    read_citation
                                            , InlineMatcher
    read_bookmark
                                            , InlineMatcher
    read_bookmark_start
                                            , InlineMatcher
    read_reference_start
                                            , InlineMatcher
    read_bookmark_ref
                                            , InlineMatcher
    read_reference_ref
                                            , InlineMatcher
    read_frame
                                            , InlineMatcher
    read_text_seq
                                            ] OdtReaderSafe (Inlines, Content) Inlines
    read_plain_text

    ----------------------
    -- Headers
    ----------------------

    --
    read_header      :: BlockMatcher
    read_header :: BlockMatcher
    read_header       = Namespace -> String -> OdtReaderSafe Blocks Blocks -> BlockMatcher
    forall e.
    Monoid e =>
    Namespace -> String -> OdtReaderSafe e e -> ElementMatcher e
    matchingElement Namespace
    NsText "h"
                        (OdtReaderSafe Blocks Blocks -> BlockMatcher)
    -> OdtReaderSafe Blocks Blocks -> BlockMatcher
    forall a b. (a -> b) -> a -> b
    $  proc Blocks
    blocks -> do
      ListLevel
    level    <- ( Namespace
    -> String
    -> ListLevel
    -> XMLConverter Namespace ReaderState Blocks ListLevel
    forall nsID attrValue extraState x.
    (NameSpaceID nsID, Read attrValue) =>
    nsID
    -> String -> attrValue -> XMLConverter nsID extraState x attrValue
    readAttrWithDefault Namespace
    NsText "outline-level" 1
                  ) -< Blocks
    blocks
      Inlines
    children <- ( [InlineMatcher]
    -> OdtReaderSafe (Inlines, Content) Inlines
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Blocks Inlines
    forall result _x.
    Monoid result =>
    [ElementMatcher result]
    -> OdtReaderSafe (result, Content) result
    -> OdtReaderSafe _x result
    matchChildContent [ InlineMatcher
    read_span
                                      , InlineMatcher
    read_spaces
                                      , InlineMatcher
    read_line_break
                                      , InlineMatcher
    read_link
                                      , InlineMatcher
    read_note
                                      , InlineMatcher
    read_citation
                                      , InlineMatcher
    read_bookmark
                                      , InlineMatcher
    read_bookmark_start
                                      , InlineMatcher
    read_reference_start
                                      , InlineMatcher
    read_bookmark_ref
                                      , InlineMatcher
    read_reference_ref
                                      , InlineMatcher
    read_frame
                                      ] OdtReaderSafe (Inlines, Content) Inlines
    read_plain_text
                  ) -< Blocks
    blocks
      Anchor
    anchor   <- OdtReaderSafe Inlines Anchor
    getHeaderAnchor -< Inlines
    children
      let idAttr :: (Anchor, [a], [a])
    idAttr = (Anchor
    anchor, [], []) -- no classes, no key-value pairs
      ((Attr, ListLevel, Inlines) -> Blocks)
    -> ArrowState
         (XMLConverterState Namespace ReaderState)
         (Attr, ListLevel, Inlines)
         Blocks
    forall (a :: * -> * -> *) b c. Arrow a => (b -> c) -> a b c
    arr ((Attr -> ListLevel -> Inlines -> Blocks)
    -> (Attr, ListLevel, Inlines) -> Blocks
    forall a b c z. (a -> b -> c -> z) -> (a, b, c) -> z
    uncurry3 Attr -> ListLevel -> Inlines -> Blocks
    headerWith) -< (Attr
    forall a a. (Anchor, [a], [a])
    idAttr, ListLevel
    level, Inlines
    children)

    ----------------------
    -- Lists
    ----------------------

    --
    read_list        :: BlockMatcher
    read_list :: BlockMatcher
    read_list         = Namespace -> String -> OdtReaderSafe Blocks Blocks -> BlockMatcher
    forall e.
    Monoid e =>
    Namespace -> String -> OdtReaderSafe e e -> ElementMatcher e
    matchingElement Namespace
    NsText "list"
    --                  $ withIncreasedListLevel
                        (OdtReaderSafe Blocks Blocks -> BlockMatcher)
    -> OdtReaderSafe Blocks Blocks -> BlockMatcher
    forall a b. (a -> b) -> a -> b
    $ OdtReaderSafe Blocks [Blocks] -> OdtReaderSafe Blocks Blocks
    forall x. OdtReaderSafe x [Blocks] -> OdtReaderSafe x Blocks
    constructList
    --                  $ liftA bulletList
                        (OdtReaderSafe Blocks [Blocks] -> OdtReaderSafe Blocks Blocks)
    -> OdtReaderSafe Blocks [Blocks] -> OdtReaderSafe Blocks Blocks
    forall a b. (a -> b) -> a -> b
    $ [ElementMatcher [Blocks]] -> OdtReaderSafe Blocks [Blocks]
    forall result _x.
    Monoid result =>
    [ElementMatcher result] -> OdtReaderSafe _x result
    matchChildContent' [ ElementMatcher [Blocks]
    read_list_item
                                             ]
    --
    read_list_item   :: ElementMatcher [Blocks]
    read_list_item :: ElementMatcher [Blocks]
    read_list_item    = Namespace
    -> String
    -> XMLConverter Namespace ReaderState [Blocks] [Blocks]
    -> ElementMatcher [Blocks]
    forall e.
    Monoid e =>
    Namespace -> String -> OdtReaderSafe e e -> ElementMatcher e
    matchingElement Namespace
    NsText "list-item"
                        (XMLConverter Namespace ReaderState [Blocks] [Blocks]
     -> ElementMatcher [Blocks])
    -> XMLConverter Namespace ReaderState [Blocks] [Blocks]
    -> ElementMatcher [Blocks]
    forall a b. (a -> b) -> a -> b
    $ (Blocks -> [Blocks])
    -> ArrowState
         (XMLConverterState Namespace ReaderState) [Blocks] Blocks
    -> XMLConverter Namespace ReaderState [Blocks] [Blocks]
    forall (a :: * -> * -> *) y z b.
    Arrow a =>
    (y -> z) -> a b y -> a b z
    liftA ([Blocks] -> [Blocks]
    compactify([Blocks] -> [Blocks])
    -> (Blocks -> [Blocks]) -> Blocks -> [Blocks]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .(Blocks -> [Blocks] -> [Blocks]
    forall a. a -> [a] -> [a]
    :[]))
                          ( [BlockMatcher]
    -> ArrowState
         (XMLConverterState Namespace ReaderState) [Blocks] Blocks
    forall result _x.
    Monoid result =>
    [ElementMatcher result] -> OdtReaderSafe _x result
    matchChildContent' [ BlockMatcher
    read_paragraph
                                               , BlockMatcher
    read_header
                                               , BlockMatcher
    read_list
                                               ]
                          )

    ----------------------
    -- Links
    ----------------------

    read_link        :: InlineMatcher
    read_link :: InlineMatcher
    read_link         = Namespace
    -> String
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    -> InlineMatcher
    forall e.
    Monoid e =>
    Namespace -> String -> OdtReaderSafe e e -> ElementMatcher e
    matchingElement Namespace
    NsText "a"
                        (ArrowState
       (XMLConverterState Namespace ReaderState) Inlines Inlines
     -> InlineMatcher)
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    -> InlineMatcher
    forall a b. (a -> b) -> a -> b
    $ (Anchor -> Anchor -> Inlines -> Inlines)
    -> OdtReaderSafe Inlines Anchor
    -> OdtReaderSafe Inlines Anchor
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    forall (a :: * -> * -> *) z y x r b.
    Arrow a =>
    (z -> y -> x -> r) -> a b z -> a b y -> a b x -> a b r
    liftA3 Anchor -> Anchor -> Inlines -> Inlines
    link
                          ( Namespace -> String -> Anchor -> OdtReaderSafe Inlines Anchor
    forall nsID extraState x.
    NameSpaceID nsID =>
    nsID -> String -> Anchor -> XMLConverter nsID extraState x Anchor
    findAttrTextWithDefault Namespace
    NsXLink  "href"  ""          )
                          ( Namespace -> String -> Anchor -> OdtReaderSafe Inlines Anchor
    forall nsID extraState x.
    NameSpaceID nsID =>
    nsID -> String -> Anchor -> XMLConverter nsID extraState x Anchor
    findAttrTextWithDefault Namespace
    NsOffice "title" ""          )
                          ( [InlineMatcher]
    -> OdtReaderSafe (Inlines, Content) Inlines
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    forall result _x.
    Monoid result =>
    [ElementMatcher result]
    -> OdtReaderSafe (result, Content) result
    -> OdtReaderSafe _x result
    matchChildContent [ InlineMatcher
    read_span
                                              , InlineMatcher
    read_note
                                              , InlineMatcher
    read_citation
                                              , InlineMatcher
    read_bookmark
                                              , InlineMatcher
    read_bookmark_start
                                              , InlineMatcher
    read_reference_start
                                              , InlineMatcher
    read_bookmark_ref
                                              , InlineMatcher
    read_reference_ref
                                              ] OdtReaderSafe (Inlines, Content) Inlines
    read_plain_text                  )

    -------------------------
    -- Footnotes
    -------------------------

    read_note        :: InlineMatcher
    read_note :: InlineMatcher
    read_note         = Namespace
    -> String
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    -> InlineMatcher
    forall e.
    Monoid e =>
    Namespace -> String -> OdtReaderSafe e e -> ElementMatcher e
    matchingElement Namespace
    NsText "note"
                        (ArrowState
       (XMLConverterState Namespace ReaderState) Inlines Inlines
     -> InlineMatcher)
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    -> InlineMatcher
    forall a b. (a -> b) -> a -> b
    $ (Blocks -> Inlines)
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Blocks
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    forall (a :: * -> * -> *) y z b.
    Arrow a =>
    (y -> z) -> a b y -> a b z
    liftA Blocks -> Inlines
    note
                        (ArrowState
       (XMLConverterState Namespace ReaderState) Inlines Blocks
     -> ArrowState
          (XMLConverterState Namespace ReaderState) Inlines Inlines)
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Blocks
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    forall a b. (a -> b) -> a -> b
    $ [BlockMatcher]
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Blocks
    forall result _x.
    Monoid result =>
    [ElementMatcher result] -> OdtReaderSafe _x result
    matchChildContent' [ BlockMatcher
    read_note_body ]

    read_note_body   :: BlockMatcher
    read_note_body :: BlockMatcher
    read_note_body    = Namespace -> String -> OdtReaderSafe Blocks Blocks -> BlockMatcher
    forall e.
    Monoid e =>
    Namespace -> String -> OdtReaderSafe e e -> ElementMatcher e
    matchingElement Namespace
    NsText "note-body"
                        (OdtReaderSafe Blocks Blocks -> BlockMatcher)
    -> OdtReaderSafe Blocks Blocks -> BlockMatcher
    forall a b. (a -> b) -> a -> b
    $ [BlockMatcher] -> OdtReaderSafe Blocks Blocks
    forall result _x.
    Monoid result =>
    [ElementMatcher result] -> OdtReaderSafe _x result
    matchChildContent' [ BlockMatcher
    read_paragraph ]

    -------------------------
    -- Citations
    -------------------------

    read_citation    :: InlineMatcher
    read_citation :: InlineMatcher
    read_citation     = Namespace
    -> String
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    -> InlineMatcher
    forall e.
    Monoid e =>
    Namespace -> String -> OdtReaderSafe e e -> ElementMatcher e
    matchingElement Namespace
    NsText "bibliography-mark"
                        (ArrowState
       (XMLConverterState Namespace ReaderState) Inlines Inlines
     -> InlineMatcher)
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    -> InlineMatcher
    forall a b. (a -> b) -> a -> b
    $ ([Citation] -> Inlines -> Inlines)
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines [Citation]
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    forall (a :: * -> * -> *) x y z b.
    Arrow a =>
    (x -> y -> z) -> a b x -> a b y -> a b z
    liftA2 [Citation] -> Inlines -> Inlines
    cite
                          ( (Anchor -> ListLevel -> [Citation])
    -> OdtReaderSafe Inlines Anchor
    -> XMLConverter Namespace ReaderState Inlines ListLevel
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines [Citation]
    forall (a :: * -> * -> *) x y z b.
    Arrow a =>
    (x -> y -> z) -> a b x -> a b y -> a b z
    liftA2 Anchor -> ListLevel -> [Citation]
    makeCitation
                            ( Namespace -> String -> Anchor -> OdtReaderSafe Inlines Anchor
    forall nsID extraState x.
    NameSpaceID nsID =>
    nsID -> String -> Anchor -> XMLConverter nsID extraState x Anchor
    findAttrTextWithDefault Namespace
    NsText "identifier" "" )
                            ( Namespace
    -> String
    -> ListLevel
    -> XMLConverter Namespace ReaderState Inlines ListLevel
    forall nsID attrValue extraState x.
    (NameSpaceID nsID, Read attrValue) =>
    nsID
    -> String -> attrValue -> XMLConverter nsID extraState x attrValue
    readAttrWithDefault Namespace
    NsText "number" 0          )
                          )
                          ( [InlineMatcher]
    -> OdtReaderSafe (Inlines, Content) Inlines
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    forall result _x.
    Monoid result =>
    [ElementMatcher result]
    -> OdtReaderSafe (result, Content) result
    -> OdtReaderSafe _x result
    matchChildContent [] OdtReaderSafe (Inlines, Content) Inlines
    read_plain_text             )
      where
       makeCitation :: T.Text -> Int -> [Citation]
       makeCitation :: Anchor -> ListLevel -> [Citation]
    makeCitation citeId :: Anchor
    citeId num :: ListLevel
    num = [Anchor
    -> [Inline]
    -> [Inline]
    -> CitationMode
    -> ListLevel
    -> ListLevel
    -> Citation
    Citation Anchor
    citeId [] [] CitationMode
    NormalCitation ListLevel
    num 0]

    ----------------------
    -- Tables
    ----------------------

    --
    read_table        :: BlockMatcher
    read_table :: BlockMatcher
    read_table         = Namespace -> String -> OdtReaderSafe Blocks Blocks -> BlockMatcher
    forall e.
    Monoid e =>
    Namespace -> String -> OdtReaderSafe e e -> ElementMatcher e
    matchingElement Namespace
    NsTable "table"
                         (OdtReaderSafe Blocks Blocks -> BlockMatcher)
    -> OdtReaderSafe Blocks Blocks -> BlockMatcher
    forall a b. (a -> b) -> a -> b
    $ ([[Blocks]] -> Blocks)
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Blocks [[Blocks]]
    -> OdtReaderSafe Blocks Blocks
    forall (a :: * -> * -> *) y z b.
    Arrow a =>
    (y -> z) -> a b y -> a b z
    liftA [[Blocks]] -> Blocks
    simpleTable'
                         (ArrowState
       (XMLConverterState Namespace ReaderState) Blocks [[Blocks]]
     -> OdtReaderSafe Blocks Blocks)
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Blocks [[Blocks]]
    -> OdtReaderSafe Blocks Blocks
    forall a b. (a -> b) -> a -> b
    $ [ElementMatcher [[Blocks]]]
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Blocks [[Blocks]]
    forall result _x.
    Monoid result =>
    [ElementMatcher result] -> OdtReaderSafe _x result
    matchChildContent'  [ ElementMatcher [[Blocks]]
    read_table_row
                                               ]

    -- | A simple table without a caption or headers
    -- | Infers the number of headers from rows
    simpleTable' :: [[Blocks]] -> Blocks
    simpleTable' :: [[Blocks]] -> Blocks
    simpleTable' []         = [Blocks] -> [[Blocks]] -> Blocks
    simpleTable [] []
    simpleTable' (x :: [Blocks]
    x : rest :: [[Blocks]]
    rest) = [Blocks] -> [[Blocks]] -> Blocks
    simpleTable (ParaModifier -> [Blocks] -> [Blocks]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (Blocks -> ParaModifier
    forall a b. a -> b -> a
    const Blocks
    forall a. Many a
    defaults) [Blocks]
    x) ([Blocks]
    x [Blocks] -> [[Blocks]] -> [[Blocks]]
    forall a. a -> [a] -> [a]
    : [[Blocks]]
    rest)
      where defaults :: Many a
    defaults = [a] -> Many a
    forall a. [a] -> Many a
    fromList []

    --
    read_table_row    :: ElementMatcher [[Blocks]]
    read_table_row :: ElementMatcher [[Blocks]]
    read_table_row     = Namespace
    -> String
    -> OdtReaderSafe [[Blocks]] [[Blocks]]
    -> ElementMatcher [[Blocks]]
    forall e.
    Monoid e =>
    Namespace -> String -> OdtReaderSafe e e -> ElementMatcher e
    matchingElement Namespace
    NsTable "table-row"
                         (OdtReaderSafe [[Blocks]] [[Blocks]] -> ElementMatcher [[Blocks]])
    -> OdtReaderSafe [[Blocks]] [[Blocks]] -> ElementMatcher [[Blocks]]
    forall a b. (a -> b) -> a -> b
    $ ([Blocks] -> [[Blocks]])
    -> ArrowState
         (XMLConverterState Namespace ReaderState) [[Blocks]] [Blocks]
    -> OdtReaderSafe [[Blocks]] [[Blocks]]
    forall (a :: * -> * -> *) y z b.
    Arrow a =>
    (y -> z) -> a b y -> a b z
    liftA ([Blocks] -> [[Blocks]] -> [[Blocks]]
    forall a. a -> [a] -> [a]
    :[])
                         (ArrowState
       (XMLConverterState Namespace ReaderState) [[Blocks]] [Blocks]
     -> OdtReaderSafe [[Blocks]] [[Blocks]])
    -> ArrowState
         (XMLConverterState Namespace ReaderState) [[Blocks]] [Blocks]
    -> OdtReaderSafe [[Blocks]] [[Blocks]]
    forall a b. (a -> b) -> a -> b
    $ [ElementMatcher [Blocks]]
    -> ArrowState
         (XMLConverterState Namespace ReaderState) [[Blocks]] [Blocks]
    forall result _x.
    Monoid result =>
    [ElementMatcher result] -> OdtReaderSafe _x result
    matchChildContent'  [ ElementMatcher [Blocks]
    read_table_cell
                                               ]

    --
    read_table_cell   :: ElementMatcher [Blocks]
    read_table_cell :: ElementMatcher [Blocks]
    read_table_cell    = Namespace
    -> String
    -> XMLConverter Namespace ReaderState [Blocks] [Blocks]
    -> ElementMatcher [Blocks]
    forall e.
    Monoid e =>
    Namespace -> String -> OdtReaderSafe e e -> ElementMatcher e
    matchingElement Namespace
    NsTable "table-cell"
                         (XMLConverter Namespace ReaderState [Blocks] [Blocks]
     -> ElementMatcher [Blocks])
    -> XMLConverter Namespace ReaderState [Blocks] [Blocks]
    -> ElementMatcher [Blocks]
    forall a b. (a -> b) -> a -> b
    $ (Blocks -> [Blocks])
    -> ArrowState
         (XMLConverterState Namespace ReaderState) [Blocks] Blocks
    -> XMLConverter Namespace ReaderState [Blocks] [Blocks]
    forall (a :: * -> * -> *) y z b.
    Arrow a =>
    (y -> z) -> a b y -> a b z
    liftA ([Blocks] -> [Blocks]
    compactify([Blocks] -> [Blocks])
    -> (Blocks -> [Blocks]) -> Blocks -> [Blocks]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .(Blocks -> [Blocks] -> [Blocks]
    forall a. a -> [a] -> [a]
    :[]))
                         (ArrowState
       (XMLConverterState Namespace ReaderState) [Blocks] Blocks
     -> XMLConverter Namespace ReaderState [Blocks] [Blocks])
    -> ArrowState
         (XMLConverterState Namespace ReaderState) [Blocks] Blocks
    -> XMLConverter Namespace ReaderState [Blocks] [Blocks]
    forall a b. (a -> b) -> a -> b
    $ [BlockMatcher]
    -> ArrowState
         (XMLConverterState Namespace ReaderState) [Blocks] Blocks
    forall result _x.
    Monoid result =>
    [ElementMatcher result] -> OdtReaderSafe _x result
    matchChildContent' [ BlockMatcher
    read_paragraph
                                              ]

    ----------------------
    -- Frames
    ----------------------

    --
    read_frame :: InlineMatcher
    read_frame :: InlineMatcher
    read_frame = Namespace
    -> String
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    -> InlineMatcher
    forall e.
    Monoid e =>
    Namespace -> String -> OdtReaderSafe e e -> ElementMatcher e
    matchingElement Namespace
    NsDraw "frame"
                 (ArrowState
       (XMLConverterState Namespace ReaderState) Inlines Inlines
     -> InlineMatcher)
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    -> InlineMatcher
    forall a b. (a -> b) -> a -> b
    $ Namespace
    -> (String -> Bool)
    -> XMLConverter Namespace ReaderState Inlines [Element]
    forall nsID extraState x.
    NameSpaceID nsID =>
    nsID
    -> (String -> Bool) -> XMLConverter nsID extraState x [Element]
    filterChildrenName' Namespace
    NsDraw (String -> [String] -> Bool
    forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
    `elem` ["image", "object", "text-box"])
               XMLConverter Namespace ReaderState Inlines [Element]
    -> ArrowState
         (XMLConverterState Namespace ReaderState) [Element] Inlines
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>> ArrowState
      (XMLConverterState Namespace ReaderState)
      Element
      (FirstMatch Inlines)
    -> ArrowState
         (XMLConverterState Namespace ReaderState)
         [Element]
         (FirstMatch Inlines)
    forall (f :: * -> *) m s x.
    (Foldable f, Monoid m) =>
    ArrowState s x m -> ArrowState s (f x) m
    foldS ArrowState
      (XMLConverterState Namespace ReaderState)
      Element
      (FirstMatch Inlines)
    read_frame_child
               ArrowState
      (XMLConverterState Namespace ReaderState)
      [Element]
      (FirstMatch Inlines)
    -> ArrowState
         (XMLConverterState Namespace ReaderState)
         (FirstMatch Inlines)
         Inlines
    -> ArrowState
         (XMLConverterState Namespace ReaderState) [Element] Inlines
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>> (FirstMatch Inlines -> Inlines)
    -> ArrowState
         (XMLConverterState Namespace ReaderState)
         (FirstMatch Inlines)
         Inlines
    forall (a :: * -> * -> *) b c. Arrow a => (b -> c) -> a b c
    arr FirstMatch Inlines -> Inlines
    forall (t :: * -> *) m. (Foldable t, Monoid m) => t m -> m
    fold

    read_frame_child :: OdtReaderSafe XML.Element (FirstMatch Inlines)
    read_frame_child :: ArrowState
      (XMLConverterState Namespace ReaderState)
      Element
      (FirstMatch Inlines)
    read_frame_child =
      proc Element
    child -> case Element -> String
    elName Element
    child of
        "image"    -> ArrowState
      (XMLConverterState Namespace ReaderState)
      Element
      (FirstMatch Inlines)
    read_frame_img      -< Element
    child
        "object"   -> ArrowState
      (XMLConverterState Namespace ReaderState)
      Element
      (FirstMatch Inlines)
    read_frame_mathml   -< Element
    child
        "text-box" -> ArrowState
      (XMLConverterState Namespace ReaderState)
      Element
      (FirstMatch Inlines)
    read_frame_text_box -< Element
    child
        _          -> FirstMatch Inlines
    -> ArrowState
         (XMLConverterState Namespace ReaderState) () (FirstMatch Inlines)
    forall (a :: * -> * -> *) c x. Arrow a => c -> a x c
    returnV FirstMatch Inlines
    forall a. Monoid a => a
    mempty      -< ()

    read_frame_img :: OdtReaderSafe XML.Element (FirstMatch Inlines)
    read_frame_img :: ArrowState
      (XMLConverterState Namespace ReaderState)
      Element
      (FirstMatch Inlines)
    read_frame_img =
      proc Element
    img -> do
        Maybe String
    src <- XMLConverter Namespace ReaderState Element (Maybe String)
    -> XMLConverter Namespace ReaderState Element (Maybe String)
    forall nsID extraState s.
    XMLConverter nsID extraState Element s
    -> XMLConverter nsID extraState Element s
    executeIn (Namespace
    -> String
    -> XMLConverter Namespace ReaderState Element (Maybe String)
    forall nsID extraState x.
    NameSpaceID nsID =>
    nsID -> String -> XMLConverter nsID extraState x (Maybe String)
    findAttr' Namespace
    NsXLink "href") -< Element
    img
        case Maybe String -> String
    forall (t :: * -> *) m. (Foldable t, Monoid m) => t m -> m
    fold Maybe String
    src of
          ""   -> FirstMatch Inlines
    -> ArrowState
         (XMLConverterState Namespace ReaderState) () (FirstMatch Inlines)
    forall (a :: * -> * -> *) c x. Arrow a => c -> a x c
    returnV FirstMatch Inlines
    forall a. Monoid a => a
    mempty -< ()
          src' :: String
    src' -> do
            let exts :: Extensions
    exts = [Extension] -> Extensions
    extensionsFromList [Extension
    Ext_auto_identifiers]
            (String, ByteString)
    resource   <- OdtReaderSafe String (String, ByteString)
    lookupResource                          -< String
    src'
            (String, ByteString)
    _          <- OdtReaderSafe (String, ByteString) (String, ByteString)
    updateMediaWithResource                 -< (String, ByteString)
    resource
            Maybe Anchor
    w          <- Namespace
    -> String -> XMLConverter Namespace ReaderState () (Maybe Anchor)
    forall nsID extraState x.
    NameSpaceID nsID =>
    nsID -> String -> XMLConverter nsID extraState x (Maybe Anchor)
    findAttrText' Namespace
    NsSVG "width"             -< ()
            Maybe Anchor
    h          <- Namespace
    -> String -> XMLConverter Namespace ReaderState () (Maybe Anchor)
    forall nsID extraState x.
    NameSpaceID nsID =>
    nsID -> String -> XMLConverter nsID extraState x (Maybe Anchor)
    findAttrText' Namespace
    NsSVG "height"            -< ()
            Inlines
    titleNodes <- [InlineMatcher] -> OdtReaderSafe () Inlines
    forall result _x.
    Monoid result =>
    [ElementMatcher result] -> OdtReaderSafe _x result
    matchChildContent' [ InlineMatcher
    read_frame_title ] -< ()
            Inlines
    alt        <- [InlineMatcher]
    -> OdtReaderSafe (Inlines, Content) Inlines
    -> OdtReaderSafe () Inlines
    forall result _x.
    Monoid result =>
    [ElementMatcher result]
    -> OdtReaderSafe (result, Content) result
    -> OdtReaderSafe _x result
    matchChildContent [] OdtReaderSafe (Inlines, Content) Inlines
    read_plain_text    -< ()
            ((Attr, Anchor, Anchor, Inlines) -> FirstMatch Inlines)
    -> ArrowState
         (XMLConverterState Namespace ReaderState)
         (Attr, Anchor, Anchor, Inlines)
         (FirstMatch Inlines)
    forall (a :: * -> * -> *) b c. Arrow a => (b -> c) -> a b c
    arr (Inlines -> FirstMatch Inlines
    forall a. a -> FirstMatch a
    firstMatch (Inlines -> FirstMatch Inlines)
    -> ((Attr, Anchor, Anchor, Inlines) -> Inlines)
    -> (Attr, Anchor, Anchor, Inlines)
    -> FirstMatch Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Attr -> Anchor -> Anchor -> Inlines -> Inlines)
    -> (Attr, Anchor, Anchor, Inlines) -> Inlines
    forall a b c d z. (a -> b -> c -> d -> z) -> (a, b, c, d) -> z
    uncurry4 Attr -> Anchor -> Anchor -> Inlines -> Inlines
    imageWith)                 -<
              (Maybe Anchor -> Maybe Anchor -> Attr
    image_attributes Maybe Anchor
    w Maybe Anchor
    h, String -> Anchor
    T.pack String
    src', Extensions -> [Inline] -> Anchor
    inlineListToIdentifier Extensions
    exts (Inlines -> [Inline]
    forall a. Many a -> [a]
    toList Inlines
    titleNodes), Inlines
    alt)

    read_frame_title :: InlineMatcher
    read_frame_title :: InlineMatcher
    read_frame_title = Namespace
    -> String
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    -> InlineMatcher
    forall e.
    Monoid e =>
    Namespace -> String -> OdtReaderSafe e e -> ElementMatcher e
    matchingElement Namespace
    NsSVG "title" ([InlineMatcher]
    -> OdtReaderSafe (Inlines, Content) Inlines
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    forall result _x.
    Monoid result =>
    [ElementMatcher result]
    -> OdtReaderSafe (result, Content) result
    -> OdtReaderSafe _x result
    matchChildContent [] OdtReaderSafe (Inlines, Content) Inlines
    read_plain_text)

    image_attributes :: Maybe T.Text -> Maybe T.Text -> Attr
    image_attributes :: Maybe Anchor -> Maybe Anchor -> Attr
    image_attributes x :: Maybe Anchor
    x y :: Maybe Anchor
    y =
      ( "", [], Anchor -> Maybe Anchor -> [(Anchor, Anchor)]
    forall b a. (Eq b, IsString b) => a -> Maybe b -> [(a, b)]
    dim "width" Maybe Anchor
    x [(Anchor, Anchor)] -> [(Anchor, Anchor)] -> [(Anchor, Anchor)]
    forall a. [a] -> [a] -> [a]
    ++ Anchor -> Maybe Anchor -> [(Anchor, Anchor)]
    forall b a. (Eq b, IsString b) => a -> Maybe b -> [(a, b)]
    dim "height" Maybe Anchor
    y)
      where
        dim :: a -> Maybe b -> [(a, b)]
    dim _ (Just "")   = []
        dim name :: a
    name (Just v :: b
    v) = [(a
    name, b
    v)]
        dim _ Nothing     = []

    read_frame_mathml :: OdtReaderSafe XML.Element (FirstMatch Inlines)
    read_frame_mathml :: ArrowState
      (XMLConverterState Namespace ReaderState)
      Element
      (FirstMatch Inlines)
    read_frame_mathml =
      proc Element
    obj -> do
        Maybe String
    src <- XMLConverter Namespace ReaderState Element (Maybe String)
    -> XMLConverter Namespace ReaderState Element (Maybe String)
    forall nsID extraState s.
    XMLConverter nsID extraState Element s
    -> XMLConverter nsID extraState Element s
    executeIn (Namespace
    -> String
    -> XMLConverter Namespace ReaderState Element (Maybe String)
    forall nsID extraState x.
    NameSpaceID nsID =>
    nsID -> String -> XMLConverter nsID extraState x (Maybe String)
    findAttr' Namespace
    NsXLink "href") -< Element
    obj
        case Maybe String -> String
    forall (t :: * -> *) m. (Foldable t, Monoid m) => t m -> m
    fold Maybe String
    src of
          ""   -> FirstMatch Inlines
    -> ArrowState
         (XMLConverterState Namespace ReaderState) () (FirstMatch Inlines)
    forall (a :: * -> * -> *) c x. Arrow a => c -> a x c
    returnV FirstMatch Inlines
    forall a. Monoid a => a
    mempty -< ()
          src' :: String
    src' -> do
            let path :: String
    path = String -> Maybe String -> String
    forall a. a -> Maybe a -> a
    fromMaybe String
    src' (String -> String -> Maybe String
    forall a. Eq a => [a] -> [a] -> Maybe [a]
    stripPrefix "./" String
    src') String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ "/content.xml"
            (_, mathml :: ByteString
    mathml) <- OdtReaderSafe String (String, ByteString)
    lookupResource -< String
    path
            case Anchor -> Either Anchor [Exp]
    readMathML (ByteString -> Anchor
    UTF8.toText (ByteString -> Anchor) -> ByteString -> Anchor
    forall a b. (a -> b) -> a -> b
    $ ByteString -> ByteString
    B.toStrict ByteString
    mathml) of
              Left _     -> FirstMatch Inlines
    -> ArrowState
         (XMLConverterState Namespace ReaderState) () (FirstMatch Inlines)
    forall (a :: * -> * -> *) c x. Arrow a => c -> a x c
    returnV FirstMatch Inlines
    forall a. Monoid a => a
    mempty -< ()
              Right exps :: [Exp]
    exps -> ([Exp] -> FirstMatch Inlines)
    -> ArrowState
         (XMLConverterState Namespace ReaderState)
         [Exp]
         (FirstMatch Inlines)
    forall (a :: * -> * -> *) b c. Arrow a => (b -> c) -> a b c
    arr (Inlines -> FirstMatch Inlines
    forall a. a -> FirstMatch a
    firstMatch (Inlines -> FirstMatch Inlines)
    -> ([Exp] -> Inlines) -> [Exp] -> FirstMatch Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Anchor -> Inlines
    displayMath (Anchor -> Inlines) -> ([Exp] -> Anchor) -> [Exp] -> Inlines
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [Exp] -> Anchor
    writeTeX) -< [Exp]
    exps

    read_frame_text_box :: OdtReaderSafe XML.Element (FirstMatch Inlines)
    read_frame_text_box :: ArrowState
      (XMLConverterState Namespace ReaderState)
      Element
      (FirstMatch Inlines)
    read_frame_text_box = proc Element
    box -> do
        Blocks
    paragraphs <- XMLConverter Namespace ReaderState Element Blocks
    -> XMLConverter Namespace ReaderState Element Blocks
    forall nsID extraState s.
    XMLConverter nsID extraState Element s
    -> XMLConverter nsID extraState Element s
    executeIn ([BlockMatcher] -> XMLConverter Namespace ReaderState Element Blocks
    forall result _x.
    Monoid result =>
    [ElementMatcher result] -> OdtReaderSafe _x result
    matchChildContent' [ BlockMatcher
    read_paragraph ]) -< Element
    box
        ([Block] -> FirstMatch Inlines)
    -> ArrowState
         (XMLConverterState Namespace ReaderState)
         [Block]
         (FirstMatch Inlines)
    forall (a :: * -> * -> *) b c. Arrow a => (b -> c) -> a b c
    arr [Block] -> FirstMatch Inlines
    read_img_with_caption -< Blocks -> [Block]
    forall a. Many a -> [a]
    toList Blocks
    paragraphs

    read_img_with_caption :: [Block] -> FirstMatch Inlines
    read_img_with_caption :: [Block] -> FirstMatch Inlines
    read_img_with_caption (Para [Image attr :: Attr
    attr alt :: [Inline]
    alt (src :: Anchor
    src,title :: Anchor
    title)] : _) =
      Inlines -> FirstMatch Inlines
    forall a. a -> FirstMatch a
    firstMatch (Inlines -> FirstMatch Inlines) -> Inlines -> FirstMatch Inlines
    forall a b. (a -> b) -> a -> b
    $ Inline -> Inlines
    forall a. a -> Many a
    singleton (Attr -> [Inline] -> (Anchor, Anchor) -> Inline
    Image Attr
    attr [Inline]
    alt (Anchor
    src, "fig:" Anchor -> Anchor -> Anchor
    forall a. Semigroup a => a -> a -> a
    <> Anchor
    title))   -- no text, default caption
    read_img_with_caption (Para (Image attr :: Attr
    attr _ (src :: Anchor
    src,title :: Anchor
    title) : txt :: [Inline]
    txt) : _) =
      Inlines -> FirstMatch Inlines
    forall a. a -> FirstMatch a
    firstMatch (Inlines -> FirstMatch Inlines) -> Inlines -> FirstMatch Inlines
    forall a b. (a -> b) -> a -> b
    $ Inline -> Inlines
    forall a. a -> Many a
    singleton (Attr -> [Inline] -> (Anchor, Anchor) -> Inline
    Image Attr
    attr [Inline]
    txt (Anchor
    src, "fig:" Anchor -> Anchor -> Anchor
    forall a. Semigroup a => a -> a -> a
    <> Anchor
    title) )  -- override caption with the text that follows
    read_img_with_caption  ( Para (_ : xs :: [Inline]
    xs) : ys :: [Block]
    ys) =
      [Block] -> FirstMatch Inlines
    read_img_with_caption ([Inline] -> Block
    Para [Inline]
    xs Block -> [Block] -> [Block]
    forall a. a -> [a] -> [a]
    : [Block]
    ys)
    read_img_with_caption _ =
      FirstMatch Inlines
    forall a. Monoid a => a
    mempty

    ----------------------
    -- Internal links
    ----------------------

    _ANCHOR_PREFIX_ :: T.Text
    _ANCHOR_PREFIX_ :: Anchor
    _ANCHOR_PREFIX_ = "anchor"

    --
    readAnchorAttr :: OdtReader _x Anchor
    readAnchorAttr :: OdtReader _x Anchor
    readAnchorAttr = Namespace -> String -> OdtReader _x Anchor
    forall nsID extraState x.
    NameSpaceID nsID =>
    nsID -> String -> FallibleXMLConverter nsID extraState x Anchor
    findAttrText Namespace
    NsText "name"

    -- | Beware: may fail
    findAnchorName :: OdtReader AnchorPrefix Anchor
    findAnchorName :: OdtReader Anchor Anchor
    findAnchorName = (      OdtReader Anchor Anchor
    -> ArrowState
         (XMLConverterState Namespace ReaderState)
         Anchor
         (Anchor, Fallible Anchor)
    forall (a :: * -> * -> *) b c. Arrow a => a b c -> a b (b, c)
    keepingTheValue OdtReader Anchor Anchor
    forall _x. OdtReader _x Anchor
    readAnchorAttr
                       ArrowState
      (XMLConverterState Namespace ReaderState)
      Anchor
      (Anchor, Fallible Anchor)
    -> ((Anchor, Fallible Anchor) -> Either () (Anchor, Anchor))
    -> ArrowState
         (XMLConverterState Namespace ReaderState)
         Anchor
         (Either () (Anchor, Anchor))
    forall (a :: * -> * -> *) b c d.
    Arrow a =>
    a b c -> (c -> d) -> a b d
    >>^  (Anchor, Fallible Anchor) -> Either () (Anchor, Anchor)
    forall (v :: * -> *) f a.
    ChoiceVector v =>
    v (Either f a) -> Either f (v a)
    spreadChoice
                     ) ArrowState
      (XMLConverterState Namespace ReaderState)
      Anchor
      (Either () (Anchor, Anchor))
    -> OdtReaderSafe (Anchor, Anchor) Anchor -> OdtReader Anchor Anchor
    forall (a :: * -> * -> *) x failure success success'.
    ArrowChoice a =>
    FallibleArrow a x failure success
    -> a success success' -> FallibleArrow a x failure success'
    >>?! OdtReaderSafe (Anchor, Anchor) Anchor
    getPrettyAnchor

    --
    maybeAddAnchorFrom :: OdtReader Inlines AnchorPrefix
                       -> OdtReaderSafe Inlines Inlines
    maybeAddAnchorFrom :: OdtReader Inlines Anchor
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    maybeAddAnchorFrom anchorReader :: OdtReader Inlines Anchor
    anchorReader =
      ArrowState
      (XMLConverterState Namespace ReaderState)
      Inlines
      (Fallible Inlines)
    -> ArrowState
         (XMLConverterState Namespace ReaderState)
         Inlines
         (Inlines, Fallible Inlines)
    forall (a :: * -> * -> *) b c. Arrow a => a b c -> a b (b, c)
    keepingTheValue (OdtReader Inlines Anchor
    anchorReader OdtReader Inlines Anchor
    -> FallibleArrow
         (ArrowState (XMLConverterState Namespace ReaderState))
         Anchor
         ()
         Inlines
    -> ArrowState
         (XMLConverterState Namespace ReaderState)
         Inlines
         (Fallible Inlines)
    forall (a :: * -> * -> *) x failure success success'.
    ArrowChoice a =>
    FallibleArrow a x failure success
    -> FallibleArrow a success failure success'
    -> FallibleArrow a x failure success'
    >>? OdtReader Anchor Anchor
    findAnchorName OdtReader Anchor Anchor
    -> (Anchor -> Inlines)
    -> FallibleArrow
         (ArrowState (XMLConverterState Namespace ReaderState))
         Anchor
         ()
         Inlines
    forall (a :: * -> * -> *) x failure success success'.
    ArrowChoice a =>
    FallibleArrow a x failure success
    -> (success -> success') -> FallibleArrow a x failure success'
    >>?^ Anchor -> Inlines
    toAnchorElem)
      ArrowState
      (XMLConverterState Namespace ReaderState)
      Inlines
      (Inlines, Fallible Inlines)
    -> ArrowState
         (XMLConverterState Namespace ReaderState)
         (Inlines, Fallible Inlines)
         Inlines
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
    Category cat =>
    cat a b -> cat b c -> cat a c
    >>>
      proc (inlines :: Inlines
    inlines, fAnchorElem :: Fallible Inlines
    fAnchorElem) -> do
      case Fallible Inlines
    fAnchorElem of
        Right anchorElem :: Inlines
    anchorElem -> ArrowState
      (XMLConverterState Namespace ReaderState) Inlines Inlines
    forall (a :: * -> * -> *) b. Arrow a => a b b
    returnA -< Inlines
    anchorElem
        Left _           -> ArrowState
      (XMLConverterState Namespace ReaderState) Inlines Inlines
    forall (a :: * -> * -> *) b. Arrow a => a b b
    returnA -< Inlines
    inlines
      where
        toAnchorElem :: Anchor -> Inlines
        toAnchorElem :: Anchor -> Inlines
    toAnchorElem anchorID :: Anchor
    anchorID = Attr -> Inlines -> Inlines
    spanWith (Anchor
    anchorID, [], []) Inlines
    forall a. Monoid a => a
    mempty
                                -- no classes, no key-value pairs

    --
    read_bookmark     :: InlineMatcher
    read_bookmark :: InlineMatcher
    read_bookmark      = Namespace
    -> String
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    -> InlineMatcher
    forall e.
    Monoid e =>
    Namespace -> String -> OdtReaderSafe e e -> ElementMatcher e
    matchingElement Namespace
    NsText "bookmark"
                         (ArrowState
       (XMLConverterState Namespace ReaderState) Inlines Inlines
     -> InlineMatcher)
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    -> InlineMatcher
    forall a b. (a -> b) -> a -> b
    $ OdtReader Inlines Anchor
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    maybeAddAnchorFrom (OdtReaderSafe Inlines Anchor -> OdtReader Inlines Anchor
    forall (a :: * -> * -> *) x success failure.
    ArrowChoice a =>
    a x success -> FallibleArrow a x failure success
    liftAsSuccess (OdtReaderSafe Inlines Anchor -> OdtReader Inlines Anchor)
    -> OdtReaderSafe Inlines Anchor -> OdtReader Inlines Anchor
    forall a b. (a -> b) -> a -> b
    $ Anchor -> OdtReaderSafe Inlines Anchor
    forall (a :: * -> * -> *) c x. Arrow a => c -> a x c
    returnV Anchor
    _ANCHOR_PREFIX_)

    --
    read_bookmark_start :: InlineMatcher
    read_bookmark_start :: InlineMatcher
    read_bookmark_start = Namespace
    -> String
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    -> InlineMatcher
    forall e.
    Monoid e =>
    Namespace -> String -> OdtReaderSafe e e -> ElementMatcher e
    matchingElement Namespace
    NsText "bookmark-start"
                         (ArrowState
       (XMLConverterState Namespace ReaderState) Inlines Inlines
     -> InlineMatcher)
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    -> InlineMatcher
    forall a b. (a -> b) -> a -> b
    $ OdtReader Inlines Anchor
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    maybeAddAnchorFrom (OdtReaderSafe Inlines Anchor -> OdtReader Inlines Anchor
    forall (a :: * -> * -> *) x success failure.
    ArrowChoice a =>
    a x success -> FallibleArrow a x failure success
    liftAsSuccess (OdtReaderSafe Inlines Anchor -> OdtReader Inlines Anchor)
    -> OdtReaderSafe Inlines Anchor -> OdtReader Inlines Anchor
    forall a b. (a -> b) -> a -> b
    $ Anchor -> OdtReaderSafe Inlines Anchor
    forall (a :: * -> * -> *) c x. Arrow a => c -> a x c
    returnV Anchor
    _ANCHOR_PREFIX_)

    --
    read_reference_start :: InlineMatcher
    read_reference_start :: InlineMatcher
    read_reference_start = Namespace
    -> String
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    -> InlineMatcher
    forall e.
    Monoid e =>
    Namespace -> String -> OdtReaderSafe e e -> ElementMatcher e
    matchingElement Namespace
    NsText "reference-mark-start"
                         (ArrowState
       (XMLConverterState Namespace ReaderState) Inlines Inlines
     -> InlineMatcher)
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    -> InlineMatcher
    forall a b. (a -> b) -> a -> b
    $ OdtReader Inlines Anchor
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    maybeAddAnchorFrom OdtReader Inlines Anchor
    forall _x. OdtReader _x Anchor
    readAnchorAttr

    -- | Beware: may fail
    findAnchorRef :: OdtReader _x Anchor
    findAnchorRef :: OdtReader _x Anchor
    findAnchorRef = (      Namespace -> String -> OdtReader _x Anchor
    forall nsID extraState x.
    NameSpaceID nsID =>
    nsID -> String -> FallibleXMLConverter nsID extraState x Anchor
    findAttrText Namespace
    NsText "ref-name"
                      OdtReader _x Anchor
    -> (Anchor -> (Anchor, Anchor))
    -> FallibleArrow
         (ArrowState (XMLConverterState Namespace ReaderState))
         _x
         ()
         (Anchor, Anchor)
    forall (a :: * -> * -> *) x failure success success'.
    ArrowChoice a =>
    FallibleArrow a x failure success
    -> (success -> success') -> FallibleArrow a x failure success'
    >>?^ (Anchor
    _ANCHOR_PREFIX_,)
                    ) FallibleArrow
      (ArrowState (XMLConverterState Namespace ReaderState))
      _x
      ()
      (Anchor, Anchor)
    -> OdtReaderSafe (Anchor, Anchor) Anchor -> OdtReader _x Anchor
    forall (a :: * -> * -> *) x failure success success'.
    ArrowChoice a =>
    FallibleArrow a x failure success
    -> a success success' -> FallibleArrow a x failure success'
    >>?! OdtReaderSafe (Anchor, Anchor) Anchor
    getPrettyAnchor

    --
    maybeInAnchorRef :: OdtReaderSafe Inlines Inlines
    maybeInAnchorRef :: ArrowState
      (XMLConverterState Namespace ReaderState) Inlines Inlines
    maybeInAnchorRef = proc Inlines
    inlines -> do
      Fallible Anchor
    fRef <- OdtReader () Anchor
    forall _x. OdtReader _x Anchor
    findAnchorRef -< ()
      case Fallible Anchor
    fRef of
        Right anchor :: Anchor
    anchor ->
          (Inlines -> Inlines)
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    forall (a :: * -> * -> *) b c. Arrow a => (b -> c) -> a b c
    arr (Anchor -> Inlines -> Inlines
    toAnchorRef Anchor
    anchor) -<< Inlines
    inlines
        Left _ -> ArrowState
      (XMLConverterState Namespace ReaderState) Inlines Inlines
    forall (a :: * -> * -> *) b. Arrow a => a b b
    returnA -< Inlines
    inlines
      where
        toAnchorRef :: Anchor -> Inlines -> Inlines
        toAnchorRef :: Anchor -> Inlines -> Inlines
    toAnchorRef anchor :: Anchor
    anchor = Anchor -> Anchor -> Inlines -> Inlines
    link ("#" Anchor -> Anchor -> Anchor
    forall a. Semigroup a => a -> a -> a
    <> Anchor
    anchor) "" -- no title

    --
    read_bookmark_ref :: InlineMatcher
    read_bookmark_ref :: InlineMatcher
    read_bookmark_ref = Namespace
    -> String
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    -> InlineMatcher
    forall e.
    Monoid e =>
    Namespace -> String -> OdtReaderSafe e e -> ElementMatcher e
    matchingElement Namespace
    NsText "bookmark-ref"
                        (ArrowState
       (XMLConverterState Namespace ReaderState) Inlines Inlines
     -> InlineMatcher)
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    -> InlineMatcher
    forall a b. (a -> b) -> a -> b
    $    ArrowState
      (XMLConverterState Namespace ReaderState) Inlines Inlines
    maybeInAnchorRef
                         ArrowState
      (XMLConverterState Namespace ReaderState) Inlines Inlines
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    forall k (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
    Category cat =>
    cat b c -> cat a b -> cat a c
    <<< [InlineMatcher]
    -> OdtReaderSafe (Inlines, Content) Inlines
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    forall result _x.
    Monoid result =>
    [ElementMatcher result]
    -> OdtReaderSafe (result, Content) result
    -> OdtReaderSafe _x result
    matchChildContent [] OdtReaderSafe (Inlines, Content) Inlines
    read_plain_text

    --
    read_reference_ref :: InlineMatcher
    read_reference_ref :: InlineMatcher
    read_reference_ref = Namespace
    -> String
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    -> InlineMatcher
    forall e.
    Monoid e =>
    Namespace -> String -> OdtReaderSafe e e -> ElementMatcher e
    matchingElement Namespace
    NsText "reference-ref"
                        (ArrowState
       (XMLConverterState Namespace ReaderState) Inlines Inlines
     -> InlineMatcher)
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    -> InlineMatcher
    forall a b. (a -> b) -> a -> b
    $    ArrowState
      (XMLConverterState Namespace ReaderState) Inlines Inlines
    maybeInAnchorRef
                         ArrowState
      (XMLConverterState Namespace ReaderState) Inlines Inlines
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    forall k (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
    Category cat =>
    cat b c -> cat a b -> cat a c
    <<< [InlineMatcher]
    -> OdtReaderSafe (Inlines, Content) Inlines
    -> ArrowState
         (XMLConverterState Namespace ReaderState) Inlines Inlines
    forall result _x.
    Monoid result =>
    [ElementMatcher result]
    -> OdtReaderSafe (result, Content) result
    -> OdtReaderSafe _x result
    matchChildContent [] OdtReaderSafe (Inlines, Content) Inlines
    read_plain_text

    ----------------------
    -- Entry point
    ----------------------

    read_text :: OdtReaderSafe _x Pandoc
    read_text :: OdtReaderSafe _x Pandoc
    read_text = [BlockMatcher] -> OdtReaderSafe _x Blocks
    forall result _x.
    Monoid result =>
    [ElementMatcher result] -> OdtReaderSafe _x result
    matchChildContent' [ BlockMatcher
    read_header
                                   , BlockMatcher
    read_paragraph
                                   , BlockMatcher
    read_list
                                   , BlockMatcher
    read_table
                                   ]
                OdtReaderSafe _x Blocks
    -> (Blocks -> Pandoc) -> OdtReaderSafe _x Pandoc
    forall (a :: * -> * -> *) b c d.
    Arrow a =>
    a b c -> (c -> d) -> a b d
    >>^ Blocks -> Pandoc
    doc

    post_process :: Pandoc -> Pandoc
    post_process :: Pandoc -> Pandoc
    post_process (Pandoc m :: Meta
    m blocks :: [Block]
    blocks) =
      Meta -> [Block] -> Pandoc
    Pandoc Meta
    m ([Block] -> [Block]
    post_process' [Block]
    blocks)

    post_process' :: [Block] -> [Block]
    post_process' :: [Block] -> [Block]
    post_process' (Table _ a :: [Alignment]
    a w :: [Double]
    w h :: [[Block]]
    h r :: [[[Block]]]
    r : Div ("", ["caption"], _) [Para inlines :: [Inline]
    inlines] : xs :: [Block]
    xs) =
      [Inline]
    -> [Alignment] -> [Double] -> [[Block]] -> [[[Block]]] -> Block
    Table [Inline]
    inlines [Alignment]
    a [Double]
    w [[Block]]
    h [[[Block]]]
    r Block -> [Block] -> [Block]
    forall a. a -> [a] -> [a]
    : [Block] -> [Block]
    post_process' [Block]
    xs
    post_process' bs :: [Block]
    bs = [Block]
    bs

    read_body :: OdtReader _x (Pandoc, MediaBag)
    read_body :: OdtReader _x (Pandoc, MediaBag)
    read_body = Namespace
    -> String
    -> OdtReader _x (Pandoc, MediaBag)
    -> OdtReader _x (Pandoc, MediaBag)
    forall nsID extraState f s.
    NameSpaceID nsID =>
    nsID
    -> String
    -> FallibleXMLConverter nsID extraState f s
    -> FallibleXMLConverter nsID extraState f s
    executeInSub Namespace
    NsOffice "body"
              (OdtReader _x (Pandoc, MediaBag)
     -> OdtReader _x (Pandoc, MediaBag))
    -> OdtReader _x (Pandoc, MediaBag)
    -> OdtReader _x (Pandoc, MediaBag)
    forall a b. (a -> b) -> a -> b
    $ Namespace
    -> String
    -> OdtReader _x (Pandoc, MediaBag)
    -> OdtReader _x (Pandoc, MediaBag)
    forall nsID extraState f s.
    NameSpaceID nsID =>
    nsID
    -> String
    -> FallibleXMLConverter nsID extraState f s
    -> FallibleXMLConverter nsID extraState f s
    executeInSub Namespace
    NsOffice "text"
              (OdtReader _x (Pandoc, MediaBag)
     -> OdtReader _x (Pandoc, MediaBag))
    -> OdtReader _x (Pandoc, MediaBag)
    -> OdtReader _x (Pandoc, MediaBag)
    forall a b. (a -> b) -> a -> b
    $ ArrowState
      (XMLConverterState Namespace ReaderState) _x (Pandoc, MediaBag)
    -> OdtReader _x (Pandoc, MediaBag)
    forall (a :: * -> * -> *) x success failure.
    ArrowChoice a =>
    a x success -> FallibleArrow a x failure success
    liftAsSuccess
              (ArrowState
       (XMLConverterState Namespace ReaderState) _x (Pandoc, MediaBag)
     -> OdtReader _x (Pandoc, MediaBag))
    -> ArrowState
         (XMLConverterState Namespace ReaderState) _x (Pandoc, MediaBag)
    -> OdtReader _x (Pandoc, MediaBag)
    forall a b. (a -> b) -> a -> b
    $ proc _x
    inlines -> do
                 Pandoc
    txt   <- OdtReaderSafe _x Pandoc
    forall _x. OdtReaderSafe _x Pandoc
    read_text     -< _x
    inlines
                 ReaderState
    state <- XMLConverter Namespace ReaderState () ReaderState
    forall nsID extraState x. XMLConverter nsID extraState x extraState
    getExtraState -< ()
                 ArrowState
      (XMLConverterState Namespace ReaderState)
      (Pandoc, MediaBag)
      (Pandoc, MediaBag)
    forall (a :: * -> * -> *) b. Arrow a => a b b
    returnA                -< (Pandoc -> Pandoc
    post_process Pandoc
    txt, ReaderState -> MediaBag
    getMediaBag ReaderState
    state)