preformatted elements

Makefile

@@ -13,6 +13,7 @@ tags: \
 	tag/void.block.gen.go \
 	tag/void.inline.gen.go \
 	tag/inlinechildren.gen.go \
+	tag/preformatted.gen.go \
 	tag/script.gen.go
 	go fmt tag/*
 
@@ -34,6 +35,9 @@ tag/void.block.gen.go: $(SOURCES) tag.void.block.txt
 tag/void.inline.gen.go: $(SOURCES) tag.void.inline.txt
 	go run script/generate-tags.go Void Inline < tag.void.inline.txt > tag/void.inline.gen.go
 
+tag/preformatted.gen.go: $(SOURCES) tag.preformatted.txt
+	go run script/generate-tags.go Preformatted < tag.preformatted.txt > tag/preformatted.gen.go
+
 tag/script.gen.go: $(SOURCES) tag.script.txt
 	go run script/generate-tags.go ScriptContent < tag.script.txt > tag/script.gen.go
 

escape.go

@@ -12,12 +12,16 @@ const unicodeNBSP = 0xa0
 
 type escapeWriter struct {
 	out                     *bufio.Writer
+	nonbreakSpaces          bool
 	spaceStarted, lastSpace bool
 	err                     error
 }
 
-func newEscapeWriter(out io.Writer) *escapeWriter {
+func newEscapeWriter(out io.Writer, nonbreakSpaces bool) *escapeWriter {
-	return &escapeWriter{out: bufio.NewWriter(out)}
+	return &escapeWriter{
+		out:            bufio.NewWriter(out),
+		nonbreakSpaces: nonbreakSpaces,
+	}
 }
 
 func (w *escapeWriter) write(r ...rune) {
@@ -59,7 +63,7 @@ func (w *escapeWriter) Write(p []byte) (int, error) {
 			continue
 		}
 
-		space := r == ' '
+		space := w.nonbreakSpaces && r == ' '
 		switch {
 		case space && w.spaceStarted:
 			w.write([]rune("  ")...)
@@ -106,9 +110,9 @@ func (w *escapeWriter) Flush() error {
 	return w.err
 }
 
-func escape(s string) string {
+func escape(s string, nonbreakSpaces bool) string {
 	var b bytes.Buffer
-	w := newEscapeWriter(&b)
+	w := newEscapeWriter(&b, nonbreakSpaces)
 	w.Write([]byte(s))
 	w.Flush()
 	return b.String()

escape_test.go

@@ -10,7 +10,7 @@ import (
 func TestEscape(t *testing.T) {
 	t.Run("attribute escape", func(t *testing.T) {
 		var buf bytes.Buffer
-		if err := html.Render(&buf, Div(Attr("foo", "\"bar\" & \"baz\""))); err != nil {
+		if err := html.WriteRaw(&buf, Div(Attr("foo", "\"bar\" & \"baz\""))); err != nil {
 			t.Fatal(err)
 		}
 
@@ -21,7 +21,7 @@ func TestEscape(t *testing.T) {
 
 	t.Run("failing writer", func(t *testing.T) {
 		ew := &errorWriter{}
-		if err := html.Render(ew, Span("foo bar baz")); err == nil {
+		if err := html.WriteRaw(ew, Span("foo bar baz")); err == nil {
 			t.Fatal("failed to fail")
 		}
 	})
@@ -30,7 +30,7 @@ func TestEscape(t *testing.T) {
 		b := []byte{'f', 0xc2, 'o', 'o'}
 
 		var buf bytes.Buffer
-		if err := html.Render(&buf, Span(string(b))); err != nil {
+		if err := html.WriteRaw(&buf, Span(string(b))); err != nil {
 			t.Fatal(err)
 		}
 
@@ -41,7 +41,7 @@ func TestEscape(t *testing.T) {
 
 	t.Run("multiple spaces", func(t *testing.T) {
 		var buf bytes.Buffer
-		if err := html.Render(&buf, Span("foo   bar")); err != nil {
+		if err := html.WriteRaw(&buf, Span("foo   bar")); err != nil {
 			t.Fatal(err)
 		}
 
@@ -52,7 +52,7 @@ func TestEscape(t *testing.T) {
 
 	t.Run("single space", func(t *testing.T) {
 		var buf bytes.Buffer
-		if err := html.Render(&buf, Span("foo bar")); err != nil {
+		if err := html.WriteRaw(&buf, Span("foo bar")); err != nil {
 			t.Fatal(err)
 		}
 
@@ -63,7 +63,7 @@ func TestEscape(t *testing.T) {
 
 	t.Run("tailing space", func(t *testing.T) {
 		var buf bytes.Buffer
-		if err := html.Render(&buf, Span("foo ")); err != nil {
+		if err := html.WriteRaw(&buf, Span("foo ")); err != nil {
 			t.Fatal(err)
 		}
 
@@ -74,7 +74,7 @@ func TestEscape(t *testing.T) {
 
 	t.Run("unicode non-break space", func(t *testing.T) {
 		var buf bytes.Buffer
-		if err := html.Render(&buf, Span(string([]rune{0xa0}))); err != nil {
+		if err := html.WriteRaw(&buf, Span(string([]rune{0xa0}))); err != nil {
 			t.Fatal(err)
 		}
 
@@ -85,7 +85,7 @@ func TestEscape(t *testing.T) {
 
 	t.Run("html characters", func(t *testing.T) {
 		var buf bytes.Buffer
-		if err := html.Render(&buf, Span("<foo&bar>")); err != nil {
+		if err := html.WriteRaw(&buf, Span("<foo&bar>")); err != nil {
 			t.Fatal(err)
 		}
 

lib.go

@@ -169,11 +169,11 @@ func Doctype(children ...any) Tag {
 
 // String returns the rendered HTML text.
 //
-// It is meant to be used for debugging. Use the Render function to avoid buffering up an entire HTML document
+// It is meant to be used for debugging. Use the Write functions to avoid buffering up an entire HTML document
 // as string.
 func (t Tag) String() string {
 	buf := bytes.NewBuffer(nil)
-	Render(buf, t)
+	WriteRaw(buf, t)
 	return buf.String()
 }
 
@@ -295,6 +295,14 @@ func Children(t Tag) []any {
 	return c
 }
 
+// Preformatted creates a new tag from t that will prevent changing the whitespaces of text content enclosed by
+// a tag.
+//
+// The input tag remains unchanged.
+func Preformatted(t Tag) Tag {
+	return t()(renderGuide{preformatted: true})
+}
+
 // Verbatim creates a new tag from t marking the new one verbatim. The content of verbatim tags is rendered
 // without HTML escaping. This may cause security issues when using it in an incosiderate way. Verbatim content
 // gets indented when rendering with indentation.
@@ -341,12 +349,12 @@ func Indent() Indentation {
 	return Indentation{Indent: "\t"}
 }
 
-// RenderIndent renders html with t as the root nodes using the specified indentation and wrapping.
+// WriteIndent renders html with t as the root nodes using the specified indentation and wrapping.
 //
 // Non-tag child nodes are rendered via fmt.Sprint. Consecutive spaces are considered to be so on purpose, and
 // are converted into  . Spaces around tags, in special cases, can behave different from when using
 // unindented rendering.
-func RenderIndent(out io.Writer, indent Indentation, t ...Tag) error {
+func WriteIndent(out io.Writer, indent Indentation, t ...Tag) error {
 	if indent.PWidth < indent.MinPWidth {
 		indent.PWidth = indent.MinPWidth
 	}
@@ -378,9 +386,14 @@ func RenderIndent(out io.Writer, indent Indentation, t ...Tag) error {
 	return nil
 }
 
-// Render renders html with t as the root nodes without indentation or wrapping.
+// Write renders html with t as the root nodes with the default indentation and wrapping.
-func Render(out io.Writer, t ...Tag) error {
+func Write(out io.Writer, t ...Tag) error {
-	return RenderIndent(out, Indentation{}, t...)
+	return WriteIndent(out, Indent(), t...)
+}
+
+// WriteRaw renders html with t as the root nodes without indentation or wrapping.
+func WriteRaw(out io.Writer, t ...Tag) error {
+	return WriteIndent(out, Indentation{}, t...)
 }
 
 // Eq returns if one or more tags are considered equivalent. Equivalent nodes, in the most cases, will result in
@@ -452,7 +465,7 @@ func MapChildren[Data any](data []Data, tag Tag) []any {
 
 // Escape escapes HTML.
 func Escape(s string) string {
-	return escape(s)
+	return escape(s, true)
 }
 
 // EscapeAttribute escape attribute values. It does not escape single-quotes, because it assumes attribute

lib_test.go

@@ -42,7 +42,7 @@ func TestLib(t *testing.T) {
 			foo := html.Define("foo+bar")
 
 			var b bytes.Buffer
-			if err := html.Render(&b, foo); err == nil {
+			if err := html.WriteRaw(&b, foo); err == nil {
 				t.Fatal("failed to fail")
 			}
 		})
@@ -143,7 +143,7 @@ func TestLib(t *testing.T) {
 
 		t.Run("invalid attribute name", func(t *testing.T) {
 			var b bytes.Buffer
-			if err := html.Render(&b, Div(Attr("foo+bar", "baz"))); err == nil {
+			if err := html.WriteRaw(&b, Div(Attr("foo+bar", "baz"))); err == nil {
 				t.Fatal()
 			}
 		})
@@ -225,7 +225,7 @@ func TestLib(t *testing.T) {
 			}
 
 			var b bytes.Buffer
-			if err := html.Render(&b, Div(tagChildren...)); err != nil {
+			if err := html.WriteRaw(&b, Div(tagChildren...)); err != nil {
 				t.Fatal(err)
 			}
 
@@ -238,7 +238,7 @@ func TestLib(t *testing.T) {
 			tags := html.MapChildren([]string{"foo", "bar", "baz"}, Div)
 
 			var b bytes.Buffer
-			if err := html.Render(&b, Div(tags...)); err != nil {
+			if err := html.WriteRaw(&b, Div(tags...)); err != nil {
 				t.Fatal(err)
 			}
 
@@ -252,7 +252,7 @@ func TestLib(t *testing.T) {
 			div1 := div0("bar")
 
 			var b bytes.Buffer
-			if err := html.Render(&b, Div(div0, div1)); err != nil {
+			if err := html.WriteRaw(&b, Div(div0, div1)); err != nil {
 				t.Fatal(err)
 			}
 
@@ -265,7 +265,7 @@ func TestLib(t *testing.T) {
 	t.Run("render", func(t *testing.T) {
 		t.Run("block", func(t *testing.T) {
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), Div("foo")); err != nil {
+			if err := html.Write(&b, Div("foo")); err != nil {
 				t.Fatal(err)
 			}
 
@@ -276,7 +276,7 @@ func TestLib(t *testing.T) {
 
 		t.Run("inline", func(t *testing.T) {
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), Span("foo")); err != nil {
+			if err := html.Write(&b, Span("foo")); err != nil {
 				t.Fatal(err)
 			}
 
@@ -287,7 +287,7 @@ func TestLib(t *testing.T) {
 
 		t.Run("inline children", func(t *testing.T) {
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), Div(P("foo"), P("bar"))); err != nil {
+			if err := html.Write(&b, Div(P("foo"), P("bar"))); err != nil {
 				t.Fatal(err)
 			}
 
@@ -300,7 +300,7 @@ func TestLib(t *testing.T) {
 			inlineP := html.Inline(P)
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), Div(inlineP("foo"), inlineP("bar"))); err != nil {
+			if err := html.Write(&b, Div(inlineP("foo"), inlineP("bar"))); err != nil {
 				t.Fatal(err)
 			}
 
@@ -311,7 +311,7 @@ func TestLib(t *testing.T) {
 
 		t.Run("void", func(t *testing.T) {
 			var b bytes.Buffer
-			if err := html.Render(&b, Br); err != nil {
+			if err := html.WriteRaw(&b, Br); err != nil {
 				t.Fatal(err)
 			}
 
@@ -322,7 +322,7 @@ func TestLib(t *testing.T) {
 
 		t.Run("void with children", func(t *testing.T) {
 			var b bytes.Buffer
-			if err := html.Render(&b, Br("foo")); err == nil {
+			if err := html.WriteRaw(&b, Br("foo")); err == nil {
 				t.Fatal()
 			}
 		})
@@ -331,7 +331,7 @@ func TestLib(t *testing.T) {
 			div := html.Verbatim(Div("foo &\nbar"))
 
 			var b bytes.Buffer
-			if err := html.Render(&b, div); err != nil {
+			if err := html.WriteRaw(&b, div); err != nil {
 				t.Fatal(err)
 			}
 
@@ -344,7 +344,7 @@ func TestLib(t *testing.T) {
 			div := html.Verbatim(Div("foo &\nbar"))
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), div); err != nil {
+			if err := html.Write(&b, div); err != nil {
 				t.Fatal(err)
 			}
 
@@ -357,7 +357,7 @@ func TestLib(t *testing.T) {
 			script := Script("let foo = 42\nlet bar = 84")
 
 			var b bytes.Buffer
-			if err := html.Render(&b, script); err != nil {
+			if err := html.WriteRaw(&b, script); err != nil {
 				t.Fatal(err)
 			}
 
@@ -370,7 +370,7 @@ func TestLib(t *testing.T) {
 			script := Script("let foo = 42\nlet bar = 84")
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), script); err != nil {
+			if err := html.Write(&b, script); err != nil {
 				t.Fatal(err)
 			}
 
@@ -383,7 +383,7 @@ func TestLib(t *testing.T) {
 			script := html.Verbatim(Script("let foo = 42\nlet bar = 84"))
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), script); err != nil {
+			if err := html.Write(&b, script); err != nil {
 				t.Fatal(err)
 			}
 
@@ -398,7 +398,7 @@ func TestLib(t *testing.T) {
 			div := Div(div0, div1)
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), div); err != nil {
+			if err := html.Write(&b, div); err != nil {
 				t.Fatal(err)
 			}
 
@@ -411,7 +411,7 @@ func TestLib(t *testing.T) {
 			p := P("foo bar baz")
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indentation{PWidth: 8, MinPWidth: 12}, p); err != nil {
+			if err := html.WriteIndent(&b, html.Indentation{PWidth: 8, MinPWidth: 12}, p); err != nil {
 				t.Fatal(err)
 			}
 
@@ -424,7 +424,7 @@ func TestLib(t *testing.T) {
 			doc := Html(Body(P("foo bar baz")))
 
 			var b bytes.Buffer
-			if err := html.Render(&b, Doctype("html"), doc); err != nil {
+			if err := html.WriteRaw(&b, Doctype("html"), doc); err != nil {
 				t.Fatal(err)
 			}
 
@@ -437,7 +437,7 @@ func TestLib(t *testing.T) {
 			doc := Html(Body(P("foo bar baz")))
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), Doctype("html"), doc); err != nil {
+			if err := html.Write(&b, Doctype("html"), doc); err != nil {
 				t.Fatal(err)
 			}
 
@@ -452,7 +452,7 @@ func TestLib(t *testing.T) {
 			double := func(i int) html.Tag { return Div(2 * i) }
 
 			var b bytes.Buffer
-			if err := html.Render(&b, double(42)); err != nil {
+			if err := html.WriteRaw(&b, double(42)); err != nil {
 				t.Fatal(err)
 			}
 
@@ -510,7 +510,7 @@ func TestLib(t *testing.T) {
 			}
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), teamHTML(myTeam)); err != nil {
+			if err := html.Write(&b, teamHTML(myTeam)); err != nil {
 				t.Fatal(err)
 			}
 
@@ -558,7 +558,7 @@ func TestLib(t *testing.T) {
 			double = double("foo")
 
 			var b bytes.Buffer
-			if err := html.Render(&b, double); err != nil {
+			if err := html.WriteRaw(&b, double); err != nil {
 				t.Fatal(err)
 			}
 
@@ -572,7 +572,7 @@ func TestLib(t *testing.T) {
 			double = double(42, 84)
 
 			var b bytes.Buffer
-			if err := html.Render(&b, double); err != nil {
+			if err := html.WriteRaw(&b, double); err != nil {
 				t.Fatal(err)
 			}
 
@@ -587,7 +587,7 @@ func TestLib(t *testing.T) {
 			double1 := double0("foo")
 
 			var b bytes.Buffer
-			if err := html.Render(&b, Div(double0, double1)); err != nil {
+			if err := html.WriteRaw(&b, Div(double0, double1)); err != nil {
 				t.Fatal(err)
 			}
 
@@ -602,7 +602,7 @@ func TestLib(t *testing.T) {
 			comment := Comment("foo &\nbar")
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), comment); err != nil {
+			if err := html.Write(&b, comment); err != nil {
 				t.Fatal(err)
 			}
 
@@ -615,7 +615,7 @@ func TestLib(t *testing.T) {
 			doctype := Doctype("html")
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), doctype); err != nil {
+			if err := html.Write(&b, doctype); err != nil {
 				t.Fatal(err)
 			}
 
@@ -628,7 +628,7 @@ func TestLib(t *testing.T) {
 			doctype := Doctype("html", "public", "-//W3C//DTD HTML 4.01//EN", "http://www.w3.org/TR/html4/strict.dtd")
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), doctype); err != nil {
+			if err := html.Write(&b, doctype); err != nil {
 				t.Fatal(err)
 			}
 
@@ -645,7 +645,7 @@ func TestLib(t *testing.T) {
 			cdata := html.FromTemplate(cdataTemplate)
 
 			var b bytes.Buffer
-			if err := html.Render(&b, cdata("foo &\nbar")); err != nil {
+			if err := html.WriteRaw(&b, cdata("foo &\nbar")); err != nil {
 				t.Fatal(err)
 			}
 

query_test.go

@@ -21,7 +21,7 @@ func TestQuery(t *testing.T) {
 		}
 
 		var b bytes.Buffer
-		if err := html.Render(&b, inlineDiv); err != nil {
+		if err := html.WriteRaw(&b, inlineDiv); err != nil {
 			t.Fatal(err)
 		}
 
@@ -109,7 +109,7 @@ func TestQuery(t *testing.T) {
 			div := Div(Span("foo"))
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), div); err != nil {
+			if err := html.Write(&b, div); err != nil {
 				t.Fatal(err)
 			}
 
@@ -123,7 +123,7 @@ func TestQuery(t *testing.T) {
 				script := Script(`function() { return "Hello, world!" }`)
 
 				var b bytes.Buffer
-				if err := html.Render(&b, script); err != nil {
+				if err := html.WriteRaw(&b, script); err != nil {
 					t.Fatal(err)
 				}
 			})
@@ -132,7 +132,7 @@ func TestQuery(t *testing.T) {
 				div := Div(Attr("foo+", "bar"))
 
 				var b bytes.Buffer
-				if err := html.Render(&b, div); err == nil {
+				if err := html.WriteRaw(&b, div); err == nil {
 					t.Fatal()
 				}
 			})
@@ -141,7 +141,7 @@ func TestQuery(t *testing.T) {
 				div := Div(Div(Attr("foo+", "bar")))
 
 				var b bytes.Buffer
-				if err := html.Render(&b, div); err == nil {
+				if err := html.WriteRaw(&b, div); err == nil {
 					t.Fatal()
 				}
 			})

render.go

@@ -13,6 +13,7 @@ type renderGuide struct {
 	inlineChildren bool
 	void           bool
 	script         bool
+	preformatted   bool
 	verbatim       bool
 }
 
@@ -32,6 +33,7 @@ func mergeRenderingGuides(rgs []renderGuide) renderGuide {
 		rg.inlineChildren = rg.inlineChildren || rgi.inlineChildren
 		rg.void = rg.void || rgi.void
 		rg.script = rg.script || rgi.script
+		rg.preformatted = rg.preformatted || rgi.preformatted
 		rg.verbatim = rg.verbatim || rgi.verbatim
 	}
 
@@ -74,12 +76,12 @@ func (r *renderer) clearWrapper() {
 	r.out = r.originalOut
 }
 
-func (r *renderer) writeEscaped(s string) {
+func (r *renderer) writeEscaped(s string, nonbreakSpaces bool) {
 	if r.err != nil {
 		return
 	}
 
-	ew := newEscapeWriter(r.out)
+	ew := newEscapeWriter(r.out, nonbreakSpaces)
 	if _, r.err = ew.Write([]byte(s)); r.err != nil {
 		return
 	}
@@ -87,12 +89,12 @@ func (r *renderer) writeEscaped(s string) {
 	r.err = ew.Flush()
 }
 
-func (r *renderer) copyEscaped(rd io.Reader) {
+func (r *renderer) copyEscaped(rd io.Reader, nonbreakSpaces bool) {
 	if r.err != nil {
 		return
 	}
 
-	ew := newEscapeWriter(r.out)
+	ew := newEscapeWriter(r.out, nonbreakSpaces)
 	if _, r.err = io.Copy(ew, rd); r.err != nil {
 		return
 	}
@@ -185,11 +187,15 @@ func (r *renderer) renderUnindented(name string, rg renderGuide, a []Attributes,
 		}
 
 		if isReader {
-			r.copyEscaped(rd)
+			r.copyEscaped(rd, !rg.preformatted)
 			continue
 		}
 
 		if ct, ok := c.(Tag); ok {
+			if rg.preformatted {
+				ct = Preformatted(ct)
+			}
+
 			ct(r)
 			continue
 		}
@@ -204,14 +210,21 @@ func (r *renderer) renderUnindented(name string, rg renderGuide, a []Attributes,
 			continue
 		}
 
-		r.writeEscaped(s)
+		r.writeEscaped(s, !rg.preformatted)
 	}
 
 	printf("</%s>", name)
 }
 
-func (r *renderer) renderChildTag(tagName string, block, lastBlock bool, ct Tag) (bool, bool) {
+func (r *renderer) renderChildTag(tagName string, rg renderGuide, lastBlock bool, ct Tag) (bool, bool) {
 	printf := r.getPrintf(tagName)
+	if rg.preformatted {
+		cr := new(renderer)
+		*cr = *r
+		cr.indent = Indentation{}
+		Preformatted(ct)(cr)
+		return false, false
+	}
 
 	var rgq renderGuidesQuery
 	ct(&rgq)
@@ -229,7 +242,7 @@ func (r *renderer) renderChildTag(tagName string, block, lastBlock bool, ct Tag)
 	r.clearWrapper()
 	cr := new(renderer)
 	*cr = *r
-	if !block {
+	if rg.inline || rg.inlineChildren {
 		cr.currentIndent += cr.indent.Indent
 		cr.pwidth -= indentLen(cr.indent.Indent)
 		if cr.pwidth < cr.indent.MinPWidth {
@@ -246,19 +259,8 @@ func (r *renderer) renderChildTag(tagName string, block, lastBlock bool, ct Tag)
 	return true, false
 }
 
-func (r *renderer) renderReaderChild(tagName string, rg renderGuide, block, lastBlock bool, rd io.Reader) bool {
+func (r *renderer) renderReaderChild(tagName string, rg renderGuide, lastBlock bool, rd io.Reader) bool {
 	printf := r.getPrintf(tagName)
-	if rg.verbatim {
-		r.clearWrapper()
-		indent := r.currentIndent
-		if !block {
-			indent += r.indent.Indent
-		}
-
-		r.copyIndented(indent, rd)
-		return false
-	}
-
 	if rg.script {
 		r.clearWrapper()
 		printf("\n")
@@ -269,12 +271,29 @@ func (r *renderer) renderReaderChild(tagName string, rg renderGuide, block, last
 		return false
 	}
 
+	if rg.verbatim {
+		r.clearWrapper()
+		indent := r.currentIndent
+		if rg.inline || rg.inlineChildren {
+			indent += r.indent.Indent
+		}
+
+		r.copyIndented(indent, rd)
+		return false
+	}
+
+	if rg.preformatted {
+		r.clearWrapper()
+		r.copyEscaped(rd, false)
+		return false
+	}
+
 	if lastBlock {
 		printf("\n%s", r.currentIndent)
 	}
 
 	newWrapper := r.ensureWrapper()
-	r.copyEscaped(rd)
+	r.copyEscaped(rd, true)
 	return newWrapper
 }
 
@@ -289,34 +308,44 @@ func (r *renderer) renderChildScript(tagName string, c any) {
 	printf("\n%s", s)
 }
 
-func (r *renderer) renderVerbatimChild(block bool, c any) {
+func (r *renderer) renderVerbatimChild(rg renderGuide, c any) {
 	s := fmt.Sprint(c)
 	if s == "" {
 		return
 	}
 
 	r.clearWrapper()
+	if rg.preformatted {
+		_, r.err = r.out.Write([]byte(s))
+		return
+	}
+
 	indent := r.currentIndent
-	if !block {
+	if rg.inline || rg.inlineChildren {
 		indent += r.indent.Indent
 	}
 
 	r.writeIndented(indent, s)
 }
 
-func (r *renderer) renderChildContent(tagName string, lastBlock bool, c any) bool {
+func (r *renderer) renderChildContent(tagName string, rg renderGuide, lastBlock bool, c any) bool {
 	s := fmt.Sprint(c)
 	if s == "" {
 		return false
 	}
 
+	if rg.preformatted {
+		r.writeEscaped(s, false)
+		return false
+	}
+
 	if lastBlock {
 		printf := r.getPrintf(tagName)
 		printf("\n%s", r.currentIndent)
 	}
 
 	newWrapper := r.ensureWrapper()
-	r.writeEscaped(s)
+	r.writeEscaped(s, true)
 	return newWrapper
 }
 
@@ -358,6 +387,11 @@ func (r *renderer) renderIndented(name string, rg renderGuide, a []Attributes, c
 		}
 	}
 
+	if rg.preformatted {
+		r.clearWrapper()
+		printf("\n")
+	}
+
 	for _, c := range children {
 		if c == nil {
 			continue
@@ -365,7 +399,7 @@ func (r *renderer) renderIndented(name string, rg renderGuide, a []Attributes, c
 
 		if ct, isTag := c.(Tag); isTag {
 			var nw bool
-			lastBlock, nw = r.renderChildTag(name, block, lastBlock, ct)
+			lastBlock, nw = r.renderChildTag(name, rg, lastBlock, ct)
 			if nw {
 				newWrapper = true
 			}
@@ -374,7 +408,7 @@ func (r *renderer) renderIndented(name string, rg renderGuide, a []Attributes, c
 		}
 
 		if rd, isReader := c.(io.Reader); isReader {
-			if r.renderReaderChild(name, rg, block, lastBlock, rd) {
+			if r.renderReaderChild(name, rg, lastBlock, rd) {
 				newWrapper = true
 			}
 
@@ -389,12 +423,12 @@ func (r *renderer) renderIndented(name string, rg renderGuide, a []Attributes, c
 		}
 
 		if rg.verbatim {
-			r.renderVerbatimChild(block, c)
+			r.renderVerbatimChild(rg, c)
 			lastBlock = true
 			continue
 		}
 
-		if r.renderChildContent(name, lastBlock, c) {
+		if r.renderChildContent(name, rg, lastBlock, c) {
 			newWrapper = true
 		}
 

render_test.go

@@ -14,7 +14,7 @@ func TestRender(t *testing.T) {
 		foo = foo("<bar><baz></bar>")
 
 		var b bytes.Buffer
-		if err := html.RenderIndent(&b, html.Indent(), foo); err != nil {
+		if err := html.Write(&b, foo); err != nil {
 			t.Fatal(err)
 		}
 
@@ -28,7 +28,7 @@ func TestRender(t *testing.T) {
 			span := Span(Attr("foo", "bar=\"&\""))
 
 			var b bytes.Buffer
-			if err := html.Render(&b, span); err != nil {
+			if err := html.WriteRaw(&b, span); err != nil {
 				t.Fatal(err)
 			}
 
@@ -41,7 +41,7 @@ func TestRender(t *testing.T) {
 			span := Span(Attr("foo", true))
 
 			var b bytes.Buffer
-			if err := html.Render(&b, span); err != nil {
+			if err := html.WriteRaw(&b, span); err != nil {
 				t.Fatal(err)
 			}
 
@@ -54,7 +54,7 @@ func TestRender(t *testing.T) {
 			comment := Comment("foo & bar & baz", "qux")
 
 			var b bytes.Buffer
-			if err := html.Render(&b, comment); err != nil {
+			if err := html.WriteRaw(&b, comment); err != nil {
 				t.Fatal(err)
 			}
 
@@ -69,7 +69,7 @@ func TestRender(t *testing.T) {
 			span := Span("<foo>bar&baz</foo>")
 
 			var b bytes.Buffer
-			if err := html.Render(&b, span); err != nil {
+			if err := html.WriteRaw(&b, span); err != nil {
 				t.Fatal(err)
 			}
 
@@ -82,7 +82,7 @@ func TestRender(t *testing.T) {
 			span := Span("consecutive spaces: \"   \"")
 
 			var b bytes.Buffer
-			if err := html.Render(&b, span); err != nil {
+			if err := html.WriteRaw(&b, span); err != nil {
 				t.Fatal(err)
 			}
 
@@ -96,7 +96,7 @@ func TestRender(t *testing.T) {
 		t.Run("fail immediately", func(t *testing.T) {
 			div := Div(Span("foo"))
 			w := &errorWriter{}
-			if err := html.Render(w, div); err == nil || !strings.Contains(err.Error(), "test write error") {
+			if err := html.WriteRaw(w, div); err == nil || !strings.Contains(err.Error(), "test write error") {
 				t.Fatal()
 			}
 		})
@@ -104,7 +104,7 @@ func TestRender(t *testing.T) {
 		t.Run("fail in tag", func(t *testing.T) {
 			div := Div(Span("foo"))
 			w := &errorWriter{failAfter: 6}
-			if err := html.Render(w, div); err == nil || !strings.Contains(err.Error(), "test write error") {
+			if err := html.WriteRaw(w, div); err == nil || !strings.Contains(err.Error(), "test write error") {
 				t.Fatal()
 			}
 		})
@@ -112,7 +112,7 @@ func TestRender(t *testing.T) {
 		t.Run("partial text children", func(t *testing.T) {
 			div := Div("foo", Div("bar"), "baz")
 			w := &errorWriter{failAfter: 5}
-			if err := html.RenderIndent(w, html.Indent(), div); err == nil || !strings.Contains(err.Error(), "test write error") {
+			if err := html.Write(w, div); err == nil || !strings.Contains(err.Error(), "test write error") {
 				t.Fatal()
 			}
 		})
@@ -120,7 +120,7 @@ func TestRender(t *testing.T) {
 		t.Run("text children", func(t *testing.T) {
 			div := Div("foo", "bar", "baz")
 			w := &errorWriter{failAfter: 5}
-			if err := html.RenderIndent(w, html.Indent(), div); err == nil || !strings.Contains(err.Error(), "test write error") {
+			if err := html.Write(w, div); err == nil || !strings.Contains(err.Error(), "test write error") {
 				t.Fatal()
 			}
 		})
@@ -131,7 +131,7 @@ func TestRender(t *testing.T) {
 			div := Div(Span("foo"))
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), div); err != nil {
+			if err := html.Write(&b, div); err != nil {
 				t.Fatal(err)
 			}
 
@@ -144,7 +144,7 @@ func TestRender(t *testing.T) {
 			div := Div(Br)
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), div); err != nil {
+			if err := html.Write(&b, div); err != nil {
 				t.Fatal(err)
 			}
 
@@ -157,7 +157,7 @@ func TestRender(t *testing.T) {
 			div := Div("foo bar baz", Div("qux quux"), "corge")
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), div); err != nil {
+			if err := html.Write(&b, div); err != nil {
 				t.Fatal(err)
 			}
 
@@ -170,7 +170,7 @@ func TestRender(t *testing.T) {
 			div := Div(Span("foo bar baz", Div("qux quux"), "corge"))
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), div); err != nil {
+			if err := html.Write(&b, div); err != nil {
 				t.Fatal(err)
 			}
 
@@ -184,7 +184,7 @@ func TestRender(t *testing.T) {
 			foo = foo("bar\nbaz\nqux")
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), foo); err != nil {
+			if err := html.Write(&b, foo); err != nil {
 				t.Fatal(err)
 			}
 
@@ -197,7 +197,7 @@ func TestRender(t *testing.T) {
 			script := Div(Script("foo()\nbar()\nbaz()"))
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), script); err != nil {
+			if err := html.Write(&b, script); err != nil {
 				t.Fatal(err)
 			}
 
@@ -212,7 +212,7 @@ func TestRender(t *testing.T) {
 			div := Div("foo")
 
 			var b bytes.Buffer
-			if err := html.Render(&b, div); err != nil {
+			if err := html.WriteRaw(&b, div); err != nil {
 				t.Fatal(err)
 			}
 
@@ -225,7 +225,7 @@ func TestRender(t *testing.T) {
 			div := Div(42)
 
 			var b bytes.Buffer
-			if err := html.Render(&b, div); err != nil {
+			if err := html.WriteRaw(&b, div); err != nil {
 				t.Fatal(err)
 			}
 
@@ -238,7 +238,7 @@ func TestRender(t *testing.T) {
 			div := Div(Div, "foo")
 
 			var b bytes.Buffer
-			if err := html.Render(&b, div); err != nil {
+			if err := html.WriteRaw(&b, div); err != nil {
 				t.Fatal(err)
 			}
 
@@ -251,7 +251,7 @@ func TestRender(t *testing.T) {
 			div := Div(Span, "foo")
 
 			var b bytes.Buffer
-			if err := html.Render(&b, div); err != nil {
+			if err := html.WriteRaw(&b, div); err != nil {
 				t.Fatal(err)
 			}
 
@@ -264,7 +264,7 @@ func TestRender(t *testing.T) {
 			span := Span("foo")
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), span); err != nil {
+			if err := html.Write(&b, span); err != nil {
 				t.Fatal(err)
 			}
 
@@ -277,7 +277,7 @@ func TestRender(t *testing.T) {
 			span := Span(42)
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), span); err != nil {
+			if err := html.Write(&b, span); err != nil {
 				t.Fatal(err)
 			}
 
@@ -290,7 +290,7 @@ func TestRender(t *testing.T) {
 			span := Span(Div, "foo")
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), span); err != nil {
+			if err := html.Write(&b, span); err != nil {
 				t.Fatal(err)
 			}
 
@@ -303,7 +303,7 @@ func TestRender(t *testing.T) {
 			span := Span(Span, "foo")
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), span); err != nil {
+			if err := html.Write(&b, span); err != nil {
 				t.Fatal(err)
 			}
 
@@ -316,7 +316,7 @@ func TestRender(t *testing.T) {
 			span := Span(Div, Span("foo"))
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), span); err != nil {
+			if err := html.Write(&b, span); err != nil {
 				t.Fatal(err)
 			}
 
@@ -329,7 +329,7 @@ func TestRender(t *testing.T) {
 			p := P("foo")
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), p); err != nil {
+			if err := html.Write(&b, p); err != nil {
 				t.Fatal(err)
 			}
 
@@ -342,7 +342,7 @@ func TestRender(t *testing.T) {
 			p := P(42)
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), p); err != nil {
+			if err := html.Write(&b, p); err != nil {
 				t.Fatal(err)
 			}
 
@@ -355,7 +355,7 @@ func TestRender(t *testing.T) {
 			p := P(P, "foo")
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), p); err != nil {
+			if err := html.Write(&b, p); err != nil {
 				t.Fatal(err)
 			}
 
@@ -368,7 +368,7 @@ func TestRender(t *testing.T) {
 			div := Div("foo")
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), div); err != nil {
+			if err := html.Write(&b, div); err != nil {
 				t.Fatal(err)
 			}
 
@@ -381,7 +381,7 @@ func TestRender(t *testing.T) {
 			div := Div(42)
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), div); err != nil {
+			if err := html.Write(&b, div); err != nil {
 				t.Fatal(err)
 			}
 
@@ -394,7 +394,7 @@ func TestRender(t *testing.T) {
 			div := Div(Div, 42)
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), div); err != nil {
+			if err := html.Write(&b, div); err != nil {
 				t.Fatal(err)
 			}
 
@@ -407,7 +407,7 @@ func TestRender(t *testing.T) {
 			div := Div(Span, 42)
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), div); err != nil {
+			if err := html.Write(&b, div); err != nil {
 				t.Fatal(err)
 			}
 
@@ -422,7 +422,7 @@ func TestRender(t *testing.T) {
 			div := Div("foo", nil, "bar")
 
 			var b bytes.Buffer
-			if err := html.Render(&b, div); err != nil {
+			if err := html.WriteRaw(&b, div); err != nil {
 				t.Fatal(err)
 			}
 
@@ -435,7 +435,7 @@ func TestRender(t *testing.T) {
 			div := html.Verbatim(Div("foo &", nil, " bar"))
 
 			var b bytes.Buffer
-			if err := html.Render(&b, div); err != nil {
+			if err := html.WriteRaw(&b, div); err != nil {
 				t.Fatal(err)
 			}
 
@@ -448,7 +448,7 @@ func TestRender(t *testing.T) {
 			script := Script("let foo =", nil, " bar && baz")
 
 			var b bytes.Buffer
-			if err := html.Render(&b, script); err != nil {
+			if err := html.WriteRaw(&b, script); err != nil {
 				t.Fatal(err)
 			}
 
@@ -461,7 +461,7 @@ func TestRender(t *testing.T) {
 			span := Span("foo", nil, "bar")
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), span); err != nil {
+			if err := html.Write(&b, span); err != nil {
 				t.Fatal(err)
 			}
 
@@ -474,7 +474,7 @@ func TestRender(t *testing.T) {
 			span := html.Verbatim(Span("foo &", nil, " bar"))
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), span); err != nil {
+			if err := html.Write(&b, span); err != nil {
 				t.Fatal(err)
 			}
 
@@ -487,7 +487,7 @@ func TestRender(t *testing.T) {
 			script := html.Inline(Script("let foo =", nil, " bar && baz"))
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), script); err != nil {
+			if err := html.Write(&b, script); err != nil {
 				t.Fatal(err)
 			}
 
@@ -500,7 +500,7 @@ func TestRender(t *testing.T) {
 			div := Div("foo", nil, "bar")
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), div); err != nil {
+			if err := html.Write(&b, div); err != nil {
 				t.Fatal(err)
 			}
 
@@ -513,7 +513,7 @@ func TestRender(t *testing.T) {
 			div := html.Verbatim(Div("foo &", nil, " bar"))
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), div); err != nil {
+			if err := html.Write(&b, div); err != nil {
 				t.Fatal(err)
 			}
 
@@ -526,7 +526,7 @@ func TestRender(t *testing.T) {
 			script := Script("let foo =", nil, " bar && baz")
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), script); err != nil {
+			if err := html.Write(&b, script); err != nil {
 				t.Fatal(err)
 			}
 
@@ -541,7 +541,7 @@ func TestRender(t *testing.T) {
 			div := Div("foo", "", "bar")
 
 			var b bytes.Buffer
-			if err := html.Render(&b, div); err != nil {
+			if err := html.WriteRaw(&b, div); err != nil {
 				t.Fatal(err)
 			}
 
@@ -554,7 +554,7 @@ func TestRender(t *testing.T) {
 			div := html.Verbatim(Div("foo &", "", " bar"))
 
 			var b bytes.Buffer
-			if err := html.Render(&b, div); err != nil {
+			if err := html.WriteRaw(&b, div); err != nil {
 				t.Fatal(err)
 			}
 
@@ -567,7 +567,7 @@ func TestRender(t *testing.T) {
 			script := Script("let foo =", "", " bar && baz")
 
 			var b bytes.Buffer
-			if err := html.Render(&b, script); err != nil {
+			if err := html.WriteRaw(&b, script); err != nil {
 				t.Fatal(err)
 			}
 
@@ -580,7 +580,7 @@ func TestRender(t *testing.T) {
 			span := Span("foo", "", "bar")
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), span); err != nil {
+			if err := html.Write(&b, span); err != nil {
 				t.Fatal(err)
 			}
 
@@ -593,7 +593,7 @@ func TestRender(t *testing.T) {
 			span := html.Verbatim(Span("foo &", "", " bar"))
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), span); err != nil {
+			if err := html.Write(&b, span); err != nil {
 				t.Fatal(err)
 			}
 
@@ -606,7 +606,7 @@ func TestRender(t *testing.T) {
 			script := html.Inline(Script("let foo =", "", " bar && baz"))
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), script); err != nil {
+			if err := html.Write(&b, script); err != nil {
 				t.Fatal(err)
 			}
 
@@ -619,7 +619,7 @@ func TestRender(t *testing.T) {
 			div := Div("foo", "", "bar")
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), div); err != nil {
+			if err := html.Write(&b, div); err != nil {
 				t.Fatal(err)
 			}
 
@@ -632,7 +632,7 @@ func TestRender(t *testing.T) {
 			div := html.Verbatim(Div("foo &", "", " bar"))
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), div); err != nil {
+			if err := html.Write(&b, div); err != nil {
 				t.Fatal(err)
 			}
 
@@ -645,7 +645,7 @@ func TestRender(t *testing.T) {
 			script := Script("let foo =", "", " bar && baz")
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), script); err != nil {
+			if err := html.Write(&b, script); err != nil {
 				t.Fatal(err)
 			}
 
@@ -661,7 +661,7 @@ func TestRender(t *testing.T) {
 			div := Div(rd)
 
 			var b bytes.Buffer
-			if err := html.Render(&b, div); err != nil {
+			if err := html.WriteRaw(&b, div); err != nil {
 				t.Fatal(err)
 			}
 
@@ -675,7 +675,7 @@ func TestRender(t *testing.T) {
 			div := html.Verbatim(Div(rd))
 
 			var b bytes.Buffer
-			if err := html.Render(&b, div); err != nil {
+			if err := html.WriteRaw(&b, div); err != nil {
 				t.Fatal(err)
 			}
 
@@ -689,7 +689,7 @@ func TestRender(t *testing.T) {
 			script := Script(rd)
 
 			var b bytes.Buffer
-			if err := html.Render(&b, script); err != nil {
+			if err := html.WriteRaw(&b, script); err != nil {
 				t.Fatal(err)
 			}
 
@@ -703,7 +703,7 @@ func TestRender(t *testing.T) {
 			span := Span(rd)
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), span); err != nil {
+			if err := html.Write(&b, span); err != nil {
 				t.Fatal(err)
 			}
 
@@ -717,7 +717,7 @@ func TestRender(t *testing.T) {
 			span := html.Verbatim(Span(rd))
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), span); err != nil {
+			if err := html.Write(&b, span); err != nil {
 				t.Fatal(err)
 			}
 
@@ -731,7 +731,7 @@ func TestRender(t *testing.T) {
 			script := html.Inline(Script(rd))
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), script); err != nil {
+			if err := html.Write(&b, script); err != nil {
 				t.Fatal(err)
 			}
 
@@ -745,7 +745,7 @@ func TestRender(t *testing.T) {
 			span := Span(Div, rd)
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), span); err != nil {
+			if err := html.Write(&b, span); err != nil {
 				t.Fatal(err)
 			}
 
@@ -759,7 +759,7 @@ func TestRender(t *testing.T) {
 			div := Div(rd)
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), div); err != nil {
+			if err := html.Write(&b, div); err != nil {
 				t.Fatal(err)
 			}
 
@@ -773,7 +773,7 @@ func TestRender(t *testing.T) {
 			div := html.Verbatim(Div(rd))
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), div); err != nil {
+			if err := html.Write(&b, div); err != nil {
 				t.Fatal(err)
 			}
 
@@ -787,7 +787,7 @@ func TestRender(t *testing.T) {
 			script := Script(rd)
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), script); err != nil {
+			if err := html.Write(&b, script); err != nil {
 				t.Fatal(err)
 			}
 
@@ -800,7 +800,7 @@ func TestRender(t *testing.T) {
 	t.Run("void", func(t *testing.T) {
 		t.Run("unindented", func(t *testing.T) {
 			var b bytes.Buffer
-			if err := html.Render(&b, Br); err != nil {
+			if err := html.WriteRaw(&b, Br); err != nil {
 				t.Fatal(err)
 			}
 
@@ -811,7 +811,7 @@ func TestRender(t *testing.T) {
 
 		t.Run("inline", func(t *testing.T) {
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), Br); err != nil {
+			if err := html.Write(&b, Br); err != nil {
 				t.Fatal(err)
 			}
 
@@ -822,7 +822,7 @@ func TestRender(t *testing.T) {
 
 		t.Run("block", func(t *testing.T) {
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), Hr); err != nil {
+			if err := html.Write(&b, Hr); err != nil {
 				t.Fatal(err)
 			}
 
@@ -835,7 +835,7 @@ func TestRender(t *testing.T) {
 	t.Run("no children", func(t *testing.T) {
 		t.Run("unindented", func(t *testing.T) {
 			var b bytes.Buffer
-			if err := html.Render(&b, Div); err != nil {
+			if err := html.WriteRaw(&b, Div); err != nil {
 				t.Fatal(err)
 			}
 
@@ -846,7 +846,7 @@ func TestRender(t *testing.T) {
 
 		t.Run("inline", func(t *testing.T) {
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), Span); err != nil {
+			if err := html.Write(&b, Span); err != nil {
 				t.Fatal(err)
 			}
 
@@ -857,7 +857,7 @@ func TestRender(t *testing.T) {
 
 		t.Run("block", func(t *testing.T) {
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), Div); err != nil {
+			if err := html.Write(&b, Div); err != nil {
 				t.Fatal(err)
 			}
 
@@ -872,7 +872,7 @@ func TestRender(t *testing.T) {
 			div := html.Verbatim(Div("foo & bar"))
 
 			var b bytes.Buffer
-			if err := html.Render(&b, div); err != nil {
+			if err := html.WriteRaw(&b, div); err != nil {
 				t.Fatal(err)
 			}
 
@@ -885,7 +885,7 @@ func TestRender(t *testing.T) {
 			span := html.Verbatim(Span("foo & bar"))
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), span); err != nil {
+			if err := html.Write(&b, span); err != nil {
 				t.Fatal(err)
 			}
 
@@ -898,7 +898,7 @@ func TestRender(t *testing.T) {
 			div := html.Verbatim(Div("foo & bar"))
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), div); err != nil {
+			if err := html.Write(&b, div); err != nil {
 				t.Fatal(err)
 			}
 
@@ -908,12 +908,108 @@ func TestRender(t *testing.T) {
 		})
 	})
 
+	t.Run("preformatted", func(t *testing.T) {
+		t.Run("simple", func(t *testing.T) {
+			pre := Pre("foo\nbar")
+
+			var b bytes.Buffer
+			if err := html.Write(&b, pre); err != nil {
+				t.Fatal(err)
+			}
+
+			if b.String() != "<pre>\nfoo\nbar\n</pre>" {
+				t.Fatal(b.String())
+			}
+		})
+
+		t.Run("indented", func(t *testing.T) {
+			div := Div(Pre("foo\nbar"))
+
+			var b bytes.Buffer
+			if err := html.Write(&b, div); err != nil {
+				t.Fatal(err)
+			}
+
+			if b.String() != "<div>\n\t<pre>\nfoo\nbar\n\t</pre>\n</div>" {
+				t.Fatal(b.String())
+			}
+		})
+
+		t.Run("child elements", func(t *testing.T) {
+			div := Div(Pre("foo", Div("bar\n\t", Span("baz\n"), "  "), "\t"))
+
+			var b bytes.Buffer
+			if err := html.Write(&b, div); err != nil {
+				t.Fatal(err)
+			}
+
+			const expect = "<div>\n\t<pre>\nfoo<div>bar\n\t<span>baz\n</span>  </div>\t\n\t</pre>\n</div>"
+			if b.String() != expect {
+				t.Fatal(b.String())
+			}
+		})
+
+		t.Run("escaping", func(t *testing.T) {
+			pre := Pre("foo & ", Span("baz & "), "qux")
+
+			var b bytes.Buffer
+			if err := html.Write(&b, pre); err != nil {
+				t.Fatal(err)
+			}
+
+			if b.String() != "<pre>\nfoo &amp; <span>baz &amp; </span>qux\n</pre>" {
+				t.Fatal(b.String())
+			}
+		})
+
+		t.Run("verbatim child element", func(t *testing.T) {
+			div := html.Verbatim(Div)
+			pre := Pre("foo", div("<span>\n\tbar\t\n</span>"), "baz")
+
+			var b bytes.Buffer
+			if err := html.Write(&b, pre); err != nil {
+				t.Fatal(err)
+			}
+
+			if b.String() != "<pre>\nfoo<div><span>\n\tbar\t\n</span></div>baz\n</pre>" {
+				t.Fatal(b.String())
+			}
+		})
+
+		t.Run("verbatim", func(t *testing.T) {
+			pre := html.Verbatim(Pre)
+			pre = pre("<div>\n  <span>foo</span>\n</div>")
+
+			var b bytes.Buffer
+			if err := html.Write(&b, pre); err != nil {
+				t.Fatal(err)
+			}
+
+			if b.String() != "<pre>\n<div>\n  <span>foo</span>\n</div>\n</pre>" {
+				t.Fatal(b.String())
+			}
+		})
+
+		t.Run("reader child", func(t *testing.T) {
+			pre := Pre(bytes.NewBufferString("foo &\nbar &\nbaz"))
+
+			var b bytes.Buffer
+			if err := html.Write(&b, pre); err != nil {
+				t.Fatal(err)
+			}
+
+			if b.String() != "<pre>\nfoo &amp;\nbar &amp;\nbaz\n</pre>" {
+				t.Fatal(b.String())
+			}
+		})
+	})
+
 	t.Run("script", func(t *testing.T) {
 		t.Run("unindented", func(t *testing.T) {
 			script := Script("let foo = bar && baz")
 
 			var b bytes.Buffer
-			if err := html.Render(&b, script); err != nil {
+			if err := html.WriteRaw(&b, script); err != nil {
 				t.Fatal(err)
 			}
 
@@ -926,7 +1022,7 @@ func TestRender(t *testing.T) {
 			script := html.Inline(Script("let foo = bar && baz"))
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), script); err != nil {
+			if err := html.Write(&b, script); err != nil {
 				t.Fatal(err)
 			}
 
@@ -939,7 +1035,7 @@ func TestRender(t *testing.T) {
 			script := Script("let foo = bar && baz")
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indent(), script); err != nil {
+			if err := html.Write(&b, script); err != nil {
 				t.Fatal(err)
 			}
 
@@ -954,7 +1050,7 @@ func TestRender(t *testing.T) {
 			p := P("foo bar baz qux quux corge")
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indentation{Indent: "\t", PWidth: 15}, p); err != nil {
+			if err := html.WriteIndent(&b, html.Indentation{Indent: "\t", PWidth: 15}, p); err != nil {
 				t.Error(err)
 			}
 
@@ -967,7 +1063,7 @@ func TestRender(t *testing.T) {
 			div := Div(P("foo bar baz qux quux corge"))
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indentation{Indent: "\t", PWidth: 21, MinPWidth: 18}, div); err != nil {
+			if err := html.WriteIndent(&b, html.Indentation{Indent: "\t", PWidth: 21, MinPWidth: 18}, div); err != nil {
 				t.Error(err)
 			}
 
@@ -980,7 +1076,7 @@ func TestRender(t *testing.T) {
 			span := Span(P("foo bar baz qux quux corge"))
 
 			var b bytes.Buffer
-			if err := html.RenderIndent(&b, html.Indentation{Indent: "\t", PWidth: 21, MinPWidth: 18}, span); err != nil {
+			if err := html.WriteIndent(&b, html.Indentation{Indent: "\t", PWidth: 21, MinPWidth: 18}, span); err != nil {
 				t.Error(err)
 			}
 

tag.block.txt

@@ -34,7 +34,6 @@ noscript
 ol
 optgroup
 picture
-pre
 q
 search
 section

tag.preformatted.txt

@@ -0,0 +1 @@
+pre

tag/block.gen.go

@@ -40,7 +40,6 @@ var Noscript = html.Define("noscript")
 var Ol = html.Define("ol")
 var Optgroup = html.Define("optgroup")
 var Picture = html.Define("picture")
-var Pre = html.Define("pre")
 var Q = html.Define("q")
 var Search = html.Define("search")
 var Section = html.Define("section")

tag/preformatted.gen.go

@@ -0,0 +1,7 @@
+// generated by ../script/generate-tags.go
+
+package tag
+
+import "code.squareroundforest.org/arpio/html"
+
+var Pre = html.Preformatted(html.Define("pre"))

validate_test.go

@@ -13,7 +13,7 @@ func TestValidate(t *testing.T) {
 			mytag := html.Define("foo+bar")
 
 			var b bytes.Buffer
-			if err := html.Render(&b, mytag); err == nil {
+			if err := html.WriteRaw(&b, mytag); err == nil {
 				t.Fatal()
 			}
 		})
@@ -22,7 +22,7 @@ func TestValidate(t *testing.T) {
 			mytag := html.Define("0foo")
 
 			var b bytes.Buffer
-			if err := html.Render(&b, mytag); err == nil {
+			if err := html.WriteRaw(&b, mytag); err == nil {
 				t.Fatal()
 			}
 		})
@@ -31,7 +31,7 @@ func TestValidate(t *testing.T) {
 			mytag := html.Define("-foo")
 
 			var b bytes.Buffer
-			if err := html.Render(&b, mytag); err == nil {
+			if err := html.WriteRaw(&b, mytag); err == nil {
 				t.Fatal()
 			}
 		})
@@ -40,7 +40,7 @@ func TestValidate(t *testing.T) {
 			mytag := html.Define("foo")
 
 			var b bytes.Buffer
-			if err := html.Render(&b, mytag); err != nil {
+			if err := html.WriteRaw(&b, mytag); err != nil {
 				t.Fatal(err)
 			}
 		})
@@ -49,7 +49,7 @@ func TestValidate(t *testing.T) {
 			mytag := html.Define("foo-bar-1")
 
 			var b bytes.Buffer
-			if err := html.Render(&b, mytag); err != nil {
+			if err := html.WriteRaw(&b, mytag); err != nil {
 				t.Fatal(err)
 			}
 		})
@@ -59,7 +59,7 @@ func TestValidate(t *testing.T) {
 		div := Div(Attr("foo+", "bar"))
 
 		var b bytes.Buffer
-		if err := html.Render(&b, div); err == nil {
+		if err := html.WriteRaw(&b, div); err == nil {
 			t.Fatal()
 		}
 	})
@@ -68,7 +68,7 @@ func TestValidate(t *testing.T) {
 		br := Br("foo")
 
 		var b bytes.Buffer
-		if err := html.Render(&b, br); err == nil {
+		if err := html.WriteRaw(&b, br); err == nil {
 			t.Fatal()
 		}
 	})
@@ -77,7 +77,7 @@ func TestValidate(t *testing.T) {
 		div := html.Verbatim(Div(Br()))
 
 		var b bytes.Buffer
-		if err := html.Render(&b, div); err != nil {
+		if err := html.WriteRaw(&b, div); err != nil {
 			t.Fatal(err)
 		}
 	})
@@ -86,7 +86,7 @@ func TestValidate(t *testing.T) {
 		script := Script(Br())
 
 		var b bytes.Buffer
-		if err := html.Render(&b, script); err == nil {
+		if err := html.WriteRaw(&b, script); err == nil {
 			t.Fatal()
 		}
 	})
@@ -95,7 +95,7 @@ func TestValidate(t *testing.T) {
 		div := Div(Div(Attr("foo+", "bar")))
 
 		var b bytes.Buffer
-		if err := html.Render(&b, div); err == nil {
+		if err := html.WriteRaw(&b, div); err == nil {
 			t.Fatal()
 		}
 	})
@@ -104,7 +104,7 @@ func TestValidate(t *testing.T) {
 		div := Div(Div(Attr("foo", "bar")))
 
 		var b bytes.Buffer
-		if err := html.Render(&b, div); err != nil {
+		if err := html.WriteRaw(&b, div); err != nil {
 			t.Fatal()
 		}
 	})
@@ -113,7 +113,7 @@ func TestValidate(t *testing.T) {
 		decl := html.Declaration("foo", "bar", "baz qux")
 
 		var b bytes.Buffer
-		if err := html.Render(&b, decl); err != nil {
+		if err := html.WriteRaw(&b, decl); err != nil {
 			t.Fatal(err)
 		}
 	})
@@ -122,7 +122,7 @@ func TestValidate(t *testing.T) {
 		decl := html.Declaration("#", "foo")
 
 		var b bytes.Buffer
-		if err := html.Render(&b, decl); err != nil {
+		if err := html.WriteRaw(&b, decl); err != nil {
 			t.Fatal(err)
 		}
 	})
@@ -132,7 +132,7 @@ func TestValidate(t *testing.T) {
 		decl = decl("bar")
 
 		var b bytes.Buffer
-		if err := html.Render(&b, decl); err == nil {
+		if err := html.WriteRaw(&b, decl); err == nil {
 			t.Fatal("failed to fail")
 		}
 	})

wrap_test.go

@@ -10,7 +10,7 @@ import (
 func TestWrap(t *testing.T) {
 	t.Run("write error", func(t *testing.T) {
 		ew := &errorWriter{failAfter: 9}
-		if err := html.RenderIndent(
+		if err := html.WriteIndent(
 			ew,
 			html.Indentation{Indent: "\t", PWidth: 12},
 			Span(Span("foo"), Span("bar"), Span("baz")),
@@ -21,7 +21,7 @@ func TestWrap(t *testing.T) {
 
 	t.Run("write error in text", func(t *testing.T) {
 		ew := &errorWriter{}
-		if err := html.RenderIndent(
+		if err := html.WriteIndent(
 			ew,
 			html.Indentation{Indent: "\t", PWidth: 2},
 			Span("foo", "bar", "baz"),
@@ -32,7 +32,7 @@ func TestWrap(t *testing.T) {
 
 	t.Run("write error on line feed", func(t *testing.T) {
 		ew := &errorWriter{failAfter: 7}
-		if err := html.RenderIndent(
+		if err := html.WriteIndent(
 			ew,
 			html.Indentation{Indent: "\t", PWidth: 3},
 			Span("foo"),
@@ -43,7 +43,7 @@ func TestWrap(t *testing.T) {
 
 	t.Run("write error on indentation", func(t *testing.T) {
 		ew := &errorWriter{failAfter: 15}
-		if err := html.RenderIndent(
+		if err := html.WriteIndent(
 			ew,
 			html.Indentation{Indent: "\t", PWidth: 3},
 			Div(Span("foo")),
@@ -54,9 +54,8 @@ func TestWrap(t *testing.T) {
 
 	t.Run("write error on flush", func(t *testing.T) {
 		ew := &errorWriter{}
-		if err := html.RenderIndent(
+		if err := html.Write(
 			ew,
-			html.Indent(),
 			Span(Span("foo"), Span("bar"), Span("baz")),
 		); err == nil {
 			t.Fatal()
@@ -65,7 +64,7 @@ func TestWrap(t *testing.T) {
 
 	t.Run("write error on flush during line feed", func(t *testing.T) {
 		ew := &errorWriter{}
-		if err := html.RenderIndent(
+		if err := html.WriteIndent(
 			ew,
 			html.Indentation{Indent: "\t", PWidth: 10},
 			Span("foo bar", Div),
@@ -76,7 +75,7 @@ func TestWrap(t *testing.T) {
 
 	t.Run("null write", func(t *testing.T) {
 		var buf bytes.Buffer
-		if err := html.Render(&buf, Div("")); err != nil {
+		if err := html.WriteRaw(&buf, Div("")); err != nil {
 			t.Fatal(err)
 		}
 
@@ -89,7 +88,7 @@ func TestWrap(t *testing.T) {
 		span := Span("foo bar baz")
 
 		var buf bytes.Buffer
-		if err := html.RenderIndent(&buf, html.Indentation{Indent: "\t", PWidth: 2}, span); err != nil {
+		if err := html.WriteIndent(&buf, html.Indentation{Indent: "\t", PWidth: 2}, span); err != nil {
 			t.Fatal(err)
 		}
 
@@ -104,7 +103,7 @@ func TestWrap(t *testing.T) {
 		span := Span("foo ", Span("bar", Attr("qux", 42)), " baz")
 
 		var buf bytes.Buffer
-		if err := html.RenderIndent(&buf, html.Indentation{Indent: "X", PWidth: 2}, span); err != nil {
+		if err := html.WriteIndent(&buf, html.Indentation{Indent: "X", PWidth: 2}, span); err != nil {
 			t.Fatal(err)
 		}
 
@@ -117,7 +116,7 @@ func TestWrap(t *testing.T) {
 		div := Div(Span("foo bar baz qux quux corge"))
 
 		var buf bytes.Buffer
-		if err := html.RenderIndent(&buf, html.Indentation{Indent: "\t", PWidth: 15}, div); err != nil {
+		if err := html.WriteIndent(&buf, html.Indentation{Indent: "\t", PWidth: 15}, div); err != nil {
 			t.Fatal(err)
 		}
 
@@ -130,7 +129,7 @@ func TestWrap(t *testing.T) {
 		div := Div(Span("foo"), " ", Span("bar"))
 
 		var buf bytes.Buffer
-		if err := html.RenderIndent(&buf, html.Indent(), div); err != nil {
+		if err := html.Write(&buf, div); err != nil {
 			t.Fatal(err)
 		}
 
@@ -143,7 +142,7 @@ func TestWrap(t *testing.T) {
 		div := Div("foo\nbar\tbaz")
 
 		var buf bytes.Buffer
-		if err := html.RenderIndent(&buf, html.Indent(), div); err != nil {
+		if err := html.Write(&buf, div); err != nil {
 			t.Fatal(err)
 		}