package mime

Import Path
	mime (on go.dev)

Dependency Relation
	imports 12 packages, and imported by 2 packages

Involved Source Files

	    encodedword.go
	    grammar.go
	    mediatype.go
	  d type.go
		Package mime implements parts of the MIME spec.

	    type_unix.go
Code Examples

	FormatMediaType
		package main
		
		import (
			"fmt"
			"mime"
		)
		
		func main() {
			mediatype := "text/html"
			params := map[string]string{
				"charset": "utf-8",
			}
		
			result := mime.FormatMediaType(mediatype, params)
		
			fmt.Println("result:", result)
		}

	ParseMediaType
		package main
		
		import (
			"fmt"
			"mime"
		)
		
		func main() {
			mediatype, params, err := mime.ParseMediaType("text/html; charset=utf-8")
			if err != nil {
				panic(err)
			}
		
			fmt.Println("type:", mediatype)
			fmt.Println("charset:", params["charset"])
		}

	WordDecoder_Decode
		package main
		
		import (
			"bytes"
			"fmt"
			"io"
			"mime"
		)
		
		func main() {
			dec := new(mime.WordDecoder)
			header, err := dec.Decode("=?utf-8?q?=C2=A1Hola,_se=C3=B1or!?=")
			if err != nil {
				panic(err)
			}
			fmt.Println(header)
		
			dec.CharsetReader = func(charset string, input io.Reader) (io.Reader, error) {
				switch charset {
				case "x-case":
					// Fake character set for example.
					// Real use would integrate with packages such
					// as code.google.com/p/go-charset
					content, err := io.ReadAll(input)
					if err != nil {
						return nil, err
					}
					return bytes.NewReader(bytes.ToUpper(content)), nil
				default:
					return nil, fmt.Errorf("unhandled charset %q", charset)
				}
			}
			header, err = dec.Decode("=?x-case?q?hello!?=")
			if err != nil {
				panic(err)
			}
			fmt.Println(header)
		}

	WordDecoder_DecodeHeader
		package main
		
		import (
			"bytes"
			"fmt"
			"io"
			"mime"
		)
		
		func main() {
			dec := new(mime.WordDecoder)
			header, err := dec.DecodeHeader("=?utf-8?q?=C3=89ric?= <eric@example.org>, =?utf-8?q?Ana=C3=AFs?= <anais@example.org>")
			if err != nil {
				panic(err)
			}
			fmt.Println(header)
		
			header, err = dec.DecodeHeader("=?utf-8?q?=C2=A1Hola,?= =?utf-8?q?_se=C3=B1or!?=")
			if err != nil {
				panic(err)
			}
			fmt.Println(header)
		
			dec.CharsetReader = func(charset string, input io.Reader) (io.Reader, error) {
				switch charset {
				case "x-case":
					// Fake character set for example.
					// Real use would integrate with packages such
					// as code.google.com/p/go-charset
					content, err := io.ReadAll(input)
					if err != nil {
						return nil, err
					}
					return bytes.NewReader(bytes.ToUpper(content)), nil
				default:
					return nil, fmt.Errorf("unhandled charset %q", charset)
				}
			}
			header, err = dec.DecodeHeader("=?x-case?q?hello_?= =?x-case?q?world!?=")
			if err != nil {
				panic(err)
			}
			fmt.Println(header)
		}

	WordEncoder_Encode
		package main
		
		import (
			"fmt"
			"mime"
		)
		
		func main() {
			fmt.Println(mime.QEncoding.Encode("utf-8", "¡Hola, señor!"))
			fmt.Println(mime.QEncoding.Encode("utf-8", "Hello!"))
			fmt.Println(mime.BEncoding.Encode("UTF-8", "¡Hola, señor!"))
			fmt.Println(mime.QEncoding.Encode("ISO-8859-1", "Caf\xE9"))
		}


