These types were not be rendered correctly by the html/template package.
Removing them gets the correct behavior.
Fixes #74
 
 import (
        "bytes"
+       "html/template"
        "errors"
        "fmt"
        "github.com/kr/pretty"
        return Sanitize(strings.ToLower(strings.Replace(strings.TrimSpace(url), " ", "-", -1)))
 }
 
-func AbsUrl(url string, base string) HTML {
+func AbsUrl(url string, base string) template.HTML {
        if strings.HasPrefix(url, "http://") || strings.HasPrefix(url, "https://") {
-               return HTML(url)
+               return template.HTML(url)
        }
-       return HTML(MakePermalink(base, url))
+       return template.HTML(MakePermalink(base, url))
 }
 
 func Gt(a interface{}, b interface{}) bool {
 
 
 import (
        "time"
+       "html/template"
 )
 
 type Node struct {
-       RSSlink     HTML
+       RSSlink     template.HTML
        Site        SiteInfo
        layout      string
        Data        map[string]interface{}
 
 type UrlPath struct {
        Url       string
-       Permalink HTML
+       Permalink template.HTML
        Slug      string
        Section   string
        Path      string
 
        "github.com/BurntSushi/toml"
        "github.com/theplant/blackfriday"
        "io"
+       "html/template"
        "io/ioutil"
        "launchpad.net/goyaml"
        "os"
 type Page struct {
        Status          string
        Images          []string
-       Content         HTML
-       Summary         HTML
+       Content         template.HTML
+       Summary         template.HTML
        RawMarkdown     string // TODO should be []byte
        Params          map[string]interface{}
        RenderedContent *bytes.Buffer
        return datum, lines
 }
 
-func (p *Page) Permalink() HTML {
+func (p *Page) Permalink() template.HTML {
        baseUrl := string(p.Site.BaseUrl)
        section := strings.TrimSpace(p.Section)
        pSlug := strings.TrimSpace(p.Slug)
                        path = section + "/" + file
                }
        }
-       return HTML(MakePermalink(baseUrl, path))
+       return template.HTML(MakePermalink(baseUrl, path))
 }
 
 func (page *Page) handleTomlMetaData(datum []byte) (interface{}, error) {
        }
 }
 
-func (p *Page) Render(layout ...string) HTML {
+func (p *Page) Render(layout ...string) template.HTML {
        curLayout := ""
 
        if len(layout) > 0 {
                curLayout = layout[0]
        }
 
-       return HTML(string(p.ExecuteTemplate(curLayout).Bytes()))
+       return template.HTML(string(p.ExecuteTemplate(curLayout).Bytes()))
 }
 
 func (p *Page) ExecuteTemplate(layout string) *bytes.Buffer {
        b := new(bytes.Buffer)
        b.ReadFrom(lines)
        content := b.Bytes()
-       page.Content = HTML(string(blackfriday.MarkdownCommon(RemoveSummaryDivider(content))))
+       page.Content = template.HTML(string(blackfriday.MarkdownCommon(RemoveSummaryDivider(content))))
        summary, plain := getSummaryString(content)
        if plain {
-               page.Summary = HTML(string(summary))
+               page.Summary = template.HTML(string(summary))
        } else {
-               page.Summary = HTML(string(blackfriday.MarkdownCommon(summary)))
+               page.Summary = template.HTML(string(blackfriday.MarkdownCommon(summary)))
        }
 }
 
        b := new(bytes.Buffer)
        b.ReadFrom(lines)
        content := b.Bytes()
-       page.Content = HTML(getRstContent(content))
+       page.Content = template.HTML(getRstContent(content))
        summary, plain := getSummaryString(content)
        if plain {
-               page.Summary = HTML(string(summary))
+               page.Summary = template.HTML(string(summary))
        } else {
-               page.Summary = HTML(getRstContent(summary))
+               page.Summary = template.HTML(getRstContent(summary))
        }
 }
 
        "path/filepath"
        "strings"
        "testing"
+       "html/template"
 )
 
 var EMPTY_PAGE = ""
 }
 
 func checkPageContent(t *testing.T, page *Page, content string) {
-       if page.Content != HTML(content) {
+       if page.Content != template.HTML(content) {
                t.Fatalf("Page content is: %s.  Expected %s", page.Content, content)
        }
 }
 
 func checkPageSummary(t *testing.T, page *Page, summary string) {
-       if page.Summary != HTML(summary) {
+       if page.Summary != template.HTML(summary) {
                t.Fatalf("Page summary is: `%s`.  Expected `%s`", page.Summary, summary)
        }
 }
 
 
 import (
        "bitbucket.org/pkg/inflect"
+       "html/template"
        "bytes"
        "fmt"
        "github.com/spf13/hugo/target"
 }
 
 type SiteInfo struct {
-       BaseUrl    URL
+       BaseUrl    template.URL
        Indexes    OrderedIndexList
        Recent     *Pages
        LastChange time.Time
 
        filepath.Walk(s.absContentDir(), walker)
        s.Info = SiteInfo{
-               BaseUrl: URL(s.Config.BaseUrl),
+               BaseUrl: template.URL(s.Config.BaseUrl),
                Title:   s.Config.Title,
                Recent:  &s.Pages,
                Config:  &s.Config,
 
 func (s *Site) ProcessShortcodes() {
        for _, page := range s.Pages {
-               page.Content = HTML(ShortcodesHandle(string(page.Content), page, s.Tmpl))
+               page.Content = template.HTML(ShortcodesHandle(string(page.Content), page, s.Tmpl))
        }
 }
 
                content = strings.Replace(content, " href='/", " href='"+baseWithSlash, -1)
                content = strings.Replace(content, " href=\"/", " href=\""+baseWithSlash, -1)
                content = strings.Replace(content, baseWithoutTrailingSlash+"//", baseWithSlash, -1)
-               page.Content = HTML(content)
+               page.Content = template.HTML(content)
        }
 }
 
                        } else {
                                n.Url = Urlize(section + "/" + "index.xml")
                        }
-                       n.Permalink = HTML(string(n.Site.BaseUrl) + n.Url)
+                       n.Permalink = template.HTML(string(n.Site.BaseUrl) + n.Url)
                        y := s.NewXMLBuffer()
                        s.Tmpl.ExecuteTemplate(y, "rss.xml", n)
                        err = s.WritePublic(section+"/index.xml", y.Bytes())
        }
 }
 
