package text

Import Path
	github.com/kr/text (on go.dev)

Dependency Relation
	imports 3 packages, and imported by one package

Involved Source Files

	   #d doc.go
		Package text provides rudimentary functions for manipulating text in
		paragraphs.

	      indent.go
	      wrap.go
Package-Level Type Names (only one, which is unexported)

	/* sort exporteds by: alphabet | popularity */
	/* one unexported ... *//* one unexported: */
	 type indentWriter (struct)
		Writer indents each line of its input.

		Fields (total 5, none are exported)
			/* 5 unexporteds ... *//* 5 unexporteds: */
			bol bool
			off int
			pre [][]byte
			sel int
			w io.Writer
		Methods (only one, which is exported)
			(*indentWriter) Write(p []byte) (n int, err error)
				The only errors returned are from the underlying indentWriter.

		Implements (at least one exported)
			*indentWriter : io.Writer


Package-Level Functions (total 6, all are exported)

	 func Indent(s, prefix string) string
		Indent inserts prefix at the beginning of each non-empty line of s. The
		end-of-line marker is NL.

	 func IndentBytes(b, prefix []byte) []byte
		IndentBytes inserts prefix at the beginning of each non-empty line of b.
		The end-of-line marker is NL.

	 func NewIndentWriter(w io.Writer, pre ...[]byte) io.Writer
		NewIndentWriter makes a new write filter that indents the input
		lines. Each line is prefixed in order with the corresponding
		element of pre. If there are more lines than elements, the last
		element of pre is repeated for each subsequent line.

	 func Wrap(s string, lim int) string
		Wrap wraps s into a paragraph of lines of length lim, with minimal
		raggedness.

	 func WrapBytes(b []byte, lim int) []byte
		WrapBytes wraps b into a paragraph of lines of length lim, with minimal
		raggedness.

	 func WrapWords(words [][]byte, spc, lim, pen int) [][][]byte
		WrapWords is the low-level line-breaking algorithm, useful if you need more
		control over the details of the text wrapping process. For most uses, either
		Wrap or WrapBytes will be sufficient and more convenient.

		WrapWords splits a list of words into lines with minimal "raggedness",
		treating each byte as one unit, accounting for spc units between adjacent
		words on each line, and attempting to limit lines to lim units. Raggedness
		is the total error over all lines, where error is the square of the
		difference of the length of the line and lim. Too-long lines (which only
		happen when a single word is longer than lim units) have pen penalty units
		added to the error.


Package-Level Variables (total 2, neither is exported)

	/* 2 unexporteds ... *//* 2 unexporteds: */
	  var nl []byte
	  var sp []byte
Package-Level Constants (only one, which is unexported)

	/* one unexported ... *//* one unexported: */
	const defaultPenalty = 100000

The pages are generated with Golds v0.4.9. (GOOS=linux GOARCH=amd64)