Package-Level Type Names (total 2, both are exported)

	/* sort exporteds by: alphabet | popularity */
	 type WordDecoder (struct)
		A WordDecoder decodes MIME headers containing RFC 2047 encoded-words.

		Fields (only one, which is exported)
			CharsetReader func(charset string, input io.Reader) (io.Reader, error)
				CharsetReader, if non-nil, defines a function to generate
				charset-conversion readers, converting from the provided
				charset into UTF-8.
				Charsets are always lower-case. utf-8, iso-8859-1 and us-ascii charsets
				are handled by default.
				One of the CharsetReader's result values must be non-nil.

		Methods (total 3, in which 2 are exported)
			(*WordDecoder) Decode(word string) (string, error)
				Decode decodes an RFC 2047 encoded-word.

			(*WordDecoder) DecodeHeader(header string) (string, error)
				DecodeHeader decodes all encoded-words of the given string. It returns an
				error if and only if CharsetReader of d returns an error.

			/* one unexported ... *//* one unexported: */
			(*WordDecoder) convert(buf *strings.Builder, charset string, content []byte) error

	 type WordEncoder byte (basic type)
		A WordEncoder is an RFC 2047 encoded-word encoder.

		Methods (total 6, in which 1 is exported)
			( WordEncoder) Encode(charset, s string) string
				Encode returns the encoded-word form of s. If s is ASCII without special
				characters, it is returned unchanged. The provided charset is the IANA
				charset name of s. It is case insensitive.

			/* 5 unexporteds ... *//* 5 unexporteds: */
			( WordEncoder) bEncode(buf *strings.Builder, charset, s string)
				bEncode encodes s using base64 encoding and writes it to buf.

			( WordEncoder) encodeWord(charset, s string) string
				encodeWord encodes a string into an encoded-word.

			( WordEncoder) openWord(buf *strings.Builder, charset string)
				openWord writes the beginning of an encoded-word into buf.

			( WordEncoder) qEncode(buf *strings.Builder, charset, s string)
				qEncode encodes s using Q encoding and writes it to buf. It splits the
				encoded-words when necessary.

			( WordEncoder) splitWord(buf *strings.Builder, charset string)
				splitWord closes the current encoded-word and opens a new one.

		As Types Of (total 2, both are exported)
			const BEncoding
			const QEncoding


Package-Level Functions (total 35, in which 5 are exported)

	 func AddExtensionType(ext, typ string) error
		AddExtensionType sets the MIME type associated with
		the extension ext to typ. The extension should begin with
		a leading dot, as in ".html".

	 func ExtensionsByType(typ string) ([]string, error)
		ExtensionsByType returns the extensions known to be associated with the MIME
		type typ. The returned extensions will each begin with a leading dot, as in
		".html". When typ has no associated extensions, ExtensionsByType returns an
		nil slice.

	 func FormatMediaType(t string, param map[string]string) string
		FormatMediaType serializes mediatype t and the parameters
		param as a media type conforming to RFC 2045 and RFC 2616.
		The type and parameter names are written in lower-case.
		When any of the arguments result in a standard violation then
		FormatMediaType returns the empty string.

	 func ParseMediaType(v string) (mediatype string, params map[string]string, err error)
		ParseMediaType parses a media type value and any optional
		parameters, per RFC 1521.  Media types are the values in
		Content-Type and Content-Disposition headers (RFC 2183).
		On success, ParseMediaType returns the media type converted
		to lowercase and trimmed of white space and a non-nil map.
		If there is an error parsing the optional parameter,
		the media type will be returned along with the error
		ErrInvalidMediaParameter.
		The returned map, params, maps from the lowercase
		attribute to the attribute value with its case preserved.

	 func TypeByExtension(ext string) string
		TypeByExtension returns the MIME type associated with the file extension ext.
		The extension ext should begin with a leading dot, as in ".html".
		When ext has no associated type, TypeByExtension returns "".
		
		Extensions are looked up first case-sensitively, then case-insensitively.
		
		The built-in table is small but on unix it is augmented by the local
		system's MIME-info database or mime.types file(s) if available under one or
		more of these names:
		
			/usr/local/share/mime/globs2
			/usr/share/mime/globs2
			/etc/mime.types
			/etc/apache2/mime.types
			/etc/apache/mime.types
		
		On Windows, MIME types are extracted from the registry.
		
		Text types have the charset parameter set to "utf-8" by default.

	/* 30 unexporteds ... *//* 30 unexporteds: */
	 func checkMediaTypeDisposition(s string) error
	 func clearSyncMap(m *sync.Map)
	 func closeWord(buf *strings.Builder)
		closeWord writes the end of an encoded-word into buf.

	 func consumeMediaParam(v string) (param, value, rest string)
	 func consumeToken(v string) (token, rest string)
		consumeToken consumes a token from the beginning of provided
		string, per RFC 2045 section 5.1 (referenced from 2183), and return
		the token consumed and the rest of the string. Returns ("", v) on
		failure to consume at least one character.

	 func consumeValue(v string) (value, rest string)
		consumeValue consumes a "value" per RFC 2045, where a value is
		either a 'token' or a 'quoted-string'.  On success, consumeValue
		returns the value consumed (and de-quoted/escaped, if a
		quoted-string) and the rest of the string. On failure, returns
		("", v).

	 func decode(encoding byte, text string) ([]byte, error)
	 func decode2231Enc(v string) (string, bool)
	 func fromHex(b byte) (byte, error)
	 func hasNonWhitespace(s string) bool
		hasNonWhitespace reports whether s (assumed to be ASCII) contains at least
		one byte of non-whitespace.

	 func init()
	 func initMime()
	 func initMimeForTests() map[string]string
	 func initMimeUnix()
	 func ishex(c byte) bool
	 func isNotTokenChar(r rune) bool
	 func isToken(s string) bool
		isToken reports whether s is a 'token' as defined by RFC 1521
		and RFC 2045.

	 func isTokenChar(r rune) bool
		isTokenChar reports whether rune is in 'token' as defined by RFC
		1521 and RFC 2045.

	 func isTSpecial(r rune) bool
		isTSpecial reports whether rune is in 'tspecials' as defined by RFC
		1521 and RFC 2045.

	 func isUTF8(charset string) bool
	 func loadMimeFile(filename string)
	 func loadMimeGlobsFile(filename string) error
	 func needsEncoding(s string) bool
	 func percentHexUnescape(s string) (string, error)
	 func qDecode(s string) ([]byte, error)
		qDecode decodes a Q encoded string.

	 func readHexByte(a, b byte) (byte, error)
		readHexByte returns the byte from its quoted-printable representation.

	 func setExtensionType(extension, mimeType string) error
	 func setMimeTypes(lowerExt, mixExt map[string]string)
		setMimeTypes is used by initMime's non-test path, and by tests.

	 func unhex(c byte) byte
	 func writeQString(buf *strings.Builder, s string)
		writeQString encodes s using Q encoding and writes it to buf.


