From f328ae15d5d28b0bd620ef55a1009802184fb343 Mon Sep 17 00:00:00 2001
From: Packit <packit>
Date: Sep 25 2020 12:57:27 +0000
Subject: ghc-blaze-markup-0.8.0.0 base


---

diff --git a/CHANGELOG b/CHANGELOG
new file mode 100644
index 0000000..7a9fa51
--- /dev/null
+++ b/CHANGELOG
@@ -0,0 +1,46 @@
+# Changelog
+
+- 0.8.0.0 (2017-01-30)
+    * Make `MarkupM` finally adhere to the Monad laws
+    * Stricten the `IsString` instance to only work with `MarkupM ()` and not
+      `MarkupM a`
+    * Change the type of `contents` to `MarkupM a -> MarkupM a`
+    * Add a `Semigroup` instance for `MarkupM`
+
+- 0.7.1.1
+    * Bump `HUnit` dependency to allow 1.5
+
+- 0.7.1.0
+    * Relax `QuickCheck` dependency to allow 2.9
+    * Add text builder instances
+
+- 0.7.0.3
+    * Relax `HUnit` dependency to allow 1.3
+
+- 0.7.0.2
+    * Relax `blaze-builder` dependency to allow 0.3
+
+- 0.7.0.1
+    * Bump `QuickCheck` dependency to allow 2.8
+
+- 0.7.0.0
+    * Depend on blaze-builder 0.4
+
+- 0.6.3.0
+    * Add combinators to insert HTML comments
+
+- 0.6.2.0
+    * Add `Applicative` instance for `MarkupM`
+
+- 0.6.1.1
+    * Bump `text` dependency to allow 1.2
+
+- 0.6.1.0
+    * Add the `null` query to Text.Blaze.Internal.
+
+- 0.6.0.0
+    * Add the operator (!?) for nicely setting conditional attributes
+
+- 0.5.2.0
+    * Provide ToHtml and ToValue instances for Int32, Int64, Word, Word32,
+      and Word64
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..8122505
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,30 @@
+Copyright Jasper Van der Jeugt 2010
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+
+    * Neither the name of Jasper Van der Jeugt nor the names of other
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/Setup.hs b/Setup.hs
new file mode 100644
index 0000000..9a994af
--- /dev/null
+++ b/Setup.hs
@@ -0,0 +1,2 @@
+import Distribution.Simple
+main = defaultMain
diff --git a/blaze-markup.cabal b/blaze-markup.cabal
new file mode 100644
index 0000000..978b543
--- /dev/null
+++ b/blaze-markup.cabal
@@ -0,0 +1,67 @@
+Name:         blaze-markup
+Version:      0.8.0.0
+Homepage:     http://jaspervdj.be/blaze
+Bug-Reports:  http://github.com/jaspervdj/blaze-markup/issues
+License:      BSD3
+License-file: LICENSE
+Author:       Jasper Van der Jeugt, Simon Meier, Deepak Jois
+Maintainer:   Jasper Van der Jeugt <m@jaspervdj.be>
+Stability:    Experimental
+Category:     Text
+Synopsis:     A blazingly fast markup combinator library for Haskell
+Description:
+  Core modules of a blazingly fast markup combinator library for the Haskell
+  programming language. The Text.Blaze module is a good
+  starting point, as well as this tutorial:
+  <http://jaspervdj.be/blaze/tutorial.html>.
+
+Build-type:    Simple
+Cabal-version: >= 1.8
+
+Extra-source-files:
+  CHANGELOG
+
+Library
+  Hs-source-dirs: src
+  Ghc-Options:    -Wall
+
+  Exposed-modules:
+    Text.Blaze
+    Text.Blaze.Internal
+    Text.Blaze.Renderer.Pretty
+    Text.Blaze.Renderer.String
+    Text.Blaze.Renderer.Text
+    Text.Blaze.Renderer.Utf8
+
+  Build-depends:
+    base          >= 4    && < 5,
+    blaze-builder >= 0.3  && < 0.5,
+    text          >= 0.10 && < 1.3,
+    bytestring    >= 0.9  && < 0.11
+
+Test-suite blaze-markup-tests
+  Type:           exitcode-stdio-1.0
+  Hs-source-dirs: src tests
+  Main-is:        TestSuite.hs
+  Ghc-options:    -Wall
+
+  Other-modules:
+    Text.Blaze.Tests
+    Text.Blaze.Tests.Util
+
+  Build-depends:
+    HUnit                      >= 1.2 && < 1.6,
+    QuickCheck                 >= 2.4 && < 2.10,
+    containers                 >= 0.3 && < 0.6,
+    test-framework             >= 0.4 && < 0.9,
+    test-framework-hunit       >= 0.3 && < 0.4,
+    test-framework-quickcheck2 >= 0.3 && < 0.4,
+    -- Copied from regular dependencies...
+    base          >= 4    && < 5,
+    blaze-builder >= 0.3  && < 0.5,
+    text          >= 0.10 && < 1.3,
+    bytestring    >= 0.9  && < 0.11
+
+Source-repository head
+  Type:     git
+  Location: http://github.com/jaspervdj/blaze-markup
diff --git a/src/Text/Blaze.hs b/src/Text/Blaze.hs
new file mode 100644
index 0000000..ab184df
--- /dev/null
+++ b/src/Text/Blaze.hs
@@ -0,0 +1,272 @@
+{-# LANGUAGE FlexibleInstances    #-}
+{-# LANGUAGE OverloadedStrings    #-}
+{-# LANGUAGE TypeSynonymInstances #-}
+-- | BlazeMarkup is a markup combinator library. It provides a way to embed
+-- markup languages like HTML and SVG in Haskell in an efficient and convenient
+-- way, with a light-weight syntax.
+--
+-- To use the library, one needs to import a set of combinators. For example,
+-- you can use HTML 4 Strict from BlazeHtml package.
+--
+-- > {-# LANGUAGE OverloadedStrings #-}
+-- > import Prelude hiding (head, id, div)
+-- > import Text.Blaze.Html4.Strict hiding (map)
+-- > import Text.Blaze.Html4.Strict.Attributes hiding (title)
+--
+-- To render the page later on, you need a so called Renderer. The recommended
+-- renderer is an UTF-8 renderer which produces a lazy bytestring.
+--
+-- > import Text.Blaze.Renderer.Utf8 (renderMarkup)
+--
+-- Now, you can describe pages using the imported combinators.
+--
+-- > page1 :: Markup
+-- > page1 = html $ do
+-- >     head $ do
+-- >         title "Introduction page."
+-- >         link ! rel "stylesheet" ! type_ "text/css" ! href "screen.css"
+-- >     body $ do
+-- >         div ! id "header" $ "Syntax"
+-- >         p "This is an example of BlazeMarkup syntax."
+-- >         ul $ mapM_ (li . toMarkup . show) [1, 2, 3]
+--
+-- The resulting HTML can now be extracted using:
+--
+-- > renderMarkup page1
+--
+module Text.Blaze
+    (
+      -- * Important types.
+      Markup
+    , Tag
+    , Attribute
+    , AttributeValue
+
+      -- * Creating attributes.
+    , dataAttribute
+    , customAttribute
+
+      -- * Converting values to Markup.
+    , ToMarkup (..)
+    , text
+    , preEscapedText
+    , lazyText
+    , preEscapedLazyText
+    , string
+    , preEscapedString
+    , unsafeByteString
+    , unsafeLazyByteString
+
+      -- * Comments
+    , textComment
+    , lazyTextComment
+    , stringComment
+    , unsafeByteStringComment
+    , unsafeLazyByteStringComment
+
+      -- * Creating tags.
+    , textTag
+    , stringTag
+
+      -- * Converting values to attribute values.
+    , ToValue (..)
+    , textValue
+    , preEscapedTextValue
+    , lazyTextValue
+    , preEscapedLazyTextValue
+    , stringValue
+    , preEscapedStringValue
+    , unsafeByteStringValue
+    , unsafeLazyByteStringValue
+
+      -- * Setting attributes
+    , (!)
+    , (!?)
+
+      -- * Modifiying Markup trees
+    , contents
+    ) where
+
+import           Data.Int            (Int32, Int64)
+import           Data.Monoid         (mconcat)
+import           Data.Word           (Word, Word32, Word64)
+
+import           Data.Text           (Text)
+import qualified Data.Text.Lazy      as LT
+import qualified Data.Text.Lazy.Builder as LTB
+
+import           Text.Blaze.Internal
+
+-- | Class allowing us to use a single function for Markup values
+--
+class ToMarkup a where
+    -- | Convert a value to Markup.
+    --
+    toMarkup :: a -> Markup
+
+    -- | Convert a value to Markup without escaping
+    --
+    preEscapedToMarkup :: a -> Markup
+    preEscapedToMarkup = toMarkup
+    {-# INLINE preEscapedToMarkup #-}
+
+instance ToMarkup Markup where
+    toMarkup = id
+    {-# INLINE toMarkup #-}
+
+instance ToMarkup [Markup] where
+    toMarkup = mconcat
+    {-# INLINE toMarkup #-}
+
+instance ToMarkup Text where
+    toMarkup = text
+    {-# INLINE toMarkup #-}
+    preEscapedToMarkup = preEscapedText
+    {-# INLINE preEscapedToMarkup #-}
+
+instance ToMarkup LT.Text where
+    toMarkup = lazyText
+    {-# INLINE toMarkup #-}
+    preEscapedToMarkup = preEscapedLazyText
+    {-# INLINE preEscapedToMarkup #-}
+
+instance ToMarkup LTB.Builder where
+    toMarkup = textBuilder
+    {-# INLINE toMarkup #-}
+    preEscapedToMarkup = preEscapedTextBuilder
+    {-# INLINE preEscapedToMarkup #-}
+
+instance ToMarkup String where
+    toMarkup = string
+    {-# INLINE toMarkup #-}
+    preEscapedToMarkup = preEscapedString
+    {-# INLINE preEscapedToMarkup #-}
+
+instance ToMarkup Int where
+    toMarkup = string . show
+    {-# INLINE toMarkup #-}
+
+instance ToMarkup Int32 where
+    toMarkup = string . show
+    {-# INLINE toMarkup #-}
+
+instance ToMarkup Int64 where
+    toMarkup = string . show
+    {-# INLINE toMarkup #-}
+
+instance ToMarkup Char where
+    toMarkup = string . return
+    {-# INLINE toMarkup #-}
+
+instance ToMarkup Bool where
+    toMarkup = string . show
+    {-# INLINE toMarkup #-}
+
+instance ToMarkup Integer where
+    toMarkup = string . show
+    {-# INLINE toMarkup #-}
+
+instance ToMarkup Float where
+    toMarkup = string . show
+    {-# INLINE toMarkup #-}
+
+instance ToMarkup Double where
+    toMarkup = string . show
+    {-# INLINE toMarkup #-}
+
+instance ToMarkup Word where
+    toMarkup = string . show
+    {-# INLINE toMarkup #-}
+
+instance ToMarkup Word32 where
+    toMarkup = string . show
+    {-# INLINE toMarkup #-}
+
+instance ToMarkup Word64 where
+    toMarkup = string . show
+    {-# INLINE toMarkup #-}
+
+-- | Class allowing us to use a single function for attribute values
+--
+class ToValue a where
+    -- | Convert a value to an attribute value
+    --
+    toValue :: a -> AttributeValue
+
+    -- | Convert a value to an attribute value without escaping
+    --
+    preEscapedToValue :: a -> AttributeValue
+    preEscapedToValue = toValue
+    {-# INLINE preEscapedToValue #-}
+
+instance ToValue AttributeValue where
+    toValue = id
+    {-# INLINE toValue #-}
+
+instance ToValue Text where
+    toValue = textValue
+    {-# INLINE toValue #-}
+    preEscapedToValue = preEscapedTextValue
+    {-# INLINE preEscapedToValue #-}
+
+instance ToValue LT.Text where
+    toValue = lazyTextValue
+    {-# INLINE toValue #-}
+    preEscapedToValue = preEscapedLazyTextValue
+    {-# INLINE preEscapedToValue #-}
+
+instance ToValue LTB.Builder where
+    toValue = textBuilderValue
+    {-# INLINE toValue #-}
+    preEscapedToValue = preEscapedTextBuilderValue
+    {-# INLINE preEscapedToValue #-}
+
+instance ToValue String where
+    toValue = stringValue
+    {-# INLINE toValue #-}
+    preEscapedToValue = preEscapedStringValue
+    {-# INLINE preEscapedToValue #-}
+
+instance ToValue Int where
+    toValue = stringValue . show
+    {-# INLINE toValue #-}
+
+instance ToValue Int32 where
+    toValue = stringValue . show
+    {-# INLINE toValue #-}
+
+instance ToValue Int64 where
+    toValue = stringValue . show
+    {-# INLINE toValue #-}
+
+instance ToValue Char where
+    toValue = stringValue . return
+    {-# INLINE toValue #-}
+
+instance ToValue Bool where
+    toValue = stringValue . show
+    {-# INLINE toValue #-}
+
+instance ToValue Integer where
+    toValue = stringValue . show
+    {-# INLINE toValue #-}
+
+instance ToValue Float where
+    toValue = stringValue . show
+    {-# INLINE toValue #-}
+
+instance ToValue Double where
+    toValue = stringValue . show
+    {-# INLINE toValue #-}
+
+instance ToValue Word where
+    toValue = stringValue . show
+    {-# INLINE toValue #-}
+
+instance ToValue Word32 where
+    toValue = stringValue . show
+    {-# INLINE toValue #-}
+
+instance ToValue Word64 where
+    toValue = stringValue . show
+    {-# INLINE toValue #-}
diff --git a/src/Text/Blaze/Internal.hs b/src/Text/Blaze/Internal.hs
new file mode 100644
index 0000000..1bc6ff1
--- /dev/null
+++ b/src/Text/Blaze/Internal.hs
@@ -0,0 +1,621 @@
+{-# LANGUAGE CPP                        #-}
+{-# LANGUAGE DeriveDataTypeable         #-}
+{-# LANGUAGE ExistentialQuantification  #-}
+{-# LANGUAGE FlexibleInstances          #-}
+{-# LANGUAGE GADTs                      #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+{-# LANGUAGE OverloadedStrings          #-}
+{-# LANGUAGE Rank2Types                 #-}
+-- | The BlazeMarkup core, consisting of functions that offer the power to
+-- generate custom markup elements. It also offers user-centric functions,
+-- which are exposed through 'Text.Blaze'.
+--
+-- While this module is exported, usage of it is not recommended, unless you
+-- know what you are doing. This module might undergo changes at any time.
+--
+module Text.Blaze.Internal
+    (
+      -- * Important types.
+      ChoiceString (..)
+    , StaticString (..)
+    , MarkupM (..)
+    , Markup
+    , Tag
+    , Attribute
+    , AttributeValue
+
+      -- * Creating custom tags and attributes.
+    , customParent
+    , customLeaf
+    , attribute
+    , dataAttribute
+    , 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.
+    , textTag
+    , stringTag
+
+      -- * Converting values to attribute values.
+    , textValue
+    , preEscapedTextValue
+    , lazyTextValue
+    , preEscapedLazyTextValue
+    , textBuilderValue
+    , preEscapedTextBuilderValue
+    , stringValue
+    , preEscapedStringValue
+    , unsafeByteStringValue
+    , unsafeLazyByteStringValue
+
+      -- * Setting attributes
+    , Attributable
+    , (!)
+    , (!?)
+
+      -- * Modifying Markup elements
+    , contents
+    , external
+
+      -- * Querying Markup elements
+    , null
+    ) where
+
+import           Control.Applicative    (Applicative (..))
+import qualified Data.List              as List
+import           Data.Monoid            (Monoid, mappend, mconcat, mempty)
+import           Prelude                hiding (null)
+
+import qualified Data.ByteString        as B
+import           Data.ByteString.Char8  (ByteString)
+import qualified Data.ByteString.Lazy   as BL
+import           Data.Text              (Text)
+import qualified Data.Text              as T
+import qualified Data.Text.Encoding     as T
+import qualified Data.Text.Lazy         as LT
+import qualified Data.Text.Lazy.Builder as LTB
+import           Data.Typeable          (Typeable)
+import           GHC.Exts               (IsString (..))
+
+#if MIN_VERSION_base(4,9,0)
+import           Data.Semigroup         (Semigroup)
+#endif
+
+-- | A static string that supports efficient output to all possible backends.
+--
+data StaticString = StaticString
+    { getString         :: String -> String  -- ^ Appending haskell string
+    , getUtf8ByteString :: B.ByteString      -- ^ UTF-8 encoded bytestring
+    , getText           :: Text              -- ^ Text value
+    }
+
+-- 'StaticString's should only be converted from string literals, as far as I
+-- can see.
+--
+instance IsString StaticString where
+    fromString s = let t = T.pack s
+                   in StaticString (s ++) (T.encodeUtf8 t) t
+
+-- | A string denoting input from different string representations.
+--
+data ChoiceString
+    -- | Static data
+    = Static {-# UNPACK #-} !StaticString
+    -- | A Haskell String
+    | String String
+    -- | A Text value
+    | Text Text
+    -- | An encoded bytestring
+    | ByteString B.ByteString
+    -- | A pre-escaped string
+    | PreEscaped ChoiceString
+    -- | External data in style/script tags, should be checked for validity
+    | External ChoiceString
+    -- | Concatenation
+    | AppendChoiceString ChoiceString ChoiceString
+    -- | Empty string
+    | EmptyChoiceString
+
+instance Monoid ChoiceString where
+    mempty = EmptyChoiceString
+    {-# INLINE mempty #-}
+    mappend = AppendChoiceString
+    {-# INLINE mappend #-}
+
+instance IsString ChoiceString where
+    fromString = String
+    {-# INLINE fromString #-}
+
+-- | The core Markup datatype.
+--
+data MarkupM a
+    -- | Tag, open tag, end tag, content
+    = Parent StaticString StaticString StaticString (MarkupM a)
+    -- | Custom parent
+    | CustomParent ChoiceString (MarkupM a)
+    -- | Tag, open tag, end tag
+    | Leaf StaticString StaticString StaticString a
+    -- | Custom leaf
+    | CustomLeaf ChoiceString Bool a
+    -- | HTML content
+    | Content ChoiceString a
+    -- | HTML comment. Note: you should wrap the 'ChoiceString' in a
+    -- 'PreEscaped'.
+    | Comment ChoiceString a
+    -- | Concatenation of two HTML pieces
+    | forall b. Append (MarkupM b) (MarkupM a)
+    -- | Add an attribute to the inner HTML. Raw key, key, value, HTML to
+    -- receive the attribute.
+    | AddAttribute StaticString StaticString ChoiceString (MarkupM a)
+    -- | Add a custom attribute to the inner HTML.
+    | AddCustomAttribute ChoiceString ChoiceString (MarkupM a)
+    -- | Empty HTML.
+    | Empty a
+    deriving (Typeable)
+
+-- | Simplification of the 'MarkupM' datatype.
+--
+type Markup = MarkupM ()
+
+instance Monoid a => Monoid (MarkupM a) where
+    mempty = Empty mempty
+    {-# INLINE mempty #-}
+    mappend x y = Append x y
+    {-# INLINE mappend #-}
+    mconcat = foldr Append (Empty mempty)
+    {-# INLINE mconcat #-}
+
+#if MIN_VERSION_base(4,9,0)
+instance Monoid a => Semigroup (MarkupM a) where
+#endif
+
+instance Functor MarkupM where
+    fmap f x =
+        -- Instead of traversing through all the nodes, we just store an extra
+        -- 'Empty' node with the new result.
+        Append x (Empty (f (markupValue x)))
+
+instance Applicative MarkupM where
+    pure x = Empty x
+    {-# INLINE pure #-}
+    (<*>) x y =
+        -- We need to add an extra 'Empty' node to store the result.
+        Append (Append x y) (Empty (markupValue x (markupValue y)))
+    {-# INLINE (<*>) #-}
+    (*>) = Append
+    {-# INLINE (*>) #-}
+    -- (<*) = Append
+    -- {-# INLINE (<*) #-}
+
+instance Monad MarkupM where
+    return x = Empty x
+    {-# INLINE return #-}
+    (>>) = Append
+    {-# INLINE (>>) #-}
+    h1 >>= f = Append h1 (f (markupValue h1))
+    {-# INLINE (>>=) #-}
+
+instance (a ~ ()) => IsString (MarkupM a) where
+    fromString x = Content (fromString x) mempty
+    {-# INLINE fromString #-}
+
+-- | Get the value from a 'MarkupM'.
+--
+markupValue :: MarkupM a -> a
+markupValue m0 = case m0 of
+    Parent _ _ _ m1           -> markupValue m1
+    CustomParent _ m1         -> markupValue m1
+    Leaf _ _ _ x              -> x
+    CustomLeaf _ _ x          -> x
+    Content _ x               -> x
+    Comment _ x               -> x
+    Append _ m1               -> markupValue m1
+    AddAttribute _ _ _ m1     -> markupValue m1
+    AddCustomAttribute _ _ m1 -> markupValue m1
+    Empty x                   -> x
+
+-- | Type for an HTML tag. This can be seen as an internal string type used by
+-- BlazeMarkup.
+--
+newtype Tag = Tag { unTag :: StaticString }
+    deriving (IsString)
+
+-- | Type for an attribute.
+--
+newtype Attribute = Attribute (forall a. MarkupM a -> MarkupM a)
+
+instance Monoid Attribute where
+    mempty                            = Attribute id
+    Attribute f `mappend` Attribute g = Attribute (g . f)
+
+-- | The type for the value part of an attribute.
+--
+newtype AttributeValue = AttributeValue { unAttributeValue :: ChoiceString }
+    deriving (IsString, Monoid)
+
+-- | Create a custom parent element
+customParent :: Tag     -- ^ Element tag
+             -> Markup  -- ^ Content
+             -> Markup  -- ^ Resulting markup
+customParent tag cont = CustomParent (Static $ unTag tag) cont
+
+-- | Create a custom leaf element
+customLeaf :: Tag     -- ^ Element tag
+           -> Bool    -- ^ Close the leaf?
+           -> Markup  -- ^ Resulting markup
+customLeaf tag close = CustomLeaf (Static $ unTag tag) close ()
+
+-- | Create an HTML attribute that can be applied to an HTML element later using
+-- the '!' operator.
+--
+attribute :: Tag             -- ^ Raw key
+          -> Tag             -- ^ Shared key string for the HTML attribute.
+          -> AttributeValue  -- ^ Value for the HTML attribute.
+          -> Attribute       -- ^ Resulting HTML attribute.
+attribute rawKey key value = Attribute $
+    AddAttribute (unTag rawKey) (unTag key) (unAttributeValue value)
+{-# INLINE attribute #-}
+
+-- | From HTML 5 onwards, the user is able to specify custom data attributes.
+--
+-- An example:
+--
+-- > <p data-foo="bar">Hello.</p>
+--
+-- We support this in BlazeMarkup using this function. The above fragment could
+-- be described using BlazeMarkup with:
+--
+-- > p ! dataAttribute "foo" "bar" $ "Hello."
+--
+dataAttribute :: Tag             -- ^ Name of the attribute.
+              -> AttributeValue  -- ^ Value for the attribute.
+              -> Attribute       -- ^ Resulting HTML attribute.
+dataAttribute tag value = Attribute $ AddCustomAttribute
+    (Static "data-" `mappend` Static (unTag tag))
+    (unAttributeValue value)
+{-# INLINE dataAttribute #-}
+
+-- | Create a custom attribute. This is not specified in the HTML spec, but some
+-- JavaScript libraries rely on it.
+--
+-- An example:
+--
+-- > <select dojoType="select">foo</select>
+--
+-- Can be produced using:
+--
+-- > select ! customAttribute "dojoType" "select" $ "foo"
+--
+customAttribute :: Tag             -- ^ Name of the attribute
+                -> AttributeValue  -- ^ Value for the attribute
+                -> Attribute       -- ^ Resulting HTML attribtue
+customAttribute tag value = Attribute $ AddCustomAttribute
+    (Static $ unTag tag)
+    (unAttributeValue value)
+{-# INLINE customAttribute #-}
+
+-- | Render text. Functions like these can be used to supply content in HTML.
+--
+text :: Text    -- ^ Text to render.
+     -> Markup  -- ^ Resulting HTML fragment.
+text = content . Text
+{-# INLINE text #-}
+
+-- | Render text without escaping.
+--
+preEscapedText :: Text    -- ^ Text to insert
+               -> Markup  -- ^ Resulting HTML fragment
+preEscapedText = content . PreEscaped . Text
+{-# INLINE preEscapedText #-}
+
+-- | A variant of 'text' for lazy 'LT.Text'.
+--
+lazyText :: LT.Text  -- ^ Text to insert
+         -> Markup   -- ^ Resulting HTML fragment
+lazyText = mconcat . map text . LT.toChunks
+{-# INLINE lazyText #-}
+
+-- | A variant of 'preEscapedText' for lazy 'LT.Text'
+--
+preEscapedLazyText :: LT.Text  -- ^ Text to insert
+                   -> Markup   -- ^ Resulting HTML fragment
+preEscapedLazyText = mconcat . map preEscapedText . LT.toChunks
+{-# INLINE preEscapedLazyText #-}
+
+-- | A variant of 'text' for text 'LTB.Builder'.
+--
+textBuilder :: LTB.Builder -- ^ Text to insert
+            -> Markup      -- ^ Resulting HTML fragment
+textBuilder = lazyText . LTB.toLazyText
+{-# INLINE textBuilder #-}
+
+-- | A variant of 'preEscapedText' for lazy 'LT.Text'
+--
+preEscapedTextBuilder :: LTB.Builder -- ^ Text to insert
+                      -> Markup      -- ^ Resulting HTML fragment
+preEscapedTextBuilder = preEscapedLazyText . LTB.toLazyText
+{-# INLINE preEscapedTextBuilder #-}
+
+content :: ChoiceString -> Markup
+content cs = Content cs ()
+{-# INLINE content #-}
+
+-- | Create an HTML snippet from a 'String'.
+--
+string :: String  -- ^ String to insert.
+       -> Markup  -- ^ Resulting HTML fragment.
+string = content . String
+{-# INLINE string #-}
+
+-- | Create an HTML snippet from a 'String' without escaping
+--
+preEscapedString :: String  -- ^ String to insert.
+                 -> Markup  -- ^ Resulting HTML fragment.
+preEscapedString = content . PreEscaped . String
+{-# INLINE preEscapedString #-}
+
+-- | Insert a 'ByteString'. This is an unsafe operation:
+--
+-- * The 'ByteString' could have the wrong encoding.
+--
+-- * The 'ByteString' might contain illegal HTML characters (no escaping is
+--   done).
+--
+unsafeByteString :: ByteString  -- ^ Value to insert.
+                 -> Markup      -- ^ Resulting HTML fragment.
+unsafeByteString = content . ByteString
+{-# 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 = mconcat . map unsafeByteString . BL.toChunks
+{-# INLINE unsafeLazyByteString #-}
+
+comment :: ChoiceString -> Markup
+comment cs = Comment cs ()
+{-# INLINE comment #-}
+
+-- | Create a comment from a 'Text' value.
+-- The text should not contain @"--"@.
+-- This is not checked by the library.
+textComment :: Text -> Markup
+textComment = comment . PreEscaped . Text
+
+-- | Create a comment from a 'LT.Text' value.
+-- The text should not contain @"--"@.
+-- This is not checked by the library.
+lazyTextComment :: LT.Text -> Markup
+lazyTextComment = comment . mconcat . map (PreEscaped . Text) . LT.toChunks
+
+-- | Create a comment from a 'String' value.
+-- The text should not contain @"--"@.
+-- This is not checked by the library.
+stringComment :: String -> Markup
+stringComment = comment . PreEscaped . String
+
+-- | Create a comment from a 'ByteString' value.
+-- The text should not contain @"--"@.
+-- This is not checked by the library.
+unsafeByteStringComment :: ByteString -> Markup
+unsafeByteStringComment = comment . PreEscaped . ByteString
+
+-- | Create a comment from a 'BL.ByteString' value.
+-- The text should not contain @"--"@.
+-- This is not checked by the library.
+unsafeLazyByteStringComment :: BL.ByteString -> Markup
+unsafeLazyByteStringComment =
+    comment . mconcat . map (PreEscaped . ByteString) . BL.toChunks
+
+-- | Create a 'Tag' from some 'Text'.
+--
+textTag :: Text  -- ^ Text to create a tag from
+        -> Tag   -- ^ Resulting tag
+textTag t = Tag $ StaticString (T.unpack t ++) (T.encodeUtf8 t) t
+
+-- | Create a 'Tag' from a 'String'.
+--
+stringTag :: String  -- ^ String to create a tag from
+          -> Tag     -- ^ Resulting tag
+stringTag = Tag . fromString
+
+-- | Render an attribute value from 'Text'.
+--
+textValue :: Text            -- ^ The actual value.
+          -> AttributeValue  -- ^ Resulting attribute value.
+textValue = AttributeValue . Text
+{-# INLINE textValue #-}
+
+-- | Render an attribute value from 'Text' without escaping.
+--
+preEscapedTextValue :: Text            -- ^ The actual value
+                    -> AttributeValue  -- ^ Resulting attribute value
+preEscapedTextValue = AttributeValue . PreEscaped . Text
+{-# INLINE preEscapedTextValue #-}
+
+-- | A variant of 'textValue' for lazy 'LT.Text'
+--
+lazyTextValue :: LT.Text         -- ^ The actual value
+              -> AttributeValue  -- ^ Resulting attribute value
+lazyTextValue = mconcat . map textValue . LT.toChunks
+{-# INLINE lazyTextValue #-}
+
+-- | A variant of 'preEscapedTextValue' for lazy 'LT.Text'
+--
+preEscapedLazyTextValue :: LT.Text         -- ^ The actual value
+                        -> AttributeValue  -- ^ Resulting attribute value
+preEscapedLazyTextValue = mconcat . map preEscapedTextValue . LT.toChunks
+{-# INLINE preEscapedLazyTextValue #-}
+
+-- | A variant of 'textValue' for text 'LTB.Builder'
+--
+textBuilderValue :: LTB.Builder    -- ^ The actual value
+                 -> AttributeValue -- ^ Resulting attribute value
+textBuilderValue = lazyTextValue . LTB.toLazyText
+{-# INLINE textBuilderValue #-}
+
+-- | A variant of 'preEscapedTextValue' for text 'LTB.Builder'
+--
+preEscapedTextBuilderValue :: LTB.Builder    -- ^ The actual value
+                           -> AttributeValue -- ^ Resulting attribute value
+preEscapedTextBuilderValue = preEscapedLazyTextValue . LTB.toLazyText
+{-# INLINE preEscapedTextBuilderValue #-}
+
+-- | Create an attribute value from a 'String'.
+--
+stringValue :: String -> AttributeValue
+stringValue = AttributeValue . String
+{-# INLINE stringValue #-}
+
+-- | Create an attribute value from a 'String' without escaping.
+--
+preEscapedStringValue :: String -> AttributeValue
+preEscapedStringValue = AttributeValue . PreEscaped . String
+{-# INLINE preEscapedStringValue #-}
+
+-- | Create an attribute value from a 'ByteString'. See 'unsafeByteString'
+-- for reasons why this might not be a good idea.
+--
+unsafeByteStringValue :: ByteString      -- ^ ByteString value
+                      -> AttributeValue  -- ^ Resulting attribute value
+unsafeByteStringValue = AttributeValue . ByteString
+{-# INLINE unsafeByteStringValue #-}
+
+-- | Create an attribute value from a lazy 'BL.ByteString'. See
+-- 'unsafeByteString' for reasons why this might not be a good idea.
+--
+unsafeLazyByteStringValue :: BL.ByteString   -- ^ ByteString value
+                          -> AttributeValue  -- ^ Resulting attribute value
+unsafeLazyByteStringValue = mconcat . map unsafeByteStringValue . BL.toChunks
+{-# INLINE unsafeLazyByteStringValue #-}
+
+-- | Used for applying attributes. You should not define your own instances of
+-- this class.
+class Attributable h where
+    -- | Apply an attribute to an element.
+    --
+    -- Example:
+    --
+    -- > img ! src "foo.png"
+    --
+    -- Result:
+    --
+    -- > <img src="foo.png" />
+    --
+    -- This can be used on nested elements as well.
+    --
+    -- Example:
+    --
+    -- > p ! style "float: right" $ "Hello!"
+    --
+    -- Result:
+    --
+    -- > <p style="float: right">Hello!</p>
+    --
+    (!) :: h -> Attribute -> h
+
+instance Attributable (MarkupM a) where
+    h ! (Attribute f) = f h
+    {-# INLINE (!) #-}
+
+instance Attributable (MarkupM a -> MarkupM b) where
+    h ! f = (! f) . h
+    {-# INLINE (!) #-}
+
+-- | Shorthand for setting an attribute depending on a conditional.
+--
+-- Example:
+--
+-- > p !? (isBig, A.class "big") $ "Hello"
+--
+-- Gives the same result as:
+--
+-- > (if isBig then p ! A.class "big" else p) "Hello"
+--
+(!?) :: Attributable h => h -> (Bool, Attribute) -> h
+(!?) h (c, a) = if c then h ! a else h
+
+-- | Mark HTML as external data. External data can be:
+--
+-- * CSS data in a @<style>@ tag;
+--
+-- * Script data in a @<script>@ tag.
+--
+-- This function is applied automatically when using the @style@ or @script@
+-- combinators.
+--
+external :: MarkupM a -> MarkupM a
+external (Content x a)              = Content (External x) a
+external (Append x y)               = Append (external x) (external y)
+external (Parent x y z i)           = Parent x y z $ external i
+external (CustomParent x i)         = CustomParent x $ external i
+external (AddAttribute x y z i)     = AddAttribute x y z $ external i
+external (AddCustomAttribute x y i) = AddCustomAttribute x y $ external i
+external x                          = x
+{-# INLINE external #-}
+
+-- | Take only the text content of an HTML tree.
+--
+-- > contents $ do
+-- >     p ! $ "Hello "
+-- >     p ! $ "Word!"
+--
+-- Result:
+--
+-- > Hello World!
+--
+contents :: MarkupM a -> MarkupM a
+contents (Parent _ _ _ c)           = contents c
+contents (CustomParent _ c)         = contents c
+contents (Content c x)              = Content c x
+contents (Append c1 c2)             = Append (contents c1) (contents c2)
+contents (AddAttribute _ _ _ c)     = contents c
+contents (AddCustomAttribute _ _ c) = contents c
+contents m                          = Empty (markupValue m)
+
+-- | Check if a 'Markup' value is completely empty (renders to the empty
+-- string).
+null :: MarkupM a -> Bool
+null markup = case markup of
+    Parent _ _ _ _           -> False
+    CustomParent _ _         -> False
+    Leaf _ _ _ _             -> False
+    CustomLeaf _ _ _         -> False
+    Content c _              -> emptyChoiceString c
+    Comment c _              -> emptyChoiceString c
+    Append c1 c2             -> null c1 && null c2
+    AddAttribute _ _ _ c     -> null c
+    AddCustomAttribute _ _ c -> null c
+    Empty _                  -> True
+  where
+    emptyChoiceString cs = case cs of
+        Static ss                -> emptyStaticString ss
+        String s                 -> List.null s
+        Text t                   -> T.null t
+        ByteString bs            -> B.null bs
+        PreEscaped c             -> emptyChoiceString c
+        External c               -> emptyChoiceString c
+        AppendChoiceString c1 c2 -> emptyChoiceString c1 && emptyChoiceString c2
+        EmptyChoiceString        -> True
+
+    emptyStaticString = B.null . getUtf8ByteString
diff --git a/src/Text/Blaze/Renderer/Pretty.hs b/src/Text/Blaze/Renderer/Pretty.hs
new file mode 100644
index 0000000..34c9802
--- /dev/null
+++ b/src/Text/Blaze/Renderer/Pretty.hs
@@ -0,0 +1,60 @@
+-- | A renderer that produces pretty HTML, mostly meant for debugging purposes.
+--
+module Text.Blaze.Renderer.Pretty
+    ( renderMarkup
+    , renderHtml
+    ) where
+
+import Text.Blaze.Internal
+import Text.Blaze.Renderer.String (fromChoiceString)
+
+-- | Render some 'Markup' to an appending 'String'.
+--
+renderString :: Markup  -- ^ Markup to render
+             -> String  -- ^ String to append
+             -> String  -- ^ Resulting String
+renderString = go 0 id
+  where
+    go :: Int -> (String -> String) -> MarkupM b -> String -> String
+    go i attrs (Parent _ open close content) =
+        ind i . getString open . attrs . (">\n" ++) . go (inc i) id content
+              . ind i . getString close .  ('\n' :)
+    go i attrs (CustomParent tag content) =
+        ind i . ('<' :) . fromChoiceString tag . attrs . (">\n" ++) .
+        go (inc i) id content . ind i . ("</" ++) . fromChoiceString tag .
+        (">\n" ++)
+    go i attrs (Leaf _ begin end _) =
+        ind i . getString begin . attrs . getString end . ('\n' :)
+    go i attrs (CustomLeaf tag close _) =
+        ind i . ('<' :) . fromChoiceString tag . attrs .
+        ((if close then " />\n" else ">\n") ++)
+    go i attrs (AddAttribute _ key value h) = flip (go i) h $
+        getString key . fromChoiceString value . ('"' :) . attrs
+    go i attrs (AddCustomAttribute key value h) = flip (go i) h $
+        (' ' : ) . fromChoiceString key . ("=\"" ++) . fromChoiceString value .
+        ('"' :) .  attrs
+    go i _ (Content content _) = ind i . fromChoiceString content . ('\n' :)
+    go i _ (Comment comment _) = ind i .
+        ("<!-- " ++) . fromChoiceString comment . (" -->\n" ++)
+    go i attrs (Append h1 h2) = go i attrs h1 . go i attrs h2
+    go _ _ (Empty _) = id
+    {-# NOINLINE go #-}
+
+    -- Increase the indentation
+    inc = (+) 4
+
+    -- Produce appending indentation
+    ind i = (replicate i ' ' ++)
+{-# INLINE renderString #-}
+
+-- | Render markup to a lazy 'String'. The result is prettified.
+--
+renderMarkup :: Markup -> String
+renderMarkup html = renderString html ""
+{-# INLINE renderMarkup #-}
+
+renderHtml :: Markup -> String
+renderHtml = renderMarkup
+{-# INLINE renderHtml #-}
+{-# DEPRECATED renderHtml
+    "Use renderHtml from Text.Blaze.Html.Renderer.Pretty instead" #-}
diff --git a/src/Text/Blaze/Renderer/String.hs b/src/Text/Blaze/Renderer/String.hs
new file mode 100644
index 0000000..c472e29
--- /dev/null
+++ b/src/Text/Blaze/Renderer/String.hs
@@ -0,0 +1,97 @@
+-- | A renderer that produces a native Haskell 'String', mostly meant for
+-- debugging purposes.
+--
+{-# LANGUAGE OverloadedStrings #-}
+module Text.Blaze.Renderer.String
+    ( fromChoiceString
+    , renderMarkup
+    , renderHtml
+    ) where
+
+import Data.List (isInfixOf)
+
+import qualified Data.ByteString.Char8 as SBC
+import qualified Data.Text as T
+import qualified Data.ByteString as S
+
+import Text.Blaze.Internal
+
+-- | Escape predefined XML entities in a string
+--
+escapeMarkupEntities :: String  -- ^ String to escape
+                   -> String  -- ^ String to append
+                   -> String  -- ^ Resulting string
+escapeMarkupEntities []     k = k
+escapeMarkupEntities (c:cs) k = case c of
+    '<'  -> '&' : 'l' : 't' : ';'             : escapeMarkupEntities cs k
+    '>'  -> '&' : 'g' : 't' : ';'             : escapeMarkupEntities cs k
+    '&'  -> '&' : 'a' : 'm' : 'p' : ';'       : escapeMarkupEntities cs k
+    '"'  -> '&' : 'q' : 'u' : 'o' : 't' : ';' : escapeMarkupEntities cs k
+    '\'' -> '&' : '#' : '3' : '9' : ';'       : escapeMarkupEntities cs k
+    x    -> x                                 : escapeMarkupEntities cs k
+
+-- | Render a 'ChoiceString'.
+--
+fromChoiceString :: ChoiceString  -- ^ String to render
+                 -> String        -- ^ String to append
+                 -> String        -- ^ Resulting string
+fromChoiceString (Static s)     = getString s
+fromChoiceString (String s)     = escapeMarkupEntities s
+fromChoiceString (Text s)       = escapeMarkupEntities $ T.unpack s
+fromChoiceString (ByteString s) = (SBC.unpack s ++)
+fromChoiceString (PreEscaped x) = case x of
+    String s -> (s ++)
+    Text   s -> (\k -> T.foldr (:) k s)
+    s        -> fromChoiceString s
+fromChoiceString (External x) = case x of
+    -- Check that the sequence "</" is *not* in the external data.
+    String s     -> if "</" `isInfixOf` s then id else (s ++)
+    Text   s     -> if "</" `T.isInfixOf` s then id else (\k -> T.foldr (:) k s)
+    ByteString s -> if "</" `S.isInfixOf` s then id else (SBC.unpack s ++)
+    s            -> fromChoiceString s
+fromChoiceString (AppendChoiceString x y) =
+    fromChoiceString x . fromChoiceString y
+fromChoiceString EmptyChoiceString = id
+{-# INLINE fromChoiceString #-}
+
+-- | Render some 'Markup' to an appending 'String'.
+--
+renderString :: Markup    -- ^ Markup to render
+             -> String  -- ^ String to append
+             -> String  -- ^ Resulting String
+renderString = go id
+  where
+    go :: (String -> String) -> MarkupM b -> String -> String
+    go attrs (Parent _ open close content) =
+        getString open . attrs . ('>' :) . go id content . getString close
+    go attrs (CustomParent tag content) =
+        ('<' :) . fromChoiceString tag . attrs . ('>' :) .  go id content .
+        ("</" ++) . fromChoiceString tag . ('>' :)
+    go attrs (Leaf _ begin end _) = getString begin . attrs . getString end
+    go attrs (CustomLeaf tag close _) =
+        ('<' :) . fromChoiceString tag . attrs .
+        (if close then (" />" ++) else ('>' :))
+    go attrs (AddAttribute _ key value h) = flip go h $
+        getString key . fromChoiceString value . ('"' :) . attrs
+    go attrs (AddCustomAttribute key value h) = flip go h $
+        (' ' :) . fromChoiceString key . ("=\"" ++) . fromChoiceString value .
+        ('"' :) .  attrs
+    go _ (Content content _) = fromChoiceString content
+    go _ (Comment comment _) =
+        ("<!-- " ++) . fromChoiceString comment . (" -->" ++)
+    go attrs (Append h1 h2) = go attrs h1 . go attrs h2
+    go _ (Empty _) = id
+    {-# NOINLINE go #-}
+{-# INLINE renderString #-}
+
+-- | Render markup to a lazy 'String'.
+--
+renderMarkup :: Markup -> String
+renderMarkup html = renderString html ""
+{-# INLINE renderMarkup #-}
+
+renderHtml :: Markup -> String
+renderHtml = renderMarkup
+{-# INLINE renderHtml #-}
+{-# DEPRECATED renderHtml
+    "Use renderHtml from Text.Blaze.Html.Renderer.String instead" #-}
diff --git a/src/Text/Blaze/Renderer/Text.hs b/src/Text/Blaze/Renderer/Text.hs
new file mode 100644
index 0000000..e68762b
--- /dev/null
+++ b/src/Text/Blaze/Renderer/Text.hs
@@ -0,0 +1,169 @@
+{-# LANGUAGE OverloadedStrings #-}
+-- | A renderer that produces a lazy 'L.Text' value, using the Text Builder.
+--
+module Text.Blaze.Renderer.Text
+    ( renderMarkupBuilder
+    , renderMarkupBuilderWith
+    , renderMarkup
+    , renderMarkupWith
+    , renderHtmlBuilder
+    , renderHtmlBuilderWith
+    , renderHtml
+    , renderHtmlWith
+    ) where
+
+import Data.Monoid (mappend, mempty)
+import Data.List (isInfixOf)
+
+import Data.Text (Text)
+import qualified Data.Text as T
+import Data.Text.Encoding (decodeUtf8)
+import qualified Data.Text.Lazy as L
+import Data.ByteString (ByteString)
+import qualified Data.ByteString as S (isInfixOf)
+
+import Text.Blaze.Internal
+import Data.Text.Lazy.Builder (Builder)
+import qualified Data.Text.Lazy.Builder as B
+
+-- | Escape predefined XML entities in a text value
+--
+escapeMarkupEntities :: Text     -- ^ Text to escape
+                   -> Builder  -- ^ Resulting text builder
+escapeMarkupEntities = T.foldr escape mempty
+  where
+    escape :: Char -> Builder -> Builder
+    escape '<'  b = B.fromText "&lt;"   `mappend` b
+    escape '>'  b = B.fromText "&gt;"   `mappend` b
+    escape '&'  b = B.fromText "&amp;"  `mappend` b
+    escape '"'  b = B.fromText "&quot;" `mappend` b
+    escape '\'' b = B.fromText "&#39;"  `mappend` b
+    escape x    b = B.singleton x       `mappend` b
+
+-- | Render a 'ChoiceString'. TODO: Optimization possibility, apply static
+-- argument transformation.
+--
+fromChoiceString :: (ByteString -> Text)  -- ^ Decoder for bytestrings
+                 -> ChoiceString          -- ^ String to render
+                 -> Builder               -- ^ Resulting builder
+fromChoiceString _ (Static s)     = B.fromText $ getText s
+fromChoiceString _ (String s)     = escapeMarkupEntities $ T.pack s
+fromChoiceString _ (Text s)       = escapeMarkupEntities s
+fromChoiceString d (ByteString s) = B.fromText $ d s
+fromChoiceString d (PreEscaped x) = case x of
+    String s -> B.fromText $ T.pack s
+    Text   s -> B.fromText s
+    s        -> fromChoiceString d s
+fromChoiceString d (External x) = case x of
+    -- Check that the sequence "</" is *not* in the external data.
+    String s     -> if "</" `isInfixOf` s then mempty else B.fromText (T.pack s)
+    Text   s     -> if "</" `T.isInfixOf` s then mempty else B.fromText s
+    ByteString s -> if "</" `S.isInfixOf` s then mempty else B.fromText (d s)
+    s            -> fromChoiceString d s
+fromChoiceString d (AppendChoiceString x y) =
+    fromChoiceString d x `mappend` fromChoiceString d y
+fromChoiceString _ EmptyChoiceString = mempty
+{-# INLINE fromChoiceString #-}
+
+-- | Render markup to a text builder
+renderMarkupBuilder :: Markup -> Builder
+renderMarkupBuilder = renderMarkupBuilderWith decodeUtf8
+{-# INLINE renderMarkupBuilder #-}
+
+renderHtmlBuilder :: Markup -> Builder
+renderHtmlBuilder = renderMarkupBuilder
+{-# INLINE renderHtmlBuilder #-}
+{-# DEPRECATED renderHtmlBuilder
+    "Use renderHtmlBuilder from Text.Blaze.Html.Renderer.Text instead" #-}
+
+-- | Render some 'Markup' to a Text 'Builder'.
+--
+renderMarkupBuilderWith :: (ByteString -> Text)  -- ^ Decoder for bytestrings
+                        -> Markup                -- ^ Markup to render
+                        -> Builder               -- ^ Resulting builder
+renderMarkupBuilderWith d = go mempty
+  where
+    go :: Builder -> MarkupM b -> Builder
+    go attrs (Parent _ open close content) =
+        B.fromText (getText open)
+            `mappend` attrs
+            `mappend` B.singleton '>'
+            `mappend` go mempty content
+            `mappend` B.fromText (getText close)
+    go attrs (CustomParent tag content) =
+        B.singleton '<'
+            `mappend` fromChoiceString d tag
+            `mappend` attrs
+            `mappend` B.singleton '>'
+            `mappend` go mempty content
+            `mappend` B.fromText "</"
+            `mappend` fromChoiceString d tag
+            `mappend` B.singleton '>'
+    go attrs (Leaf _ begin end _) =
+        B.fromText (getText begin)
+            `mappend` attrs
+            `mappend` B.fromText (getText end)
+    go attrs (CustomLeaf tag close _) =
+        B.singleton '<'
+            `mappend` fromChoiceString d tag
+            `mappend` attrs
+            `mappend` (if close then B.fromText " />" else B.singleton '>')
+    go attrs (AddAttribute _ key value h) =
+        go (B.fromText (getText key)
+            `mappend` fromChoiceString d value
+            `mappend` B.singleton '"'
+            `mappend` attrs) h
+    go attrs (AddCustomAttribute key value h) =
+        go (B.singleton ' '
+            `mappend` fromChoiceString d key
+            `mappend` B.fromText "=\""
+            `mappend` fromChoiceString d value
+            `mappend` B.singleton '"'
+            `mappend` attrs) h
+    go _ (Content content _) = fromChoiceString d content
+    go _ (Comment comment _) =
+        B.fromText "<!-- "
+            `mappend` fromChoiceString d comment
+            `mappend` " -->"
+    go attrs (Append h1 h2) = go attrs h1 `mappend` go attrs h2
+    go _ (Empty _) = mempty
+    {-# NOINLINE go #-}
+{-# INLINE renderMarkupBuilderWith #-}
+
+renderHtmlBuilderWith :: (ByteString -> Text)  -- ^ Decoder for bytestrings
+                      -> Markup                -- ^ Markup to render
+                      -> Builder               -- ^ Resulting builder
+renderHtmlBuilderWith = renderMarkupBuilderWith
+{-# INLINE renderHtmlBuilderWith #-}
+{-# DEPRECATED renderHtmlBuilderWith
+    "Use renderHtmlBuilderWith from Text.Blaze.Html.Renderer.Text instead" #-}
+
+-- | Render markup to a lazy Text value. If there are any ByteString's in the
+-- input markup, this function will consider them as UTF-8 encoded values and
+-- decode them that way.
+--
+renderMarkup :: Markup -> L.Text
+renderMarkup = renderMarkupWith decodeUtf8
+{-# INLINE renderMarkup #-}
+
+renderHtml :: Markup -> L.Text
+renderHtml = renderMarkup
+{-# INLINE renderHtml #-}
+{-# DEPRECATED renderHtml
+    "Use renderHtml from Text.Blaze.Html.Renderer.Text instead" #-}
+
+-- | Render markup to a lazy Text value. This function allows you to specify what
+-- should happen with ByteString's in the input HTML. You can decode them or
+-- drop them, this depends on the application...
+--
+renderMarkupWith :: (ByteString -> Text)  -- ^ Decoder for ByteString's.
+                 -> Markup                -- ^ Markup to render
+                 -> L.Text                -- Resulting lazy text
+renderMarkupWith d = B.toLazyText . renderMarkupBuilderWith d
+
+renderHtmlWith :: (ByteString -> Text)  -- ^ Decoder for ByteString's.
+               -> Markup                -- ^ Markup to render
+               -> L.Text                -- ^ Resulting lazy text
+renderHtmlWith = renderMarkupWith
+{-# DEPRECATED renderHtmlWith
+    "Use renderHtmlWith from Text.Blaze.Html.Renderer.Text instead" #-}
diff --git a/src/Text/Blaze/Renderer/Utf8.hs b/src/Text/Blaze/Renderer/Utf8.hs
new file mode 100644
index 0000000..79d62ef
--- /dev/null
+++ b/src/Text/Blaze/Renderer/Utf8.hs
@@ -0,0 +1,130 @@
+{-# LANGUAGE OverloadedStrings #-}
+module Text.Blaze.Renderer.Utf8
+    ( renderMarkupBuilder
+    , renderMarkup
+    , renderMarkupToByteStringIO
+    , renderHtmlBuilder
+    , renderHtml
+    , renderHtmlToByteStringIO
+    ) where
+
+import Data.Monoid (mappend, mempty)
+import Data.List (isInfixOf)
+
+import qualified Data.ByteString.Lazy as L
+import qualified Data.Text as T (isInfixOf)
+import qualified Data.ByteString as S (ByteString, isInfixOf)
+
+import Text.Blaze.Internal
+import Blaze.ByteString.Builder (Builder)
+import qualified Blaze.ByteString.Builder           as B
+import qualified Blaze.ByteString.Builder.Html.Utf8 as B
+
+-- | Render a 'ChoiceString'.
+--
+fromChoiceString :: ChoiceString  -- ^ String to render
+                 -> Builder       -- ^ Resulting builder
+fromChoiceString (Static s)     = B.copyByteString $ getUtf8ByteString s
+fromChoiceString (String s)     = B.fromHtmlEscapedString s
+fromChoiceString (Text s)       = B.fromHtmlEscapedText s
+fromChoiceString (ByteString s) = B.fromByteString s
+fromChoiceString (PreEscaped x) = case x of
+    String s -> B.fromString s
+    Text   s -> B.fromText s
+    s        -> fromChoiceString s
+fromChoiceString (External x) = case x of
+    -- Check that the sequence "</" is *not* in the external data.
+    String s     -> if "</" `isInfixOf` s then mempty else B.fromString s
+    Text   s     -> if "</" `T.isInfixOf` s then mempty else B.fromText s
+    ByteString s -> if "</" `S.isInfixOf` s then mempty else B.fromByteString s
+    s            -> fromChoiceString s
+fromChoiceString (AppendChoiceString x y) =
+    fromChoiceString x `mappend` fromChoiceString y
+fromChoiceString EmptyChoiceString = mempty
+{-# INLINE fromChoiceString #-}
+
+-- | Render some 'Markup' to a 'Builder'.
+--
+renderMarkupBuilder, renderHtmlBuilder :: Markup     -- ^ Markup to render
+                  -> Builder  -- ^ Resulting builder
+renderMarkupBuilder = go mempty
+  where
+    go :: Builder -> MarkupM b -> Builder
+    go attrs (Parent _ open close content) =
+        B.copyByteString (getUtf8ByteString open)
+            `mappend` attrs
+            `mappend` B.fromChar '>'
+            `mappend` go mempty content
+            `mappend` B.copyByteString (getUtf8ByteString close)
+    go attrs (CustomParent tag content) =
+        B.fromChar '<'
+            `mappend` fromChoiceString tag
+            `mappend` attrs
+            `mappend` B.fromChar '>'
+            `mappend` go mempty content
+            `mappend` B.fromByteString "</"
+            `mappend` fromChoiceString tag
+            `mappend` B.fromChar '>'
+    go attrs (Leaf _ begin end _) =
+        B.copyByteString (getUtf8ByteString begin)
+            `mappend` attrs
+            `mappend` B.copyByteString (getUtf8ByteString end)
+    go attrs (CustomLeaf tag close _) =
+        B.fromChar '<'
+            `mappend` fromChoiceString tag
+            `mappend` attrs
+            `mappend` (if close then B.fromByteString " />" else B.fromChar '>')
+    go attrs (AddAttribute _ key value h) =
+        go (B.copyByteString (getUtf8ByteString key)
+            `mappend` fromChoiceString value
+            `mappend` B.fromChar '"'
+            `mappend` attrs) h
+    go attrs (AddCustomAttribute key value h) =
+        go (B.fromChar ' '
+            `mappend` fromChoiceString key
+            `mappend` B.fromByteString "=\""
+            `mappend` fromChoiceString value
+            `mappend` B.fromChar '"'
+            `mappend` attrs) h
+    go _ (Content content _) = fromChoiceString content
+    go _ (Comment comment _) =
+        B.fromByteString "<!-- "
+            `mappend` fromChoiceString comment
+            `mappend` B.fromByteString " -->"
+    go attrs (Append h1 h2) = go attrs h1 `mappend` go attrs h2
+    go _ (Empty _) = mempty
+    {-# NOINLINE go #-}
+{-# INLINE renderMarkupBuilder #-}
+
+renderHtmlBuilder = renderMarkupBuilder
+{-# INLINE renderHtmlBuilder #-}
+{-# DEPRECATED renderHtmlBuilder
+    "Use renderHtmlBuilder from Text.Blaze.Html.Renderer.Utf8 instead" #-}
+
+-- | Render HTML to a lazy UTF-8 encoded 'L.ByteString.'
+--
+renderMarkup, renderHtml :: Markup          -- ^ Markup to render
+                         -> L.ByteString  -- ^ Resulting 'L.ByteString'
+renderMarkup = B.toLazyByteString . renderMarkupBuilder
+{-# INLINE renderMarkup #-}
+
+renderHtml = renderMarkup
+{-# INLINE renderHtml #-}
+{-# DEPRECATED renderHtml
+    "Use renderHtml from Text.Blaze.Html.Renderer.Utf8 instead" #-}
+
+
+-- | Repeatedly render HTML to a buffer and process this buffer using the given
+-- IO action.
+--
+renderMarkupToByteStringIO, renderHtmlToByteStringIO :: (S.ByteString -> IO ())
+                                                        -- ^ IO action to execute per rendered buffer
+                                                     -> Markup          -- ^ Markup to render
+                                                     -> IO ()         -- ^ Resulting IO action
+renderMarkupToByteStringIO io = B.toByteStringIO io . renderMarkupBuilder
+{-# INLINE renderMarkupToByteStringIO #-}
+
+renderHtmlToByteStringIO = renderMarkupToByteStringIO
+{-# INLINE renderHtmlToByteStringIO #-}
+{-# DEPRECATED renderHtmlToByteStringIO
+    "Use renderMarkupToByteStringIO from Text.Blaze.Html.Renderer.Utf8 instead" #-}
diff --git a/tests/TestSuite.hs b/tests/TestSuite.hs
new file mode 100644
index 0000000..d5f6a4e
--- /dev/null
+++ b/tests/TestSuite.hs
@@ -0,0 +1,12 @@
+-- | Main module to run all tests.
+--
+module Main where
+
+import Test.Framework (defaultMain, testGroup)
+
+import qualified Text.Blaze.Tests
+
+main :: IO ()
+main = defaultMain
+    [ testGroup "Text.Blaze.Tests" Text.Blaze.Tests.tests
+    ]
diff --git a/tests/Text/Blaze/Tests.hs b/tests/Text/Blaze/Tests.hs
new file mode 100644
index 0000000..48097f9
--- /dev/null
+++ b/tests/Text/Blaze/Tests.hs
@@ -0,0 +1,238 @@
+{-# LANGUAGE OverloadedStrings, FlexibleInstances, TypeSynonymInstances #-}
+{-# OPTIONS_GHC -fno-warn-orphans        #-}
+{-# OPTIONS_GHC -fno-warn-unused-do-bind #-}
+module Text.Blaze.Tests
+    ( tests
+    ) where
+
+import Prelude hiding (div, id, null)
+import Data.Monoid (mempty, mappend)
+import Control.Monad (replicateM)
+import Control.Applicative (Applicative (..), (<$>))
+import Data.Word (Word8)
+import Data.Char (ord, isControl)
+import qualified Data.List as List
+import qualified Prelude as Prelude
+
+import Test.Framework (Test)
+import Test.HUnit (Assertion, (@=?))
+import Test.Framework.Providers.HUnit (testCase)
+import Test.Framework.Providers.QuickCheck2 (testProperty)
+import Test.QuickCheck
+import qualified Data.ByteString as SB
+import qualified Data.ByteString.Lazy as LB
+import qualified Data.ByteString.Lazy.Char8 as LBC
+
+import Text.Blaze
+import Text.Blaze.Internal
+import Text.Blaze.Tests.Util
+
+tests :: [Test]
+tests = [ testProperty "left identity Monoid law"  monoidLeftIdentity
+        , testProperty "right identity Monoid law" monoidRightIdentity
+        , testProperty "associativity Monoid law"  monoidAssociativity
+        , testProperty "mconcat Monoid law"        monoidConcat
+        , testProperty "identity Applicative law"  applicativeIdentity
+        , testProperty "post escaping characters"  postEscapingCharacters
+        , testProperty "valid UTF-8"               isValidUtf8
+        , testProperty "external </ sequence"      externalEndSequence
+        , testProperty "well nested <>"            wellNestedBrackets
+        , testProperty "unsafeByteString id"       unsafeByteStringId
+
+        , testCase     "conditional attributes"    conditionalAttributes
+        , testCase     "contents 1"                contents1
+        , testCase     "empty 1"                   empty1
+        , testCase     "empty 2"                   empty2
+        , testCase     "comment 1"                 comment1
+        ]
+
+-- | The left identity Monoid law.
+--
+monoidLeftIdentity :: Markup -> Bool
+monoidLeftIdentity h = (return () >> h) == h
+
+-- | The right identity Monoid law.
+--
+monoidRightIdentity :: Markup -> Bool
+monoidRightIdentity h = (h >> return ()) == h
+
+-- | The associativity Monoid law.
+--
+monoidAssociativity :: Markup -> Markup -> Markup -> Bool
+monoidAssociativity x y z = (x >> (y >> z)) == ((x >> y) >> z)
+
+-- | Concatenation Monoid law.
+--
+monoidConcat :: [Markup] -> Bool
+monoidConcat xs = sequence_ xs == foldr (>>) (return ()) xs
+
+-- | Applicative identity law.
+--
+applicativeIdentity :: Markup -> Bool
+applicativeIdentity x = (pure Prelude.id <*> x) == x
+
+-- | Escaped content cannot contain certain characters.
+--
+postEscapingCharacters :: String -> Bool
+postEscapingCharacters str =
+    LB.all (`notElem` forbidden) $ renderUsingUtf8 (string str)
+  where
+    forbidden = map (fromIntegral . ord) "\"'<>"
+
+-- | Check if the produced bytes are valid UTF-8
+--
+isValidUtf8 :: Markup -> Bool
+isValidUtf8 = isValidUtf8' . LB.unpack . renderUsingUtf8
+  where
+    isIn x y z = (x <= z) && (z <= y)
+    isValidUtf8' :: [Word8] -> Bool
+    isValidUtf8' [] = True
+    isValidUtf8' (x:t)
+        -- One byte
+        | isIn 0x00 0x7f x = isValidUtf8' t
+        -- Two bytes
+        | isIn 0xc0 0xdf x = case t of
+            (y:t') -> isIn 0x80 0xbf y && isValidUtf8' t'
+            _      -> False
+        -- Three bytes
+        | isIn 0xe0 0xef x = case t of
+            (y:z:t') -> all (isIn 0x80 0xbf) [y, z] && isValidUtf8' t'
+            _        -> False
+        -- Four bytes
+        | isIn 0xf0 0xf7 x = case t of
+            (y:z:u:t') -> all (isIn 0x80 0xbf) [y, z, u] && isValidUtf8' t'
+            _          -> False
+        | otherwise = False
+
+-- | Rendering an unsafe bytestring should not do anything
+--
+unsafeByteStringId :: [Word8] -> Bool
+unsafeByteStringId ws =
+    LB.pack ws == renderUsingUtf8 (unsafeByteString $ SB.pack ws)
+
+-- | Check if the "</" sequence does not appear in @<script>@ or @<style>@ tags.
+--
+externalEndSequence :: String -> Bool
+externalEndSequence = not . List.isInfixOf "</" . LBC.unpack
+                    . renderUsingUtf8 . external . string
+
+-- | Check that the "<>" characters are well-nested.
+--
+wellNestedBrackets :: Markup -> Bool
+wellNestedBrackets = wellNested False . LBC.unpack . renderUsingUtf8
+  where
+    wellNested isOpen [] = not isOpen
+    wellNested isOpen (x:xs) = case x of
+        '<' -> if isOpen then False else wellNested True xs
+        '>' -> if isOpen then wellNested False xs else False
+        _   -> wellNested isOpen xs
+
+conditionalAttributes :: Assertion
+conditionalAttributes =
+    "<p class=\"foo\">Hello</p><p id=\"2nd\">World</p>" @=? renderUsingUtf8 html
+  where
+    html = do
+        p !? (4 > length [()], class_ "foo") $ "Hello"
+        p !? (List.null [()], class_ "bar") !? (True, id "2nd") $ "World"
+
+contents1 :: Assertion
+contents1 = "Hello World!" @=? renderUsingUtf8 (contents html)
+  where
+    html :: Markup
+    html = div $ do
+        p ! id "para" $ "Hello "
+        stringComment "Test test"
+        img ! name "An image"
+        p "World!"
+
+empty1 :: Assertion
+empty1 = True @=? null html
+  where
+    html :: Markup
+    html = do
+        ""
+        ""
+        mempty
+
+empty2 :: Assertion
+empty2 = False @=? null html
+  where
+    html :: Markup
+    html = "" `mappend` "" `mappend` p "a"
+
+comment1 :: Assertion
+comment1 = preEscapedString "<div>Hello <!-- Test --> World!</div>" @=? html
+  where
+    html :: Markup
+    html = div $ do
+        "Hello "
+        stringComment "Test"
+        " World!"
+
+-- Show instance for the HTML type, so we can debug.
+--
+instance Show Markup where
+    show = show . renderUsingUtf8
+
+-- Eq instance for the HTML type, so we can compare the results.
+--
+instance Eq Markup where
+    x == y =  renderUsingString x == renderUsingString y
+           && renderUsingText x   == renderUsingText y
+           && renderUsingUtf8 x   == renderUsingUtf8 y
+           -- Some cross-checks
+           && renderUsingString x == renderUsingText y
+           && renderUsingText x   == renderUsingUtf8 y
+
+-- Arbitrary instance for the HTML type.
+--
+instance Arbitrary Markup where
+    arbitrary = arbitraryMarkup 4
+
+-- | Auxiliary function for the arbitrary instance of the HTML type, used
+-- to limit the depth and size of the type.
+--
+arbitraryMarkup :: Int       -- ^ Maximum depth.
+              -> Gen Markup  -- ^ Resulting arbitrary HTML snippet.
+arbitraryMarkup depth = do
+    -- Choose the size (width) of this element.
+    size <- choose (0, 3)
+
+    -- Generate `size` new HTML snippets.
+    children <- replicateM size arbitraryChild
+
+    -- Return a concatenation of these children.
+    return $ sequence_ children
+  where
+    -- Generate an arbitrary child. Do not take a parent when we have no depth
+    -- left, obviously.
+    arbitraryChild = do
+        child <- oneof $  [arbitraryLeaf, arbitraryString, return mempty]
+                       ++ [arbitraryParent | depth > 0]
+
+        -- Generate some attributes for the child.
+        size <- choose (0, 4)
+        attributes <- replicateM size arbitraryAttribute
+        return $ foldl (!) child attributes
+
+    -- Generate an arbitrary parent element.
+    arbitraryParent = do
+        parent <- elements [p, div, table]
+        parent <$> arbitraryMarkup (depth - 1)
+
+    -- Generate an arbitrary leaf element.
+    arbitraryLeaf = oneof $ map return [img, br, area]
+
+    -- Generate arbitrary string element.
+    arbitraryString = do
+        s <- genString
+        return $ string s
+
+    -- Generate an arbitrary HTML attribute.
+    arbitraryAttribute = do
+        attr <- elements [id, class_, name]
+        value <- genString
+        return $ attr $ stringValue value
+
+    -- Don't use control characters
+    genString = filter (not . isControl) <$> arbitrary
diff --git a/tests/Text/Blaze/Tests/Util.hs b/tests/Text/Blaze/Tests/Util.hs
new file mode 100644
index 0000000..571652d
--- /dev/null
+++ b/tests/Text/Blaze/Tests/Util.hs
@@ -0,0 +1,71 @@
+-- | Utility functions for the blaze tests
+--
+{-# LANGUAGE OverloadedStrings #-}
+module Text.Blaze.Tests.Util
+    ( renderUsingString
+    , renderUsingText
+    , renderUsingUtf8
+	, p, div, table, img, br, area
+	, id, class_, name
+    ) where
+
+import Prelude hiding (div, id)
+import Text.Blaze.Internal
+
+import Blaze.ByteString.Builder as B (toLazyByteString)
+import Blaze.ByteString.Builder.Char.Utf8 as B (fromString)
+import Data.Text.Lazy.Encoding (encodeUtf8)
+import qualified Data.ByteString.Lazy as LB
+import qualified Text.Blaze.Renderer.String as String (renderMarkup)
+import qualified Text.Blaze.Renderer.Text as Text (renderMarkup)
+import qualified Text.Blaze.Renderer.Utf8 as Utf8 (renderMarkup)
+
+-- | Render Markup to an UTF-8 encoded ByteString using the String renderer
+--
+renderUsingString :: Markup -> LB.ByteString
+renderUsingString = toLazyByteString . fromString . String.renderMarkup
+
+-- | Render Markup to an UTF-8 encoded ByteString using the Text renderer
+--
+renderUsingText :: Markup -> LB.ByteString
+renderUsingText = encodeUtf8 . Text.renderMarkup
+
+-- | Render HTML to an UTF-8 encoded ByteString using the Utf8 renderer
+--
+renderUsingUtf8 :: Markup -> LB.ByteString
+renderUsingUtf8 = Utf8.renderMarkup
+
+-- Some definitions for HTML combinators to enable testing
+
+p :: Markup   -- ^ Inner HTML.
+  -> Markup   -- ^ Resulting HTML.
+p = Parent "p" "<p" "</p>"
+
+div :: Markup   -- ^ Inner HTML.
+    -> Markup   -- ^ Resulting HTML.
+div = Parent "div" "<div" "</div>"
+
+table :: Markup   -- ^ Inner HTML.
+      -> Markup   -- ^ Resulting HTML.
+table = Parent "table" "<table" "</table>"
+
+img :: Markup   -- ^ Resulting HTML.
+img = Leaf "img" "<img" ">" ()
+
+br :: Markup   -- ^ Resulting HTML.
+br = Leaf "br" "<br" ">" ()
+
+area :: Markup   -- ^ Resulting HTML.
+area = Leaf "area" "<area" ">" ()
+
+class_ :: AttributeValue  -- ^ Attribute value.
+       -> Attribute       -- ^ Resulting attribute.
+class_ = attribute "class" " class=\""
+
+id :: AttributeValue  -- ^ Attribute value.
+   -> Attribute       -- ^ Resulting attribute.
+id = attribute "id" " id=\""
+
+name :: AttributeValue  -- ^ Attribute value.
+     -> Attribute       -- ^ Resulting attribute.
+name = attribute "name" " name=\""