Function bodies 497 total

func (d *Document) LineCount() int {
	if len(d.Source) == 0 {
		return 0
	}
	lines := bytes.Count(d.Source, []byte("\n"))
	if d.Source[len(d.Source)-1] != '\n' {
		lines++
	}
	return lines
}

func (d *Document) File() (*lint.File, error) {
	if d.fileReady {
		return d.file, d.fileErr
	}

	f, err := lint.NewFile(d.Path, d.Source)
	if err != nil {
		d.fileErr = fmt.Errorf("parsing markdown: %w", err)
		d.fileReady = true
		return nil, d.fileErr
	}

	d.file = f
	d.fileReady = true
	return d.file, nil
}

func (d *Document) PlainText() (string, error) {
	if d.plainTextReady {
		return d.plainText, d.plainTextErr
	}

	f, err := d.File()
	if err != nil {
		d.plainTextErr = err
		d.plainTextReady = true
		return "", err
	}

	d.plainText = mdtext.ExtractPlainText(f.AST, f.Source)
	d.plainTextReady = true
	return d.plainText, nil
}

func (d *Document) WordCount() (int, error) {
	if d.wordCountReady {
		return d.wordCount, d.wordCountErr
	}

	text, err := d.PlainText()
	if err != nil {
		d.wordCountErr = err
		d.wordCountReady = true
		return 0, err
	}

	d.wordCount = mdtext.CountWords(text)
	d.wordCountReady = true
	return d.wordCount, nil
}

func (d *Document) HeadingCount() (int, error) {
	if d.headingCountReady {
		return d.headingCount, d.headingCountErr
	}

	f, err := d.File()
	if err != nil {
		d.headingCountErr = err
		d.headingCountReady = true
		return 0, err
	}

	count := 0
	_ = ast.Walk(f.AST, func(n ast.Node, entering bool) (ast.WalkStatus, error) {
		if entering {
			if _, ok := n.(*ast.Heading); ok {
				count++
			}
		}
		return ast.WalkContinue, nil
	})

	d.headingCount = count
	d.headingCountReady = true
	return d.headingCount, nil
}

func Collect(paths []string, defs []Definition) ([]Row, error) {
	rows := make([]Row, 0, len(paths))
	for _, path := range paths {
		source, err := os.ReadFile(path)
		if err != nil {
			return nil, fmt.Errorf("reading %q: %w", path, err)
		}

		doc := NewDocument(path, source)
		values := make(map[string]Value, len(defs))
		for _, def := range defs {
			v, err := def.Compute(doc)
			if err != nil {
				return nil, fmt.Errorf("computing %q for %q: %w", def.Name, path, err)
			}
			values[def.Name] = v
		}

		rows = append(rows, Row{
			Path:    path,
			Metrics: values,
		})
	}
	return rows, nil
}

func SortRows(rows []Row, by Definition, order Order) {
	sort.Slice(rows, func(i, j int) bool {
		a := rows[i].Metrics[by.Name]
		b := rows[j].Metrics[by.Name]

		// Available values sort before unavailable values.
		if a.Available != b.Available {
			return a.Available
		}

		if a.Available && b.Available {
			diff := a.Number - b.Number
			if math.Abs(diff) > 1e-9 {
				if order == OrderAsc {
					return diff < 0
				}
				return diff > 0
			}
		}

		// Stable deterministic tie-break.
		return rows[i].Path < rows[j].Path
	})
}

func LimitRows(rows []Row, top int) []Row {
	if top <= 0 || top >= len(rows) {
		return rows
	}
	return rows[:top]
}

func FormatValue(def Definition, value Value) string {
	v := JSONValue(def, value)
	if v == nil {
		return "-"
	}

	switch n := v.(type) {
	case int64:
		return strconv.FormatInt(n, 10)
	case float64:
		return fmt.Sprintf("%.*f", def.Precision, n)
	default:
		return "-"
	}
}

func JSONValue(def Definition, value Value) any {
	if !value.Available {
		return nil
	}

	switch def.Kind {
	case KindInteger:
		return int64(math.Round(value.Number))
	case KindFloat:
		if def.Precision < 0 {
			return value.Number
		}
		scale := math.Pow10(def.Precision)
		return math.Round(value.Number*scale) / scale
	default:
		return value.Number
	}
}

