i++
                        column++
                    }
                }

                check(startLine >= 0 && startColumn >= 0 && endLine >= 0 && endColumn >= 0)
                return LineColumnInfo(startLine, startColumn, endLine, endColumn)
            }
        }
    }
}


internal
fun FlyweightCapableTreeStructure<LighterASTNode>.print(
    node: LighterASTNode = root,

		"ExecutingRequests",  // 6
		"DispatchedRequests", // 7
		"RejectedRequests",   // 8
		"TimedoutRequests",   // 9
		"CancelledRequests",  // 10
	}
	tabPrint(tabWriter, rowForHeaders(columnHeaders))
	endLine(tabWriter)
	plNames := make([]string, 0, len(cfgCtlr.priorityLevelStates))
	for plName := range cfgCtlr.priorityLevelStates {
		plNames = append(plNames, plName)
	}
	sort.Strings(plNames)
	for i := range plNames {

	pos := p.pos()

	// list can have wrong pos b/c extend dance.
	pos.EndLine = blocks[len(blocks)-1].Pos().EndLine
Loose:
	for i, c := range blocks {
		c := c.(*Item)
		if i+1 < len(blocks) {
			if blocks[i+1].Pos().StartLine-c.EndLine > 1 {
				b.loose = true
				break Loose
			}
		}
		for j, d := range c.Blocks {
			endLine := d.Pos().EndLine
			if j+1 < len(c.Blocks) {

		if !ok {
			break
		}
		s = s[skipSpace(s, end):]
	}

	if s == "" {
		return &Empty{p.pos()}
	}

	// Recompute EndLine because a line of b.text
	// might have been taken away to start a table.
	pos := p.pos()
	pos.EndLine = pos.StartLine + len(b.text) - 1
	return &Paragraph{
		pos,
		p.newText(pos, s),
	}
}

func newPara(p *parseState, s line) (line, bool) {

    }

    @Override
    public Optional<Integer> startColumn() {
        return delegate.startColumn();
    }

    @Override
    public Optional<Integer> endLine() {
        return delegate.endLine();
    }

    @Override
    public Optional<Integer> endColumn() {
        return delegate.endColumn();
    }

    @Override
    public String toString() {

	begSpecs := pos[0].Start
	endSpecs := pos[len(pos)-1].End
	beg := fset.File(begSpecs).LineStart(lineAt(fset, begSpecs))
	endLine := lineAt(fset, endSpecs)
	endFile := fset.File(endSpecs)
	var end token.Pos
	if endLine == endFile.LineCount() {
		end = endSpecs
	} else {
		end = endFile.LineStart(endLine + 1) // beginning of next line
	}
	first := len(f.Comments)
	last := -1
	for i, g := range f.Comments {

		return nil, err
	}

	var ret []Command
	for _, child := range res.AST.Children {
		cmd := Command{
			Cmd:       child.Value,
			Original:  child.Original,
			StartLine: child.StartLine,
			EndLine:   child.EndLine,
			Flags:     child.Flags,
		}

		// Only happens for ONBUILD
		if child.Next != nil && len(child.Next.Children) > 0 {
			cmd.SubCmd = child.Next.Children[0].Value
			child = child.Next.Children[0]

}

func (t *Table) printMarkdown(buf *bytes.Buffer, s mdState) {
}

func (b *tableBuilder) build(p buildState) Block {
	pos := p.pos()
	pos.StartLine-- // builder does not count header
	pos.EndLine = pos.StartLine + 1 + len(b.rows)
	t := &Table{
		Position: pos,
	}
	width := tableCount(b.hdr)
	t.Header = b.parseRow(p, b.hdr, pos.StartLine, width)
	t.Align = b.parseAlign(b.delim, width)

			for _, p := range b.Preds {
				pbi := p.Block().ID
				if !endlines[pbi].SameFileAndLine(firstPos) {
					b.Values[firstPosIndex].Pos = firstPos.WithIsStmt()
					if f.pass.debug > 0 {
						fmt.Printf("Mark stmt differing-pred %s %s %s %s, different=%s ending %s\n",
							f.Name, b, b.Values[firstPosIndex], flc(firstPos), p.Block(), flc(endlines[pbi]))
					}
					break
				}
			}
		}

Bálint Hegyi <******@****.***> 1695636814 +0200