diff --git a/LICENSE b/LICENSE
new file mode 100644
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,24 @@
+Copyright (c) 2014, lucid
+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 lucid nor the
+      names of its 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 <COPYRIGHT HOLDER> 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/README.md b/README.md
new file mode 100644
--- /dev/null
+++ b/README.md
@@ -0,0 +1,117 @@
+lucid
+=====
+
+Clear to write, read and edit DSL for writing HTML
+
+## Introduction
+
+HTML terms in Lucid are written with a postfix ‘`_`’ to indicate data
+rather than code. Some examples:
+
+`p_`, `class_`, `table_`, `style_`
+
+See `Lucid.Html5` for a complete list of Html5 combinators.
+
+Plain text is written using the `OverloadedStrings` and
+`ExtendedDefaultRules` extensions, and is automatically escaped:
+
+``` haskell
+λ> "123 < 456" :: Html ()
+```
+
+``` html
+123 &lt; 456
+```
+
+Elements nest by function application:
+
+``` haskell
+λ> table_ (tr_ (td_ (p_ "Hello, World!")))
+```
+
+``` html
+<table><tr><td><p>Hello, World!</p></td></tr></table>
+```
+
+Elements are juxtaposed via monoidal append:
+
+``` haskell
+λ> p_ "hello" <> p_ "sup"
+```
+
+``` html
+<p>hello</p><p>sup</p>
+```
+
+Or monadic sequencing:
+
+``` haskell
+λ> div_ (do p_ "hello"; p_ "sup")
+```
+
+``` html
+<div><p>hello</p><p>sup</p></div>
+```
+
+Attributes are set using the 'with' combinator:
+
+``` haskell
+λ> with p_ [class_ "brand"] "Lucid Inc"
+```
+
+``` html
+<p class="brand">Lucid Inc</p>
+```
+
+Here is a fuller example of Lucid:
+
+``` haskell
+with table_ [rows_ "2"]
+     (tr_ (do with td_ [class_ "top",colspan_ "2"]
+                   (p_ "Hello, attributes!")
+              td_ "yay!"))
+```
+
+``` html
+<table rows="2">
+  <tr>
+     <td class="top" colspan="2">
+       <p>Hello, attributes!</p>
+     </td>
+     <td>yay!</td>
+  </tr>
+</table>
+```
+
+## Rendering
+
+For proper rendering you can easily run some HTML immediately with:
+
+``` haskell
+λ> renderText (p_ "Hello!")
+```
+
+``` html
+"<p>Hello!</p>"
+```
+
+Or to bytes:
+
+``` haskell
+λ> renderBS (with p_ [style_ "color:red"] "Hello!")
+```
+
+``` html
+"<p style=\"color:red\">Hello!</p>"
+```
+
+For ease of use in GHCi, there is a `Show` instance, as
+demonstrated above.
+
+If the above rendering functions aren't suited for your purpose, you
+can run the monad directly via `execHtml` and use the more low-level
+blaze `Builder`, which has a plethora of output modes in
+Blaze.ByteString.Builder.
+
+See the documentation for the `Lucid` module for information about
+using it as a monad transformer.
diff --git a/Setup.hs b/Setup.hs
new file mode 100644
--- /dev/null
+++ b/Setup.hs
@@ -0,0 +1,2 @@
+import Distribution.Simple
+main = defaultMain
diff --git a/lucid.cabal b/lucid.cabal
new file mode 100644
--- /dev/null
+++ b/lucid.cabal
@@ -0,0 +1,27 @@
+name:                lucid
+version:             0.0
+synopsis:            Clear to write, read and edit DSL for HTML
+description:         Clear to write, read and edit DSL for HTML. See the 'Lucid' module
+                     for description and documentation.
+license:             BSD3
+license-file:        LICENSE
+author:              Chris Done
+maintainer:          chrisdone@gmail.com
+copyright:           2014 Chris Done
+category:            Web
+build-type:          Simple
+cabal-version:       >=1.8
+extra-source-files:  README.md
+
+library
+  hs-source-dirs:    src/
+  ghc-options:       -Wall -O2
+  exposed-modules:   Lucid
+                     Lucid.Base
+                     Lucid.Html5
+                     Lucid.Bootstrap
+  build-depends:     base >= 4 && <5
+                   , blaze-builder
+                   , bytestring
+                   , text
+                   , transformers
diff --git a/src/Lucid.hs b/src/Lucid.hs
new file mode 100644
--- /dev/null
+++ b/src/Lucid.hs
@@ -0,0 +1,92 @@
+-- | Clear to write, read and edit DSL for writing HTML
+
+module Lucid
+  (-- * Intro
+   -- $intro
+   renderText
+  ,renderBS
+  ,renderTextT
+  ,renderBST
+   -- * Running
+   -- $running
+  ,execHtmlT
+  ,evalHtmlT
+  ,runHtmlT
+  -- * Combinators
+  ,with
+   -- * Types
+  ,Html
+  ,Attr(..)
+   -- * Classes
+  ,ToText(..)
+  ,ToHtml(..)
+  ,Mixed(..)
+  ,With
+  -- * Re-exports
+  ,module Lucid.Html5)
+ where
+
+import Lucid.Base
+import Lucid.Html5
+
+-- $intro
+--
+-- HTML terms in Lucid are written with a postfix ‘@_@’ to indicate data
+-- rather than code. Some examples:
+--
+-- 'p_', 'class_', 'table_', 'style_'
+--
+-- See "Lucid.Html5" for a complete list of Html5 combinators.
+--
+-- Plain text is written using the @OverloadedStrings@ and
+-- @ExtendedDefaultRules@ extensions, and is automatically escaped:
+--
+-- >>> "123 < 456" :: Html ()
+-- 123 &lt; 456
+--
+-- Elements nest by function application:
+--
+-- >>> table_ (tr_ (td_ (p_ "Hello, World!")))
+-- <table><tr><td><p>Hello, World!</p></td></tr></table>
+--
+-- Elements are juxtaposed via monoidal append:
+--
+-- >>> p_ "hello" <> p_ "sup"
+-- <p>hello</p><p>sup</p>
+--
+-- Or monadic sequencing:
+--
+-- >>> div_ (do p_ "hello"; p_ "sup")
+-- <div><p>hello</p><p>sup</p></div>
+--
+-- Attributes are set using the 'with' combinator:
+--
+-- >>> with p_ [class_ "brand"] "Lucid Inc"
+-- <p class="brand">Lucid Inc</p>
+--
+-- Here is a fuller example of Lucid:
+--
+-- @
+-- with table_ [rows_ "2"]
+--      (tr_ (do with td_ [class_ "top",colspan_ "2"]
+--                    (p_ "Hello, attributes!")
+--               td_ "yay!"))
+-- @
+--
+-- For proper rendering you can easily run some HTML immediately with:
+--
+-- >>> renderText (p_ "Hello!")
+-- > "<p>Hello!</p>"
+--
+-- >>> renderBS (with p_ [style_ "color:red"] "Hello!")
+-- "<p style=\"color:red\">Hello!</p>"
+--
+-- For ease of use in GHCi, there is a 'Show' instance, as
+-- demonstrated above.
+
+-- $running
+--
+-- If the above rendering functions aren't suited for your purpose,
+-- you can run the monad directly and use the more low-level blaze
+-- `Builder`, which has a plethora of output modes in
+-- "Blaze.ByteString.Builder".
diff --git a/src/Lucid/Base.hs b/src/Lucid/Base.hs
new file mode 100644
--- /dev/null
+++ b/src/Lucid/Base.hs
@@ -0,0 +1,299 @@
+{-# LANGUAGE KindSignatures #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE GADTs #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+-- | Base types and combinators.
+
+module Lucid.Base
+  (-- * Rendering
+   renderText
+  ,renderBS
+  ,renderTextT
+  ,renderBST
+   -- * Running
+  ,execHtmlT
+  ,evalHtmlT
+  ,runHtmlT
+  -- * Combinators
+  ,with
+  ,makeElement
+  ,makeElementNoEnd
+   -- * Types
+  ,Html
+  ,Attr(..)
+  ,HtmlT
+   -- * Classes
+  ,ToText(..)
+  ,ToHtml(..)
+  ,Mixed(..)
+  ,With)
+  where
+
+import           Blaze.ByteString.Builder (Builder)
+import qualified Blaze.ByteString.Builder as Blaze
+import qualified Blaze.ByteString.Builder.Html.Utf8 as Blaze
+import           Control.Applicative
+import           Control.Monad
+import           Data.ByteString.Lazy (ByteString)
+import           Data.Functor.Identity
+import           Data.Monoid
+import           Data.String
+import           Data.Text (Text)
+import qualified Data.Text as T
+import qualified Data.Text.Lazy as LT
+import qualified Data.Text.Lazy.Encoding as LT
+
+--------------------------------------------------------------------------------
+-- Types
+
+-- | Simple HTML builder type. Defined in terms of 'HtmlT'. Check out
+-- that type for instance information.
+--
+-- Simple use-cases will just use this type. But if you want to
+-- transformer over Reader or something, you can go and use 'HtmlT'.
+type Html = HtmlT Identity
+
+-- | A monad transformer that generates HTML. Use the simpler 'Html'
+-- type if you don't want to transform over some other monad.
+newtype HtmlT m a =
+  HtmlT {runHtmlT :: m (Builder -> Builder -> Builder,a)
+         -- ^ This is the low-level way to run the HTML transformer,
+         -- finally returning an element builder and a value. You can
+         -- pass 'mempty' for both arguments for a top-level call. See
+         -- 'evalHtmlT' and 'execHtmlT' for easier to use functions.
+         }
+
+-- | Monoid is right-associative, a la the 'Builder' in it.
+instance Monoid a => Monoid (Html a) where
+  mempty = HtmlT (return (\_ _ -> mempty,mempty))
+  mappend (HtmlT get_f_a) (HtmlT get_g_b) =
+    HtmlT (do ~(f,a) <- get_f_a
+              ~(g,b) <- get_g_b
+              return (\attr inner ->
+                        f attr inner <>
+                        g attr inner
+                     ,a <> b))
+
+-- | Based on the monad instance.
+instance Monad m => Applicative (HtmlT m) where
+  pure = return
+  (<*>) = ap
+
+-- | Just re-uses Monad.
+instance Monad m => Functor (HtmlT m) where
+  fmap = liftM
+
+-- | Basically acts like Writer.
+instance Monad m => Monad (HtmlT m) where
+  return a = HtmlT (return (\_ _ -> mempty,a))
+  HtmlT get_g_a >>= f =
+    HtmlT (do ~(g,a) <- get_g_a
+              let HtmlT get_f'_b = f a
+              ~(f',b) <- get_f'_b
+              return (\attr inner ->
+                        g attr inner <>
+                        f' attr inner
+                     ,b))
+
+-- | We pack it via string. Could possibly encode straight into a
+-- builder. That might be faster.
+instance (Monad m,a ~ ()) => IsString (HtmlT m a) where
+  fromString m' =
+    HtmlT (return (\_ _ -> encode (T.pack m'),()))
+
+-- | Just calls 'renderText'.
+instance (m ~ Identity) => Show (HtmlT m a) where
+  show = LT.unpack . renderText
+
+-- | An attribute.
+data Attr =
+  Attr {attrName :: !Builder -- ^ The attribute name.
+       ,attrValue :: !Text   -- ^ The attribute value.
+       }
+
+-- | Used for attributes.
+class ToText a where
+  toText :: a -> Text
+
+instance ToText String where
+  toText = T.pack
+
+instance ToText Text where
+  toText = id
+
+-- | Can be converted to HTML.
+class ToHtml a where
+  toHtml :: a -> Html ()
+  toHtmlRaw :: a -> Html ()
+
+instance ToHtml String where
+  toHtml = fromString
+  toHtmlRaw m = HtmlT (return ((\_ _ -> Blaze.fromString m),()))
+
+instance ToHtml Int where
+  toHtml i = HtmlT (return ((\_ _ -> Blaze.fromInthost i),()))
+  toHtmlRaw = toHtml
+
+instance ToHtml Text where
+  toHtml m = HtmlT (return ((\_ _ -> encode m),()))
+  toHtmlRaw m = HtmlT (return ((\_ _ -> Blaze.fromText m),()))
+
+-- | Used for names that are mixed, e.g. 'style_'.
+class Mixed a r where
+  mixed :: Builder -> a -> r
+
+-- | Attributes can be a mixed thing e.g. 'style_'.
+instance (ToText a) => Mixed a Attr where
+  mixed s = Attr s . toText
+
+-- | HTML elements can be a mixed thing e.g. 'style_'.
+instance (Monad m,a ~ HtmlT m r,r ~ ()) => Mixed a (HtmlT m r) where
+  mixed = makeElement
+
+-- | With an element use these attributes.
+class With a where
+  -- | With the given element(s), use the given attributes.
+  with :: a -- ^ Some element, either @Html ()@ or @Html () -> Html ()@.
+       -> [Attr] -> a
+
+-- | For the contentless elements: 'br_'
+instance (Monad m,a ~ ()) => With (HtmlT m a) where
+  with f =
+    \attr ->
+      HtmlT (do ~(f',_) <- runHtmlT f
+                return (\attr' m' -> f' (attr' <> mconcat (map buildAttr attr)) m',()))
+    where buildAttr :: Attr -> Builder
+          buildAttr (Attr key val) =
+            Blaze.fromString " " <>
+            key <>
+            if val == mempty
+               then mempty
+               else Blaze.fromString "=\"" <>
+                    Blaze.fromText val <>
+                    Blaze.fromText "\""
+
+-- | For the contentful elements: 'div_'
+instance (Monad m,a ~ ()) => With (HtmlT m a -> HtmlT m a) where
+  with f =
+    \attr inner ->
+      HtmlT (do ~(f',_) <- runHtmlT (f inner)
+                return ((\attr' m' ->
+                           f' (attr' <>
+                               mconcat (map buildAttr attr))
+                              m'),
+                        ()) )
+    where buildAttr :: Attr -> Builder
+          buildAttr (Attr key val) =
+            Blaze.fromString " " <>
+            key <>
+            if val == mempty
+               then mempty
+               else Blaze.fromString "=\"" <>
+                    Blaze.fromText val <>
+                    Blaze.fromText "\""
+
+--------------------------------------------------------------------------------
+-- Running
+
+-- | Render the HTML to a lazy 'ByteString'.
+--
+-- This is a convenience function defined in terms of 'execHtmlT',
+-- 'runIdentity' and 'Blaze.toLazyByteString'. Check the source if
+-- you're interested in the lower-level behaviour.
+--
+renderBS :: Html a -> ByteString
+renderBS = Blaze.toLazyByteString . runIdentity . execHtmlT
+
+-- | Render the HTML to a lazy 'Text'.
+--
+-- This is a convenience function defined in terms of 'execHtmlT',
+-- 'runIdentity' and 'Blaze.toLazyByteString', and
+-- 'LT.decodeUtf8'. Check the source if you're interested in the
+-- lower-level behaviour.
+--
+renderText :: Html a -> LT.Text
+renderText = LT.decodeUtf8 . Blaze.toLazyByteString . runIdentity . execHtmlT
+
+-- | Render the HTML to a lazy 'ByteString', but in a monad.
+--
+-- This is a convenience function defined in terms of 'execHtmlT' and
+-- 'Blaze.toLazyByteString'. Check the source if you're interested in
+-- the lower-level behaviour.
+--
+renderBST :: Monad m => HtmlT m a -> m ByteString
+renderBST = liftM Blaze.toLazyByteString . execHtmlT
+
+-- | Render the HTML to a lazy 'Text', but in a monad.
+--
+-- This is a convenience function defined in terms of 'execHtmlT' and
+-- 'Blaze.toLazyByteString', and 'LT.decodeUtf8'. Check the source if
+-- you're interested in the lower-level behaviour.
+--
+renderTextT :: Monad m => HtmlT m a -> m LT.Text
+renderTextT = liftM (LT.decodeUtf8 . Blaze.toLazyByteString) . execHtmlT
+
+--------------------------------------------------------------------------------
+-- Running, transformer versions
+
+-- | Build the HTML. Analogous to @execState@.
+--
+-- You might want to use this is if you want to do something with the
+-- raw 'Builder'. Otherwise for simple cases you can just use
+-- 'renderText' or 'renderBS'.
+execHtmlT :: Monad m
+          => HtmlT m a  -- ^ The HTML to generate.
+          -> m Builder  -- ^ The @a@ is discarded.
+execHtmlT m =
+  do (f,_) <- runHtmlT m
+     return (f mempty mempty)
+
+-- | Evaluate the HTML to its return value. Analogous to @evalState@.
+--
+-- Use this if you want to ignore the HTML output of an action
+-- completely and just get the result.
+--
+-- For using with the 'Html' type, you'll need 'runIdentity' e.g.
+--
+-- >>> runIdentity (evalHtmlT (p_ "Hello!"))
+-- ()
+--
+evalHtmlT :: Monad m
+          => HtmlT m a -- ^ HTML monad to evaluate.
+          -> m a       -- ^ Ignore the HTML output and just return the value.
+evalHtmlT m =
+  do (_,a) <- runHtmlT m
+     return a
+
+--------------------------------------------------------------------------------
+-- Combinators
+
+-- | Make an HTML builder.
+makeElement :: Monad m
+            => Builder -- ^ Name.
+            -> HtmlT m a  -- ^ Children HTML.
+            -> HtmlT m () -- ^ A parent element.
+makeElement name =
+  \m' ->
+    HtmlT (do ~(f,_) <- runHtmlT m'
+              return ((\attr m -> s "<" <> name <> attr <> s ">" <> m <> f mempty mempty <> s "</" <>
+                                   name <> s ">"),
+                      ()))
+  where s = Blaze.fromString
+
+-- | Make an HTML builder for
+makeElementNoEnd :: Monad m
+                 => Builder -- ^ Name.
+                 -> HtmlT m () -- ^ A parent element.
+makeElementNoEnd name =
+  HtmlT (return ((\attr _ -> s "<" <> name <> attr <> s ">"),
+                 ()))
+  where s = Blaze.fromString
+
+--------------------------------------------------------------------------------
+-- Encoding
+
+-- | Encode the given strict plain text to an encoded HTML builder.
+encode :: Text -> Builder
+encode = Blaze.fromHtmlEscapedText
diff --git a/src/Lucid/Bootstrap.hs b/src/Lucid/Bootstrap.hs
new file mode 100644
--- /dev/null
+++ b/src/Lucid/Bootstrap.hs
@@ -0,0 +1,127 @@
+-- | Bootstrap layout elements. See
+-- <http://getbootstrap.com/2.3.2/scaffolding.html> for more
+-- information.
+
+module Lucid.Bootstrap
+   (
+    -- * Containers
+    container_
+   ,containerFluid_
+   -- * Rows
+   ,row_
+   ,rowFluid_
+   -- * Spans
+   ,span1_
+   ,span2_
+   ,span3_
+   ,span4_
+   ,span5_
+   ,span6_
+   ,span7_
+   ,span8_
+   ,span9_
+   ,span10_
+   ,span11_
+   ,span12_)
+  where
+
+import Lucid.Base
+import Lucid.Html5
+
+import qualified Blaze.ByteString.Builder.Char.Utf8 as Blaze
+
+-- | A grid container.
+container_ :: Monad m => HtmlT m () -> HtmlT m ()
+container_ =
+  with (makeElement (Blaze.fromString "div"))
+       [class_ "container"]
+
+-- | A fluid grid container.
+containerFluid_ :: Monad m => HtmlT m () -> HtmlT m ()
+containerFluid_ =
+  with (makeElement (Blaze.fromString "div"))
+       [class_ "container-fluid"]
+
+-- | A grid row.
+row_ :: Monad m => HtmlT m () -> HtmlT m ()
+row_ =
+  with (makeElement (Blaze.fromString "div"))
+       [class_ "row"]
+
+-- | A fluid grid row.
+rowFluid_ :: Monad m => HtmlT m () -> HtmlT m ()
+rowFluid_ =
+  with (makeElement (Blaze.fromString "div"))
+       [class_ "row-fluid"]
+
+-- | A span of 1 column.
+span1_ :: Monad m => HtmlT m () -> HtmlT m ()
+span1_ =
+  with (makeElement (Blaze.fromString "div"))
+       [class_ "span1"]
+
+-- | A span of 2 columns.
+span2_ :: Monad m => HtmlT m () -> HtmlT m ()
+span2_ =
+  with (makeElement (Blaze.fromString "div"))
+       [class_ "span2"]
+
+-- | A span of 3 columns.
+span3_ :: Monad m => HtmlT m () -> HtmlT m ()
+span3_ =
+  with (makeElement (Blaze.fromString "div"))
+       [class_ "span3"]
+
+-- | A span of 4 columns.
+span4_ :: Monad m => HtmlT m () -> HtmlT m ()
+span4_ =
+  with (makeElement (Blaze.fromString "div"))
+       [class_ "span4"]
+
+-- | A span of 5 columns.
+span5_ :: Monad m => HtmlT m () -> HtmlT m ()
+span5_ =
+  with (makeElement (Blaze.fromString "div"))
+       [class_ "span5"]
+
+-- | A span of 6 columns.
+span6_ :: Monad m => HtmlT m () -> HtmlT m ()
+span6_ =
+  with (makeElement (Blaze.fromString "div"))
+       [class_ "span6"]
+
+-- | A span of 7 columns.
+span7_ :: Monad m => HtmlT m () -> HtmlT m ()
+span7_ =
+  with (makeElement (Blaze.fromString "div"))
+       [class_ "span7"]
+
+-- | A span of 8 columns.
+span8_ :: Monad m => HtmlT m () -> HtmlT m ()
+span8_ =
+  with (makeElement (Blaze.fromString "div"))
+       [class_ "span8"]
+
+-- | A span of 9 columns.
+span9_ :: Monad m => HtmlT m () -> HtmlT m ()
+span9_ =
+  with (makeElement (Blaze.fromString "div"))
+       [class_ "span9"]
+
+-- | A span of 10 columns.
+span10_ :: Monad m => HtmlT m () -> HtmlT m ()
+span10_ =
+  with (makeElement (Blaze.fromString "div"))
+       [class_ "span10"]
+
+-- | A span of 11 columns.
+span11_ :: Monad m => HtmlT m () -> HtmlT m ()
+span11_ =
+  with (makeElement (Blaze.fromString "div"))
+       [class_ "span11"]
+
+-- | A span of 12 columns.
+span12_ :: Monad m => HtmlT m () -> HtmlT m ()
+span12_ =
+  with (makeElement (Blaze.fromString "div"))
+       [class_ "span12"]
diff --git a/src/Lucid/Html5.hs b/src/Lucid/Html5.hs
new file mode 100644
--- /dev/null
+++ b/src/Lucid/Html5.hs
@@ -0,0 +1,1078 @@
+-- | Html5 terms.
+
+module Lucid.Html5 where
+
+import           Lucid.Base
+
+import qualified Blaze.ByteString.Builder.Char.Utf8 as Blaze
+import           Data.Monoid
+
+-- | @DOCTYPE@ element
+doctype_  :: Monad m => HtmlT m ()
+doctype_ = makeElementNoEnd (Blaze.fromString "!DOCTYPE HTML")
+
+-- | @DOCTYPE@ element + @html@ element
+doctypehtml_  :: Monad m => HtmlT m () -> HtmlT m ()
+doctypehtml_ m =
+  do doctype_
+     html_ m
+
+-- | @a@ element
+a_  :: Monad m => HtmlT m () -> HtmlT m ()
+a_ = makeElement (Blaze.fromString "a")
+
+-- | @abbr@ element
+abbr_  :: Monad m => HtmlT m () -> HtmlT m ()
+abbr_ = makeElement (Blaze.fromString "abbr")
+
+-- | @address@ element
+address_  :: Monad m => HtmlT m () -> HtmlT m ()
+address_ = makeElement (Blaze.fromString "address")
+
+-- | @area@ element
+area_  :: Monad m => HtmlT m ()
+area_ = makeElementNoEnd (Blaze.fromString "area")
+
+-- | @article@ element
+article_  :: Monad m => HtmlT m () -> HtmlT m ()
+article_ = makeElement (Blaze.fromString "article")
+
+-- | @aside@ element
+aside_  :: Monad m => HtmlT m () -> HtmlT m ()
+aside_ = makeElement (Blaze.fromString "aside")
+
+-- | @audio@ element
+audio_  :: Monad m => HtmlT m () -> HtmlT m ()
+audio_ = makeElement (Blaze.fromString "audio")
+
+-- | @b@ element
+b_  :: Monad m => HtmlT m () -> HtmlT m ()
+b_ = makeElement (Blaze.fromString "b")
+
+-- | @base@ element
+base_  :: Monad m => HtmlT m ()
+base_ = makeElementNoEnd (Blaze.fromString "base")
+
+-- | @bdo@ element
+bdo_  :: Monad m => HtmlT m () -> HtmlT m ()
+bdo_ = makeElement (Blaze.fromString "bdo")
+
+-- | @blockquote@ element
+blockquote_  :: Monad m => HtmlT m () -> HtmlT m ()
+blockquote_ = makeElement (Blaze.fromString "blockquote")
+
+-- | @body@ element
+body_  :: Monad m => HtmlT m () -> HtmlT m ()
+body_ = makeElement (Blaze.fromString "body")
+
+-- | @br@ element
+br_  :: Monad m => HtmlT m ()
+br_ = makeElementNoEnd (Blaze.fromString "br")
+
+-- | @button@ element
+button_  :: Monad m => HtmlT m () -> HtmlT m ()
+button_ = makeElement (Blaze.fromString "button")
+
+-- | @canvas@ element
+canvas_  :: Monad m => HtmlT m () -> HtmlT m ()
+canvas_ = makeElement (Blaze.fromString "canvas")
+
+-- | @caption@ element
+caption_  :: Monad m => HtmlT m () -> HtmlT m ()
+caption_ = makeElement (Blaze.fromString "caption")
+
+-- | @cite@ element or @cite@ attribute.
+cite_ :: Mixed a r => a -> r
+cite_ = mixed (Blaze.fromString "cite")
+
+-- | @code@ element
+code_  :: Monad m => HtmlT m () -> HtmlT m ()
+code_ = makeElement (Blaze.fromString "code")
+
+-- | @col@ element
+col_  :: Monad m => HtmlT m ()
+col_ = makeElementNoEnd (Blaze.fromString "col")
+
+-- | @colgroup@ element
+colgroup_  :: Monad m => HtmlT m () -> HtmlT m ()
+colgroup_ = makeElement (Blaze.fromString "colgroup")
+
+-- | @command@ element
+command_  :: Monad m => HtmlT m () -> HtmlT m ()
+command_ = makeElement (Blaze.fromString "command")
+
+-- | @datalist@ element
+datalist_  :: Monad m => HtmlT m () -> HtmlT m ()
+datalist_ = makeElement (Blaze.fromString "datalist")
+
+-- | @dd@ element
+dd_  :: Monad m => HtmlT m () -> HtmlT m ()
+dd_ = makeElement (Blaze.fromString "dd")
+
+-- | @del@ element
+del_  :: Monad m => HtmlT m () -> HtmlT m ()
+del_ = makeElement (Blaze.fromString "del")
+
+-- | @details@ element
+details_  :: Monad m => HtmlT m () -> HtmlT m ()
+details_ = makeElement (Blaze.fromString "details")
+
+-- | @dfn@ element
+dfn_  :: Monad m => HtmlT m () -> HtmlT m ()
+dfn_ = makeElement (Blaze.fromString "dfn")
+
+-- | @div@ element
+div_  :: Monad m => HtmlT m () -> HtmlT m ()
+div_ = makeElement (Blaze.fromString "div")
+
+-- | @dl@ element
+dl_  :: Monad m => HtmlT m () -> HtmlT m ()
+dl_ = makeElement (Blaze.fromString "dl")
+
+-- | @dt@ element
+dt_  :: Monad m => HtmlT m () -> HtmlT m ()
+dt_ = makeElement (Blaze.fromString "dt")
+
+-- | @em@ element
+em_  :: Monad m => HtmlT m () -> HtmlT m ()
+em_ = makeElement (Blaze.fromString "em")
+
+-- | @embed@ element
+embed_  :: Monad m => HtmlT m ()
+embed_ = makeElementNoEnd (Blaze.fromString "embed")
+
+-- | @fieldset@ element
+fieldset_  :: Monad m => HtmlT m () -> HtmlT m ()
+fieldset_ = makeElement (Blaze.fromString "fieldset")
+
+-- | @figcaption@ element
+figcaption_  :: Monad m => HtmlT m () -> HtmlT m ()
+figcaption_ = makeElement (Blaze.fromString "figcaption")
+
+-- | @figure@ element
+figure_  :: Monad m => HtmlT m () -> HtmlT m ()
+figure_ = makeElement (Blaze.fromString "figure")
+
+-- | @footer@ element
+footer_  :: Monad m => HtmlT m () -> HtmlT m ()
+footer_ = makeElement (Blaze.fromString "footer")
+
+-- | @form@ element or @form@ attribute
+form_ :: Mixed a r => a -> r
+form_ = mixed (Blaze.fromString "form")
+
+-- | @h1@ element
+h1_  :: Monad m => HtmlT m () -> HtmlT m ()
+h1_ = makeElement (Blaze.fromString "h1")
+
+-- | @h2@ element
+h2_  :: Monad m => HtmlT m () -> HtmlT m ()
+h2_ = makeElement (Blaze.fromString "h2")
+
+-- | @h3@ element
+h3_  :: Monad m => HtmlT m () -> HtmlT m ()
+h3_ = makeElement (Blaze.fromString "h3")
+
+-- | @h4@ element
+h4_  :: Monad m => HtmlT m () -> HtmlT m ()
+h4_ = makeElement (Blaze.fromString "h4")
+
+-- | @h5@ element
+h5_  :: Monad m => HtmlT m () -> HtmlT m ()
+h5_ = makeElement (Blaze.fromString "h5")
+
+-- | @h6@ element
+h6_  :: Monad m => HtmlT m () -> HtmlT m ()
+h6_ = makeElement (Blaze.fromString "h6")
+
+-- | @head@ element
+head_  :: Monad m => HtmlT m () -> HtmlT m ()
+head_ = makeElement (Blaze.fromString "head")
+
+-- | @header@ element
+header_  :: Monad m => HtmlT m () -> HtmlT m ()
+header_ = makeElement (Blaze.fromString "header")
+
+-- | @hgroup@ element
+hgroup_  :: Monad m => HtmlT m () -> HtmlT m ()
+hgroup_ = makeElement (Blaze.fromString "hgroup")
+
+-- | @hr@ element
+hr_  :: Monad m => HtmlT m ()
+hr_ = makeElementNoEnd (Blaze.fromString "hr")
+
+-- | @html@ element
+html_  :: Monad m => HtmlT m () -> HtmlT m ()
+html_ = makeElement (Blaze.fromString "html")
+
+-- | @i@ element
+i_  :: Monad m => HtmlT m () -> HtmlT m ()
+i_ = makeElement (Blaze.fromString "i")
+
+-- | @iframe@ element
+iframe_  :: Monad m => HtmlT m () -> HtmlT m ()
+iframe_ = makeElement (Blaze.fromString "iframe")
+
+-- | @img@ element
+img_  :: Monad m => HtmlT m ()
+img_ = makeElementNoEnd (Blaze.fromString "img")
+
+-- | @input@ element
+input_  :: Monad m => HtmlT m ()
+input_ = makeElementNoEnd (Blaze.fromString "input")
+
+-- | @ins@ element
+ins_  :: Monad m => HtmlT m () -> HtmlT m ()
+ins_ = makeElement (Blaze.fromString "ins")
+
+-- | @kbd@ element
+kbd_  :: Monad m => HtmlT m () -> HtmlT m ()
+kbd_ = makeElement (Blaze.fromString "kbd")
+
+-- | @keygen@ element
+keygen_  :: Monad m => HtmlT m ()
+keygen_ = makeElementNoEnd (Blaze.fromString "keygen")
+
+-- | @label@ element or @label@ attribute
+label_ :: Mixed a r => a -> r
+label_ = mixed (Blaze.fromString "label")
+
+-- | @legend@ element
+legend_  :: Monad m => HtmlT m () -> HtmlT m ()
+legend_ = makeElement (Blaze.fromString "legend")
+
+-- | @li@ element
+li_  :: Monad m => HtmlT m () -> HtmlT m ()
+li_ = makeElement (Blaze.fromString "li")
+
+-- | @link@ element
+link_  :: Monad m => HtmlT m ()
+link_ = makeElementNoEnd (Blaze.fromString "link")
+
+-- | @map@ element
+map_  :: Monad m => HtmlT m () -> HtmlT m ()
+map_ = makeElement (Blaze.fromString "map")
+
+-- | @mark@ element
+mark_  :: Monad m => HtmlT m () -> HtmlT m ()
+mark_ = makeElement (Blaze.fromString "mark")
+
+-- | @menu@ element
+menu_  :: Monad m => HtmlT m () -> HtmlT m ()
+menu_ = makeElement (Blaze.fromString "menu")
+
+-- | @menuitem@ element
+menuitem_  :: Monad m => HtmlT m ()
+menuitem_ = makeElementNoEnd (Blaze.fromString "menuitem")
+
+-- | @meta@ element
+meta_  :: Monad m => HtmlT m ()
+meta_ = makeElementNoEnd (Blaze.fromString "meta")
+
+-- | @meter@ element
+meter_  :: Monad m => HtmlT m () -> HtmlT m ()
+meter_ = makeElement (Blaze.fromString "meter")
+
+-- | @nav@ element
+nav_  :: Monad m => HtmlT m () -> HtmlT m ()
+nav_ = makeElement (Blaze.fromString "nav")
+
+-- | @noscript@ element
+noscript_  :: Monad m => HtmlT m () -> HtmlT m ()
+noscript_ = makeElement (Blaze.fromString "noscript")
+
+-- | @object@ element
+object_  :: Monad m => HtmlT m () -> HtmlT m ()
+object_ = makeElement (Blaze.fromString "object")
+
+-- | @ol@ element
+ol_  :: Monad m => HtmlT m () -> HtmlT m ()
+ol_ = makeElement (Blaze.fromString "ol")
+
+-- | @optgroup@ element
+optgroup_  :: Monad m => HtmlT m () -> HtmlT m ()
+optgroup_ = makeElement (Blaze.fromString "optgroup")
+
+-- | @option@ element
+option_  :: Monad m => HtmlT m () -> HtmlT m ()
+option_ = makeElement (Blaze.fromString "option")
+
+-- | @output@ element
+output_  :: Monad m => HtmlT m () -> HtmlT m ()
+output_ = makeElement (Blaze.fromString "output")
+
+-- | @p@ element
+p_  :: Monad m => HtmlT m () -> HtmlT m ()
+p_ = makeElement (Blaze.fromString "p")
+
+-- | @param@ element
+param_  :: Monad m => HtmlT m ()
+param_ = makeElementNoEnd (Blaze.fromString "param")
+
+-- | @pre@ element
+pre_  :: Monad m => HtmlT m () -> HtmlT m ()
+pre_ = makeElement (Blaze.fromString "pre")
+
+-- | @progress@ element
+progress_  :: Monad m => HtmlT m () -> HtmlT m ()
+progress_ = makeElement (Blaze.fromString "progress")
+
+-- | @q@ element
+q_  :: Monad m => HtmlT m () -> HtmlT m ()
+q_ = makeElement (Blaze.fromString "q")
+
+-- | @rp@ element
+rp_  :: Monad m => HtmlT m () -> HtmlT m ()
+rp_ = makeElement (Blaze.fromString "rp")
+
+-- | @rt@ element
+rt_  :: Monad m => HtmlT m () -> HtmlT m ()
+rt_ = makeElement (Blaze.fromString "rt")
+
+-- | @ruby@ element
+ruby_  :: Monad m => HtmlT m () -> HtmlT m ()
+ruby_ = makeElement (Blaze.fromString "ruby")
+
+-- | @samp@ element
+samp_  :: Monad m => HtmlT m () -> HtmlT m ()
+samp_ = makeElement (Blaze.fromString "samp")
+
+-- | @script@ element
+script_  :: Monad m => HtmlT m () -> HtmlT m ()
+script_ = makeElement (Blaze.fromString "script")
+
+-- | @section@ element
+section_  :: Monad m => HtmlT m () -> HtmlT m ()
+section_ = makeElement (Blaze.fromString "section")
+
+-- | @select@ element
+select_  :: Monad m => HtmlT m () -> HtmlT m ()
+select_ = makeElement (Blaze.fromString "select")
+
+-- | @small@ element
+small_  :: Monad m => HtmlT m () -> HtmlT m ()
+small_ = makeElement (Blaze.fromString "small")
+
+-- | @source@ element
+source_  :: Monad m => HtmlT m ()
+source_ = makeElementNoEnd (Blaze.fromString "source")
+
+-- | @span@ element or @span@ attribute
+span_  :: Mixed a r => a -> r
+span_ = mixed (Blaze.fromString "span")
+
+-- | @strong@ element
+strong_  :: Monad m => HtmlT m () -> HtmlT m ()
+strong_ = makeElement (Blaze.fromString "strong")
+
+-- | @style@ element or @style@ attribute
+style_  :: Mixed a r => a -> r
+style_ = mixed (Blaze.fromString "style")
+
+-- | @sub@ element
+sub_  :: Monad m => HtmlT m () -> HtmlT m ()
+sub_ = makeElement (Blaze.fromString "sub")
+
+-- | @summary@ element or @summary@ attribute
+summary_  :: Mixed a r => a -> r
+summary_ = mixed (Blaze.fromString "summary")
+
+-- | @sup@ element
+sup_  :: Monad m => HtmlT m () -> HtmlT m ()
+sup_ = makeElement (Blaze.fromString "sup")
+
+-- | @table@ element
+table_  :: Monad m => HtmlT m () -> HtmlT m ()
+table_ = makeElement (Blaze.fromString "table")
+
+-- | @tbody@ element
+tbody_  :: Monad m => HtmlT m () -> HtmlT m ()
+tbody_ = makeElement (Blaze.fromString "tbody")
+
+-- | @td@ element
+td_  :: Monad m => HtmlT m () -> HtmlT m ()
+td_ = makeElement (Blaze.fromString "td")
+
+-- | @textarea@ element
+textarea_  :: Monad m => HtmlT m () -> HtmlT m ()
+textarea_ = makeElement (Blaze.fromString "textarea")
+
+-- | @tfoot@ element
+tfoot_  :: Monad m => HtmlT m () -> HtmlT m ()
+tfoot_ = makeElement (Blaze.fromString "tfoot")
+
+-- | @th@ element
+th_  :: Monad m => HtmlT m () -> HtmlT m ()
+th_ = makeElement (Blaze.fromString "th")
+
+-- | @thead@ element
+thead_  :: Monad m => HtmlT m () -> HtmlT m ()
+thead_ = makeElement (Blaze.fromString "thead")
+
+-- | @time@ element
+time_  :: Monad m => HtmlT m () -> HtmlT m ()
+time_ = makeElement (Blaze.fromString "time")
+
+-- | @title@ element or @title@ attribute
+title_  :: Mixed a r => a -> r
+title_ = mixed (Blaze.fromString "title")
+
+-- | @tr@ element
+tr_  :: Monad m => HtmlT m () -> HtmlT m ()
+tr_ = makeElement (Blaze.fromString "tr")
+
+-- | @track@ element
+track_  :: Monad m => HtmlT m ()
+track_ = makeElementNoEnd (Blaze.fromString "track")
+
+-- | @ul@ element
+ul_  :: Monad m => HtmlT m () -> HtmlT m ()
+ul_ = makeElement (Blaze.fromString "ul")
+
+-- | @var@ element
+var_  :: Monad m => HtmlT m () -> HtmlT m ()
+var_ = makeElement (Blaze.fromString "var")
+
+-- | @video@ element
+video_  :: Monad m => HtmlT m () -> HtmlT m ()
+video_ = makeElement (Blaze.fromString "video")
+
+-- | @wbr@ element
+wbr_  :: Monad m => HtmlT m ()
+wbr_ = makeElementNoEnd (Blaze.fromString "wbr")
+
+-- | The @accept@ attribute.
+accept_ :: ToText a => a -> Attr
+accept_ = Attr (Blaze.fromString "accept") . toText
+
+-- | The @acceptCharset@ attribute.
+acceptCharset_ :: ToText a => a -> Attr
+acceptCharset_ = Attr (Blaze.fromString "acceptCharset") . toText
+
+-- | The @accesskey@ attribute.
+accesskey_ :: ToText a => a -> Attr
+accesskey_ = Attr (Blaze.fromString "accesskey") . toText
+
+-- | The @action@ attribute.
+action_ :: ToText a => a -> Attr
+action_ = Attr (Blaze.fromString "action") . toText
+
+-- | The @alt@ attribute.
+alt_ :: ToText a => a -> Attr
+alt_ = Attr (Blaze.fromString "alt") . toText
+
+-- | The @async@ attribute.
+async_ :: ToText a => a -> Attr
+async_ = Attr (Blaze.fromString "async") . toText
+
+-- | The @autocomplete@ attribute.
+autocomplete_ :: ToText a => a -> Attr
+autocomplete_ = Attr (Blaze.fromString "autocomplete") . toText
+
+-- | The @autofocus@ attribute.
+autofocus_ :: Attr
+autofocus_ = Attr (Blaze.fromString "autofocus") mempty
+
+-- | The @autoplay@ attribute.
+autoplay_ :: ToText a => a -> Attr
+autoplay_ = Attr (Blaze.fromString "autoplay") . toText
+
+-- | The @challenge@ attribute.
+challenge_ :: ToText a => a -> Attr
+challenge_ = Attr (Blaze.fromString "challenge") . toText
+
+-- | The @charset@ attribute.
+charset_ :: ToText a => a -> Attr
+charset_ = Attr (Blaze.fromString "charset") . toText
+
+-- | The @checked@ attribute.
+checked_ :: Attr
+checked_ = Attr (Blaze.fromString "checked") mempty
+
+-- | The @class@ attribute.
+class_ :: ToText a => a -> Attr
+class_ = Attr (Blaze.fromString "class") . toText
+
+-- | The @cols@ attribute.
+cols_ :: ToText a => a -> Attr
+cols_ = Attr (Blaze.fromString "cols") . toText
+
+-- | The @colspan@ attribute.
+colspan_ :: ToText a => a -> Attr
+colspan_ = Attr (Blaze.fromString "colspan") . toText
+
+-- | The @content@ attribute.
+content_ :: ToText a => a -> Attr
+content_ = Attr (Blaze.fromString "content") . toText
+
+-- | The @contenteditable@ attribute.
+contenteditable_ :: ToText a => a -> Attr
+contenteditable_ = Attr (Blaze.fromString "contenteditable") . toText
+
+-- | The @contextmenu@ attribute.
+contextmenu_ :: ToText a => a -> Attr
+contextmenu_ = Attr (Blaze.fromString "contextmenu") . toText
+
+-- | The @controls@ attribute.
+controls_ :: ToText a => a -> Attr
+controls_ = Attr (Blaze.fromString "controls") . toText
+
+-- | The @coords@ attribute.
+coords_ :: ToText a => a -> Attr
+coords_ = Attr (Blaze.fromString "coords") . toText
+
+-- | The @data@ attribute.
+data_ :: ToText a => a -> Attr
+data_ = Attr (Blaze.fromString "data") . toText
+
+-- | The @datetime@ attribute.
+datetime_ :: ToText a => a -> Attr
+datetime_ = Attr (Blaze.fromString "datetime") . toText
+
+-- | The @defer@ attribute.
+defer_ :: ToText a => a -> Attr
+defer_ = Attr (Blaze.fromString "defer") . toText
+
+-- | The @dir@ attribute.
+dir_ :: ToText a => a -> Attr
+dir_ = Attr (Blaze.fromString "dir") . toText
+
+-- | The @disabled@ attribute.
+disabled_ :: ToText a => a -> Attr
+disabled_ = Attr (Blaze.fromString "disabled") . toText
+
+-- | The @draggable@ attribute.
+draggable_ :: ToText a => a -> Attr
+draggable_ = Attr (Blaze.fromString "draggable") . toText
+
+-- | The @enctype@ attribute.
+enctype_ :: ToText a => a -> Attr
+enctype_ = Attr (Blaze.fromString "enctype") . toText
+
+-- | The @for@ attribute.
+for_ :: ToText a => a -> Attr
+for_ = Attr (Blaze.fromString "for") . toText
+
+-- | The @formaction@ attribute.
+formaction_ :: ToText a => a -> Attr
+formaction_ = Attr (Blaze.fromString "formaction") . toText
+
+-- | The @formenctype@ attribute.
+formenctype_ :: ToText a => a -> Attr
+formenctype_ = Attr (Blaze.fromString "formenctype") . toText
+
+-- | The @formmethod@ attribute.
+formmethod_ :: ToText a => a -> Attr
+formmethod_ = Attr (Blaze.fromString "formmethod") . toText
+
+-- | The @formnovalidate@ attribute.
+formnovalidate_ :: ToText a => a -> Attr
+formnovalidate_ = Attr (Blaze.fromString "formnovalidate") . toText
+
+-- | The @formtarget@ attribute.
+formtarget_ :: ToText a => a -> Attr
+formtarget_ = Attr (Blaze.fromString "formtarget") . toText
+
+-- | The @headers@ attribute.
+headers_ :: ToText a => a -> Attr
+headers_ = Attr (Blaze.fromString "headers") . toText
+
+-- | The @height@ attribute.
+height_ :: ToText a => a -> Attr
+height_ = Attr (Blaze.fromString "height") . toText
+
+-- | The @hidden@ attribute.
+hidden_ :: ToText a => a -> Attr
+hidden_ = Attr (Blaze.fromString "hidden") . toText
+
+-- | The @high@ attribute.
+high_ :: ToText a => a -> Attr
+high_ = Attr (Blaze.fromString "high") . toText
+
+-- | The @href@ attribute.
+href_ :: ToText a => a -> Attr
+href_ = Attr (Blaze.fromString "href") . toText
+
+-- | The @hreflang@ attribute.
+hreflang_ :: ToText a => a -> Attr
+hreflang_ = Attr (Blaze.fromString "hreflang") . toText
+
+-- | The @httpEquiv@ attribute.
+httpEquiv_ :: ToText a => a -> Attr
+httpEquiv_ = Attr (Blaze.fromString "httpEquiv") . toText
+
+-- | The @icon@ attribute.
+icon_ :: ToText a => a -> Attr
+icon_ = Attr (Blaze.fromString "icon") . toText
+
+-- | The @id@ attribute.
+id_ :: ToText a => a -> Attr
+id_ = Attr (Blaze.fromString "id") . toText
+
+-- | The @ismap@ attribute.
+ismap_ :: ToText a => a -> Attr
+ismap_ = Attr (Blaze.fromString "ismap") . toText
+
+-- | The @item@ attribute.
+item_ :: ToText a => a -> Attr
+item_ = Attr (Blaze.fromString "item") . toText
+
+-- | The @itemprop@ attribute.
+itemprop_ :: ToText a => a -> Attr
+itemprop_ = Attr (Blaze.fromString "itemprop") . toText
+
+-- | The @keytype@ attribute.
+keytype_ :: ToText a => a -> Attr
+keytype_ = Attr (Blaze.fromString "keytype") . toText
+
+-- | The @lang@ attribute.
+lang_ :: ToText a => a -> Attr
+lang_ = Attr (Blaze.fromString "lang") . toText
+
+-- | The @list@ attribute.
+list_ :: ToText a => a -> Attr
+list_ = Attr (Blaze.fromString "list") . toText
+
+-- | The @loop@ attribute.
+loop_ :: ToText a => a -> Attr
+loop_ = Attr (Blaze.fromString "loop") . toText
+
+-- | The @low@ attribute.
+low_ :: ToText a => a -> Attr
+low_ = Attr (Blaze.fromString "low") . toText
+
+-- | The @manifest@ attribute.
+manifest_ :: ToText a => a -> Attr
+manifest_ = Attr (Blaze.fromString "manifest") . toText
+
+-- | The @max@ attribute.
+max_ :: ToText a => a -> Attr
+max_ = Attr (Blaze.fromString "max") . toText
+
+-- | The @maxlength@ attribute.
+maxlength_ :: ToText a => a -> Attr
+maxlength_ = Attr (Blaze.fromString "maxlength") . toText
+
+-- | The @media@ attribute.
+media_ :: ToText a => a -> Attr
+media_ = Attr (Blaze.fromString "media") . toText
+
+-- | The @method@ attribute.
+method_ :: ToText a => a -> Attr
+method_ = Attr (Blaze.fromString "method") . toText
+
+-- | The @min@ attribute.
+min_ :: ToText a => a -> Attr
+min_ = Attr (Blaze.fromString "min") . toText
+
+-- | The @multiple@ attribute.
+multiple_ :: ToText a => a -> Attr
+multiple_ = Attr (Blaze.fromString "multiple") . toText
+
+-- | The @name@ attribute.
+name_ :: ToText a => a -> Attr
+name_ = Attr (Blaze.fromString "name") . toText
+
+-- | The @novalidate@ attribute.
+novalidate_ :: ToText a => a -> Attr
+novalidate_ = Attr (Blaze.fromString "novalidate") . toText
+
+-- | The @onbeforeonload@ attribute.
+onbeforeonload_ :: ToText a => a -> Attr
+onbeforeonload_ = Attr (Blaze.fromString "onbeforeonload") . toText
+
+-- | The @onbeforeprint@ attribute.
+onbeforeprint_ :: ToText a => a -> Attr
+onbeforeprint_ = Attr (Blaze.fromString "onbeforeprint") . toText
+
+-- | The @onblur@ attribute.
+onblur_ :: ToText a => a -> Attr
+onblur_ = Attr (Blaze.fromString "onblur") . toText
+
+-- | The @oncanplay@ attribute.
+oncanplay_ :: ToText a => a -> Attr
+oncanplay_ = Attr (Blaze.fromString "oncanplay") . toText
+
+-- | The @oncanplaythrough@ attribute.
+oncanplaythrough_ :: ToText a => a -> Attr
+oncanplaythrough_ = Attr (Blaze.fromString "oncanplaythrough") . toText
+
+-- | The @onchange@ attribute.
+onchange_ :: ToText a => a -> Attr
+onchange_ = Attr (Blaze.fromString "onchange") . toText
+
+-- | The @onclick@ attribute.
+onclick_ :: ToText a => a -> Attr
+onclick_ = Attr (Blaze.fromString "onclick") . toText
+
+-- | The @oncontextmenu@ attribute.
+oncontextmenu_ :: ToText a => a -> Attr
+oncontextmenu_ = Attr (Blaze.fromString "oncontextmenu") . toText
+
+-- | The @ondblclick@ attribute.
+ondblclick_ :: ToText a => a -> Attr
+ondblclick_ = Attr (Blaze.fromString "ondblclick") . toText
+
+-- | The @ondrag@ attribute.
+ondrag_ :: ToText a => a -> Attr
+ondrag_ = Attr (Blaze.fromString "ondrag") . toText
+
+-- | The @ondragend@ attribute.
+ondragend_ :: ToText a => a -> Attr
+ondragend_ = Attr (Blaze.fromString "ondragend") . toText
+
+-- | The @ondragenter@ attribute.
+ondragenter_ :: ToText a => a -> Attr
+ondragenter_ = Attr (Blaze.fromString "ondragenter") . toText
+
+-- | The @ondragleave@ attribute.
+ondragleave_ :: ToText a => a -> Attr
+ondragleave_ = Attr (Blaze.fromString "ondragleave") . toText
+
+-- | The @ondragover@ attribute.
+ondragover_ :: ToText a => a -> Attr
+ondragover_ = Attr (Blaze.fromString "ondragover") . toText
+
+-- | The @ondragstart@ attribute.
+ondragstart_ :: ToText a => a -> Attr
+ondragstart_ = Attr (Blaze.fromString "ondragstart") . toText
+
+-- | The @ondrop@ attribute.
+ondrop_ :: ToText a => a -> Attr
+ondrop_ = Attr (Blaze.fromString "ondrop") . toText
+
+-- | The @ondurationchange@ attribute.
+ondurationchange_ :: ToText a => a -> Attr
+ondurationchange_ = Attr (Blaze.fromString "ondurationchange") . toText
+
+-- | The @onemptied@ attribute.
+onemptied_ :: ToText a => a -> Attr
+onemptied_ = Attr (Blaze.fromString "onemptied") . toText
+
+-- | The @onended@ attribute.
+onended_ :: ToText a => a -> Attr
+onended_ = Attr (Blaze.fromString "onended") . toText
+
+-- | The @onerror@ attribute.
+onerror_ :: ToText a => a -> Attr
+onerror_ = Attr (Blaze.fromString "onerror") . toText
+
+-- | The @onfocus@ attribute.
+onfocus_ :: ToText a => a -> Attr
+onfocus_ = Attr (Blaze.fromString "onfocus") . toText
+
+-- | The @onformchange@ attribute.
+onformchange_ :: ToText a => a -> Attr
+onformchange_ = Attr (Blaze.fromString "onformchange") . toText
+
+-- | The @onforminput@ attribute.
+onforminput_ :: ToText a => a -> Attr
+onforminput_ = Attr (Blaze.fromString "onforminput") . toText
+
+-- | The @onhaschange@ attribute.
+onhaschange_ :: ToText a => a -> Attr
+onhaschange_ = Attr (Blaze.fromString "onhaschange") . toText
+
+-- | The @oninput@ attribute.
+oninput_ :: ToText a => a -> Attr
+oninput_ = Attr (Blaze.fromString "oninput") . toText
+
+-- | The @oninvalid@ attribute.
+oninvalid_ :: ToText a => a -> Attr
+oninvalid_ = Attr (Blaze.fromString "oninvalid") . toText
+
+-- | The @onkeydown@ attribute.
+onkeydown_ :: ToText a => a -> Attr
+onkeydown_ = Attr (Blaze.fromString "onkeydown") . toText
+
+-- | The @onkeyup@ attribute.
+onkeyup_ :: ToText a => a -> Attr
+onkeyup_ = Attr (Blaze.fromString "onkeyup") . toText
+
+-- | The @onload@ attribute.
+onload_ :: ToText a => a -> Attr
+onload_ = Attr (Blaze.fromString "onload") . toText
+
+-- | The @onloadeddata@ attribute.
+onloadeddata_ :: ToText a => a -> Attr
+onloadeddata_ = Attr (Blaze.fromString "onloadeddata") . toText
+
+-- | The @onloadedmetadata@ attribute.
+onloadedmetadata_ :: ToText a => a -> Attr
+onloadedmetadata_ = Attr (Blaze.fromString "onloadedmetadata") . toText
+
+-- | The @onloadstart@ attribute.
+onloadstart_ :: ToText a => a -> Attr
+onloadstart_ = Attr (Blaze.fromString "onloadstart") . toText
+
+-- | The @onmessage@ attribute.
+onmessage_ :: ToText a => a -> Attr
+onmessage_ = Attr (Blaze.fromString "onmessage") . toText
+
+-- | The @onmousedown@ attribute.
+onmousedown_ :: ToText a => a -> Attr
+onmousedown_ = Attr (Blaze.fromString "onmousedown") . toText
+
+-- | The @onmousemove@ attribute.
+onmousemove_ :: ToText a => a -> Attr
+onmousemove_ = Attr (Blaze.fromString "onmousemove") . toText
+
+-- | The @onmouseout@ attribute.
+onmouseout_ :: ToText a => a -> Attr
+onmouseout_ = Attr (Blaze.fromString "onmouseout") . toText
+
+-- | The @onmouseover@ attribute.
+onmouseover_ :: ToText a => a -> Attr
+onmouseover_ = Attr (Blaze.fromString "onmouseover") . toText
+
+-- | The @onmouseup@ attribute.
+onmouseup_ :: ToText a => a -> Attr
+onmouseup_ = Attr (Blaze.fromString "onmouseup") . toText
+
+-- | The @onmousewheel@ attribute.
+onmousewheel_ :: ToText a => a -> Attr
+onmousewheel_ = Attr (Blaze.fromString "onmousewheel") . toText
+
+-- | The @ononline@ attribute.
+ononline_ :: ToText a => a -> Attr
+ononline_ = Attr (Blaze.fromString "ononline") . toText
+
+-- | The @onpagehide@ attribute.
+onpagehide_ :: ToText a => a -> Attr
+onpagehide_ = Attr (Blaze.fromString "onpagehide") . toText
+
+-- | The @onpageshow@ attribute.
+onpageshow_ :: ToText a => a -> Attr
+onpageshow_ = Attr (Blaze.fromString "onpageshow") . toText
+
+-- | The @onpause@ attribute.
+onpause_ :: ToText a => a -> Attr
+onpause_ = Attr (Blaze.fromString "onpause") . toText
+
+-- | The @onplay@ attribute.
+onplay_ :: ToText a => a -> Attr
+onplay_ = Attr (Blaze.fromString "onplay") . toText
+
+-- | The @onplaying@ attribute.
+onplaying_ :: ToText a => a -> Attr
+onplaying_ = Attr (Blaze.fromString "onplaying") . toText
+
+-- | The @onprogress@ attribute.
+onprogress_ :: ToText a => a -> Attr
+onprogress_ = Attr (Blaze.fromString "onprogress") . toText
+
+-- | The @onpropstate@ attribute.
+onpropstate_ :: ToText a => a -> Attr
+onpropstate_ = Attr (Blaze.fromString "onpropstate") . toText
+
+-- | The @onratechange@ attribute.
+onratechange_ :: ToText a => a -> Attr
+onratechange_ = Attr (Blaze.fromString "onratechange") . toText
+
+-- | The @onreadystatechange@ attribute.
+onreadystatechange_ :: ToText a => a -> Attr
+onreadystatechange_ = Attr (Blaze.fromString "onreadystatechange") . toText
+
+-- | The @onredo@ attribute.
+onredo_ :: ToText a => a -> Attr
+onredo_ = Attr (Blaze.fromString "onredo") . toText
+
+-- | The @onresize@ attribute.
+onresize_ :: ToText a => a -> Attr
+onresize_ = Attr (Blaze.fromString "onresize") . toText
+
+-- | The @onscroll@ attribute.
+onscroll_ :: ToText a => a -> Attr
+onscroll_ = Attr (Blaze.fromString "onscroll") . toText
+
+-- | The @onseeked@ attribute.
+onseeked_ :: ToText a => a -> Attr
+onseeked_ = Attr (Blaze.fromString "onseeked") . toText
+
+-- | The @onseeking@ attribute.
+onseeking_ :: ToText a => a -> Attr
+onseeking_ = Attr (Blaze.fromString "onseeking") . toText
+
+-- | The @onselect@ attribute.
+onselect_ :: ToText a => a -> Attr
+onselect_ = Attr (Blaze.fromString "onselect") . toText
+
+-- | The @onstalled@ attribute.
+onstalled_ :: ToText a => a -> Attr
+onstalled_ = Attr (Blaze.fromString "onstalled") . toText
+
+-- | The @onstorage@ attribute.
+onstorage_ :: ToText a => a -> Attr
+onstorage_ = Attr (Blaze.fromString "onstorage") . toText
+
+-- | The @onsubmit@ attribute.
+onsubmit_ :: ToText a => a -> Attr
+onsubmit_ = Attr (Blaze.fromString "onsubmit") . toText
+
+-- | The @onsuspend@ attribute.
+onsuspend_ :: ToText a => a -> Attr
+onsuspend_ = Attr (Blaze.fromString "onsuspend") . toText
+
+-- | The @ontimeupdate@ attribute.
+ontimeupdate_ :: ToText a => a -> Attr
+ontimeupdate_ = Attr (Blaze.fromString "ontimeupdate") . toText
+
+-- | The @onundo@ attribute.
+onundo_ :: ToText a => a -> Attr
+onundo_ = Attr (Blaze.fromString "onundo") . toText
+
+-- | The @onunload@ attribute.
+onunload_ :: ToText a => a -> Attr
+onunload_ = Attr (Blaze.fromString "onunload") . toText
+
+-- | The @onvolumechange@ attribute.
+onvolumechange_ :: ToText a => a -> Attr
+onvolumechange_ = Attr (Blaze.fromString "onvolumechange") . toText
+
+-- | The @onwaiting@ attribute.
+onwaiting_ :: ToText a => a -> Attr
+onwaiting_ = Attr (Blaze.fromString "onwaiting") . toText
+
+-- | The @open@ attribute.
+open_ :: ToText a => a -> Attr
+open_ = Attr (Blaze.fromString "open") . toText
+
+-- | The @optimum@ attribute.
+optimum_ :: ToText a => a -> Attr
+optimum_ = Attr (Blaze.fromString "optimum") . toText
+
+-- | The @pattern@ attribute.
+pattern_ :: ToText a => a -> Attr
+pattern_ = Attr (Blaze.fromString "pattern") . toText
+
+-- | The @ping@ attribute.
+ping_ :: ToText a => a -> Attr
+ping_ = Attr (Blaze.fromString "ping") . toText
+
+-- | The @placeholder@ attribute.
+placeholder_ :: ToText a => a -> Attr
+placeholder_ = Attr (Blaze.fromString "placeholder") . toText
+
+-- | The @preload@ attribute.
+preload_ :: ToText a => a -> Attr
+preload_ = Attr (Blaze.fromString "preload") . toText
+
+-- | The @pubdate@ attribute.
+pubdate_ :: ToText a => a -> Attr
+pubdate_ = Attr (Blaze.fromString "pubdate") . toText
+
+-- | The @radiogroup@ attribute.
+radiogroup_ :: ToText a => a -> Attr
+radiogroup_ = Attr (Blaze.fromString "radiogroup") . toText
+
+-- | The @readonly@ attribute.
+readonly_ :: ToText a => a -> Attr
+readonly_ = Attr (Blaze.fromString "readonly") . toText
+
+-- | The @rel@ attribute.
+rel_ :: ToText a => a -> Attr
+rel_ = Attr (Blaze.fromString "rel") . toText
+
+-- | The @required@ attribute.
+required_ :: ToText a => a -> Attr
+required_ = Attr (Blaze.fromString "required") . toText
+
+-- | The @reversed@ attribute.
+reversed_ :: ToText a => a -> Attr
+reversed_ = Attr (Blaze.fromString "reversed") . toText
+
+-- | The @rows@ attribute.
+rows_ :: ToText a => a -> Attr
+rows_ = Attr (Blaze.fromString "rows") . toText
+
+-- | The @rowspan@ attribute.
+rowspan_ :: ToText a => a -> Attr
+rowspan_ = Attr (Blaze.fromString "rowspan") . toText
+
+-- | The @sandbox@ attribute.
+sandbox_ :: ToText a => a -> Attr
+sandbox_ = Attr (Blaze.fromString "sandbox") . toText
+
+-- | The @scope@ attribute.
+scope_ :: ToText a => a -> Attr
+scope_ = Attr (Blaze.fromString "scope") . toText
+
+-- | The @scoped@ attribute.
+scoped_ :: ToText a => a -> Attr
+scoped_ = Attr (Blaze.fromString "scoped") . toText
+
+-- | The @seamless@ attribute.
+seamless_ :: ToText a => a -> Attr
+seamless_ = Attr (Blaze.fromString "seamless") . toText
+
+-- | The @selected@ attribute.
+selected_ :: ToText a => a -> Attr
+selected_ = Attr (Blaze.fromString "selected") . toText
+
+-- | The @shape@ attribute.
+shape_ :: ToText a => a -> Attr
+shape_ = Attr (Blaze.fromString "shape") . toText
+
+-- | The @size@ attribute.
+size_ :: ToText a => a -> Attr
+size_ = Attr (Blaze.fromString "size") . toText
+
+-- | The @sizes@ attribute.
+sizes_ :: ToText a => a -> Attr
+sizes_ = Attr (Blaze.fromString "sizes") . toText
+
+-- | The @spellcheck@ attribute.
+spellcheck_ :: ToText a => a -> Attr
+spellcheck_ = Attr (Blaze.fromString "spellcheck") . toText
+
+-- | The @src@ attribute.
+src_ :: ToText a => a -> Attr
+src_ = Attr (Blaze.fromString "src") . toText
+
+-- | The @srcdoc@ attribute.
+srcdoc_ :: ToText a => a -> Attr
+srcdoc_ = Attr (Blaze.fromString "srcdoc") . toText
+
+-- | The @start@ attribute.
+start_ :: ToText a => a -> Attr
+start_ = Attr (Blaze.fromString "start") . toText
+
+-- | The @step@ attribute.
+step_ :: ToText a => a -> Attr
+step_ = Attr (Blaze.fromString "step") . toText
+
+-- | The @subject@ attribute.
+subject_ :: ToText a => a -> Attr
+subject_ = Attr (Blaze.fromString "subject") . toText
+
+-- | The @tabindex@ attribute.
+tabindex_ :: ToText a => a -> Attr
+tabindex_ = Attr (Blaze.fromString "tabindex") . toText
+
+-- | The @target@ attribute.
+target_ :: ToText a => a -> Attr
+target_ = Attr (Blaze.fromString "target") . toText
+
+-- | The @type@ attribute.
+type_ :: ToText a => a -> Attr
+type_ = Attr (Blaze.fromString "type") . toText
+
+-- | The @usemap@ attribute.
+usemap_ :: ToText a => a -> Attr
+usemap_ = Attr (Blaze.fromString "usemap") . toText
+
+-- | The @value@ attribute.
+value_ :: ToText a => a -> Attr
+value_ = Attr (Blaze.fromString "value") . toText
+
+-- | The @width@ attribute.
+width_ :: ToText a => a -> Attr
+width_ = Attr (Blaze.fromString "width") . toText
+
+-- | The @wrap@ attribute.
+wrap_ :: ToText a => a -> Attr
+wrap_ = Attr (Blaze.fromString "wrap") . toText
+
+-- | The @xmlns@ attribute.
+xmlns_ :: ToText a => a -> Attr
+xmlns_ = Attr (Blaze.fromString "xmlns") . toText