func All() []Definition {
	defs := append([]Definition(nil), registry...)
	sort.Slice(defs, func(i, j int) bool {
		return defs[i].ID < defs[j].ID
	})
	return defs
}

func ForScope(scope Scope) []Definition {
	all := All()
	defs := make([]Definition, 0, len(all))
	for _, def := range all {
		if def.Scope == scope {
			defs = append(defs, def)
		}
	}
	return defs
}

func Defaults(scope Scope) []Definition {
	defs := ForScope(scope)
	out := make([]Definition, 0, len(defs))
	for _, def := range defs {
		if def.Default {
			out = append(out, def)
		}
	}
	return out
}

func Lookup(query string) (Definition, bool) {
	for _, def := range All() {
		if matches(def, query) {
			return def, true
		}
	}
	return Definition{}, false
}

func LookupScope(scope Scope, query string) (Definition, bool) {
	for _, def := range ForScope(scope) {
		if matches(def, query) {
			return def, true
		}
	}
	return Definition{}, false
}

func Resolve(scope Scope, names []string) ([]Definition, error) {
	if len(names) == 0 {
		return Defaults(scope), nil
	}

	seen := make(map[string]struct{}, len(names))
	defs := make([]Definition, 0, len(names))
	for _, raw := range names {
		name := strings.TrimSpace(raw)
		if name == "" {
			continue
		}

		def, ok := LookupScope(scope, name)
		if !ok {
			return nil, unknownMetricErr(scope, name)
		}

		if _, exists := seen[def.ID]; exists {
			continue
		}
		seen[def.ID] = struct{}{}
		defs = append(defs, def)
	}

	if len(defs) == 0 {
		return nil, fmt.Errorf("no metrics selected")
	}
	return defs, nil
}

func SplitList(raw string) []string {
	if strings.TrimSpace(raw) == "" {
		return nil
	}
	parts := strings.Split(raw, ",")
	out := make([]string, 0, len(parts))
	for _, p := range parts {
		p = strings.TrimSpace(p)
		if p != "" {
			out = append(out, p)
		}
	}
	return out
}

func matches(def Definition, query string) bool {
	q := strings.TrimSpace(query)
	if q == "" {
		return false
	}
	return strings.EqualFold(def.ID, q) || def.Name == strings.ToLower(q)
}

func unknownMetricErr(scope Scope, name string) error {
	return fmt.Errorf(
		"unknown metric %q (available: %s)",
		name,
		strings.Join(availableNames(scope), ", "),
	)
}

func availableNames(scope Scope) []string {
	defs := ForScope(scope)
	names := make([]string, 0, len(defs))
	for _, def := range defs {
		names = append(names, def.Name)
	}
	sort.Strings(names)
	return names
}

func ParseScope(raw string) (Scope, error) {
	switch strings.ToLower(strings.TrimSpace(raw)) {
	case "", string(ScopeFile):
		return ScopeFile, nil
	default:
		return "", fmt.Errorf("unknown scope %q (supported: file)", raw)
	}
}

func ParseOrder(raw string) (Order, error) {
	switch strings.ToLower(strings.TrimSpace(raw)) {
	case "", string(OrderDesc):
		return OrderDesc, nil
	case string(OrderAsc):
		return OrderAsc, nil
	default:
		return "", fmt.Errorf("unknown order %q (supported: asc, desc)", raw)
	}
}

func AvailableValue(n float64) Value {
	return Value{
		Number:    n,
		Available: true,
	}
}

func (f *JSONFormatter) Format(w io.Writer, diagnostics []lint.Diagnostic) error {
	items := make([]jsonDiagnostic, 0, len(diagnostics))
	for _, d := range diagnostics {
		items = append(items, jsonDiagnostic{
			File:     d.File,
			Line:     d.Line,
			Column:   d.Column,
			Rule:     d.RuleID,
			Name:     d.RuleName,
			Severity: string(d.Severity),
			Message:  d.Message,
		})
	}
	enc := json.NewEncoder(w)
	enc.SetIndent("", "  ")
	return enc.Encode(items)
}

func (f *TextFormatter) Format(w io.Writer, diagnostics []lint.Diagnostic) error {
	for _, d := range diagnostics {
		var err error
		if f.Color {
			// file in cyan, rule in yellow
			_, err = fmt.Fprintf(w, "\033[36m%s:%d:%d\033[0m \033[33m%s\033[0m %s\n",
				d.File, d.Line, d.Column, d.RuleID, d.Message)
		} else {
			_, err = fmt.Fprintf(w, "%s:%d:%d %s %s\n",
				d.File, d.Line, d.Column, d.RuleID, d.Message)
		}
		if err != nil {
			return err
		}
	}
	return nil
}

