package textproto

Import Path
	net/textproto (on go.dev)

Dependency Relation
	imports 10 packages, and imported by 5 packages

Involved Source Files

	    header.go
	    pipeline.go
	    reader.go
	  d textproto.go
		Package textproto implements generic support for text-based request/response
		protocols in the style of HTTP, NNTP, and SMTP.
		
		The package provides:
		
		Error, which represents a numeric error response from
		a server.
		
		Pipeline, to manage pipelined requests and responses
		in a client.
		
		Reader, to read numeric response code lines,
		key: value headers, lines wrapped with leading spaces
		on continuation lines, and whole text blocks ending
		with a dot on a line by itself.
		
		Writer, to write dot-encoded text blocks.
		
		Conn, a convenient packaging of Reader, Writer, and Pipeline for use
		with a single network connection.

	    writer.go
Package-Level Type Names (total 10, in which 7 are exported)

	/* sort exporteds by: alphabet | popularity */
	 type Conn (struct)
		A Conn represents a textual network protocol connection.
		It consists of a Reader and Writer to manage I/O
		and a Pipeline to sequence concurrent requests on the connection.
		These embedded types carry methods with them;
		see the documentation of those types for details.

		Fields (total 11, in which 5 are exported)
			Pipeline Pipeline
			Reader Reader
			Reader.R *bufio.Reader
			Writer Writer
			Writer.W *bufio.Writer
			/* 6 unexporteds ... *//* 6 unexporteds: */
			conn io.ReadWriteCloser
			Pipeline.id uint
			Pipeline.mu sync.Mutex
			Pipeline.request sequencer
			Pipeline.response sequencer
			Reader.buf []byte
				// a re-usable buffer for readContinuedLineSlice

		Methods (total 24, in which 19 are exported)
			(*Conn) Close() error
				Close closes the connection.

			(*Conn) Cmd(format string, args ...any) (id uint, err error)
				Cmd is a convenience method that sends a command after
				waiting its turn in the pipeline. The command text is the
				result of formatting format with args and appending \r\n.
				Cmd returns the id of the command, for use with StartResponse and EndResponse.
				
				For example, a client might run a HELP command that returns a dot-body
				by using:
				
					id, err := c.Cmd("HELP")
					if err != nil {
						return nil, err
					}
				
					c.StartResponse(id)
					defer c.EndResponse(id)
				
					if _, _, err = c.ReadCodeLine(110); err != nil {
						return nil, err
					}
					text, err := c.ReadDotBytes()
					if err != nil {
						return nil, err
					}
					return c.ReadCodeLine(250)

			(*Conn) DotReader() io.Reader
				DotReader returns a new Reader that satisfies Reads using the
				decoded text of a dot-encoded block read from r.
				The returned Reader is only valid until the next call
				to a method on r.
				
				Dot encoding is a common framing used for data blocks
				in text protocols such as SMTP.  The data consists of a sequence
				of lines, each of which ends in "\r\n".  The sequence itself
				ends at a line containing just a dot: ".\r\n".  Lines beginning
				with a dot are escaped with an additional dot to avoid
				looking like the end of the sequence.
				
				The decoded form returned by the Reader's Read method
				rewrites the "\r\n" line endings into the simpler "\n",
				removes leading dot escapes if present, and stops with error io.EOF
				after consuming (and discarding) the end-of-sequence line.

			(*Conn) DotWriter() io.WriteCloser
				DotWriter returns a writer that can be used to write a dot-encoding to w.
				It takes care of inserting leading dots when necessary,
				translating line-ending \n into \r\n, and adding the final .\r\n line
				when the DotWriter is closed. The caller should close the
				DotWriter before the next call to a method on w.
				
				See the documentation for Reader's DotReader method for details about dot-encoding.

			(*Conn) EndRequest(id uint)
				EndRequest notifies p that the request with the given id has been sent
				(or, if this is a server, received).

			(*Conn) EndResponse(id uint)
				EndResponse notifies p that the response with the given id has been received
				(or, if this is a server, sent).

			(*Conn) Next() uint
				Next returns the next id for a request/response pair.

			(*Conn) PrintfLine(format string, args ...any) error
				PrintfLine writes the formatted output followed by \r\n.

			(*Conn) ReadCodeLine(expectCode int) (code int, message string, err error)
				ReadCodeLine reads a response code line of the form
				
					code message
				
				where code is a three-digit status code and the message
				extends to the rest of the line. An example of such a line is:
				
					220 plan9.bell-labs.com ESMTP
				
				If the prefix of the status does not match the digits in expectCode,
				ReadCodeLine returns with err set to &Error{code, message}.
				For example, if expectCode is 31, an error will be returned if
				the status is not in the range [310,319].
				
				If the response is multi-line, ReadCodeLine returns an error.
				
				An expectCode <= 0 disables the check of the status code.

			(*Conn) ReadContinuedLine() (string, error)
				ReadContinuedLine reads a possibly continued line from r,
				eliding the final trailing ASCII white space.
				Lines after the first are considered continuations if they
				begin with a space or tab character. In the returned data,
				continuation lines are separated from the previous line
				only by a single space: the newline and leading white space
				are removed.
				
				For example, consider this input:
				
					Line 1
					  continued...
					Line 2
				
				The first call to ReadContinuedLine will return "Line 1 continued..."
				and the second will return "Line 2".
				
				Empty lines are never continued.

			(*Conn) ReadContinuedLineBytes() ([]byte, error)
				ReadContinuedLineBytes is like ReadContinuedLine but
				returns a []byte instead of a string.

			(*Conn) ReadDotBytes() ([]byte, error)
				ReadDotBytes reads a dot-encoding and returns the decoded data.
				
				See the documentation for the DotReader method for details about dot-encoding.

			(*Conn) ReadDotLines() ([]string, error)
				ReadDotLines reads a dot-encoding and returns a slice
				containing the decoded lines, with the final \r\n or \n elided from each.
				
				See the documentation for the DotReader method for details about dot-encoding.

			(*Conn) ReadLine() (string, error)
				ReadLine reads a single line from r,
				eliding the final \n or \r\n from the returned string.

			(*Conn) ReadLineBytes() ([]byte, error)
				ReadLineBytes is like ReadLine but returns a []byte instead of a string.

			(*Conn) ReadMIMEHeader() (MIMEHeader, error)
				ReadMIMEHeader reads a MIME-style header from r.
				The header is a sequence of possibly continued Key: Value lines
				ending in a blank line.
				The returned map m maps CanonicalMIMEHeaderKey(key) to a
				sequence of values in the same order encountered in the input.
				
				For example, consider this input:
				
					My-Key: Value 1
					Long-Key: Even
					       Longer Value
					My-Key: Value 2
				
				Given that input, ReadMIMEHeader returns the map:
				
					map[string][]string{
						"My-Key": {"Value 1", "Value 2"},
						"Long-Key": {"Even Longer Value"},
					}

			(*Conn) ReadResponse(expectCode int) (code int, message string, err error)
				ReadResponse reads a multi-line response of the form:
				
					code-message line 1
					code-message line 2
					...
					code message line n
				
				where code is a three-digit status code. The first line starts with the
				code and a hyphen. The response is terminated by a line that starts
				with the same code followed by a space. Each line in message is
				separated by a newline (\n).
				
				See page 36 of RFC 959 (https://www.ietf.org/rfc/rfc959.txt) for
				details of another form of response accepted:
				
					code-message line 1
					message line 2
					...
					code message line n
				
				If the prefix of the status does not match the digits in expectCode,
				ReadResponse returns with err set to &Error{code, message}.
				For example, if expectCode is 31, an error will be returned if
				the status is not in the range [310,319].
				
				An expectCode <= 0 disables the check of the status code.

			(*Conn) StartRequest(id uint)
				StartRequest blocks until it is time to send (or, if this is a server, receive)
				the request with the given id.

			(*Conn) StartResponse(id uint)
				StartResponse blocks until it is time to receive (or, if this is a server, send)
				the request with the given id.

			/* 5 unexporteds ... *//* 5 unexporteds: */
			(*Conn) readCodeLine(expectCode int) (code int, continued bool, message string, err error)
			(*Conn) readContinuedLineSlice(validateFirstLine func([]byte) error) ([]byte, error)
				readContinuedLineSlice reads continued lines from the reader buffer,
				returning a byte slice with all lines. The validateFirstLine function
				is run on the first read line, and if it returns an error then this
				error is returned from readContinuedLineSlice.

			(*Conn) readLineSlice() ([]byte, error)
			(*Conn) skipSpace() int
				skipSpace skips R over all spaces and returns the number of bytes skipped.

			(*Conn) upcomingHeaderKeys() (n int)
				upcomingHeaderKeys returns an approximation of the number of keys
				that will be in this header. If it gets confused, it returns 0.

		Implements (at least one exported)
			*Conn : io.Closer
		As Outputs Of (at least 2, both are exported)
			func Dial(network, addr string) (*Conn, error)
			func NewConn(conn io.ReadWriteCloser) *Conn

	 type Error (struct)
		An Error represents a numeric error response from a server.

		Fields (total 2, both are exported)
			Code int
			Msg string
		Methods (only one, which is exported)
			(*Error) Error() string
		Implements (at least one exported)
			*Error : error

	 type MIMEHeader (map)
		A MIMEHeader represents a MIME-style header mapping
		keys to sets of values.

		Methods (total 5, all are exported)
			( MIMEHeader) Add(key, value string)
				Add adds the key, value pair to the header.
				It appends to any existing values associated with key.

			( MIMEHeader) Del(key string)
				Del deletes the values associated with key.

			( MIMEHeader) Get(key string) string
				Get gets the first value associated with the given key.
				It is case insensitive; CanonicalMIMEHeaderKey is used
				to canonicalize the provided key.
				If there are no values associated with the key, Get returns "".
				To use non-canonical keys, access the map directly.

			( MIMEHeader) Set(key, value string)
				Set sets the header entries associated with key to
				the single element value. It replaces any existing
				values associated with key.

			( MIMEHeader) Values(key string) []string
				Values returns all values associated with the given key.
				It is case insensitive; CanonicalMIMEHeaderKey is
				used to canonicalize the provided key. To use non-canonical
				keys, access the map directly.
				The returned slice is not a copy.

		As Outputs Of (at least 3, in which 1 is exported)
			func (*Reader).ReadMIMEHeader() (MIMEHeader, error)
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func readMIMEHeader(r *Reader, maxMemory, maxHeaders int64) (MIMEHeader, error)
			func mime/multipart.readMIMEHeader(r *Reader, maxMemory, maxHeaders int64) (MIMEHeader, error)
		As Inputs Of (at least 2, in which 1 is exported)
			func mime/multipart.(*Writer).CreatePart(header MIMEHeader) (io.Writer, error)
			/* at least one unexported ... *//* at least one unexported: */
			func mime/multipart.mimeHeaderSize(h MIMEHeader) (size int64)

	 type Pipeline (struct)
		A Pipeline manages a pipelined in-order request/response sequence.
		
		To use a Pipeline p to manage multiple clients on a connection,
		each client should run:
		
			id := p.Next()	// take a number
		
			p.StartRequest(id)	// wait for turn to send request
			«send request»
			p.EndRequest(id)	// notify Pipeline that request is sent
		
			p.StartResponse(id)	// wait for turn to read response
			«read response»
			p.EndResponse(id)	// notify Pipeline that response is read
		
		A pipelined server can use the same calls to ensure that
		responses computed in parallel are written in the correct order.

		Fields (total 4, none are exported)
			/* 4 unexporteds ... *//* 4 unexporteds: */
			id uint
			mu sync.Mutex
			request sequencer
			response sequencer
		Methods (total 5, all are exported)
			(*Pipeline) EndRequest(id uint)
				EndRequest notifies p that the request with the given id has been sent
				(or, if this is a server, received).

			(*Pipeline) EndResponse(id uint)
				EndResponse notifies p that the response with the given id has been received
				(or, if this is a server, sent).

			(*Pipeline) Next() uint
				Next returns the next id for a request/response pair.

			(*Pipeline) StartRequest(id uint)
				StartRequest blocks until it is time to send (or, if this is a server, receive)
				the request with the given id.

			(*Pipeline) StartResponse(id uint)
				StartResponse blocks until it is time to receive (or, if this is a server, send)
				the request with the given id.


	 type ProtocolError string (basic type)
		A ProtocolError describes a protocol violation such
		as an invalid response or a hung-up connection.

		Methods (only one, which is exported)
			( ProtocolError) Error() string
		Implements (at least one exported)
			 ProtocolError : error

	 type Reader (struct)
		A Reader implements convenience methods for reading requests
		or responses from a text protocol network connection.

		Fields (total 3, in which 1 is exported)
			R *bufio.Reader
			/* 2 unexporteds ... *//* 2 unexporteds: */
			buf []byte
				// a re-usable buffer for readContinuedLineSlice

			dot *dotReader
		Methods (total 16, in which 10 are exported)
			(*Reader) DotReader() io.Reader
				DotReader returns a new Reader that satisfies Reads using the
				decoded text of a dot-encoded block read from r.
				The returned Reader is only valid until the next call
				to a method on r.
				
				Dot encoding is a common framing used for data blocks
				in text protocols such as SMTP.  The data consists of a sequence
				of lines, each of which ends in "\r\n".  The sequence itself
				ends at a line containing just a dot: ".\r\n".  Lines beginning
				with a dot are escaped with an additional dot to avoid
				looking like the end of the sequence.
				
				The decoded form returned by the Reader's Read method
				rewrites the "\r\n" line endings into the simpler "\n",
				removes leading dot escapes if present, and stops with error io.EOF
				after consuming (and discarding) the end-of-sequence line.

			(*Reader) ReadCodeLine(expectCode int) (code int, message string, err error)
				ReadCodeLine reads a response code line of the form
				
					code message
				
				where code is a three-digit status code and the message
				extends to the rest of the line. An example of such a line is:
				
					220 plan9.bell-labs.com ESMTP
				
				If the prefix of the status does not match the digits in expectCode,
				ReadCodeLine returns with err set to &Error{code, message}.
				For example, if expectCode is 31, an error will be returned if
				the status is not in the range [310,319].
				
				If the response is multi-line, ReadCodeLine returns an error.
				
				An expectCode <= 0 disables the check of the status code.

			(*Reader) ReadContinuedLine() (string, error)
				ReadContinuedLine reads a possibly continued line from r,
				eliding the final trailing ASCII white space.
				Lines after the first are considered continuations if they
				begin with a space or tab character. In the returned data,
				continuation lines are separated from the previous line
				only by a single space: the newline and leading white space
				are removed.
				
				For example, consider this input:
				
					Line 1
					  continued...
					Line 2
				
				The first call to ReadContinuedLine will return "Line 1 continued..."
				and the second will return "Line 2".
				
				Empty lines are never continued.

			(*Reader) ReadContinuedLineBytes() ([]byte, error)
				ReadContinuedLineBytes is like ReadContinuedLine but
				returns a []byte instead of a string.

			(*Reader) ReadDotBytes() ([]byte, error)
				ReadDotBytes reads a dot-encoding and returns the decoded data.
				
				See the documentation for the DotReader method for details about dot-encoding.

			(*Reader) ReadDotLines() ([]string, error)
				ReadDotLines reads a dot-encoding and returns a slice
				containing the decoded lines, with the final \r\n or \n elided from each.
				
				See the documentation for the DotReader method for details about dot-encoding.

			(*Reader) ReadLine() (string, error)
				ReadLine reads a single line from r,
				eliding the final \n or \r\n from the returned string.

			(*Reader) ReadLineBytes() ([]byte, error)
				ReadLineBytes is like ReadLine but returns a []byte instead of a string.

			(*Reader) ReadMIMEHeader() (MIMEHeader, error)
				ReadMIMEHeader reads a MIME-style header from r.
				The header is a sequence of possibly continued Key: Value lines
				ending in a blank line.
				The returned map m maps CanonicalMIMEHeaderKey(key) to a
				sequence of values in the same order encountered in the input.
				
				For example, consider this input:
				
					My-Key: Value 1
					Long-Key: Even
					       Longer Value
					My-Key: Value 2
				
				Given that input, ReadMIMEHeader returns the map:
				
					map[string][]string{
						"My-Key": {"Value 1", "Value 2"},
						"Long-Key": {"Even Longer Value"},
					}

			(*Reader) ReadResponse(expectCode int) (code int, message string, err error)
				ReadResponse reads a multi-line response of the form:
				
					code-message line 1
					code-message line 2
					...
					code message line n
				
				where code is a three-digit status code. The first line starts with the
				code and a hyphen. The response is terminated by a line that starts
				with the same code followed by a space. Each line in message is
				separated by a newline (\n).
				
				See page 36 of RFC 959 (https://www.ietf.org/rfc/rfc959.txt) for
				details of another form of response accepted:
				
					code-message line 1
					message line 2
					...
					code message line n
				
				If the prefix of the status does not match the digits in expectCode,
				ReadResponse returns with err set to &Error{code, message}.
				For example, if expectCode is 31, an error will be returned if
				the status is not in the range [310,319].
				
				An expectCode <= 0 disables the check of the status code.

			/* 6 unexporteds ... *//* 6 unexporteds: */
			(*Reader) closeDot()
				closeDot drains the current DotReader if any,
				making sure that it reads until the ending dot line.

			(*Reader) readCodeLine(expectCode int) (code int, continued bool, message string, err error)
			(*Reader) readContinuedLineSlice(validateFirstLine func([]byte) error) ([]byte, error)
				readContinuedLineSlice reads continued lines from the reader buffer,
				returning a byte slice with all lines. The validateFirstLine function
				is run on the first read line, and if it returns an error then this
				error is returned from readContinuedLineSlice.

			(*Reader) readLineSlice() ([]byte, error)
			(*Reader) skipSpace() int
				skipSpace skips R over all spaces and returns the number of bytes skipped.

			(*Reader) upcomingHeaderKeys() (n int)
				upcomingHeaderKeys returns an approximation of the number of keys
				that will be in this header. If it gets confused, it returns 0.

		As Outputs Of (at least 2, in which 1 is exported)
			func NewReader(r *bufio.Reader) *Reader
			/* at least one unexported ... *//* at least one unexported: */
			func net/http.newTextprotoReader(br *bufio.Reader) *Reader
		As Inputs Of (at least 3, none are exported)
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			func readMIMEHeader(r *Reader, maxMemory, maxHeaders int64) (MIMEHeader, error)
			func net/http.putTextprotoReader(r *Reader)
			func mime/multipart.readMIMEHeader(r *Reader, maxMemory, maxHeaders int64) (MIMEHeader, error)

	 type Writer (struct)
		A Writer implements convenience methods for writing
		requests or responses to a text protocol network connection.

		Fields (total 2, in which 1 is exported)
			W *bufio.Writer
			/* one unexported ... *//* one unexported: */
			dot *dotWriter
		Methods (total 3, in which 2 are exported)
			(*Writer) DotWriter() io.WriteCloser
				DotWriter returns a writer that can be used to write a dot-encoding to w.
				It takes care of inserting leading dots when necessary,
				translating line-ending \n into \r\n, and adding the final .\r\n line
				when the DotWriter is closed. The caller should close the
				DotWriter before the next call to a method on w.
				
				See the documentation for Reader's DotReader method for details about dot-encoding.

			(*Writer) PrintfLine(format string, args ...any) error
				PrintfLine writes the formatted output followed by \r\n.

			/* one unexported ... *//* one unexported: */
			(*Writer) closeDot()
		As Outputs Of (at least one exported)
			func NewWriter(w *bufio.Writer) *Writer

	/* 3 unexporteds ... *//* 3 unexporteds: */
	 type dotReader (struct)

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			r *Reader
			state int
		Methods (only one, which is exported)
			(*dotReader) Read(b []byte) (n int, err error)
				Read satisfies reads by decoding dot-encoded data read from d.r.

		Implements (at least one exported)
			*dotReader : io.Reader

	 type dotWriter (struct)

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			state int
			w *Writer
		Methods (total 2, both are exported)
			(*dotWriter) Close() error
			(*dotWriter) Write(b []byte) (n int, err error)
		Implements (at least 5, in which 4 are exported)
			*dotWriter : internal/bisect.Writer
			*dotWriter : io.Closer
			*dotWriter : io.WriteCloser
			*dotWriter : io.Writer
			/* at least one unexported ... *//* at least one unexported: */
			*dotWriter : crypto/tls.transcriptHash

	 type sequencer (struct)
		A sequencer schedules a sequence of numbered events that must
		happen in order, one after the other. The event numbering must start
		at 0 and increment without skipping. The event number wraps around
		safely as long as there are not 2^32 simultaneous events pending.

		Fields (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			id uint
			mu sync.Mutex
			wait map[uint]chan struct{}
		Methods (total 2, both are exported)
			(*sequencer) End(id uint)
				End notifies the sequencer that the event numbered id has completed,
				allowing it to schedule the event numbered id+1.  It is a run-time error
				to call End with an id that is not the number of the active event.

			(*sequencer) Start(id uint)
				Start waits until it is time for the event numbered id to begin.
				That is, except for the first event, it waits until End(id-1) has
				been called.



Package-Level Functions (total 18, in which 7 are exported)

	 func CanonicalMIMEHeaderKey(s string) string
		CanonicalMIMEHeaderKey returns the canonical format of the
		MIME header key s. The canonicalization converts the first
		letter and any letter following a hyphen to upper case;
		the rest are converted to lowercase. For example, the
		canonical key for "accept-encoding" is "Accept-Encoding".
		MIME header keys are assumed to be ASCII only.
		If s contains a space or invalid header field bytes, it is
		returned without modifications.

	 func Dial(network, addr string) (*Conn, error)
		Dial connects to the given address on the given network using net.Dial
		and then returns a new Conn for the connection.

	 func NewConn(conn io.ReadWriteCloser) *Conn
		NewConn returns a new Conn using conn for I/O.

	 func NewReader(r *bufio.Reader) *Reader
		NewReader returns a new Reader reading from r.
		
		To avoid denial of service attacks, the provided bufio.Reader
		should be reading from an io.LimitReader or similar Reader to bound
		the size of responses.

	 func NewWriter(w *bufio.Writer) *Writer
		NewWriter returns a new Writer writing to w.

	 func TrimBytes(b []byte) []byte
		TrimBytes returns b without leading and trailing ASCII space.

	 func TrimString(s string) string
		TrimString returns s without leading and trailing ASCII space.

	/* 11 unexporteds ... *//* 11 unexporteds: */
	 func canonicalMIMEHeaderKey(a []byte) (_ string, ok bool)
		canonicalMIMEHeaderKey is like CanonicalMIMEHeaderKey but is
		allowed to mutate the provided byte slice before returning the
		string.
		
		For invalid inputs (if a contains spaces or non-token bytes), a
		is unchanged and a string copy is returned.
		
		ok is true if the header key contains only valid characters and spaces.
		ReadMIMEHeader accepts header keys containing spaces, but does not
		canonicalize them.

	 func initCommonHeader()
	 func isASCIILetter(b byte) bool
	 func isASCIISpace(b byte) bool
	 func mustHaveFieldNameColon(line []byte) error
		mustHaveFieldNameColon ensures that, per RFC 7230, the
		field-name is on a single line, so the first line must
		contain a colon.

	 func noValidation(_ []byte) error
		noValidation is a no-op validation func for readContinuedLineSlice
		that permits any lines.

	 func parseCodeLine(line string, expectCode int) (code int, continued bool, message string, err error)
	 func readMIMEHeader(r *Reader, maxMemory, maxHeaders int64) (MIMEHeader, error)
		readMIMEHeader is a version of ReadMIMEHeader which takes a limit on the header size.
		It is called by the mime/multipart package.

	 func trim(s []byte) []byte
		trim returns s with leading and trailing spaces and tabs removed.
		It does not assume Unicode or UTF-8.

	 func validHeaderFieldByte(c byte) bool
		validHeaderFieldByte reports whether c is a valid byte in a header
		field name. RFC 7230 says:
		
			header-field   = field-name ":" OWS field-value OWS
			field-name     = token
			tchar = "!" / "#" / "$" / "%" / "&" / "'" / "*" / "+" / "-" / "." /
			        "^" / "_" / "`" / "|" / "~" / DIGIT / ALPHA
			token = 1*tchar

	 func validHeaderValueByte(c byte) bool
		validHeaderValueByte reports whether c is a valid byte in a header
		field value. RFC 7230 says:
		
			field-content  = field-vchar [ 1*( SP / HTAB ) field-vchar ]
			field-vchar    = VCHAR / obs-text
			obs-text       = %x80-FF
		
		RFC 5234 says:
		
			HTAB           =  %x09
			SP             =  %x20
			VCHAR          =  %x21-7E


Package-Level Variables (total 6, none are exported)

	/* 6 unexporteds ... *//* 6 unexporteds: */
	  var colon []byte
	  var commonHeader map[string]string
		commonHeader interns common header strings.

	  var commonHeaderOnce sync.Once
	  var crnl []byte
	  var dotcrnl []byte
	  var nl []byte
Package-Level Constants (total 5, none are exported)

	/* 5 unexporteds ... *//* 5 unexporteds: */
	const toLower = 32
	const wstateBegin = 0 // initial state; must be zero
	const wstateBeginLine = 1 // beginning of line
	const wstateCR = 2 // wrote \r (possibly at end of line)
	const wstateData = 3 // writing data in middle of line

The pages are generated with Golds v0.6.7. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.