{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE CPP #-}
#if MIN_VERSION_blaze_markup(0,7,1)
#define PRE_BUILDER
#endif
module Text.BlazeT.Internal
    (
    -- * Entities exported only by the @blazeT@ version of this module
    MarkupT(..)
    ,MarkupI
    ,mapMarkupT
    -- ** Specializations for @blaze-markup@ backwards compatibility
    ,MarkupM
    ,Markup
    ,Markup2
    -- ** Running
    ,runMarkupT
    ,runMarkup
    ,runWith
    -- ** Executing
    ,execMarkupT
    ,execMarkup
    ,execWith
    -- ** Wrappers
    ,wrapMarkupT
    ,wrapMarkupT2
    ,wrapMarkup
    ,wrapMarkup2
    ,
    
    -- * Entities exported also by "Text.Blaze.Internal"
    -- $descr1
    
      -- ** Important types.
      Text.Blaze.ChoiceString (..)
    , Text.Blaze.StaticString (..)
    -- , MarkupM
    -- , Markup
    , Text.Blaze.Tag
    , Text.Blaze.Attribute
    , Text.Blaze.AttributeValue

      -- ** Creating custom tags and attributes.
    , customParent
    , customLeaf
    , Text.Blaze.attribute
    , Text.Blaze.dataAttribute
    , Text.Blaze.customAttribute

      -- ** Converting values to Markup.
    , text
    , preEscapedText
    , lazyText
    , preEscapedLazyText
    , textBuilder
    , preEscapedTextBuilder
    , string
    , preEscapedString
    , unsafeByteString
    , unsafeLazyByteString

      -- ** Comments
    , textComment
    , lazyTextComment
    , stringComment
    , unsafeByteStringComment
    , unsafeLazyByteStringComment

      -- ** Converting values to tags.
    , Text.Blaze.textTag
    , Text.Blaze.stringTag

      -- ** Converting values to attribute values.
    , Text.Blaze.textValue
    , Text.Blaze.preEscapedTextValue
    , Text.Blaze.lazyTextValue
    , Text.Blaze.preEscapedLazyTextValue
    , Text.Blaze.textBuilderValue
    , Text.Blaze.preEscapedTextBuilderValue
    , Text.Blaze.stringValue
    , Text.Blaze.preEscapedStringValue
    , Text.Blaze.unsafeByteStringValue
    , Text.Blaze.unsafeLazyByteStringValue

      -- ** Setting attributes
    , Text.Blaze.Attributable
    , (Text.Blaze.!)
    , (Text.Blaze.!?)

      -- ** Modifying Markup elements
    , contents
    , external

      -- ** Querying Markup elements
    , null

  ) where

import           Control.Arrow
import           Control.Monad.Identity
import           Control.Monad.Trans.Class
import           Control.Monad.Writer.Strict
import qualified Data.ByteString as BS
import qualified Data.ByteString.Lazy as BL
import           Data.String
import qualified Data.Text as T
import qualified Data.Text.Lazy as LT
import qualified Data.Text.Lazy.Builder as LTB
import qualified Text.Blaze
import qualified Text.Blaze.Internal as Text.Blaze

{- | Everything is build around the simple @newtype@ definition of the
'MarkupT' transformer, which makes use the 'Monoid' instance of Blaze
'Text.Blaze.Markup' and is simply a 'WriterT' writing Blaze
'Text.Blaze.Markup':
-}
newtype MarkupT m a= MarkupT { forall (m :: * -> *) a. MarkupT m a -> WriterT Markup m a
fromMarkupT :: WriterT Text.Blaze.Markup m a }
                     deriving (forall a b. a -> MarkupT m b -> MarkupT m a
forall a b. (a -> b) -> MarkupT m a -> MarkupT m b
forall (m :: * -> *) a b.
Functor m =>
a -> MarkupT m b -> MarkupT m a
forall (m :: * -> *) a b.
Functor m =>
(a -> b) -> MarkupT m a -> MarkupT m b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> MarkupT m b -> MarkupT m a
$c<$ :: forall (m :: * -> *) a b.
Functor m =>
a -> MarkupT m b -> MarkupT m a
fmap :: forall a b. (a -> b) -> MarkupT m a -> MarkupT m b
$cfmap :: forall (m :: * -> *) a b.
Functor m =>
(a -> b) -> MarkupT m a -> MarkupT m b
Functor
#if MIN_VERSION_base(4,8,0)
                              ,forall a. a -> MarkupT m a
forall a b. MarkupT m a -> MarkupT m b -> MarkupT m a
forall a b. MarkupT m a -> MarkupT m b -> MarkupT m b
forall a b. MarkupT m (a -> b) -> MarkupT m a -> MarkupT m b
forall a b c.
(a -> b -> c) -> MarkupT m a -> MarkupT m b -> MarkupT m c
forall (f :: * -> *).
Functor f
-> (forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
forall {m :: * -> *}. Applicative m => Functor (MarkupT m)
forall (m :: * -> *) a. Applicative m => a -> MarkupT m a
forall (m :: * -> *) a b.
Applicative m =>
MarkupT m a -> MarkupT m b -> MarkupT m a
forall (m :: * -> *) a b.
Applicative m =>
MarkupT m a -> MarkupT m b -> MarkupT m b
forall (m :: * -> *) a b.
Applicative m =>
MarkupT m (a -> b) -> MarkupT m a -> MarkupT m b
forall (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c) -> MarkupT m a -> MarkupT m b -> MarkupT m c
<* :: forall a b. MarkupT m a -> MarkupT m b -> MarkupT m a
$c<* :: forall (m :: * -> *) a b.
Applicative m =>
MarkupT m a -> MarkupT m b -> MarkupT m a
*> :: forall a b. MarkupT m a -> MarkupT m b -> MarkupT m b
$c*> :: forall (m :: * -> *) a b.
Applicative m =>
MarkupT m a -> MarkupT m b -> MarkupT m b
liftA2 :: forall a b c.
(a -> b -> c) -> MarkupT m a -> MarkupT m b -> MarkupT m c
$cliftA2 :: forall (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c) -> MarkupT m a -> MarkupT m b -> MarkupT m c
<*> :: forall a b. MarkupT m (a -> b) -> MarkupT m a -> MarkupT m b
$c<*> :: forall (m :: * -> *) a b.
Applicative m =>
MarkupT m (a -> b) -> MarkupT m a -> MarkupT m b
pure :: forall a. a -> MarkupT m a
$cpure :: forall (m :: * -> *) a. Applicative m => a -> MarkupT m a
Applicative
#endif
                              ,forall a. a -> MarkupT m a
forall a b. MarkupT m a -> MarkupT m b -> MarkupT m b
forall a b. MarkupT m a -> (a -> MarkupT m b) -> MarkupT m b
forall {m :: * -> *}. Monad m => Applicative (MarkupT m)
forall (m :: * -> *) a. Monad m => a -> MarkupT m a
forall (m :: * -> *) a b.
Monad m =>
MarkupT m a -> MarkupT m b -> MarkupT m b
forall (m :: * -> *) a b.
Monad m =>
MarkupT m a -> (a -> MarkupT m b) -> MarkupT m b
forall (m :: * -> *).
Applicative m
-> (forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
return :: forall a. a -> MarkupT m a
$creturn :: forall (m :: * -> *) a. Monad m => a -> MarkupT m a
>> :: forall a b. MarkupT m a -> MarkupT m b -> MarkupT m b
$c>> :: forall (m :: * -> *) a b.
Monad m =>
MarkupT m a -> MarkupT m b -> MarkupT m b
>>= :: forall a b. MarkupT m a -> (a -> MarkupT m b) -> MarkupT m b
$c>>= :: forall (m :: * -> *) a b.
Monad m =>
MarkupT m a -> (a -> MarkupT m b) -> MarkupT m b
Monad
                              ,MonadWriter Text.Blaze.Markup
                              ,forall (m :: * -> *) a. Monad m => m a -> MarkupT m a
forall (t :: (* -> *) -> * -> *).
(forall (m :: * -> *) a. Monad m => m a -> t m a) -> MonadTrans t
lift :: forall (m :: * -> *) a. Monad m => m a -> MarkupT m a
$clift :: forall (m :: * -> *) a. Monad m => m a -> MarkupT m a
MonadTrans
                              )

type MarkupI a = MarkupT Identity a

-- | Map both the return value and markup of a computation using the
-- given function
mapMarkupT :: (m (a,Text.Blaze.Markup) -> n (b,Text.Blaze.Markup)) -> MarkupT m a -> MarkupT n b
mapMarkupT :: forall (m :: * -> *) a (n :: * -> *) b.
(m (a, Markup) -> n (b, Markup)) -> MarkupT m a -> MarkupT n b
mapMarkupT m (a, Markup) -> n (b, Markup)
f = forall (m :: * -> *) a. WriterT Markup m a -> MarkupT m a
MarkupT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a w (n :: * -> *) b w'.
(m (a, w) -> n (b, w')) -> WriterT w m a -> WriterT w' n b
mapWriterT m (a, Markup) -> n (b, Markup)
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. MarkupT m a -> WriterT Markup m a
fromMarkupT
{-# INLINE mapMarkupT #-}

type MarkupM a = forall m . Monad m => MarkupT m a
type Markup = MarkupM ()
type Markup2 = forall m . Monad m => MarkupT m () -> MarkupT m ()

runMarkupT :: MarkupT m a -> m (a,Text.Blaze.Markup)
runMarkupT :: forall (m :: * -> *) a. MarkupT m a -> m (a, Markup)
runMarkupT = forall w (m :: * -> *) a. WriterT w m a -> m (a, w)
runWriterT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. MarkupT m a -> WriterT Markup m a
fromMarkupT
{-# INLINE runMarkupT #-}

-- | run the MarkupT and return a pair consisting of the result of the
-- computation and the blaze markup rendered with a blaze renderer
-- like 'Text.BlazeT.Renderer.Text.renderHtml'
runWith :: Monad m => (MarkupI () -> c) -> MarkupT m a -> m (a, c)
runWith :: forall (m :: * -> *) c a.
Monad m =>
(MarkupI () -> c) -> MarkupT m a -> m (a, c)
runWith MarkupI () -> c
renderer =  forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (d, b) (d, c)
second forall a b. (a -> b) -> a -> b
$ MarkupI () -> c
renderer forall b c a. (b -> c) -> (a -> b) -> a -> c
. Markup -> Markup
wrapMarkup) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. MarkupT m a -> m (a, Markup)
runMarkupT  
{-# INLINE runWith #-}
  
execMarkupT :: Monad m => MarkupT m a -> m Text.Blaze.Markup
execMarkupT :: forall (m :: * -> *) a. Monad m => MarkupT m a -> m Markup
execMarkupT = forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM forall a b. (a, b) -> b
snd forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. MarkupT m a -> m (a, Markup)
runMarkupT
{-# INLINE execMarkupT #-}

execWith :: Monad m => (MarkupI () -> c) -> MarkupT m a -> m c
execWith :: forall (m :: * -> *) c a.
Monad m =>
(MarkupI () -> c) -> MarkupT m a -> m c
execWith MarkupI () -> c
renderer = forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM forall a b. (a, b) -> b
snd forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) c a.
Monad m =>
(MarkupI () -> c) -> MarkupT m a -> m (a, c)
runWith MarkupI () -> c
renderer
{-# INLINE execWith #-}

runMarkup :: MarkupI a -> (a, Text.Blaze.Markup)
runMarkup :: forall a. MarkupI a -> (a, Markup)
runMarkup = forall a. Identity a -> a
runIdentity forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. MarkupT m a -> m (a, Markup)
runMarkupT
{-# INLINE runMarkup #-}

execMarkup :: MarkupI a -> Text.Blaze.Markup
execMarkup :: forall a. MarkupI a -> Markup
execMarkup = forall a b. (a, b) -> b
snd forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. MarkupI a -> (a, Markup)
runMarkup
{-# INLINE execMarkup #-}

-- | Wrapper for 'Text.Blaze.Markup' is simply
-- 'tell'
wrapMarkupT :: Monad m => Text.Blaze.Markup -> MarkupT m ()
wrapMarkupT :: forall (m :: * -> *). Monad m => Markup -> MarkupT m ()
wrapMarkupT = forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell
{-# INLINE wrapMarkupT #-}

wrapMarkup :: Text.Blaze.Markup -> Markup
wrapMarkup :: Markup -> Markup
wrapMarkup = forall (m :: * -> *). Monad m => Markup -> MarkupT m ()
wrapMarkupT
{-# INLINE wrapMarkup #-}


-- | Wrapper for functions that modify 'Text.Blaze.Markup' is simply
-- 'censor'
wrapMarkupT2 ::  Monad m => (Text.Blaze.Markup -> Text.Blaze.Markup)
                 -> MarkupT m a -> MarkupT m a
wrapMarkupT2 :: forall (m :: * -> *) a.
Monad m =>
(Markup -> Markup) -> MarkupT m a -> MarkupT m a
wrapMarkupT2 = forall w (m :: * -> *) a. MonadWriter w m => (w -> w) -> m a -> m a
censor
{-# INLINE wrapMarkupT2 #-}

wrapMarkup2 :: (Text.Blaze.Markup -> Text.Blaze.Markup) -> Markup2
wrapMarkup2 :: (Markup -> Markup) -> Markup2
wrapMarkup2 = forall (m :: * -> *) a.
Monad m =>
(Markup -> Markup) -> MarkupT m a -> MarkupT m a
wrapMarkupT2
{-# INLINE wrapMarkup2 #-}


mappendMarkupT
#if defined(MIN_VERSION_base)
#  if MIN_VERSION_base(4, 11, 0)
  :: (Monad m, Semigroup a)
#  else
  :: (Monad m, Monoid a)
#  endif
#else
  -- Almost certainly GHC < 8, which corresponds to `base` w/o Semigroup
  :: (Monad m, Monoid a)
#endif
  => MarkupT m a
  -> MarkupT m a
  -> MarkupT m a
MarkupT m a
a mappendMarkupT :: forall (m :: * -> *) a.
(Monad m, Semigroup a) =>
MarkupT m a -> MarkupT m a -> MarkupT m a
`mappendMarkupT` MarkupT m a
b = do {a
a' <- MarkupT m a
a; MarkupT m a
b forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a
a' forall a. Semigroup a => a -> a -> a
<>)}

#if defined(MIN_VERSION_base)
#  if MIN_VERSION_base(4, 11, 0)
instance (Monad m,Semigroup a) => Semigroup (MarkupT m a) where
  <> :: MarkupT m a -> MarkupT m a -> MarkupT m a
(<>) = forall (m :: * -> *) a.
(Monad m, Semigroup a) =>
MarkupT m a -> MarkupT m a -> MarkupT m a
mappendMarkupT
  {-# INLINE (<>) #-}
#  else
instance (Monad m,Monoid a) => Monoid (MarkupT m a) where
  mempty = return mempty
  {-# INLINE mempty #-}
  mappend = mappendMarkupT
  {-# INLINE mappend #-}
#  endif
#else
  -- Almost certainly GHC < 8, which corresponds to `base` w/o Semigroup
instance (Monad m,Monoid a) => Monoid (MarkupT m a) where
  mempty = return mempty
  {-# INLINE mempty #-}
  mappend = mappendMarkupT
  {-# INLINE mappend #-}
#endif


instance Monad m => Text.Blaze.Attributable (MarkupT m a) where
  MarkupT m a
h ! :: MarkupT m a -> Attribute -> MarkupT m a
! Attribute
a = forall (m :: * -> *) a.
Monad m =>
(Markup -> Markup) -> MarkupT m a -> MarkupT m a
wrapMarkupT2 (forall h. Attributable h => h -> Attribute -> h
Text.Blaze.! Attribute
a) MarkupT m a
h
  {-# INLINE (!) #-}

instance Monad m => Text.Blaze.Attributable (a -> MarkupT m b) where
  a -> MarkupT m b
h ! :: (a -> MarkupT m b) -> Attribute -> a -> MarkupT m b
! Attribute
a = \a
x -> forall (m :: * -> *) a.
Monad m =>
(Markup -> Markup) -> MarkupT m a -> MarkupT m a
wrapMarkupT2 (forall h. Attributable h => h -> Attribute -> h
Text.Blaze.! Attribute
a) forall a b. (a -> b) -> a -> b
$ a -> MarkupT m b
h a
x
  {-# INLINE (!) #-}

instance Monad m => IsString (MarkupT m ()) where
  fromString :: String -> MarkupT m ()
fromString = Markup -> Markup
wrapMarkup forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. IsString a => String -> a
fromString
  {-# INLINE fromString #-}

unsafeByteString :: BS.ByteString -> Markup
unsafeByteString :: ByteString -> Markup
unsafeByteString = Markup -> Markup
wrapMarkup forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Markup
Text.Blaze.unsafeByteString
{-# INLINE unsafeByteString #-}

-- | Insert a lazy 'BL.ByteString'. See 'unsafeByteString' for reasons why this
-- is an unsafe operation.
--
unsafeLazyByteString :: BL.ByteString  -- ^ Value to insert
                     -> Markup         -- ^ Resulting HTML fragment
unsafeLazyByteString :: ByteString -> Markup
unsafeLazyByteString = Markup -> Markup
wrapMarkup forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Markup
Text.Blaze.unsafeLazyByteString
{-# INLINE unsafeLazyByteString #-}

external :: Monad m => MarkupT m a -> MarkupT m a
external :: forall (m :: * -> *) a. Monad m => MarkupT m a -> MarkupT m a
external = forall (m :: * -> *) a.
Monad m =>
(Markup -> Markup) -> MarkupT m a -> MarkupT m a
wrapMarkupT2  forall a. MarkupM a -> MarkupM a
Text.Blaze.external
{-# INLINE external #-}

contents :: Monad m => MarkupT m a -> MarkupT m a
contents :: forall (m :: * -> *) a. Monad m => MarkupT m a -> MarkupT m a
contents = forall (m :: * -> *) a.
Monad m =>
(Markup -> Markup) -> MarkupT m a -> MarkupT m a
wrapMarkupT2  forall a. MarkupM a -> MarkupM a
Text.Blaze.contents
{-# INLINE contents #-}

customParent ::Text.Blaze.Tag -> Markup2
customParent :: Tag -> Markup2
customParent = (Markup -> Markup) -> Markup2
wrapMarkup2 forall b c a. (b -> c) -> (a -> b) -> a -> c
. Tag -> Markup -> Markup
Text.Blaze.customParent
{-# INLINE customParent #-}

customLeaf :: Text.Blaze.Tag -> Bool -> Markup
customLeaf :: Tag -> Bool -> Markup
customLeaf = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Markup -> Markup
wrapMarkup forall b c a. (b -> c) -> (a -> b) -> a -> c
. Tag -> Bool -> Markup
Text.Blaze.customLeaf
{-# INLINE customLeaf #-}

preEscapedText :: T.Text -> Markup
preEscapedText :: Text -> Markup
preEscapedText = Markup -> Markup
wrapMarkup forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Markup
Text.Blaze.preEscapedText
{-# INLINE preEscapedText #-}

preEscapedLazyText :: LT.Text -> Markup
preEscapedLazyText :: Text -> Markup
preEscapedLazyText = Markup -> Markup
wrapMarkup forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Markup
Text.Blaze.preEscapedLazyText
{-# INLINE preEscapedLazyText #-}

preEscapedTextBuilder :: LTB.Builder -> Markup
textBuilder :: LTB.Builder -> Markup

#ifdef PRE_BUILDER
preEscapedTextBuilder :: Builder -> Markup
preEscapedTextBuilder = Markup -> Markup
wrapMarkup forall b c a. (b -> c) -> (a -> b) -> a -> c
. Builder -> Markup
Text.Blaze.preEscapedTextBuilder
textBuilder :: Builder -> Markup
textBuilder = Markup -> Markup
wrapMarkup forall b c a. (b -> c) -> (a -> b) -> a -> c
. Builder -> Markup
Text.Blaze.textBuilder
{-# INLINE preEscapedTextBuilder #-}
{-# INLINE textBuilder #-}
#else
preEscapedTextBuilder = error "This function needs blaze-markup 0.7.1.0"
textBuilder = error "This function needs blaze-markup 0.7.1.0"
#endif

preEscapedString :: String -> Markup
preEscapedString :: String -> Markup
preEscapedString = Markup -> Markup
wrapMarkup forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Markup
Text.Blaze.preEscapedString
{-# INLINE preEscapedString #-}

string :: String -> Markup
string :: String -> Markup
string = Markup -> Markup
wrapMarkup forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Markup
Text.Blaze.string
{-# INLINE string #-}

text :: T.Text -> Markup
text :: Text -> Markup
text = Markup -> Markup
wrapMarkup forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Markup
Text.Blaze.text
{-# INLINE text #-}

lazyText :: LT.Text -> Markup
lazyText :: Text -> Markup
lazyText = Markup -> Markup
wrapMarkup forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Markup
Text.Blaze.lazyText
{-# INLINE lazyText #-}


textComment :: T.Text -> Markup
textComment :: Text -> Markup
textComment = Markup -> Markup
wrapMarkup forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Markup
Text.Blaze.textComment

lazyTextComment :: LT.Text -> Markup
lazyTextComment :: Text -> Markup
lazyTextComment = Markup -> Markup
wrapMarkup forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Markup
Text.Blaze.lazyTextComment

stringComment :: String -> Markup
stringComment :: String -> Markup
stringComment = Markup -> Markup
wrapMarkup forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Markup
Text.Blaze.stringComment

unsafeByteStringComment :: BS.ByteString -> Markup
unsafeByteStringComment :: ByteString -> Markup
unsafeByteStringComment = Markup -> Markup
wrapMarkup forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Markup
Text.Blaze.unsafeByteStringComment

unsafeLazyByteStringComment :: BL.ByteString -> Markup
unsafeLazyByteStringComment :: ByteString -> Markup
unsafeLazyByteStringComment = Markup -> Markup
wrapMarkup forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Markup
Text.Blaze.unsafeLazyByteStringComment

-- $descr1
-- The following is an adaptation of all "Text.Blaze.Internal" exports to
-- @blazeT@ types.
-- 
-- Entities that are reexported from "Text.Blaze.Internal" have the original
-- documentation attached to them.
--
-- Entities that had to be adapted are tagged with \"(Adapted)\". For
-- their documentation consult the "Text.Blaze.Internal" documentation.