"author",
}

// Synopsis returns a cleaned version of the first sentence in text.
// That sentence ends after the first period followed by space and not
// preceded by exactly one uppercase letter, or at the first paragraph break.
// The result string has no \n, \r, or \t characters and uses only single
// spaces between words. If text starts with any of the [IllegalPrefixes],
// the result is the empty string.

			dumpNL(out, indent)
			dumpTo(out, indent, item)
		}

	case *ListItem:
		fmt.Fprintf(out, "Item Number=%q", x.Number)
		dumpTo(out, indent+1, x.Content)

	case *Paragraph:
		fmt.Fprintf(out, "Paragraph")
		dumpTo(out, indent+1, x.Text)

	case *Code:
		fmt.Fprintf(out, "Code")
		dumpTo(out, indent+1, x.Text)

	case []Text:
		for _, t := range x {
			dumpNL(out, indent)

	}
	return true
}

// block prints the block x to out.
func (p *commentPrinter) block(out *bytes.Buffer, x Block) {
	switch x := x.(type) {
	default:
		fmt.Fprintf(out, "?%T", x)

	case *Paragraph:
		p.text(out, "", x.Text)
		out.WriteString("\n")

	case *Heading:
		out.WriteString("# ")
		p.text(out, "", x.Text)
		out.WriteString("\n")

	case *Code:
		md := x.Text
		for md != "" {

		dumpBlock(b, depth)
	}
}

func dumpBlock(b md.Block, depth int) {
	typeName := strings.TrimPrefix(fmt.Sprintf("%T", b), "*markdown.")
	dprintf(depth, "%s\n", typeName)
	switch b := b.(type) {
	case *md.Paragraph:
		dumpInlines(b.Text.Inline, depth+1)
	case *md.Heading:
		dumpInlines(b.Text.Inline, depth+1)
	case *md.List:
		dumpBlocks(b.Items, depth+1)
	case *md.Item:
		dumpBlocks(b.Blocks, depth+1)
	default:

            if (propertyDoc.getDescription() == null) {
                throw new RuntimeException(String.format("Docbook content for '%s.%s' does not contain a description paragraph.", classDoc.getName(), propName));
            }

            props.put(propName, propertyDoc);
        }

        for (PropertyDoc propertyDoc : props.values()) {

        return sections[0]
    }

    Element getDescription() {
        if (comment.isEmpty() || comment[0].tagName != 'para') {
            throw new RuntimeException("Class $className does not have a description paragraph.")
        }
        return comment[0]
    }

    PropertyDoc findProperty(String name) {
        return classProperties.find { it.name == name }
    }

    BlockDoc getBlock(String name) {

                if (methodDoc.getDescription() == null) {
                    throw new RuntimeException(String.format("Docbook content for '%s %s' does not contain a description paragraph.", classDoc.getName(), method.getSignature()));
                }
                PropertyDoc property = classDoc.findProperty(methodName);
                boolean multiValued = false;

	return s[i+2 : j], s[:i]
}

func newSetextHeading(p *parseState, s line) (line, bool) {
	var n int
	peek := s
	if p.nextB() == p.para() && peek.trimSetext(&n) {
		p.closeBlock()
		para, ok := p.last().(*Paragraph)
		if !ok {
			return s, false
		}
		p.deleteLast()
		p.doneBlock(&Heading{Position{para.StartLine, p.lineno}, n, para.Text, ""})
		return line{}, true
	}
	return s, false
}

		}
		samples = samples[1:]
	}
}

func wrap(prefix, text string, width int) string {
	doc := &comment.Doc{Content: []comment.Block{&comment.Paragraph{Text: []comment.Text{comment.Plain(text)}}}}
	pr := &comment.Printer{TextPrefix: prefix, TextWidth: width}
	return string(pr.Text(doc))
}

func formatDesc(t *testing.T) string {
	var b strings.Builder

	}
	return out.Bytes()
}

// block prints the block x to out.
func (p *htmlPrinter) block(out *bytes.Buffer, x Block) {
	switch x := x.(type) {
	default:
		fmt.Fprintf(out, "?%T", x)

	case *Paragraph:
		if !p.tight {
			out.WriteString("<p>")
		}
		p.text(out, x.Text)
		out.WriteString("\n")

	case *Heading:
		out.WriteString("<h")
		h := strconv.Itoa(p.headingLevel())
		out.WriteString(h)