packages feed

lucid (empty) → 0.0

raw patch · 8 files changed

+1766/−0 lines, 8 filesdep +basedep +blaze-builderdep +bytestringsetup-changed

Dependencies added: base, blaze-builder, bytestring, text, transformers

Files

+ LICENSE view
@@ -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.
+ README.md view
@@ -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.
+ Setup.hs view
@@ -0,0 +1,2 @@+import Distribution.Simple+main = defaultMain
+ lucid.cabal view
@@ -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
+ src/Lucid.hs view
@@ -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".
+ src/Lucid/Base.hs view
@@ -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
+ src/Lucid/Bootstrap.hs view
@@ -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"]
+ src/Lucid/Html5.hs view
@@ -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