renderer/html.go - external/github.com/olekukonko/tablewriter - Git at Google

 package renderer

 import (
 	"errors"
 	"fmt"
 	"html"
 	"io"
 	"strings"

 	"github.com/olekukonko/ll"

 	"github.com/olekukonko/tablewriter/tw"
 )

 // HTMLConfig defines settings for the HTML table renderer.
 type HTMLConfig struct {
 	EscapeContent  bool   // Whether to escape cell content
 	AddLinesTag    bool   // Whether to wrap multiline content in <lines> tags
 	TableClass     string // CSS class for <table>
 	HeaderClass    string // CSS class for <thead>
 	BodyClass      string // CSS class for <tbody>
 	FooterClass    string // CSS class for <tfoot>
 	RowClass       string // CSS class for <tr> in body
 	HeaderRowClass string // CSS class for <tr> in header
 	FooterRowClass string // CSS class for <tr> in footer
 }

 // HTML renders tables in HTML format with customizable classes and content handling.
 type HTML struct {
 	config       HTMLConfig  // Renderer configuration
 	w            io.Writer   // Output w
 	trace        []string    // Debug trace messages
 	debug        bool        // Enables debug logging
 	tableStarted bool        // Tracks if <table> tag is open
 	tbodyStarted bool        // Tracks if <tbody> tag is open
 	tfootStarted bool        // Tracks if <tfoot> tag is open
 	vMergeTrack  map[int]int // Tracks vertical merge spans by column index
 	logger       *ll.Logger
 }

 // NewHTML initializes an HTML renderer with the given w, debug setting, and optional configuration.
 // It panics if the w is nil and applies defaults for unset config fields.
 // Update: see https://github.com/olekukonko/tablewriter/issues/258
 func NewHTML(configs ...HTMLConfig) *HTML {
 	cfg := HTMLConfig{
 		EscapeContent: true,
 		AddLinesTag:   false,
 	}
 	if len(configs) > 0 {
 		userCfg := configs[0]
 		cfg.EscapeContent = userCfg.EscapeContent
 		cfg.AddLinesTag = userCfg.AddLinesTag
 		cfg.TableClass = userCfg.TableClass
 		cfg.HeaderClass = userCfg.HeaderClass
 		cfg.BodyClass = userCfg.BodyClass
 		cfg.FooterClass = userCfg.FooterClass
 		cfg.RowClass = userCfg.RowClass
 		cfg.HeaderRowClass = userCfg.HeaderRowClass
 		cfg.FooterRowClass = userCfg.FooterRowClass
 	}
 	return &HTML{
 		config:       cfg,
 		vMergeTrack:  make(map[int]int),
 		tableStarted: false,
 		tbodyStarted: false,
 		tfootStarted: false,
 		logger:       ll.New("html").Disable(),
 	}
 }

 func (h *HTML) Logger(logger *ll.Logger) {
 	h.logger = logger
 }

 // Config returns a Rendition representation of the current configuration.
 func (h *HTML) Config() tw.Rendition {
 	return tw.Rendition{
 		Borders:   tw.BorderNone,
 		Symbols:   tw.NewSymbols(tw.StyleNone),
 		Settings:  tw.Settings{},
 		Streaming: false,
 	}
 }

 // debugLog appends a formatted message to the debug trace if debugging is enabled.
 // func (h *HTML) debugLog(format string, a ...interface{}) {
 //	if h.debug {
 //		msg := fmt.Sprintf(format, a...)
 //		h.trace = append(h.trace, fmt.Sprintf("[HTML] %s", msg))
 //	}
 //}

 // Debug returns the accumulated debug trace messages.
 func (h *HTML) Debug() []string {
 	return h.trace
 }

 // Start begins the HTML table rendering by opening the <table> tag.
 func (h *HTML) Start(w io.Writer) error {
 	h.w = w
 	h.Reset()
 	h.logger.Debug("HTML.Start() called.")

 	classAttr := tw.Empty
 	if h.config.TableClass != tw.Empty {
 		classAttr = fmt.Sprintf(` class="%s"`, h.config.TableClass)
 	}
 	h.logger.Debugf("Writing opening <table%s> tag", classAttr)
 	_, err := fmt.Fprintf(h.w, "<table%s>\n", classAttr)
 	if err != nil {
 		return err
 	}
 	h.tableStarted = true
 	return nil
 }

 // closePreviousSection closes any open <tbody> or <tfoot> sections.
 func (h *HTML) closePreviousSection() {
 	if h.tbodyStarted {
 		h.logger.Debug("Closing <tbody> tag")
 		fmt.Fprintln(h.w, "</tbody>")
 		h.tbodyStarted = false
 	}
 	if h.tfootStarted {
 		h.logger.Debug("Closing <tfoot> tag")
 		fmt.Fprintln(h.w, "</tfoot>")
 		h.tfootStarted = false
 	}
 }

 // Header renders the <thead> section with header rows, supporting horizontal merges.
 func (h *HTML) Header(headers [][]string, ctx tw.Formatting) {
 	if !h.tableStarted {
 		h.logger.Debug("WARN: Header called before Start")
 		return
 	}
 	if len(headers) == 0 || len(headers[0]) == 0 {
 		h.logger.Debug("Header: No headers")
 		return
 	}

 	h.closePreviousSection()
 	classAttr := tw.Empty
 	if h.config.HeaderClass != tw.Empty {
 		classAttr = fmt.Sprintf(` class="%s"`, h.config.HeaderClass)
 	}
 	fmt.Fprintf(h.w, "<thead%s>\n", classAttr)

 	headerRow := headers[0]
 	numCols := 0
 	if len(ctx.Row.Current) > 0 {
 		maxKey := -1
 		for k := range ctx.Row.Current {
 			if k > maxKey {
 				maxKey = k
 			}
 		}
 		numCols = maxKey + 1
 	} else if len(headerRow) > 0 {
 		numCols = len(headerRow)
 	}

 	indent := "  "
 	rowClassAttr := tw.Empty
 	if h.config.HeaderRowClass != tw.Empty {
 		rowClassAttr = fmt.Sprintf(` class="%s"`, h.config.HeaderRowClass)
 	}
 	fmt.Fprintf(h.w, "%s<tr%s>", indent, rowClassAttr)

 	renderedCols := 0
 	for colIdx := 0; renderedCols < numCols && colIdx < numCols; {
 		// Skip columns consumed by vertical merges
 		if remainingSpan, merging := h.vMergeTrack[colIdx]; merging && remainingSpan > 1 {
 			h.logger.Debugf("Header: Skipping col %d due to vmerge", colIdx)
 			h.vMergeTrack[colIdx]--
 			if h.vMergeTrack[colIdx] <= 1 {
 				delete(h.vMergeTrack, colIdx)
 			}
 			colIdx++
 			continue
 		}

 		// Render cell
 		cellCtx, ok := ctx.Row.Current[colIdx]
 		if !ok {
 			cellCtx = tw.CellContext{Align: tw.AlignCenter}
 		}
 		originalContent := tw.Empty
 		if colIdx < len(headerRow) {
 			originalContent = headerRow[colIdx]
 		}

 		tag, attributes, processedContent := h.renderRowCell(originalContent, cellCtx, true, colIdx)
 		fmt.Fprintf(h.w, "<%s%s>%s</%s>", tag, attributes, processedContent, tag)
 		renderedCols++

 		// Handle horizontal merges
 		hSpan := 1
 		if cellCtx.Merge.Horizontal.Present && cellCtx.Merge.Horizontal.Start {
 			hSpan = cellCtx.Merge.Horizontal.Span
 			renderedCols += (hSpan - 1)
 		}
 		colIdx += hSpan
 	}
 	fmt.Fprintf(h.w, "</tr>\n")
 	fmt.Fprintln(h.w, "</thead>")
 }

 // Row renders a <tr> element within <tbody>, supporting horizontal and vertical merges.
 func (h *HTML) Row(row []string, ctx tw.Formatting) {
 	if !h.tableStarted {
 		h.logger.Debug("WARN: Row called before Start")
 		return
 	}

 	if !h.tbodyStarted {
 		h.closePreviousSection()
 		classAttr := tw.Empty
 		if h.config.BodyClass != tw.Empty {
 			classAttr = fmt.Sprintf(` class="%s"`, h.config.BodyClass)
 		}
 		h.logger.Debugf("Writing opening <tbody%s> tag", classAttr)
 		fmt.Fprintf(h.w, "<tbody%s>\n", classAttr)
 		h.tbodyStarted = true
 	}

 	h.logger.Debugf("Rendering row data: %v", row)
 	numCols := 0
 	if len(ctx.Row.Current) > 0 {
 		maxKey := -1
 		for k := range ctx.Row.Current {
 			if k > maxKey {
 				maxKey = k
 			}
 		}
 		numCols = maxKey + 1
 	} else if len(row) > 0 {
 		numCols = len(row)
 	}

 	indent := "  "
 	rowClassAttr := tw.Empty
 	if h.config.RowClass != tw.Empty {
 		rowClassAttr = fmt.Sprintf(` class="%s"`, h.config.RowClass)
 	}
 	fmt.Fprintf(h.w, "%s<tr%s>", indent, rowClassAttr)

 	renderedCols := 0
 	for colIdx := 0; renderedCols < numCols && colIdx < numCols; {
 		// Skip columns consumed by vertical merges
 		if remainingSpan, merging := h.vMergeTrack[colIdx]; merging && remainingSpan > 1 {
 			h.logger.Debugf("Row: Skipping render for col %d due to vertical merge (remaining %d)", colIdx, remainingSpan-1)
 			h.vMergeTrack[colIdx]--
 			if h.vMergeTrack[colIdx] <= 1 {
 				delete(h.vMergeTrack, colIdx)
 			}
 			colIdx++
 			continue
 		}

 		// Render cell
 		cellCtx, ok := ctx.Row.Current[colIdx]
 		if !ok {
 			cellCtx = tw.CellContext{Align: tw.AlignLeft}
 		}
 		originalContent := tw.Empty
 		if colIdx < len(row) {
 			originalContent = row[colIdx]
 		}

 		tag, attributes, processedContent := h.renderRowCell(originalContent, cellCtx, false, colIdx)
 		fmt.Fprintf(h.w, "<%s%s>%s</%s>", tag, attributes, processedContent, tag)
 		renderedCols++

 		// Handle horizontal merges
 		hSpan := 1
 		if cellCtx.Merge.Horizontal.Present && cellCtx.Merge.Horizontal.Start {
 			hSpan = cellCtx.Merge.Horizontal.Span
 			renderedCols += (hSpan - 1)
 		}
 		colIdx += hSpan
 	}
 	fmt.Fprintf(h.w, "</tr>\n")
 }

 // Footer renders the <tfoot> section with footer rows, supporting horizontal merges.
 func (h *HTML) Footer(footers [][]string, ctx tw.Formatting) {
 	if !h.tableStarted {
 		h.logger.Debug("WARN: Footer called before Start")
 		return
 	}
 	if len(footers) == 0 || len(footers[0]) == 0 {
 		h.logger.Debug("Footer: No footers")
 		return
 	}

 	h.closePreviousSection()
 	classAttr := tw.Empty
 	if h.config.FooterClass != tw.Empty {
 		classAttr = fmt.Sprintf(` class="%s"`, h.config.FooterClass)
 	}
 	fmt.Fprintf(h.w, "<tfoot%s>\n", classAttr)
 	h.tfootStarted = true

 	footerRow := footers[0]
 	numCols := 0
 	if len(ctx.Row.Current) > 0 {
 		maxKey := -1
 		for k := range ctx.Row.Current {
 			if k > maxKey {
 				maxKey = k
 			}
 		}
 		numCols = maxKey + 1
 	} else if len(footerRow) > 0 {
 		numCols = len(footerRow)
 	}

 	indent := "  "
 	rowClassAttr := tw.Empty
 	if h.config.FooterRowClass != tw.Empty {
 		rowClassAttr = fmt.Sprintf(` class="%s"`, h.config.FooterRowClass)
 	}
 	fmt.Fprintf(h.w, "%s<tr%s>", indent, rowClassAttr)

 	renderedCols := 0
 	for colIdx := 0; renderedCols < numCols && colIdx < numCols; {
 		cellCtx, ok := ctx.Row.Current[colIdx]
 		if !ok {
 			cellCtx = tw.CellContext{Align: tw.AlignRight}
 		}
 		originalContent := tw.Empty
 		if colIdx < len(footerRow) {
 			originalContent = footerRow[colIdx]
 		}

 		tag, attributes, processedContent := h.renderRowCell(originalContent, cellCtx, false, colIdx)
 		fmt.Fprintf(h.w, "<%s%s>%s</%s>", tag, attributes, processedContent, tag)
 		renderedCols++

 		hSpan := 1
 		if cellCtx.Merge.Horizontal.Present && cellCtx.Merge.Horizontal.Start {
 			hSpan = cellCtx.Merge.Horizontal.Span
 			renderedCols += (hSpan - 1)
 		}
 		colIdx += hSpan
 	}
 	fmt.Fprintf(h.w, "</tr>\n")
 	fmt.Fprintln(h.w, "</tfoot>")
 	h.tfootStarted = false
 }

 // renderRowCell generates HTML for a single cell, handling content escaping, merges, and alignment.
 func (h *HTML) renderRowCell(originalContent string, cellCtx tw.CellContext, isHeader bool, colIdx int) (tag, attributes, processedContent string) {
 	tag = "td"
 	if isHeader {
 		tag = "th"
 	}

 	// Process content
 	processedContent = originalContent
 	containsNewline := strings.Contains(originalContent, "\n")

 	if h.config.EscapeContent {
 		if containsNewline {
 			const newlinePlaceholder = "[[--HTML_RENDERER_BR_PLACEHOLDER--]]"
 			tempContent := strings.ReplaceAll(originalContent, "\n", newlinePlaceholder)
 			escapedContent := html.EscapeString(tempContent)
 			processedContent = strings.ReplaceAll(escapedContent, newlinePlaceholder, "<br>")
 		} else {
 			processedContent = html.EscapeString(originalContent)
 		}
 	} else if containsNewline {
 		processedContent = strings.ReplaceAll(originalContent, "\n", "<br>")
 	}

 	if containsNewline && h.config.AddLinesTag {
 		processedContent = "<lines>" + processedContent + "</lines>"
 	}

 	// Build attributes
 	var attrBuilder strings.Builder
 	merge := cellCtx.Merge

 	if merge.Horizontal.Present && merge.Horizontal.Start && merge.Horizontal.Span > 1 {
 		fmt.Fprintf(&attrBuilder, ` colspan="%d"`, merge.Horizontal.Span)
 	}

 	vSpan := 0
 	if !isHeader {
 		if merge.Vertical.Present && merge.Vertical.Start {
 			vSpan = merge.Vertical.Span
 		} else if merge.Hierarchical.Present && merge.Hierarchical.Start {
 			vSpan = merge.Hierarchical.Span
 		}
 		if vSpan > 1 {
 			fmt.Fprintf(&attrBuilder, ` rowspan="%d"`, vSpan)
 			h.vMergeTrack[colIdx] = vSpan
 			h.logger.Debugf("renderRowCell: Tracking rowspan=%d for col %d", vSpan, colIdx)
 		}
 	}

 	if style := getHTMLStyle(cellCtx.Align); style != tw.Empty {
 		attrBuilder.WriteString(style)
 	}
 	attributes = attrBuilder.String()
 	return
 }

 // Line is a no-op for HTML rendering, as structural lines are handled by tags.
 func (h *HTML) Line(ctx tw.Formatting) {}

 // Reset clears the renderer's internal state, including debug traces and merge tracking.
 func (h *HTML) Reset() {
 	h.logger.Debug("HTML.Reset() called.")
 	h.tableStarted = false
 	h.tbodyStarted = false
 	h.tfootStarted = false
 	h.vMergeTrack = make(map[int]int)
 	h.trace = nil
 }

 // Close ensures all open HTML tags (<table>, <tbody>, <tfoot>) are properly closed.
 func (h *HTML) Close() error {
 	if h.w == nil {
 		return errors.New("HTML Renderer Close called on nil internal w")
 	}

 	if h.tableStarted {
 		h.logger.Debug("HTML.Close() called.")
 		h.closePreviousSection()
 		h.logger.Debug("Closing <table> tag.")
 		_, err := fmt.Fprintln(h.w, "</table>")
 		h.tableStarted = false
 		h.tbodyStarted = false
 		h.tfootStarted = false
 		h.vMergeTrack = make(map[int]int)
 		return err
 	}
 	h.logger.Debug("HTML.Close() called, but table was not started (no-op).")
 	return nil
 }
	package renderer

	import (
	"errors"
	"fmt"
	"html"
	"io"
	"strings"

	"github.com/olekukonko/ll"

	"github.com/olekukonko/tablewriter/tw"
	)

	// HTMLConfig defines settings for the HTML table renderer.
	type HTMLConfig struct {
	EscapeContent bool // Whether to escape cell content
	AddLinesTag bool // Whether to wrap multiline content in <lines> tags
	TableClass string // CSS class for <table>
	HeaderClass string // CSS class for <thead>
	BodyClass string // CSS class for <tbody>
	FooterClass string // CSS class for <tfoot>
	RowClass string // CSS class for <tr> in body
	HeaderRowClass string // CSS class for <tr> in header
	FooterRowClass string // CSS class for <tr> in footer
	}

	// HTML renders tables in HTML format with customizable classes and content handling.
	type HTML struct {
	config HTMLConfig // Renderer configuration
	w io.Writer // Output w
	trace []string // Debug trace messages
	debug bool // Enables debug logging
	tableStarted bool // Tracks if <table> tag is open
	tbodyStarted bool // Tracks if <tbody> tag is open
	tfootStarted bool // Tracks if <tfoot> tag is open
	vMergeTrack map[int]int // Tracks vertical merge spans by column index
	logger *ll.Logger
	}

	// NewHTML initializes an HTML renderer with the given w, debug setting, and optional configuration.
	// It panics if the w is nil and applies defaults for unset config fields.
	// Update: see https://github.com/olekukonko/tablewriter/issues/258
	func NewHTML(configs ...HTMLConfig) *HTML {
	cfg := HTMLConfig{
	EscapeContent: true,
	AddLinesTag: false,
	}
	if len(configs) > 0 {
	userCfg := configs[0]
	cfg.EscapeContent = userCfg.EscapeContent
	cfg.AddLinesTag = userCfg.AddLinesTag
	cfg.TableClass = userCfg.TableClass
	cfg.HeaderClass = userCfg.HeaderClass
	cfg.BodyClass = userCfg.BodyClass
	cfg.FooterClass = userCfg.FooterClass
	cfg.RowClass = userCfg.RowClass
	cfg.HeaderRowClass = userCfg.HeaderRowClass
	cfg.FooterRowClass = userCfg.FooterRowClass
	}
	return &HTML{
	config: cfg,
	vMergeTrack: make(map[int]int),
	tableStarted: false,
	tbodyStarted: false,
	tfootStarted: false,
	logger: ll.New("html").Disable(),
	}
	}

	func (h HTML) Logger(logger ll.Logger) {
	h.logger = logger
	}

	// Config returns a Rendition representation of the current configuration.
	func (h *HTML) Config() tw.Rendition {
	return tw.Rendition{
	Borders: tw.BorderNone,
	Symbols: tw.NewSymbols(tw.StyleNone),
	Settings: tw.Settings{},
	Streaming: false,
	}
	}

	// debugLog appends a formatted message to the debug trace if debugging is enabled.
	// func (h *HTML) debugLog(format string, a ...interface{}) {
	// if h.debug {
	// msg := fmt.Sprintf(format, a...)
	// h.trace = append(h.trace, fmt.Sprintf("[HTML] %s", msg))
	// }
	//}

	// Debug returns the accumulated debug trace messages.
	func (h *HTML) Debug() []string {
	return h.trace
	}

	// Start begins the HTML table rendering by opening the <table> tag.
	func (h *HTML) Start(w io.Writer) error {
	h.w = w
	h.Reset()
	h.logger.Debug("HTML.Start() called.")

	classAttr := tw.Empty
	if h.config.TableClass != tw.Empty {
	classAttr = fmt.Sprintf(` class="%s"`, h.config.TableClass)
	}
	h.logger.Debugf("Writing opening <table%s> tag", classAttr)
	_, err := fmt.Fprintf(h.w, "<table%s>\n", classAttr)
	if err != nil {
	return err
	}
	h.tableStarted = true
	return nil
	}

	// closePreviousSection closes any open <tbody> or <tfoot> sections.
	func (h *HTML) closePreviousSection() {
	if h.tbodyStarted {
	h.logger.Debug("Closing <tbody> tag")
	fmt.Fprintln(h.w, "</tbody>")
	h.tbodyStarted = false
	}
	if h.tfootStarted {
	h.logger.Debug("Closing <tfoot> tag")
	fmt.Fprintln(h.w, "</tfoot>")
	h.tfootStarted = false
	}
	}

	// Header renders the <thead> section with header rows, supporting horizontal merges.
	func (h *HTML) Header(headers [][]string, ctx tw.Formatting) {
	if !h.tableStarted {
	h.logger.Debug("WARN: Header called before Start")
	return
	}
	if len(headers) == 0 \|\| len(headers[0]) == 0 {
	h.logger.Debug("Header: No headers")
	return
	}

	h.closePreviousSection()
	classAttr := tw.Empty
	if h.config.HeaderClass != tw.Empty {
	classAttr = fmt.Sprintf(` class="%s"`, h.config.HeaderClass)
	}
	fmt.Fprintf(h.w, "<thead%s>\n", classAttr)

	headerRow := headers[0]
	numCols := 0
	if len(ctx.Row.Current) > 0 {
	maxKey := -1
	for k := range ctx.Row.Current {
	if k > maxKey {
	maxKey = k
	}
	}
	numCols = maxKey + 1
	} else if len(headerRow) > 0 {
	numCols = len(headerRow)
	}

	indent := " "
	rowClassAttr := tw.Empty
	if h.config.HeaderRowClass != tw.Empty {
	rowClassAttr = fmt.Sprintf(` class="%s"`, h.config.HeaderRowClass)
	}
	fmt.Fprintf(h.w, "%s<tr%s>", indent, rowClassAttr)

	renderedCols := 0
	for colIdx := 0; renderedCols < numCols && colIdx < numCols; {
	// Skip columns consumed by vertical merges
	if remainingSpan, merging := h.vMergeTrack[colIdx]; merging && remainingSpan > 1 {
	h.logger.Debugf("Header: Skipping col %d due to vmerge", colIdx)
	h.vMergeTrack[colIdx]--
	if h.vMergeTrack[colIdx] <= 1 {
	delete(h.vMergeTrack, colIdx)
	}
	colIdx++
	continue
	}

	// Render cell
	cellCtx, ok := ctx.Row.Current[colIdx]
	if !ok {
	cellCtx = tw.CellContext{Align: tw.AlignCenter}
	}
	originalContent := tw.Empty
	if colIdx < len(headerRow) {
	originalContent = headerRow[colIdx]
	}

	tag, attributes, processedContent := h.renderRowCell(originalContent, cellCtx, true, colIdx)
	fmt.Fprintf(h.w, "<%s%s>%s</%s>", tag, attributes, processedContent, tag)
	renderedCols++

	// Handle horizontal merges
	hSpan := 1
	if cellCtx.Merge.Horizontal.Present && cellCtx.Merge.Horizontal.Start {
	hSpan = cellCtx.Merge.Horizontal.Span
	renderedCols += (hSpan - 1)
	}
	colIdx += hSpan
	}
	fmt.Fprintf(h.w, "</tr>\n")
	fmt.Fprintln(h.w, "</thead>")
	}

	// Row renders a <tr> element within <tbody>, supporting horizontal and vertical merges.
	func (h *HTML) Row(row []string, ctx tw.Formatting) {
	if !h.tableStarted {
	h.logger.Debug("WARN: Row called before Start")
	return
	}

	if !h.tbodyStarted {
	h.closePreviousSection()
	classAttr := tw.Empty
	if h.config.BodyClass != tw.Empty {
	classAttr = fmt.Sprintf(` class="%s"`, h.config.BodyClass)
	}
	h.logger.Debugf("Writing opening <tbody%s> tag", classAttr)
	fmt.Fprintf(h.w, "<tbody%s>\n", classAttr)
	h.tbodyStarted = true
	}

	h.logger.Debugf("Rendering row data: %v", row)
	numCols := 0
	if len(ctx.Row.Current) > 0 {
	maxKey := -1
	for k := range ctx.Row.Current {
	if k > maxKey {
	maxKey = k
	}
	}
	numCols = maxKey + 1
	} else if len(row) > 0 {
	numCols = len(row)
	}

	indent := " "
	rowClassAttr := tw.Empty
	if h.config.RowClass != tw.Empty {
	rowClassAttr = fmt.Sprintf(` class="%s"`, h.config.RowClass)
	}
	fmt.Fprintf(h.w, "%s<tr%s>", indent, rowClassAttr)

	renderedCols := 0
	for colIdx := 0; renderedCols < numCols && colIdx < numCols; {
	// Skip columns consumed by vertical merges
	if remainingSpan, merging := h.vMergeTrack[colIdx]; merging && remainingSpan > 1 {
	h.logger.Debugf("Row: Skipping render for col %d due to vertical merge (remaining %d)", colIdx, remainingSpan-1)
	h.vMergeTrack[colIdx]--
	if h.vMergeTrack[colIdx] <= 1 {
	delete(h.vMergeTrack, colIdx)
	}
	colIdx++
	continue
	}

	// Render cell
	cellCtx, ok := ctx.Row.Current[colIdx]
	if !ok {
	cellCtx = tw.CellContext{Align: tw.AlignLeft}
	}
	originalContent := tw.Empty
	if colIdx < len(row) {
	originalContent = row[colIdx]
	}

	tag, attributes, processedContent := h.renderRowCell(originalContent, cellCtx, false, colIdx)
	fmt.Fprintf(h.w, "<%s%s>%s</%s>", tag, attributes, processedContent, tag)
	renderedCols++

	// Handle horizontal merges
	hSpan := 1
	if cellCtx.Merge.Horizontal.Present && cellCtx.Merge.Horizontal.Start {
	hSpan = cellCtx.Merge.Horizontal.Span
	renderedCols += (hSpan - 1)
	}
	colIdx += hSpan
	}
	fmt.Fprintf(h.w, "</tr>\n")
	}

	// Footer renders the <tfoot> section with footer rows, supporting horizontal merges.
	func (h *HTML) Footer(footers [][]string, ctx tw.Formatting) {
	if !h.tableStarted {
	h.logger.Debug("WARN: Footer called before Start")
	return
	}
	if len(footers) == 0 \|\| len(footers[0]) == 0 {
	h.logger.Debug("Footer: No footers")
	return
	}

	h.closePreviousSection()
	classAttr := tw.Empty
	if h.config.FooterClass != tw.Empty {
	classAttr = fmt.Sprintf(` class="%s"`, h.config.FooterClass)
	}
	fmt.Fprintf(h.w, "<tfoot%s>\n", classAttr)
	h.tfootStarted = true

	footerRow := footers[0]
	numCols := 0
	if len(ctx.Row.Current) > 0 {
	maxKey := -1
	for k := range ctx.Row.Current {
	if k > maxKey {
	maxKey = k
	}
	}
	numCols = maxKey + 1
	} else if len(footerRow) > 0 {
	numCols = len(footerRow)
	}

	indent := " "
	rowClassAttr := tw.Empty
	if h.config.FooterRowClass != tw.Empty {
	rowClassAttr = fmt.Sprintf(` class="%s"`, h.config.FooterRowClass)
	}
	fmt.Fprintf(h.w, "%s<tr%s>", indent, rowClassAttr)

	renderedCols := 0
	for colIdx := 0; renderedCols < numCols && colIdx < numCols; {
	cellCtx, ok := ctx.Row.Current[colIdx]
	if !ok {
	cellCtx = tw.CellContext{Align: tw.AlignRight}
	}
	originalContent := tw.Empty
	if colIdx < len(footerRow) {
	originalContent = footerRow[colIdx]
	}

	tag, attributes, processedContent := h.renderRowCell(originalContent, cellCtx, false, colIdx)
	fmt.Fprintf(h.w, "<%s%s>%s</%s>", tag, attributes, processedContent, tag)
	renderedCols++

	hSpan := 1
	if cellCtx.Merge.Horizontal.Present && cellCtx.Merge.Horizontal.Start {
	hSpan = cellCtx.Merge.Horizontal.Span
	renderedCols += (hSpan - 1)
	}
	colIdx += hSpan
	}
	fmt.Fprintf(h.w, "</tr>\n")
	fmt.Fprintln(h.w, "</tfoot>")
	h.tfootStarted = false
	}

	// renderRowCell generates HTML for a single cell, handling content escaping, merges, and alignment.
	func (h *HTML) renderRowCell(originalContent string, cellCtx tw.CellContext, isHeader bool, colIdx int) (tag, attributes, processedContent string) {
	tag = "td"
	if isHeader {
	tag = "th"
	}

	// Process content
	processedContent = originalContent
	containsNewline := strings.Contains(originalContent, "\n")

	if h.config.EscapeContent {
	if containsNewline {
	const newlinePlaceholder = "[[--HTML_RENDERER_BR_PLACEHOLDER--]]"
	tempContent := strings.ReplaceAll(originalContent, "\n", newlinePlaceholder)
	escapedContent := html.EscapeString(tempContent)
	processedContent = strings.ReplaceAll(escapedContent, newlinePlaceholder, "<br>")
	} else {
	processedContent = html.EscapeString(originalContent)
	}
	} else if containsNewline {
	processedContent = strings.ReplaceAll(originalContent, "\n", "<br>")
	}

	if containsNewline && h.config.AddLinesTag {
	processedContent = "<lines>" + processedContent + "</lines>"
	}

	// Build attributes
	var attrBuilder strings.Builder
	merge := cellCtx.Merge

	if merge.Horizontal.Present && merge.Horizontal.Start && merge.Horizontal.Span > 1 {
	fmt.Fprintf(&attrBuilder, ` colspan="%d"`, merge.Horizontal.Span)
	}

	vSpan := 0
	if !isHeader {
	if merge.Vertical.Present && merge.Vertical.Start {
	vSpan = merge.Vertical.Span
	} else if merge.Hierarchical.Present && merge.Hierarchical.Start {
	vSpan = merge.Hierarchical.Span
	}
	if vSpan > 1 {
	fmt.Fprintf(&attrBuilder, ` rowspan="%d"`, vSpan)
	h.vMergeTrack[colIdx] = vSpan
	h.logger.Debugf("renderRowCell: Tracking rowspan=%d for col %d", vSpan, colIdx)
	}
	}

	if style := getHTMLStyle(cellCtx.Align); style != tw.Empty {
	attrBuilder.WriteString(style)
	}
	attributes = attrBuilder.String()
	return
	}

	// Line is a no-op for HTML rendering, as structural lines are handled by tags.
	func (h *HTML) Line(ctx tw.Formatting) {}

	// Reset clears the renderer's internal state, including debug traces and merge tracking.
	func (h *HTML) Reset() {
	h.logger.Debug("HTML.Reset() called.")
	h.tableStarted = false
	h.tbodyStarted = false
	h.tfootStarted = false
	h.vMergeTrack = make(map[int]int)
	h.trace = nil
	}

	// Close ensures all open HTML tags (<table>, <tbody>, <tfoot>) are properly closed.
	func (h *HTML) Close() error {
	if h.w == nil {
	return errors.New("HTML Renderer Close called on nil internal w")
	}

	if h.tableStarted {
	h.logger.Debug("HTML.Close() called.")
	h.closePreviousSection()
	h.logger.Debug("Closing <table> tag.")
	_, err := fmt.Fprintln(h.w, "</table>")
	h.tableStarted = false
	h.tbodyStarted = false
	h.tfootStarted = false
	h.vMergeTrack = make(map[int]int)
	return err
	}
	h.logger.Debug("HTML.Close() called, but table was not started (no-op).")
	return nil
	}