func CloneRule(r Rule) Rule {
	if c, ok := r.(Configurable); ok {
		// Create a new zero-value instance of the same concrete type.
		rv := reflect.ValueOf(r)
		if rv.Kind() == reflect.Ptr {
			newPtr := reflect.New(rv.Elem().Type())
			clone := newPtr.Interface().(Rule)
			if cc, ok := clone.(Configurable); ok {
				_ = cc.ApplySettings(c.DefaultSettings())
			}
			return clone
		}
	}

	// Fallback: reflect-based copy for non-Configurable rules.
	rv := reflect.ValueOf(r)
	if rv.Kind() == reflect.Ptr {
		newPtr := reflect.New(rv.Elem().Type())
		newPtr.Elem().Set(rv.Elem())
		return newPtr.Interface().(Rule)
	}

	// Value type — already a copy.
	return r
}

func ByID(id string) Rule {
	for _, r := range registry {
		if r.ID() == id {
			return r
		}
	}
	return nil
}

func (r *Rule) Check(f *lint.File) []lint.Diagnostic {
	var diags []lint.Diagnostic

	_ = ast.Walk(f.AST, func(n ast.Node, entering bool) (ast.WalkStatus, error) {
		if !entering {
			return ast.WalkContinue, nil
		}
		fcb, ok := n.(*ast.FencedCodeBlock)
		if !ok {
			return ast.WalkContinue, nil
		}

		openStart, openEnd := fencedcodestyle.FenceOpenLineRange(f.Source, fcb)
		closeStart, _ := fencedcodestyle.FenceCloseLineRange(f.Source, fcb, openEnd)

		openLine := f.LineOfOffset(openStart)
		closeLine := f.LineOfOffset(closeStart)

		// Check blank line before opening fence
		if openLine > 1 {
			prevLineIdx := openLine - 2 // 0-based index of the line before
			if prevLineIdx >= 0 && prevLineIdx < len(f.Lines) {
				if !isBlank(f.Lines[prevLineIdx]) {
					diags = append(diags, lint.Diagnostic{
						File:     f.Path,
						Line:     openLine,
						Column:   1,
						RuleID:   r.ID(),
						RuleName: r.Name(),
						Severity: lint.Warning,
						Message:  "fenced code block should 

func (r *Rule) Fix(f *lint.File) []byte {
	insertBeforeLine, insertAfterLine := collectFenceBlankLineInsertions(f)

	if len(insertBeforeLine) == 0 && len(insertAfterLine) == 0 {
		return f.Source
	}

	var result []string
	for i, line := range f.Lines {
		lineNum := i + 1
		if insertBeforeLine[lineNum] {
			result = append(result, "")
		}
		result = append(result, string(line))
		if insertAfterLine[lineNum] {
			result = append(result, "")
		}
	}

	return []byte(strings.Join(result, "\n"))
}

func collectFenceBlankLineInsertions(f *lint.File) (beforeSet, afterSet map[int]bool) {
	beforeSet = make(map[int]bool)
	afterSet = make(map[int]bool)

	_ = ast.Walk(f.AST, func(n ast.Node, entering bool) (ast.WalkStatus, error) {
		if !entering {
			return ast.WalkContinue, nil
		}
		fcb, ok := n.(*ast.FencedCodeBlock)
		if !ok {
			return ast.WalkContinue, nil
		}

		openStart, openEnd := fencedcodestyle.FenceOpenLineRange(f.Source, fcb)
		closeStart, _ := fencedcodestyle.FenceCloseLineRange(f.Source, fcb, openEnd)

		openLine := f.LineOfOffset(openStart)
		closeLine := f.LineOfOffset(closeStart)

		if needsBlankBefore(f, openLine) {
			beforeSet[openLine] = true
		}
		if needsBlankAfter(f, closeLine) {
			afterSet[closeLine] = true
		}

		return ast.WalkContinue, nil
	})

	return beforeSet, afterSet
}

func needsBlankBefore(f *lint.File, line int) bool {
	if line <= 1 {
		return false
	}
	prevIdx := line - 2
	return prevIdx >= 0 && prevIdx < len(f.Lines) && !isBlank(f.Lines[prevIdx])
}

func (r *Rule) Check(f *lint.File) []lint.Diagnostic {
	var diags []lint.Diagnostic
	codeLines := lint.CollectCodeBlockLines(f)

	_ = ast.Walk(f.AST, func(n ast.Node, entering bool) (ast.WalkStatus, error) {
		if !entering {
			return ast.WalkContinue, nil
		}
		heading, ok := n.(*ast.Heading)
		if !ok {
			return ast.WalkContinue, nil
		}

		line := headingLine(heading, f)

		// Skip headings whose lines overlap with code block regions.
		if codeLines[line] {
			return ast.WalkContinue, nil
		}
		lastLine := headingLastLine(heading, f)

		// Check blank line before (not needed for line 1)
		if line > 1 {
			prevLineIdx := line - 2 // 0-based index
			if prevLineIdx >= 0 && prevLineIdx < len(f.Lines) {
				prevLine := strings.TrimSpace(string(f.Lines[prevLineIdx]))
				if prevLine != "" {
					diags = append(diags, lint.Diagnostic{
						File:     f.Path,
						Line:     line,
						Column:   1,
						RuleID:   r.ID(),
						RuleName: r.Name(),
						Severity: lint.Warning,
						Messa

func (r *Rule) Fix(f *lint.File) []byte {
	insertBefore, insertAfter := collectHeadingBlankLineInsertions(f)

	if len(insertBefore) == 0 && len(insertAfter) == 0 {
		return f.Source
	}

	lines := make([]string, len(f.Lines))
	for i, l := range f.Lines {
		lines[i] = string(l)
	}

	var result []string
	for i, line := range lines {
		lineNum := i + 1
		if insertBefore[lineNum] {
			// Avoid inserting a blank line if one was just inserted
			// after the previous line (prevents double blank lines).
			if !insertAfter[lineNum-1] {
				result = append(result, "")
			}
		}
		result = append(result, line)
		if insertAfter[lineNum] {
			result = append(result, "")
		}
	}

	return []byte(strings.Join(result, "\n"))
}

func collectHeadingBlankLineInsertions(f *lint.File) (insertBefore, insertAfter map[int]bool) {
	insertBefore = make(map[int]bool)
	insertAfter = make(map[int]bool)
	codeLines := lint.CollectCodeBlockLines(f)

	type headingInfo struct {
		line     int
		lastLine int
	}
	var headings []headingInfo

	_ = ast.Walk(f.AST, func(n ast.Node, entering bool) (ast.WalkStatus, error) {
		if !entering {
			return ast.WalkContinue, nil
		}
		heading, ok := n.(*ast.Heading)
		if !ok {
			return ast.WalkContinue, nil
		}
		line := headingLine(heading, f)
		if codeLines[line] {
			return ast.WalkContinue, nil
		}
		headings = append(headings, headingInfo{line: line, lastLine: headingLastLine(heading, f)})
		return ast.WalkContinue, nil
	})

	lines := f.Lines
	for _, h := range headings {
		if h.line > 1 && isNonBlankLine(lines, h.line-2) {
			insertBefore[h.line] = true
		}
		if isNonBlankLine(lines, h.lastLine) {
			insertAfter[h.lastLine] = true
		}
	}

	return insertBefore, insertAfter
}

func isNonBlankLine(lines [][]byte, idx int) bool {
	if idx < 0 || idx >= len(lines) {
		return false
	}
	return strings.TrimSpace(string(lines[idx])) != ""
}

func headingLine(heading *ast.Heading, f *lint.File) int {
	lines := heading.Lines()
	if lines.Len() > 0 {
		return f.LineOfOffset(lines.At(0).Start)
	}
	for c := heading.FirstChild(); c != nil; c = c.NextSibling() {
		if t, ok := c.(*ast.Text); ok {
			return f.LineOfOffset(t.Segment.Start)
		}
	}
	return 1
}

func headingLastLine(heading *ast.Heading, f *lint.File) int {
	lines := heading.Lines()
	if lines.Len() > 0 {
		// Setext headings: the underline is on the line after the text
		lastSeg := lines.At(lines.Len() - 1)
		textLine := f.LineOfOffset(lastSeg.Start)
		// Check if next line is an underline (setext)
		if isSetextHeading(heading, f.Source) {
			return textLine + 1
		}
		return textLine
	}
	// ATX heading is a single line
	return headingLine(heading, f)
}

func isSetextHeading(heading *ast.Heading, source []byte) bool {
	lines := heading.Lines()
	if lines.Len() == 0 {
		return false
	}
	seg := lines.At(0)
	lineStart := seg.Start
	for lineStart > 0 && source[lineStart-1] != '\n' {
		lineStart--
	}
	if lineStart < len(source) && source[lineStart] == '#' {
		return false
	}
	return true
}

func (r *Rule) Check(f *lint.File) []lint.Diagnostic {
	var diags []lint.Diagnostic
	codeLines := lint.CollectCodeBlockLines(f)

	_ = ast.Walk(f.AST, func(n ast.Node, entering bool) (ast.WalkStatus, error) {
		if !entering {
			return ast.WalkContinue, nil
		}

		list, ok := n.(*ast.List)
		if !ok {
			return ast.WalkContinue, nil
		}

		if _, isListItem := list.Parent().(*ast.ListItem); isListItem {
			return ast.WalkContinue, nil
		}

		listStartLine := lineOfNode(f, list)
		listEndLine := lastLineOfNode(f, list)

		if codeLines[listStartLine] || codeLines[listEndLine] {
			return ast.WalkContinue, nil
		}

		if d, ok := r.checkAdjacentBlank(f, listStartLine, -1, "list should be preceded by a blank line"); ok {
			diags = append(diags, d)
		}
		if d, ok := r.checkAdjacentBlank(f, listEndLine, +1, "list should be followed by a blank line"); ok {
			diags = append(diags, d)
		}

		return ast.WalkContinue, nil
	})

	return diags
}

func (r *Rule) checkAdjacentBlank(f *lint.File, targetLine, direction int, msg string) (lint.Diagnostic, bool) {
	totalLines := len(f.Lines)
	adjLine := targetLine + direction
	if adjLine < 1 || adjLine > totalLines {
		return lint.Diagnostic{}, false
	}
	if isBlank(f.Lines[adjLine-1]) {
		return lint.Diagnostic{}, false
	}
	return lint.Diagnostic{
		File:     f.Path,
		Line:     targetLine,
		Column:   1,
		RuleID:   r.ID(),
		RuleName: r.Name(),
		Severity: lint.Warning,
		Message:  msg,
	}, true
}

func isInlineNode(n ast.Node) bool {
	switch n.(type) {
	case *ast.Text, *ast.String, *ast.CodeSpan, *ast.Emphasis,
		*ast.Link, *ast.Image, *ast.AutoLink, *ast.RawHTML:
		return true
	}
	return false
}

func lineOfNode(f *lint.File, n ast.Node) int {
	// Inline nodes do not have Lines(); use Segment for Text nodes.
	if t, ok := n.(*ast.Text); ok {
		return f.LineOfOffset(t.Segment.Start)
	}
	if isInlineNode(n) {
		// For other inline nodes, recurse into children.
		if n.HasChildren() {
			for c := n.FirstChild(); c != nil; c = c.NextSibling() {
				line := lineOfNode(f, c)
				if line > 0 {
					return line
				}
			}
		}
		return 0
	}
	if n.Lines().Len() > 0 {
		seg := n.Lines().At(0)
		return f.LineOfOffset(seg.Start)
	}
	// For container nodes, find the first child with lines.
	if n.HasChildren() {
		for c := n.FirstChild(); c != nil; c = c.NextSibling() {
			line := lineOfNode(f, c)
			if line > 0 {
				return line
			}
		}
	}
	return 0
}

func lastLineOfNode(f *lint.File, n ast.Node) int {
	// Inline nodes do not have Lines(); use Segment for Text nodes.
	if t, ok := n.(*ast.Text); ok {
		return f.LineOfOffset(t.Segment.Stop - 1)
	}
	if isInlineNode(n) {
		if n.HasChildren() {
			for c := n.LastChild(); c != nil; c = c.PreviousSibling() {
				line := lastLineOfNode(f, c)
				if line > 0 {
					return line
				}
			}
		}
		return 0
	}
	if n.Lines().Len() > 0 {
		seg := n.Lines().At(n.Lines().Len() - 1)
		return f.LineOfOffset(seg.Start)
	}
	// For container nodes, find the last child with lines.
	if n.HasChildren() {
		for c := n.LastChild(); c != nil; c = c.PreviousSibling() {
			line := lastLineOfNode(f, c)
			if line > 0 {
				return line
			}
		}
	}
	return 0
}

func (r *Rule) Fix(f *lint.File) []byte {
	beforeSet, afterSet := r.collectBlankLineInsertions(f)

	if len(beforeSet) == 0 && len(afterSet) == 0 {
		result := make([]byte, len(f.Source))
		copy(result, f.Source)
		return result
	}

	var resultLines [][]byte
	for i, line := range f.Lines {
		lineNum := i + 1
		if beforeSet[lineNum] {
			resultLines = append(resultLines, []byte{})
		}
		resultLines = append(resultLines, line)
		if afterSet[lineNum] {
			resultLines = append(resultLines, []byte{})
		}
	}

	return bytes.Join(resultLines, []byte("\n"))
}

func (r *Rule) collectBlankLineInsertions(f *lint.File) (beforeSet, afterSet map[int]bool) {
	beforeSet = make(map[int]bool)
	afterSet = make(map[int]bool)
	codeLines := lint.CollectCodeBlockLines(f)

	_ = ast.Walk(f.AST, func(n ast.Node, entering bool) (ast.WalkStatus, error) {
		if !entering {
			return ast.WalkContinue, nil
		}

		list, ok := n.(*ast.List)
		if !ok {
			return ast.WalkContinue, nil
		}

		if _, isListItem := list.Parent().(*ast.ListItem); isListItem {
			return ast.WalkContinue, nil
		}

		listStartLine := lineOfNode(f, list)
		listEndLine := lastLineOfNode(f, list)

		if codeLines[listStartLine] || codeLines[listEndLine] {
			return ast.WalkContinue, nil
		}

		if needsBlankAdjacent(f, listStartLine, -1) {
			beforeSet[listStartLine] = true
		}
		if needsBlankAdjacent(f, listEndLine, +1) {
			afterSet[listEndLine] = true
		}

		return ast.WalkContinue, nil
	})

	return beforeSet, afterSet
}

func needsBlankAdjacent(f *lint.File, targetLine, direction int) bool {
	adjLine := targetLine + direction
	if adjLine < 1 || adjLine > len(f.Lines) {
		return false
	}
	return !isBlank(f.Lines[adjLine-1])
}

func renderTemplate(params map[string]string, entries []fileEntry, columns ...map[string]columnConfig) (string, error) {
	var buf strings.Builder

	header := params["header"]
	row := params["row"]
	footer := params["footer"]

	// Build column map from the row template if we have column constraints.
	var cols map[string]columnConfig
	var colMap map[int]string
	if len(columns) > 0 && columns[0] != nil && len(columns[0]) > 0 {
		cols = columns[0]
		colMap = buildColumnMap(row)
	}

	if header != "" {
		buf.WriteString(ensureTrailingNewline(header))
	}

	tmpl, err := template.New("row").Option("missingkey=zero").Parse(row)
	if err != nil {
		return "", err
	}

	for _, entry := range entries {
		var rowBuf bytes.Buffer
		if err := tmpl.Execute(&rowBuf, entry.fields); err != nil {
			return "", err
		}
		rendered := rowBuf.String()

		// Apply column constraints to table rows.
		if cols != nil && colMap != nil {
			rendered = applyColumnConstraints(rendered, cols, colMap)
		}

		buf.WriteStri

func renderMinimal(entries []fileEntry) string {
	var buf strings.Builder
	for _, entry := range entries {
		path := entry.fields["filename"]
		basename := filepath.Base(path)
		buf.WriteString("- [" + basename + "](" + path + ")\n")
	}
	return buf.String()
}

func renderEmpty(params map[string]string) string {
	empty := params["empty"]
	if empty == "" {
		return ""
	}
	return ensureTrailingNewline(empty)
}

func parseColumnConfig(raw map[string]any) map[string]columnConfig {
	gc := gensection.ParseColumnConfig(raw)
	if gc == nil {
		return nil
	}
	result := make(map[string]columnConfig, len(gc))
	for k, v := range gc {
		result[k] = columnConfig{
			maxWidth: v.MaxWidth,
			wrap:     v.Wrap,
		}
	}
	return result
}