    {-# LANGUAGE FlexibleInstances #-}
    {-# LANGUAGE DeriveDataTypeable #-}
    {- |
       Module      : Text.Pandoc.XML.Light.Types
       Copyright   : Copyright (C) 2007 Galois, Inc., 2021-2024 John MacFarlane
       License     : GNU GPL, version 2 or above

       Maintainer  : John MacFarlane <jgm@berkeley.edu>
       Stability   : alpha
       Portability : portable

       This code is taken from xml-light, released under the BSD3 license.
       It has been modified to use Text instead of String, and the fromXL*
       functions have been added.
    -}
    module Text.Pandoc.XML.Light.Types
      ( -- * Basic types, duplicating those from xml-light but with Text
        -- instead of String
        Line
      , Content(..)
      , Element(..)
      , Attr(..)
      , CData(..)
      , CDataKind(..)
      , QName(..)
      , Node(..)
      , unode
      , unqual
      , add_attr
      , add_attrs
      -- * Conversion functions from xml-light types
      , fromXLQName
      , fromXLCData
      , fromXLElement
      , fromXLAttr
      , fromXLContent
      ) where

    import Data.Text (Text)
    import qualified Data.Text as T
    import Data.Data (Data)
    import Data.Typeable (Typeable)
    import qualified Text.XML.Light as XL

    --
    -- type definitions lightly modified from xml-light
    --

    -- | A line is an Integer
    type Line     = Integer

    -- | XML content
    data Content  = Elem Element
                  | Text CData
                  | CRef Text
                    deriving (Int -> Content -> ShowS
    [Content] -> ShowS
    Content -> String
    (Int -> Content -> ShowS)
    -> (Content -> String) -> ([Content] -> ShowS) -> Show Content
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Content -> ShowS
    showsPrec :: Int -> Content -> ShowS
    $cshow :: Content -> String
    show :: Content -> String
    $cshowList :: [Content] -> ShowS
    showList :: [Content] -> ShowS
    Show, Typeable, Typeable Content
    Typeable Content =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Content -> c Content)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Content)
    -> (Content -> Constr)
    -> (Content -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Content))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Content))
    -> ((forall b. Data b => b -> b) -> Content -> Content)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Content -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Content -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Content -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Content -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Content -> m Content)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Content -> m Content)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Content -> m Content)
    -> Data Content
    Content -> Constr
    Content -> DataType
    (forall b. Data b => b -> b) -> Content -> Content
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Content -> u
    forall u. (forall d. Data d => d -> u) -> Content -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Content -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Content -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Content -> m Content
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Content -> m Content
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Content
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Content -> c Content
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Content)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Content)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Content -> c Content
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Content -> c Content
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Content
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Content
    $ctoConstr :: Content -> Constr
    toConstr :: Content -> Constr
    $cdataTypeOf :: Content -> DataType
    dataTypeOf :: Content -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Content)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Content)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Content)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Content)
    $cgmapT :: (forall b. Data b => b -> b) -> Content -> Content
    gmapT :: (forall b. Data b => b -> b) -> Content -> Content
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Content -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Content -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Content -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Content -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Content -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Content -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Content -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Content -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Content -> m Content
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Content -> m Content
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Content -> m Content
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Content -> m Content
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Content -> m Content
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Content -> m Content
    Data, Eq Content
    Eq Content =>
    (Content -> Content -> Ordering)
    -> (Content -> Content -> Bool)
    -> (Content -> Content -> Bool)
    -> (Content -> Content -> Bool)
    -> (Content -> Content -> Bool)
    -> (Content -> Content -> Content)
    -> (Content -> Content -> Content)
    -> Ord Content
    Content -> Content -> Bool
    Content -> Content -> Ordering
    Content -> Content -> Content
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: Content -> Content -> Ordering
    compare :: Content -> Content -> Ordering
    $c< :: Content -> Content -> Bool
    < :: Content -> Content -> Bool
    $c<= :: Content -> Content -> Bool
    <= :: Content -> Content -> Bool
    $c> :: Content -> Content -> Bool
    > :: Content -> Content -> Bool
    $c>= :: Content -> Content -> Bool
    >= :: Content -> Content -> Bool
    $cmax :: Content -> Content -> Content
    max :: Content -> Content -> Content
    $cmin :: Content -> Content -> Content
    min :: Content -> Content -> Content
    Ord, Content -> Content -> Bool
    (Content -> Content -> Bool)
    -> (Content -> Content -> Bool) -> Eq Content
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Content -> Content -> Bool
    == :: Content -> Content -> Bool
    $c/= :: Content -> Content -> Bool
    /= :: Content -> Content -> Bool
    Eq)

    -- | XML elements
    data Element  = Element {
                      Element -> QName
    elName      :: QName,
                      Element -> [Attr]
    elAttribs   :: [Attr],
                      Element -> [Content]
    elContent   :: [Content],
                      Element -> Maybe Line
    elLine      :: Maybe Line
                    } deriving (Int -> Element -> ShowS
    [Element] -> ShowS
    Element -> String
    (Int -> Element -> ShowS)
    -> (Element -> String) -> ([Element] -> ShowS) -> Show Element
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Element -> ShowS
    showsPrec :: Int -> Element -> ShowS
    $cshow :: Element -> String
    show :: Element -> String
    $cshowList :: [Element] -> ShowS
    showList :: [Element] -> ShowS
    Show, Typeable, Typeable Element
    Typeable Element =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Element -> c Element)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Element)
    -> (Element -> Constr)
    -> (Element -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Element))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Element))
    -> ((forall b. Data b => b -> b) -> Element -> Element)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Element -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Element -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Element -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Element -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Element -> m Element)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Element -> m Element)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Element -> m Element)
    -> Data Element
    Element -> Constr
    Element -> DataType
    (forall b. Data b => b -> b) -> Element -> Element
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Element -> u
    forall u. (forall d. Data d => d -> u) -> Element -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Element -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Element -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Element -> m Element
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Element -> m Element
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Element
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Element -> c Element
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Element)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Element)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Element -> c Element
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Element -> c Element
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Element
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Element
    $ctoConstr :: Element -> Constr
    toConstr :: Element -> Constr
    $cdataTypeOf :: Element -> DataType
    dataTypeOf :: Element -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Element)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Element)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Element)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Element)
    $cgmapT :: (forall b. Data b => b -> b) -> Element -> Element
    gmapT :: (forall b. Data b => b -> b) -> Element -> Element
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Element -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Element -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Element -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Element -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Element -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Element -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Element -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Element -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Element -> m Element
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Element -> m Element
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Element -> m Element
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Element -> m Element
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Element -> m Element
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Element -> m Element
    Data, Eq Element
    Eq Element =>
    (Element -> Element -> Ordering)
    -> (Element -> Element -> Bool)
    -> (Element -> Element -> Bool)
    -> (Element -> Element -> Bool)
    -> (Element -> Element -> Bool)
    -> (Element -> Element -> Element)
    -> (Element -> Element -> Element)
    -> Ord Element
    Element -> Element -> Bool
    Element -> Element -> Ordering
    Element -> Element -> Element
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: Element -> Element -> Ordering
    compare :: Element -> Element -> Ordering
    $c< :: Element -> Element -> Bool
    < :: Element -> Element -> Bool
    $c<= :: Element -> Element -> Bool
    <= :: Element -> Element -> Bool
    $c> :: Element -> Element -> Bool
    > :: Element -> Element -> Bool
    $c>= :: Element -> Element -> Bool
    >= :: Element -> Element -> Bool
    $cmax :: Element -> Element -> Element
    max :: Element -> Element -> Element
    $cmin :: Element -> Element -> Element
    min :: Element -> Element -> Element
    Ord, Element -> Element -> Bool
    (Element -> Element -> Bool)
    -> (Element -> Element -> Bool) -> Eq Element
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Element -> Element -> Bool
    == :: Element -> Element -> Bool
    $c/= :: Element -> Element -> Bool
    /= :: Element -> Element -> Bool
    Eq)

    -- | XML attributes
    data Attr     = Attr {
                      Attr -> QName
    attrKey :: QName,
                      Attr -> Text
    attrVal :: Text
                    } deriving (Attr -> Attr -> Bool
    (Attr -> Attr -> Bool) -> (Attr -> Attr -> Bool) -> Eq Attr
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Attr -> Attr -> Bool
    == :: Attr -> Attr -> Bool
    $c/= :: Attr -> Attr -> Bool
    /= :: Attr -> Attr -> Bool
    Eq, Eq Attr
    Eq Attr =>
    (Attr -> Attr -> Ordering)
    -> (Attr -> Attr -> Bool)
    -> (Attr -> Attr -> Bool)
    -> (Attr -> Attr -> Bool)
    -> (Attr -> Attr -> Bool)
    -> (Attr -> Attr -> Attr)
    -> (Attr -> Attr -> Attr)
    -> Ord Attr
    Attr -> Attr -> Bool
    Attr -> Attr -> Ordering
    Attr -> Attr -> Attr
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: Attr -> Attr -> Ordering
    compare :: Attr -> Attr -> Ordering
    $c< :: Attr -> Attr -> Bool
    < :: Attr -> Attr -> Bool
    $c<= :: Attr -> Attr -> Bool
    <= :: Attr -> Attr -> Bool
    $c> :: Attr -> Attr -> Bool
    > :: Attr -> Attr -> Bool
    $c>= :: Attr -> Attr -> Bool
    >= :: Attr -> Attr -> Bool
    $cmax :: Attr -> Attr -> Attr
    max :: Attr -> Attr -> Attr
    $cmin :: Attr -> Attr -> Attr
    min :: Attr -> Attr -> Attr
    Ord, Int -> Attr -> ShowS
    [Attr] -> ShowS
    Attr -> String
    (Int -> Attr -> ShowS)
    -> (Attr -> String) -> ([Attr] -> ShowS) -> Show Attr
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Attr -> ShowS
    showsPrec :: Int -> Attr -> ShowS
    $cshow :: Attr -> String
    show :: Attr -> String
    $cshowList :: [Attr] -> ShowS
    showList :: [Attr] -> ShowS
    Show, Typeable, Typeable Attr
    Typeable Attr =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Attr -> c Attr)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Attr)
    -> (Attr -> Constr)
    -> (Attr -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Attr))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Attr))
    -> ((forall b. Data b => b -> b) -> Attr -> Attr)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Attr -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Attr -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Attr -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Attr -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Attr -> m Attr)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Attr -> m Attr)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Attr -> m Attr)
    -> Data Attr
    Attr -> Constr
    Attr -> DataType
    (forall b. Data b => b -> b) -> Attr -> Attr
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Attr -> u
    forall u. (forall d. Data d => d -> u) -> Attr -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Attr -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Attr -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Attr -> m Attr
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Attr -> m Attr
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Attr
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Attr -> c Attr
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Attr)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Attr)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Attr -> c Attr
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Attr -> c Attr
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Attr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Attr
    $ctoConstr :: Attr -> Constr
    toConstr :: Attr -> Constr
    $cdataTypeOf :: Attr -> DataType
    dataTypeOf :: Attr -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Attr)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Attr)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Attr)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Attr)
    $cgmapT :: (forall b. Data b => b -> b) -> Attr -> Attr
    gmapT :: (forall b. Data b => b -> b) -> Attr -> Attr
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Attr -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Attr -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Attr -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Attr -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Attr -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Attr -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Attr -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Attr -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Attr -> m Attr
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Attr -> m Attr
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Attr -> m Attr
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Attr -> m Attr
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Attr -> m Attr
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Attr -> m Attr
    Data)

    -- | XML CData
    data CData    = CData {
                      CData -> CDataKind
    cdVerbatim  :: CDataKind,
                      CData -> Text
    cdData      :: Text,
                      CData -> Maybe Line
    cdLine      :: Maybe Line
                    } deriving (Int -> CData -> ShowS
    [CData] -> ShowS
    CData -> String
    (Int -> CData -> ShowS)
    -> (CData -> String) -> ([CData] -> ShowS) -> Show CData
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> CData -> ShowS
    showsPrec :: Int -> CData -> ShowS
    $cshow :: CData -> String
    show :: CData -> String
    $cshowList :: [CData] -> ShowS
    showList :: [CData] -> ShowS
    Show, Typeable, Typeable CData
    Typeable CData =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> CData -> c CData)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c CData)
    -> (CData -> Constr)
    -> (CData -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c CData))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CData))
    -> ((forall b. Data b => b -> b) -> CData -> CData)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CData -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CData -> r)
    -> (forall u. (forall d. Data d => d -> u) -> CData -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> CData -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> CData -> m CData)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> CData -> m CData)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> CData -> m CData)
    -> Data CData
    CData -> Constr
    CData -> DataType
    (forall b. Data b => b -> b) -> CData -> CData
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> CData -> u
    forall u. (forall d. Data d => d -> u) -> CData -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CData -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CData -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CData -> m CData
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CData -> m CData
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CData
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CData -> c CData
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CData)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CData)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CData -> c CData
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CData -> c CData
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CData
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CData
    $ctoConstr :: CData -> Constr
    toConstr :: CData -> Constr
    $cdataTypeOf :: CData -> DataType
    dataTypeOf :: CData -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CData)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CData)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CData)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CData)
    $cgmapT :: (forall b. Data b => b -> b) -> CData -> CData
    gmapT :: (forall b. Data b => b -> b) -> CData -> CData
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CData -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CData -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CData -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CData -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> CData -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> CData -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CData -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CData -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CData -> m CData
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CData -> m CData
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CData -> m CData
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CData -> m CData
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CData -> m CData
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CData -> m CData
    Data, Eq CData
    Eq CData =>
    (CData -> CData -> Ordering)
    -> (CData -> CData -> Bool)
    -> (CData -> CData -> Bool)
    -> (CData -> CData -> Bool)
    -> (CData -> CData -> Bool)
    -> (CData -> CData -> CData)
    -> (CData -> CData -> CData)
    -> Ord CData
    CData -> CData -> Bool
    CData -> CData -> Ordering
    CData -> CData -> CData
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: CData -> CData -> Ordering
    compare :: CData -> CData -> Ordering
    $c< :: CData -> CData -> Bool
    < :: CData -> CData -> Bool
    $c<= :: CData -> CData -> Bool
    <= :: CData -> CData -> Bool
    $c> :: CData -> CData -> Bool
    > :: CData -> CData -> Bool
    $c>= :: CData -> CData -> Bool
    >= :: CData -> CData -> Bool
    $cmax :: CData -> CData -> CData
    max :: CData -> CData -> CData
    $cmin :: CData -> CData -> CData
    min :: CData -> CData -> CData
    Ord, CData -> CData -> Bool
    (CData -> CData -> Bool) -> (CData -> CData -> Bool) -> Eq CData
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: CData -> CData -> Bool
    == :: CData -> CData -> Bool
    $c/= :: CData -> CData -> Bool
    /= :: CData -> CData -> Bool
    Eq)

    data CDataKind
     = CDataText      -- ^ Ordinary character data; pretty printer escapes &, < etc.
     | CDataVerbatim  -- ^ Unescaped character data; pretty printer embeds it in <![CDATA[..
     | CDataRaw       -- ^ As-is character data; pretty printer passes it along without any escaping or CDATA wrap-up.
       deriving ( CDataKind -> CDataKind -> Bool
    (CDataKind -> CDataKind -> Bool)
    -> (CDataKind -> CDataKind -> Bool) -> Eq CDataKind
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: CDataKind -> CDataKind -> Bool
    == :: CDataKind -> CDataKind -> Bool
    $c/= :: CDataKind -> CDataKind -> Bool
    /= :: CDataKind -> CDataKind -> Bool
    Eq, Eq CDataKind
    Eq CDataKind =>
    (CDataKind -> CDataKind -> Ordering)
    -> (CDataKind -> CDataKind -> Bool)
    -> (CDataKind -> CDataKind -> Bool)
    -> (CDataKind -> CDataKind -> Bool)
    -> (CDataKind -> CDataKind -> Bool)
    -> (CDataKind -> CDataKind -> CDataKind)
    -> (CDataKind -> CDataKind -> CDataKind)
    -> Ord CDataKind
    CDataKind -> CDataKind -> Bool
    CDataKind -> CDataKind -> Ordering
    CDataKind -> CDataKind -> CDataKind
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: CDataKind -> CDataKind -> Ordering
    compare :: CDataKind -> CDataKind -> Ordering
    $c< :: CDataKind -> CDataKind -> Bool
    < :: CDataKind -> CDataKind -> Bool
    $c<= :: CDataKind -> CDataKind -> Bool
    <= :: CDataKind -> CDataKind -> Bool
    $c> :: CDataKind -> CDataKind -> Bool
    > :: CDataKind -> CDataKind -> Bool
    $c>= :: CDataKind -> CDataKind -> Bool
    >= :: CDataKind -> CDataKind -> Bool
    $cmax :: CDataKind -> CDataKind -> CDataKind
    max :: CDataKind -> CDataKind -> CDataKind
    $cmin :: CDataKind -> CDataKind -> CDataKind
    min :: CDataKind -> CDataKind -> CDataKind
    Ord, Int -> CDataKind -> ShowS
    [CDataKind] -> ShowS
    CDataKind -> String
    (Int -> CDataKind -> ShowS)
    -> (CDataKind -> String)
    -> ([CDataKind] -> ShowS)
    -> Show CDataKind
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> CDataKind -> ShowS
    showsPrec :: Int -> CDataKind -> ShowS
    $cshow :: CDataKind -> String
    show :: CDataKind -> String
    $cshowList :: [CDataKind] -> ShowS
    showList :: [CDataKind] -> ShowS
    Show, Typeable, Typeable CDataKind
    Typeable CDataKind =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> CDataKind -> c CDataKind)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c CDataKind)
    -> (CDataKind -> Constr)
    -> (CDataKind -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c CDataKind))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CDataKind))
    -> ((forall b. Data b => b -> b) -> CDataKind -> CDataKind)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> CDataKind -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> CDataKind -> r)
    -> (forall u. (forall d. Data d => d -> u) -> CDataKind -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> CDataKind -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> CDataKind -> m CDataKind)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> CDataKind -> m CDataKind)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> CDataKind -> m CDataKind)
    -> Data CDataKind
    CDataKind -> Constr
    CDataKind -> DataType
    (forall b. Data b => b -> b) -> CDataKind -> CDataKind
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> CDataKind -> u
    forall u. (forall d. Data d => d -> u) -> CDataKind -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CDataKind -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CDataKind -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CDataKind -> m CDataKind
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CDataKind -> m CDataKind
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CDataKind
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CDataKind -> c CDataKind
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CDataKind)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CDataKind)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CDataKind -> c CDataKind
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CDataKind -> c CDataKind
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CDataKind
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CDataKind
    $ctoConstr :: CDataKind -> Constr
    toConstr :: CDataKind -> Constr
    $cdataTypeOf :: CDataKind -> DataType
    dataTypeOf :: CDataKind -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CDataKind)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CDataKind)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CDataKind)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CDataKind)
    $cgmapT :: (forall b. Data b => b -> b) -> CDataKind -> CDataKind
    gmapT :: (forall b. Data b => b -> b) -> CDataKind -> CDataKind
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CDataKind -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CDataKind -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CDataKind -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CDataKind -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> CDataKind -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> CDataKind -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CDataKind -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CDataKind -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CDataKind -> m CDataKind
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CDataKind -> m CDataKind
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CDataKind -> m CDataKind
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CDataKind -> m CDataKind
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CDataKind -> m CDataKind
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CDataKind -> m CDataKind
    Data )

    -- | XML qualified names
    data QName    = QName {
                      QName -> Text
    qName   :: Text,
                      QName -> Maybe Text
    qURI    :: Maybe Text,
                      QName -> Maybe Text
    qPrefix :: Maybe Text
                    } deriving (Int -> QName -> ShowS
    [QName] -> ShowS
    QName -> String
    (Int -> QName -> ShowS)
    -> (QName -> String) -> ([QName] -> ShowS) -> Show QName
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> QName -> ShowS
    showsPrec :: Int -> QName -> ShowS
    $cshow :: QName -> String
    show :: QName -> String
    $cshowList :: [QName] -> ShowS
    showList :: [QName] -> ShowS
    Show, Typeable, Typeable QName
    Typeable QName =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> QName -> c QName)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c QName)
    -> (QName -> Constr)
    -> (QName -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c QName))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c QName))
    -> ((forall b. Data b => b -> b) -> QName -> QName)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> QName -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> QName -> r)
    -> (forall u. (forall d. Data d => d -> u) -> QName -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> QName -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> QName -> m QName)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> QName -> m QName)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> QName -> m QName)
    -> Data QName
    QName -> Constr
    QName -> DataType
    (forall b. Data b => b -> b) -> QName -> QName
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> QName -> u
    forall u. (forall d. Data d => d -> u) -> QName -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> QName -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> QName -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> QName -> m QName
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> QName -> m QName
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c QName
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> QName -> c QName
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c QName)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c QName)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> QName -> c QName
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> QName -> c QName
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c QName
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c QName
    $ctoConstr :: QName -> Constr
    toConstr :: QName -> Constr
    $cdataTypeOf :: QName -> DataType
    dataTypeOf :: QName -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c QName)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c QName)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c QName)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c QName)
    $cgmapT :: (forall b. Data b => b -> b) -> QName -> QName
    gmapT :: (forall b. Data b => b -> b) -> QName -> QName
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> QName -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> QName -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> QName -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> QName -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> QName -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> QName -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> QName -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> QName -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> QName -> m QName
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> QName -> m QName
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> QName -> m QName
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> QName -> m QName
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> QName -> m QName
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> QName -> m QName
    Data)

    instance Eq QName where
      QName
    q1 == :: QName -> QName -> Bool
    == QName
    q2  = QName -> QName -> Ordering
    forall a. Ord a => a -> a -> Ordering
    compare QName
    q1 QName
    q2 Ordering -> Ordering -> Bool
    forall a. Eq a => a -> a -> Bool
    == Ordering
    EQ

    instance Ord QName where
      compare :: QName -> QName -> Ordering
    compare QName
    q1 QName
    q2 =
        case Text -> Text -> Ordering
    forall a. Ord a => a -> a -> Ordering
    compare (QName -> Text
    qName QName
    q1) (QName -> Text
    qName QName
    q2) of
          Ordering
    EQ  -> case (QName -> Maybe Text
    qURI QName
    q1, QName -> Maybe Text
    qURI QName
    q2) of
                   (Maybe Text
    Nothing,Maybe Text
    Nothing) -> Maybe Text -> Maybe Text -> Ordering
    forall a. Ord a => a -> a -> Ordering
    compare (QName -> Maybe Text
    qPrefix QName
    q1) (QName -> Maybe Text
    qPrefix QName
    q2)
                   (Maybe Text
    u1,Maybe Text
    u2)           -> Maybe Text -> Maybe Text -> Ordering
    forall a. Ord a => a -> a -> Ordering
    compare Maybe Text
    u1 Maybe Text
    u2
          Ordering
    x   -> Ordering
    x

    class Node t where
     node :: QName -> t -> Element

    instance Node ([Attr],[Content]) where
      node :: QName -> ([Attr], [Content]) -> Element
    node QName
    n ([Attr]
    attrs,[Content]
    cont) = Element { elName :: QName
    elName     = QName
    n
                                    , elAttribs :: [Attr]
    elAttribs  = [Attr]
    attrs
                                    , elContent :: [Content]
    elContent  = [Content]
    cont
                                    , elLine :: Maybe Line
    elLine     = Maybe Line
    forall a. Maybe a
    Nothing
                                    }

    instance Node [Attr]             where node :: QName -> [Attr] -> Element
    node QName
    n [Attr]
    as   = QName -> ([Attr], [Content]) -> Element
    forall t. Node t => QName -> t -> Element
    node QName
    n ([Attr]
    as,[]::[Content])
    instance Node Attr               where node :: QName -> Attr -> Element
    node QName
    n Attr
    a    = QName -> [Attr] -> Element
    forall t. Node t => QName -> t -> Element
    node QName
    n [Attr
    a]
    instance Node ()                 where node :: QName -> () -> Element
    node QName
    n ()   = QName -> [Attr] -> Element
    forall t. Node t => QName -> t -> Element
    node QName
    n ([]::[Attr])

    instance Node [Content]          where node :: QName -> [Content] -> Element
    node QName
    n [Content]
    cs     = QName -> ([Attr], [Content]) -> Element
    forall t. Node t => QName -> t -> Element
    node QName
    n ([]::[Attr],[Content]
    cs)
    instance Node Content            where node :: QName -> Content -> Element
    node QName
    n Content
    c      = QName -> [Content] -> Element
    forall t. Node t => QName -> t -> Element
    node QName
    n [Content
    c]
    instance Node ([Attr],Content)   where node :: QName -> ([Attr], Content) -> Element
    node QName
    n ([Attr]
    as,Content
    c) = QName -> ([Attr], [Content]) -> Element
    forall t. Node t => QName -> t -> Element
    node QName
    n ([Attr]
    as,[Content
    c])
    instance Node (Attr,Content)     where node :: QName -> (Attr, Content) -> Element
    node QName
    n (Attr
    a,Content
    c)  = QName -> ([Attr], [Content]) -> Element
    forall t. Node t => QName -> t -> Element
    node QName
    n ([Attr
    a],[Content
    c])

    instance Node ([Attr],[Element]) where
      node :: QName -> ([Attr], [Element]) -> Element
    node QName
    n ([Attr]
    as,[Element]
    cs) = QName -> ([Attr], [Content]) -> Element
    forall t. Node t => QName -> t -> Element
    node QName
    n ([Attr]
    as,(Element -> Content) -> [Element] -> [Content]
    forall a b. (a -> b) -> [a] -> [b]
    map Element -> Content
    Elem [Element]
    cs)

    instance Node ([Attr],Element)   where node :: QName -> ([Attr], Element) -> Element
    node QName
    n ([Attr]
    as,Element
    c) = QName -> ([Attr], [Element]) -> Element
    forall t. Node t => QName -> t -> Element
    node QName
    n ([Attr]
    as,[Element
    c])
    instance Node (Attr,Element)     where node :: QName -> (Attr, Element) -> Element
    node QName
    n (Attr
    a,Element
    c)  = QName -> ([Attr], Element) -> Element
    forall t. Node t => QName -> t -> Element
    node QName
    n ([Attr
    a],Element
    c)
    instance Node [Element]          where node :: QName -> [Element] -> Element
    node QName
    n [Element]
    es     = QName -> ([Attr], [Element]) -> Element
    forall t. Node t => QName -> t -> Element
    node QName
    n ([]::[Attr],[Element]
    es)
    instance Node Element            where node :: QName -> Element -> Element
    node QName
    n Element
    e      = QName -> [Element] -> Element
    forall t. Node t => QName -> t -> Element
    node QName
    n [Element
    e]

    instance Node ([Attr],[CData])   where
      node :: QName -> ([Attr], [CData]) -> Element
    node QName
    n ([Attr]
    as,[CData]
    cs) = QName -> ([Attr], [Content]) -> Element
    forall t. Node t => QName -> t -> Element
    node QName
    n ([Attr]
    as,(CData -> Content) -> [CData] -> [Content]
    forall a b. (a -> b) -> [a] -> [b]
    map CData -> Content
    Text [CData]
    cs)

    instance Node ([Attr],CData)     where node :: QName -> ([Attr], CData) -> Element
    node QName
    n ([Attr]
    as,CData
    c) = QName -> ([Attr], [CData]) -> Element
    forall t. Node t => QName -> t -> Element
    node QName
    n ([Attr]
    as,[CData
    c])
    instance Node (Attr,CData)       where node :: QName -> (Attr, CData) -> Element
    node QName
    n (Attr
    a,CData
    c)  = QName -> ([Attr], CData) -> Element
    forall t. Node t => QName -> t -> Element
    node QName
    n ([Attr
    a],CData
    c)
    instance Node [CData]            where node :: QName -> [CData] -> Element
    node QName
    n [CData]
    es     = QName -> ([Attr], [CData]) -> Element
    forall t. Node t => QName -> t -> Element
    node QName
    n ([]::[Attr],[CData]
    es)
    instance Node CData              where node :: QName -> CData -> Element
    node QName
    n CData
    e      = QName -> [CData] -> Element
    forall t. Node t => QName -> t -> Element
    node QName
    n [CData
    e]

    instance Node ([Attr],Text)      where
      node :: QName -> ([Attr], Text) -> Element
    node QName
    n ([Attr]
    as,Text
    t) = QName -> ([Attr], CData) -> Element
    forall t. Node t => QName -> t -> Element
    node QName
    n ([Attr]
    as, CData { cdVerbatim :: CDataKind
    cdVerbatim = CDataKind
    CDataText
                                        , cdData :: Text
    cdData = Text
    t
                                        , cdLine :: Maybe Line
    cdLine = Maybe Line
    forall a. Maybe a
    Nothing })

    instance Node (Attr,Text )       where node :: QName -> (Attr, Text) -> Element
    node QName
    n (Attr
    a,Text
    t)  = QName -> ([Attr], Text) -> Element
    forall t. Node t => QName -> t -> Element
    node QName
    n ([Attr
    a],Text
    t)
    instance Node Text               where node :: QName -> Text -> Element
    node QName
    n Text
    t      = QName -> ([Attr], Text) -> Element
    forall t. Node t => QName -> t -> Element
    node QName
    n ([]::[Attr],Text
    t)

    -- | Create node with unqualified name
    unode :: Node t => Text -> t -> Element
    unode :: forall t. Node t => Text -> t -> Element
    unode = QName -> t -> Element
    forall t. Node t => QName -> t -> Element
    node (QName -> t -> Element) -> (Text -> QName) -> Text -> t -> Element
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> QName
    unqual

    unqual :: Text -> QName
    unqual :: Text -> QName
    unqual Text
    x = Text -> Maybe Text -> Maybe Text -> QName
    QName Text
    x Maybe Text
    forall a. Maybe a
    Nothing Maybe Text
    forall a. Maybe a
    Nothing

    -- | Add an attribute to an element.
    add_attr :: Attr -> Element -> Element
    add_attr :: Attr -> Element -> Element
    add_attr Attr
    a Element
    e = [Attr] -> Element -> Element
    add_attrs [Attr
    a] Element
    e

    -- | Add some attributes to an element.
    add_attrs :: [Attr] -> Element -> Element
    add_attrs :: [Attr] -> Element -> Element
    add_attrs [Attr]
    as Element
    e = Element
    e { elAttribs = as ++ elAttribs e }

    --
    -- conversion from xml-light
    --

    fromXLQName :: XL.QName -> QName
    fromXLQName :: QName -> QName
    fromXLQName QName
    qn = QName { qName :: Text
    qName = String -> Text
    T.pack (String -> Text) -> String -> Text
    forall a b. (a -> b) -> a -> b
    $ QName -> String
    XL.qName QName
    qn
                           , qURI :: Maybe Text
    qURI = String -> Text
    T.pack (String -> Text) -> Maybe String -> Maybe Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> QName -> Maybe String
    XL.qURI QName
    qn
                           , qPrefix :: Maybe Text
    qPrefix = String -> Text
    T.pack (String -> Text) -> Maybe String -> Maybe Text
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> QName -> Maybe String
    XL.qPrefix QName
    qn }

    fromXLCData :: XL.CData -> CData
    fromXLCData :: CData -> CData
    fromXLCData CData
    cd = CData { cdVerbatim :: CDataKind
    cdVerbatim = case CData -> CDataKind
    XL.cdVerbatim CData
    cd of
                                            CDataKind
    XL.CDataText -> CDataKind
    CDataText
                                            CDataKind
    XL.CDataVerbatim -> CDataKind
    CDataVerbatim
                                            CDataKind
    XL.CDataRaw -> CDataKind
    CDataRaw
                           , cdData :: Text
    cdData = String -> Text
    T.pack (String -> Text) -> String -> Text
    forall a b. (a -> b) -> a -> b
    $ CData -> String
    XL.cdData CData
    cd
                           , cdLine :: Maybe Line
    cdLine = CData -> Maybe Line
    XL.cdLine CData
    cd }

    fromXLElement :: XL.Element -> Element
    fromXLElement :: Element -> Element
    fromXLElement Element
    el = Element { elName :: QName
    elName = QName -> QName
    fromXLQName (QName -> QName) -> QName -> QName
    forall a b. (a -> b) -> a -> b
    $ Element -> QName
    XL.elName Element
    el
                               , elAttribs :: [Attr]
    elAttribs = (Attr -> Attr) -> [Attr] -> [Attr]
    forall a b. (a -> b) -> [a] -> [b]
    map Attr -> Attr
    fromXLAttr ([Attr] -> [Attr]) -> [Attr] -> [Attr]
    forall a b. (a -> b) -> a -> b
    $ Element -> [Attr]
    XL.elAttribs Element
    el
                               , elContent :: [Content]
    elContent = (Content -> Content) -> [Content] -> [Content]
    forall a b. (a -> b) -> [a] -> [b]
    map Content -> Content
    fromXLContent ([Content] -> [Content]) -> [Content] -> [Content]
    forall a b. (a -> b) -> a -> b
    $ Element -> [Content]
    XL.elContent Element
    el
                               , elLine :: Maybe Line
    elLine = Element -> Maybe Line
    XL.elLine Element
    el }

    fromXLAttr :: XL.Attr -> Attr
    fromXLAttr :: Attr -> Attr
    fromXLAttr (XL.Attr QName
    qn String
    s) = QName -> Text -> Attr
    Attr (QName -> QName
    fromXLQName QName
    qn) (String -> Text
    T.pack String
    s)

    fromXLContent :: XL.Content -> Content
    fromXLContent :: Content -> Content
    fromXLContent (XL.Elem Element
    el) = Element -> Content
    Elem (Element -> Content) -> Element -> Content
    forall a b. (a -> b) -> a -> b
    $ Element -> Element
    fromXLElement Element
    el
    fromXLContent (XL.Text CData
    cd) = CData -> Content
    Text (CData -> Content) -> CData -> Content
    forall a b. (a -> b) -> a -> b
    $ CData -> CData
    fromXLCData CData
    cd
    fromXLContent (XL.CRef String
    s)  = Text -> Content
    CRef (String -> Text
    T.pack String
    s)