-func permalink(s *Site, plink string) HTML {
-       return HTML(MakePermalink(string(s.Info.BaseUrl), plink))
+func permalink(s *Site, plink string) template.HTML {
+       return template.HTML(MakePermalink(string(s.Info.BaseUrl), plink))
 }
 
 func (s *Site) NewNode() *Node {
 
        "fmt"
        "strings"
        "testing"
+       "html/template"
 )
 
 var TEMPLATE_TITLE = "{{ .Title }}"
        }{
                {PAGE_SIMPLE_TITLE, TEMPLATE_TITLE, "simple template"},
                {PAGE_SIMPLE_TITLE, TEMPLATE_FUNC, "simple-template"},
-               {PAGE_WITH_MD, TEMPLATE_CONTENT, "<h1>heading 1</h1>\n<p>text</p>\n<h2>heading 2</h2>\n<p>more text</p>\n"},
+               {PAGE_WITH_MD, TEMPLATE_CONTENT, "<h1>heading 1</h1>\n\n<p>text</p>\n\n<h2>heading 2</h2>\n\n<p>more text</p>\n"},
        }
 
        s := new(Site)
                        t.Fatalf("Unable to add template")
                }
 
+               p.Content = template.HTML(p.Content)
                html, err2 := s.RenderThing(p, templateName)
                if err2 != nil {
                        t.Errorf("Unable to render html: %s", err)
 
 // It should not be used for HTML from a third-party, or HTML with
 // unclosed tags or comments. The outputs of a sound HTML sanitizer
 // and a template escaped by this package are fine for use with HTML.
-type HTML template.HTML
 
 type Template interface {
        ExecuteTemplate(wr io.Writer, name string, data interface{}) error
        AddTemplate(name, tpl string) error
 }
 
-type URL template.URL
-
 type templateErr struct {
        name string
        err  error