Package-Level Variables (total 13, in which 1 is exported)

	  var ErrInvalidMediaParameter error
		ErrInvalidMediaParameter is returned by ParseMediaType if
		the media type value was found but there was an error parsing
		the optional parameters

	/* 12 unexporteds ... *//* 12 unexporteds: */
	  var builtinTypesLower map[string]string
	  var errInvalidWord error
	  var extensions sync.Map // map[string][]string; slice values are append-only.
	  var extensionsMu sync.Mutex // Guards stores (but not loads) on extensions.
		extensions maps from MIME type to list of lowercase file
		extensions: "image/jpeg" => [".jpg", ".jpeg"]

	  var maxBase64Len int
	  var mimeGlobs []string
		See https://specifications.freedesktop.org/shared-mime-info-spec/shared-mime-info-spec-0.21.html
		for the FreeDesktop Shared MIME-info Database specification.

	  var mimeTypes sync.Map // map[string]string; ".Z" => "application/x-compress"
	  var mimeTypesLower sync.Map // map[string]string; ".z" => "application/x-compress"
	  var once sync.Once // guards initMime
	  var osInitMime ()
	  var testInitMime ()
	  var typeFiles []string
		Common locations for mime.types files on unix.


Package-Level Constants (total 5, in which 2 are exported)

	const BEncoding WordEncoder = 98
		BEncoding represents Base64 encoding scheme as defined by RFC 2045.

	const QEncoding WordEncoder = 113
		QEncoding represents the Q-encoding scheme as defined by RFC 2047.

	/* 3 unexporteds ... *//* 3 unexporteds: */
	const maxContentLen int = 63
		maxContentLen is how much content can be encoded, ignoring the header and
		2-byte footer.

	const maxEncodedWordLen = 75
		The maximum length of an encoded-word is 75 characters.
		See RFC 2047, section 2.

	const upperhex = "0123456789ABCDEF"

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.