From 59d7937a1be9ed88b9d851b88976224268a71e0c Mon Sep 17 00:00:00 2001
From: dyma solovei <dmytro.y.solovei@gmail.com>
Date: Mon, 26 Feb 2024 18:40:56 +0100
Subject: [PATCH 1/5] feat: add CSS classes for code cells in in wrapper.go

This removes the need for custom renderers to do that on their own
---
 render/html/html.go         |  6 ------
 render/html/html_test.go    | 23 ++++-------------------
 render/html/wrapper.go      |  9 ++++++++-
 render/html/wrapper_test.go | 16 ++++++++++++++++
 4 files changed, 28 insertions(+), 26 deletions(-)

diff --git a/render/html/html.go b/render/html/html.go
index fa598c3..ff8db14 100644
--- a/render/html/html.go
+++ b/render/html/html.go
@@ -77,18 +77,12 @@ func (r *Renderer) renderCode(w io.Writer, cell schema.Cell) error {
 		return nil
 	}
 
-	div.Open(w, attributes{"class": {"cm-editor", "cm-s-jupyter"}}, true)
-	div.Open(w, attributes{"class": {"highlight", "hl-ipython3"}}, true)
-
 	io.WriteString(w, "<pre><code class=\"language-") // TODO: not sure if that's useful here
 	io.WriteString(w, code.Language())
 	io.WriteString(w, "\">")
 	w.Write(code.Text())
 	io.WriteString(w, "</code></pre>")
 
-	div.Close(w)
-	div.Close(w)
-
 	return nil
 }
 
diff --git a/render/html/html_test.go b/render/html/html_test.go
index 86ed678..38b3e2f 100644
--- a/render/html/html_test.go
+++ b/render/html/html_test.go
@@ -76,29 +76,14 @@ func TestRenderer(t *testing.T) {
 					Lang: "python",
 				},
 				want: &node{
-					tag: "div",
-					attr: map[string][]string{
-						"class": {"cm-editor", "cm-s-jupyter"},
-					},
+					tag: "pre",
 					children: []*node{
 						{
-							tag: "div",
+							tag: "code",
 							attr: map[string][]string{
-								"class": {"highlight"},
-							},
-							children: []*node{
-								{
-									tag: "pre",
-									children: []*node{
-										{
-											tag: "code",
-											attr: map[string][]string{
-												"class": {"language-python"},
-											},
-											content: "print('Hi, mom!')",
-										},
-									}},
+								"class": {"language-python"},
 							},
+							content: "print('Hi, mom!')",
 						},
 					},
 				},
diff --git a/render/html/wrapper.go b/render/html/wrapper.go
index 42987e2..9a90f31 100644
--- a/render/html/wrapper.go
+++ b/render/html/wrapper.go
@@ -79,6 +79,9 @@ func (wr *Wrapper) WrapInput(w io.Writer, cell schema.Cell, render render.Render
 			},
 			"data-type": {"inline"},
 		}, true)
+
+		div.Open(w, attributes{"class": {"cm-editor", "cm-s-jupyter"}}, true)
+		div.Open(w, attributes{"class": {"highlight", "hl-ipython3"}}, true)
 	} else if isMd {
 		div.Open(w, attributes{
 			"class": {
@@ -93,7 +96,11 @@ func (wr *Wrapper) WrapInput(w io.Writer, cell schema.Cell, render render.Render
 	// Cell itself
 	_ = render(w, cell)
 
-	if isCode || isMd {
+	if isCode {
+		div.Close(w)
+		div.Close(w)
+		div.Close(w)
+	} else if isMd {
 		div.Close(w)
 	}
 
diff --git a/render/html/wrapper_test.go b/render/html/wrapper_test.go
index db95d7d..83c2180 100644
--- a/render/html/wrapper_test.go
+++ b/render/html/wrapper_test.go
@@ -201,6 +201,22 @@ func TestWrapper_WrapInput(t *testing.T) {
 									},
 									"data-type": {"inline"},
 								},
+								children: []*node{
+									{
+										tag: "div",
+										attr: map[string][]string{
+											"class": {"cm-editor", "cm-s-jupyter"},
+										},
+										children: []*node{
+											{
+												tag: "div",
+												attr: map[string][]string{
+													"class": {"highlight"},
+												},
+											},
+										},
+									},
+								},
 							},
 						},
 					},

From 240c05350a90d8ca36f5627dd8150ae119cfb2ef Mon Sep 17 00:00:00 2001
From: dyma solovei <dmytro.y.solovei@gmail.com>
Date: Mon, 26 Feb 2024 19:23:23 +0100
Subject: [PATCH 2/5] test: fix error printing when comparing HTML structure

Drop superficial nodes with '\n' content --> their only purpose is making
the generated HTML more readable. They should be disregarded during tests.
---
 render/html/wrapper_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/render/html/wrapper_test.go b/render/html/wrapper_test.go
index 83c2180..fe7c9de 100644
--- a/render/html/wrapper_test.go
+++ b/render/html/wrapper_test.go
@@ -702,7 +702,7 @@ func findFirst(n *stdhtml.Node, target string) *stdhtml.Node {
 // Add modifications are done on the copy, so the original node is not modified.
 func dropChildElements(n *stdhtml.Node) *stdhtml.Node {
 	cp := *n
-	if cp.FirstChild != nil && cp.FirstChild.Type != stdhtml.TextNode {
+	if fc := cp.FirstChild; fc != nil && (fc.Type != stdhtml.TextNode || fc.Data == "\n") {
 		cp.FirstChild = nil
 	}
 	cp.NextSibling = nil

From b51732d28413afccd5faf9bd582e04a5cb6d20cb Mon Sep 17 00:00:00 2001
From: dyma solovei <dmytro.y.solovei@gmail.com>
Date: Tue, 27 Feb 2024 18:06:38 +0100
Subject: [PATCH 3/5] feat: wrap the whole notebook in jp-Notebook div

CSS, if any, is now written during the call to WrapAll.
This only happens once per notebook, so wrapping CSSWriter
into WriterOnce is redundant.

Removed WriterOnce, it's not used anywhere else.

Added a test case for SVG images in html.Renderer.
---
 pkg/test/render.go          |  1 +
 render/html/html.go         |  4 ++--
 render/html/html_test.go    | 23 ++++++++---------------
 render/html/wrapper.go      | 30 ++++++++++--------------------
 render/html/wrapper_test.go | 16 ++++++++++++++++
 render/render.go            | 11 ++++++++---
 6 files changed, 45 insertions(+), 40 deletions(-)

diff --git a/pkg/test/render.go b/pkg/test/render.go
index 78b65ba..860af44 100644
--- a/pkg/test/render.go
+++ b/pkg/test/render.go
@@ -17,6 +17,7 @@ type fakeWrapper struct{}
 var _ render.CellWrapper = (*fakeWrapper)(nil)
 
 func (*fakeWrapper) RegisterFuncs(render.RenderCellFuncRegistry)                    {}
+func (*fakeWrapper) WrapAll(io.Writer, func(io.Writer) error) error                 { return nil }
 func (*fakeWrapper) Wrap(w io.Writer, c schema.Cell, r render.RenderCellFunc) error { return r(w, c) }
 func (*fakeWrapper) WrapInput(w io.Writer, c schema.Cell, r render.RenderCellFunc) error {
 	return r(w, c)
diff --git a/render/html/html.go b/render/html/html.go
index ff8db14..699c97a 100644
--- a/render/html/html.go
+++ b/render/html/html.go
@@ -15,10 +15,10 @@ type Config struct {
 
 type Option func(*Config)
 
-// WithCSSWriter
+// WithCSSWriter registers a writer for CSS stylesheet.
 func WithCSSWriter(w io.Writer) Option {
 	return func(c *Config) {
-		c.CSSWriter = &WriterOnce{w: w}
+		c.CSSWriter = w
 	}
 }
 
diff --git a/render/html/html_test.go b/render/html/html_test.go
index 38b3e2f..0b1e06f 100644
--- a/render/html/html_test.go
+++ b/render/html/html_test.go
@@ -66,6 +66,13 @@ func TestRenderer(t *testing.T) {
 					"src": {"data:image/jpeg;base64, base64-encoded-image"},
 				}},
 			},
+			{
+				name: "image/svg+xml",
+				cell: test.DisplayData("svg-image", "image/svg+xml"),
+				want: &node{tag: "img", attr: map[string][]string{
+					"src": {"data:image/svg+xml;base64, svg-image"},
+				}},
+			},
 			{
 				name: "code cell",
 				cell: &test.CodeCell{
@@ -108,20 +115,6 @@ func TestRenderer(t *testing.T) {
 }
 
 func TestRenderer_CSSWriter(t *testing.T) {
-	t.Run("WithCSSWriter wraps in WriterOnce", func(t *testing.T) {
-		// Arrange
-		var cfg html.Config
-		opt := html.WithCSSWriter(io.Discard)
-
-		// Act
-		opt(&cfg)
-
-		// Assert
-		if _, ok := cfg.CSSWriter.(*html.WriterOnce); !ok {
-			t.Errorf("expected *html.WriterOnce, got %T", cfg.CSSWriter)
-		}
-	})
-
 	t.Run("captures correct css", func(t *testing.T) {
 		// Arrange
 		var css bytes.Buffer
@@ -134,7 +127,7 @@ func TestRenderer_CSSWriter(t *testing.T) {
 		}
 
 		// Act
-		err = r.Wrap(io.Discard, test.Markdown(""), noopRender)
+		err = r.WrapAll(io.Discard, func(w io.Writer) error { return nil })
 		require.NoError(t, err)
 
 		// Assert
diff --git a/render/html/wrapper.go b/render/html/wrapper.go
index 9a90f31..537e5b8 100644
--- a/render/html/wrapper.go
+++ b/render/html/wrapper.go
@@ -5,7 +5,6 @@ import (
 	"io"
 	"sort"
 	"strings"
-	"sync"
 
 	"github.com/bevzzz/nb/render"
 	"github.com/bevzzz/nb/schema"
@@ -15,9 +14,8 @@ import (
 
 /*
 TODO:
-	- make class prefixes configurable (probably on the html.Renderer level).
+	- make class prefixes configurable (probably on the html.Config level).
 	- refactor to use tagger
-	- add WrapAll / WrapNotebook that would add a <div class="jp-Notebook"> (then there's no need for WriterOnce)
 */
 
 // Wrapper wraps cells in the HTML produced by the original Jupyter's nbconvert.
@@ -25,11 +23,19 @@ type Wrapper struct {
 	Config
 }
 
-func (wr *Wrapper) Wrap(w io.Writer, cell schema.Cell, render render.RenderCellFunc) error {
+var _ render.CellWrapper = (*Wrapper)(nil)
+
+func (wr *Wrapper) WrapAll(w io.Writer, render func(io.Writer) error) error {
 	if wr.CSSWriter != nil {
 		wr.CSSWriter.Write(jupyterCSS)
 	}
 
+	div.Open(w, attributes{"class": {"jp-Notebook"}}, true)
+	defer div.Close(w)
+	return render(w)
+}
+
+func (wr *Wrapper) Wrap(w io.Writer, cell schema.Cell, render render.RenderCellFunc) error {
 	var ct string
 	switch cell.Type() {
 	case schema.Markdown:
@@ -301,19 +307,3 @@ func (attrs attributes) WriteTo(w io.Writer) (n64 int64, err error) {
 	}
 	return
 }
-
-// WriterOnce writes to the writer once only.
-// TODO: move to util
-type WriterOnce struct {
-	w    io.Writer
-	once sync.Once
-}
-
-var _ io.Writer = (*WriterOnce)(nil)
-
-func (w *WriterOnce) Write(p []byte) (n int, err error) {
-	w.once.Do(func() {
-		n, err = w.w.Write(p)
-	})
-	return
-}
diff --git a/render/html/wrapper_test.go b/render/html/wrapper_test.go
index fe7c9de..e64ea38 100644
--- a/render/html/wrapper_test.go
+++ b/render/html/wrapper_test.go
@@ -19,6 +19,22 @@ import (
 
 func noopRender(w io.Writer, c schema.Cell) error { return nil }
 
+func TestWrapper_WrapAll(t *testing.T) {
+	// Arrange
+	var w html.Wrapper
+	var buf bytes.Buffer
+	want := node{tag: "div", attr: map[string][]string{
+		"class": {"jp-Notebook"},
+	}}
+
+	// Act
+	err := w.WrapAll(&buf, func(w io.Writer) error { return nil })
+	require.NoError(t, err)
+
+	// Assert
+	checkDOM(t, &buf, &want)
+}
+
 func TestWrapper_Wrap(t *testing.T) {
 	for _, tt := range []struct {
 		name string
diff --git a/render/render.go b/render/render.go
index b55a937..2547ddc 100644
--- a/render/render.go
+++ b/render/render.go
@@ -70,14 +70,19 @@ func WithCellRenderers(crs ...CellRenderer) Option {
 
 // CellWrapper renders common wrapping elements for every cell type.
 type CellWrapper interface {
-	// Wrap the entire cell block.
+	// Wrap the entire cell.
 	Wrap(io.Writer, schema.Cell, RenderCellFunc) error
 
-	// Wrap input block.
+	// WrapInput wraps input block.
 	WrapInput(io.Writer, schema.Cell, RenderCellFunc) error
 
-	// Wrap output block (code cells).
+	// WrapOuput wraps output block (code cells).
 	WrapOutput(io.Writer, schema.Outputter, RenderCellFunc) error
+
+	// WrapAll wraps all cells in the notebook.
+	// This method will be called once and will receive a function
+	// to render the rest of the notebook.
+	WrapAll(io.Writer, func(io.Writer) error) error
 }
 
 // renderer is a base Renderer implementation.

From d807ef10449c7bbcdd71a5c9c86854ad136443cb Mon Sep 17 00:00:00 2001
From: dyma solovei <dmytro.y.solovei@gmail.com>
Date: Tue, 5 Mar 2024 22:02:08 +0100
Subject: [PATCH 4/5] refactor: close HTML tags automatically

---
 render/html/wrapper.go | 172 +++++++++++++++++++++--------------------
 1 file changed, 88 insertions(+), 84 deletions(-)

diff --git a/render/html/wrapper.go b/render/html/wrapper.go
index 537e5b8..29b6568 100644
--- a/render/html/wrapper.go
+++ b/render/html/wrapper.go
@@ -15,7 +15,6 @@ import (
 /*
 TODO:
 	- make class prefixes configurable (probably on the html.Config level).
-	- refactor to use tagger
 */
 
 // Wrapper wraps cells in the HTML produced by the original Jupyter's nbconvert.
@@ -26,16 +25,21 @@ type Wrapper struct {
 var _ render.CellWrapper = (*Wrapper)(nil)
 
 func (wr *Wrapper) WrapAll(w io.Writer, render func(io.Writer) error) error {
+	tag := tagger{Writer: w}
+	defer tag.Close()
+
 	if wr.CSSWriter != nil {
 		wr.CSSWriter.Write(jupyterCSS)
 	}
 
-	div.Open(w, attributes{"class": {"jp-Notebook"}}, true)
-	defer div.Close(w)
+	tag.Open("div", attributes{"class": {"jp-Notebook"}})
 	return render(w)
 }
 
 func (wr *Wrapper) Wrap(w io.Writer, cell schema.Cell, render render.RenderCellFunc) error {
+	tag := tagger{Writer: w}
+	defer tag.Close()
+
 	var ct string
 	switch cell.Type() {
 	case schema.Markdown:
@@ -47,78 +51,75 @@ func (wr *Wrapper) Wrap(w io.Writer, cell schema.Cell, render render.RenderCellF
 		ct = "jp-RawCell"
 	}
 
-	div.Open(w, attributes{"class": {"jp-Cell", ct, "jp-Notebook-cell"}}, true)
+	tag.Open("div", attributes{"class": {"jp-Cell", ct, "jp-Notebook-cell"}})
 	render(w, cell)
-	div.Close(w)
 	return nil
 }
 
 func (wr *Wrapper) WrapInput(w io.Writer, cell schema.Cell, render render.RenderCellFunc) error {
-	div.Open(w, attributes{
+	tag := tagger{Writer: w}
+	defer tag.Close()
+
+	tag.Open("div", attributes{
 		"class":    {"jp-Cell-inputWrapper"},
-		"tabindex": {0}}, true)
+		"tabindex": {0}})
 
-	div.Open(w, attributes{"class": {"jp-Collapser", "jp-InputCollapser", "jp-Cell-inputCollapser"}}, true)
+	tag.Open("div", attributes{"class": {"jp-Collapser", "jp-InputCollapser", "jp-Cell-inputCollapser"}})
 	io.WriteString(w, " ")
-	div.Close(w)
+	tag.CloseLast()
 
 	// TODO: add collapser-child <div class="jp-Collapser-child"></div> and collapsing functionality
 	// Pure CSS Collapsible: https://www.digitalocean.com/community/tutorials/css-collapsible
 
-	div.Open(w, attributes{"class": {"jp-InputArea", "jp-Cell-inputArea"}}, true)
+	tag.Open("div", attributes{"class": {"jp-InputArea", "jp-Cell-inputArea"}})
 
 	// Prompt In:[1]
-	div.Open(w, attributes{"class": {"jp-InputPrompt", "jp-InputArea-prompt"}}, false)
+	tag.OpenInline("div", attributes{"class": {"jp-InputPrompt", "jp-InputArea-prompt"}})
 	if ex, ok := cell.(interface{ ExecutionCount() int }); ok {
 		fmt.Fprintf(w, "In\u00a0[%d]:", ex.ExecutionCount())
 	}
-	div.Close(w)
+	tag.CloseLast()
 
 	isCode := cell.Type() == schema.Code
 	isMd := cell.Type() == schema.Markdown
 	if isCode {
-		div.Open(w, attributes{
+		tag.Open("div", attributes{
 			"class": {
 				"jp-CodeMirrorEditor",
 				"jp-Editor",
 				"jp-InputArea-editor",
 			},
 			"data-type": {"inline"},
-		}, true)
+		})
 
-		div.Open(w, attributes{"class": {"cm-editor", "cm-s-jupyter"}}, true)
-		div.Open(w, attributes{"class": {"highlight", "hl-ipython3"}}, true)
+		tag.Open("div", attributes{"class": {"cm-editor", "cm-s-jupyter"}})
+		tag.Open("div", attributes{"class": {"highlight", "hl-ipython3"}})
 	} else if isMd {
-		div.Open(w, attributes{
+		tag.Open("div", attributes{
 			"class": {
 				"jp-RenderedMarkdown",
 				"jp-MarkdownOutput",
 				"jp-RenderedHTMLCommon",
 			},
 			"data-mime-type": {common.MarkdownText},
-		}, true)
+		})
 	}
 
 	// Cell itself
 	_ = render(w, cell)
-
-	if isCode {
-		div.Close(w)
-		div.Close(w)
-		div.Close(w)
-	} else if isMd {
-		div.Close(w)
-	}
-
-	div.Close(w)
-	div.Close(w)
 	return nil
 }
 
 func (wr *Wrapper) WrapOutput(w io.Writer, cell schema.Outputter, render render.RenderCellFunc) error {
-	div.Open(w, attributes{"class": {"jp-Cell-outputWrapper"}}, true)
-	div.OpenClose(w, attributes{"class": {"jp-Collapser", "jp-OutputCollapser", "jp-Cell-outputCollapser"}})
-	div.Open(w, attributes{"class": {"jp-OutputArea jp-Cell-outputArea"}}, true)
+	tag := tagger{Writer: w}
+	defer tag.Close()
+
+	tag.Open("div", attributes{"class": {"jp-Cell-outputWrapper"}})
+
+	tag.OpenInline("div", attributes{"class": {"jp-Collapser", "jp-OutputCollapser", "jp-Cell-outputCollapser"}})
+	tag.CloseLast()
+
+	tag.Open("div", attributes{"class": {"jp-OutputArea jp-Cell-outputArea"}})
 
 	// TODO: see how application/json would be handled
 	// TODO: jp-RenderedJavaScript is a thing and so is jp-RenderedLatex (but I don't think we need to do anything about the latter)
@@ -160,95 +161,98 @@ func (wr *Wrapper) WrapOutput(w io.Writer, cell schema.Outputter, render render.
 
 	// Looks like this will always wrap the whole output area!
 	if child {
-		div.Open(w, attributes{"class": {childClass}}, true)
+		tag.Open("div", attributes{"class": {childClass}})
 	}
 
-	div.Open(w, attributes{"class": {"jp-OutputPrompt", "jp-OutputArea-prompt"}}, false)
+	tag.OpenInline("div", attributes{"class": {"jp-OutputPrompt", "jp-OutputArea-prompt"}})
 	for _, out := range cell.Outputs() {
 		if ex, ok := out.(interface{ ExecutionCount() int }); ok {
 			fmt.Fprintf(w, "Out\u00a0[%d]:", ex.ExecutionCount())
 			break
 		}
 	}
-	div.Close(w)
+	tag.CloseLast()
 
-	div.Open(w, attributes{
+	tag.Open("div", attributes{
 		"class":          {renderedClass, "jp-OutputArea-output", outputtypeclass},
 		"data-mime-type": {datamimetype},
-	}, true)
+	})
 	for _, out := range cell.Outputs() {
 		_ = render(w, out)
 	}
-	div.Close(w)
-
-	if child {
-		div.Close(w)
-	}
-
-	div.Close(w)
-	div.Close(w)
+	tag.CloseLast()
 	return nil
 }
 
-const (
-	div tag = "div"
-)
-
-type tag string
-
-// Open the tag with the attributes, e.g. <div class="container" checked>.
-func (t tag) Open(w io.Writer, attrs attributes, newline bool) {
-	t._open(w, attrs, newline)
-}
-
-func (t tag) _open(w io.Writer, attrs attributes, newline bool) {
-	io.WriteString(w, "<")
-	io.WriteString(w, string(t))
-	attrs.WriteTo(w)
-	io.WriteString(w, ">")
-	if newline {
-		io.WriteString(w, "\n")
-	}
-}
-
-func (t tag) Close(w io.Writer) {
-	fmt.Fprintf(w, "</%s>\n", t)
+// tagger is a straightforward utility for writing HTML tags.
+//
+// Example:
+//
+//	tag := tagger{Writer: os.Stdout}
+//	defer tag.Close()
+//	tag.Open("div", attributes{"class": {"box"}})
+//	tag.Open("pre", attributes{"class": {"hl", "python"}})
+//
+// tagger also supports empty tags.
+type tagger struct {
+	Writer io.Writer
+	opened []string
 }
 
-func (t tag) OpenClose(w io.Writer, attrs attributes) {
-	t._open(w, attrs, false)
-	t.Close(w)
+// Open opens the tag with the attributes.
+func (t *tagger) Open(tag string, attr attributes) {
+	t.openTag(tag, attr, true)
 }
 
-// Empty writes the attributes in an empty-element tag, e.g. <div class="container" />.
-func (t tag) Empty(w io.Writer, attrs attributes) {
-	io.WriteString(w, "<")
-	io.WriteString(w, string(t))
-	attrs.WriteTo(w)
-	io.WriteString(w, " />")
+// Open inline does not add a newline '\n' after the opening tag.
+func (t *tagger) OpenInline(tag string, attr attributes) {
+	t.openTag(tag, attr, false)
 }
 
-type tagger struct {
-	opened []tag
+// Empty creates an empty HTML tag, like <input />.
+func (t *tagger) Empty(tag string, attr attributes) {
+	io.WriteString(t.Writer, "<")
+	io.WriteString(t.Writer, tag)
+	attr.WriteTo(t.Writer)
+	io.WriteString(t.Writer, " />")
 }
 
-// Open opens the tag with the attributes.
-func (t *tagger) Open(tag tag, w io.Writer, attr attributes) {
-	tag.Open(w, attr, true) // TODO: redo
+func (t *tagger) openTag(tag string, attr attributes, newline bool) {
+	io.WriteString(t.Writer, "<")
+	io.WriteString(t.Writer, tag)
+	attr.WriteTo(t.Writer)
+	io.WriteString(t.Writer, ">")
+	if newline {
+		io.WriteString(t.Writer, "\n")
+	}
 	t.opened = append(t.opened, tag)
 }
 
 // Close closes all opened tags in reverse order.
-func (t *tagger) Close(w io.Writer) {
+// Always adds a newline after the tag.
+func (t *tagger) Close() {
 	l := len(t.opened)
 	if l == 0 {
 		return
 	}
 	for i := l - 1; i >= 0; i-- {
-		t.opened[i].Close(w)
+		t.closeTag(t.opened[i])
 	}
 }
 
+func (t *tagger) CloseLast() {
+	l := len(t.opened)
+	if l == 0 {
+		return
+	}
+	t.closeTag(t.opened[l-1])
+	t.opened = t.opened[:l-1]
+}
+
+func (t *tagger) closeTag(tag string) {
+	fmt.Fprintf(t.Writer, "</%s>\n", tag)
+}
+
 type attributes map[string][]interface{}
 
 // WriteTo writes values of each attribute in a space-separated list, e.g. class="container box jp-NotebookCell".

From 1a26fa4ea4d0470dac835f2beb4056a3156d52a2 Mon Sep 17 00:00:00 2001
From: dyma solovei <dmytro.y.solovei@gmail.com>
Date: Tue, 5 Mar 2024 22:14:13 +0100
Subject: [PATCH 5/5] chore: cleanup wrapper.go

---
 render/html/wrapper.go | 15 +++++----------
 1 file changed, 5 insertions(+), 10 deletions(-)

diff --git a/render/html/wrapper.go b/render/html/wrapper.go
index 29b6568..d297a07 100644
--- a/render/html/wrapper.go
+++ b/render/html/wrapper.go
@@ -80,9 +80,8 @@ func (wr *Wrapper) WrapInput(w io.Writer, cell schema.Cell, render render.Render
 	}
 	tag.CloseLast()
 
-	isCode := cell.Type() == schema.Code
-	isMd := cell.Type() == schema.Markdown
-	if isCode {
+	switch cell.Type() {
+	case schema.Code:
 		tag.Open("div", attributes{
 			"class": {
 				"jp-CodeMirrorEditor",
@@ -94,7 +93,8 @@ func (wr *Wrapper) WrapInput(w io.Writer, cell schema.Cell, render render.Render
 
 		tag.Open("div", attributes{"class": {"cm-editor", "cm-s-jupyter"}})
 		tag.Open("div", attributes{"class": {"highlight", "hl-ipython3"}})
-	} else if isMd {
+
+	case schema.Markdown:
 		tag.Open("div", attributes{
 			"class": {
 				"jp-RenderedMarkdown",
@@ -105,7 +105,6 @@ func (wr *Wrapper) WrapInput(w io.Writer, cell schema.Cell, render render.Render
 		})
 	}
 
-	// Cell itself
 	_ = render(w, cell)
 	return nil
 }
@@ -115,13 +114,10 @@ func (wr *Wrapper) WrapOutput(w io.Writer, cell schema.Outputter, render render.
 	defer tag.Close()
 
 	tag.Open("div", attributes{"class": {"jp-Cell-outputWrapper"}})
-
 	tag.OpenInline("div", attributes{"class": {"jp-Collapser", "jp-OutputCollapser", "jp-Cell-outputCollapser"}})
 	tag.CloseLast()
-
 	tag.Open("div", attributes{"class": {"jp-OutputArea jp-Cell-outputArea"}})
 
-	// TODO: see how application/json would be handled
 	// TODO: jp-RenderedJavaScript is a thing and so is jp-RenderedLatex (but I don't think we need to do anything about the latter)
 
 	var child bool
@@ -155,11 +151,10 @@ func (wr *Wrapper) WrapOutput(w io.Writer, cell schema.Outputter, render render.
 	} else if strings.HasPrefix(datamimetype, "image/") {
 		renderedClass = "jp-RenderedImage"
 		child = true
-	} else if datamimetype == "application/vnd.jupyter.stderr" {
+	} else if datamimetype == common.Stderr {
 		renderedClass = "jp-RenderedText"
 	}
 
-	// Looks like this will always wrap the whole output area!
 	if child {
 		tag.Open("div", attributes{"class": {childClass}})
 	}