package base64

Import Path
	github.com/segmentio/asm/base64 (on go.dev)

Dependency Relation
	imports 4 packages, and imported by one package

Involved Source Files

	    base64.go
	    base64_amd64.go
	    base64_asm.go
	    decode_amd64.go
	    encode_amd64.go
	    decode_amd64.s
	    encode_amd64.s
Package-Level Type Names (only one, which is exported)

	/* sort exporteds by: alphabet | popularity */
	 type Encoding (struct)
		An Encoding is a radix 64 encoding/decoding scheme, defined by a
		64-character alphabet.

		Fields (total 5, none are exported)
			/* 5 unexporteds ... *//* 5 unexporteds: */
			base *base64.Encoding
			dec func(dst []byte, src []byte, lut *int8) (int, int)
			declut [48]int8
			enc func(dst []byte, src []byte, lut *int8) (int, int)
			enclut [32]int8
		Methods (total 10, in which 8 are exported)
			(*Encoding) Decode(dst, src []byte) (n int, err error)
				Decode decodes src using the defined encoding alphabet.
				This will write DecodedLen(len(src)) bytes to dst and return the number of
				bytes written.

			(*Encoding) DecodeString(s string) ([]byte, error)
				DecodeString decodes the base64 encoded string s, returns the decoded
				value as bytes.

			(*Encoding) DecodedLen(n int) int
				DecodedLen calculates the decoded byte length for a base64-encoded message
				of length n.

			(*Encoding) Encode(dst, src []byte)
				Encode encodes src using the defined encoding alphabet.
				This will write EncodedLen(len(src)) bytes to dst.

			(*Encoding) EncodeToString(src []byte) string
				Encode encodes src using the encoding enc, writing
				EncodedLen(len(src)) bytes to dst.

			(*Encoding) EncodedLen(n int) int
				EncodedLen calculates the base64-encoded byte length for a message
				of length n.

			( Encoding) Strict() *Encoding
				Strict creates a duplicate encoding updated with strict decoding enabled.
				This requires that trailing padding bits are zero.

			( Encoding) WithPadding(padding rune) *Encoding
				WithPadding creates a duplicate Encoding updated with a specified padding
				character, or NoPadding to disable padding. The padding character must not
				be contained in the encoding alphabet, must not be '\r' or '\n', and must
				be no greater than '\xFF'.

			/* 2 unexporteds ... *//* 2 unexporteds: */
			(*Encoding) enableDecodeAVX2(encoder string)
			(*Encoding) enableEncodeAVX2(encoder string)
		As Outputs Of (at least 4, in which 3 are exported)
			func NewEncoding(encoder string) *Encoding
			func Encoding.Strict() *Encoding
			func Encoding.WithPadding(padding rune) *Encoding
			/* at least one unexported ... *//* at least one unexported: */
			func newEncoding(encoder string) *Encoding
		As Types Of (total 4, all are exported)
			  var RawStdEncoding *Encoding
			  var RawURLEncoding *Encoding
			  var StdEncoding *Encoding
			  var URLEncoding *Encoding


Package-Level Functions (total 5, in which 1 is exported)

	 func NewEncoding(encoder string) *Encoding
		NewEncoding returns a new padded Encoding defined by the given alphabet,
		which must be a 64-byte string that does not contain the padding character
		or CR / LF ('\r', '\n'). Unlike the standard library, the encoding alphabet
		cannot be abitrary, and it must follow one of the know standard encoding
		variants.
		
		Required alphabet values:
		    * [0,26):  characters 'A'..'Z'
		    * [26,52): characters 'a'..'z'
		    * [52,62): characters '0'..'9'
		Flexible alphabet value options:
		    * RFC 4648, RFC 1421, RFC 2045, RFC 2152, RFC 4880: '+' and '/'
		    * RFC 4648 URI: '-' and '_'
		    * RFC 3501: '+' and ','
		
		The resulting Encoding uses the default padding character ('='), which may
		be changed or disabled via WithPadding. The padding characters is urestricted,
		but it must be a character outside of the encoder alphabet.

	/* 4 unexporteds ... *//* 4 unexporteds: */
	 func decodeAVX2(dst []byte, src []byte, lut *int8) (int, int)
	 func decodeAVX2URI(dst []byte, src []byte, lut *int8) (int, int)
	 func encodeAVX2(dst []byte, src []byte, lut *int8) (int, int)
	 func newEncoding(encoder string) *Encoding
Package-Level Variables (total 5, in which 4 are exported)

	  var RawStdEncoding *Encoding
		RawStdEncoding is the standard unpadded base64 encoding defined in RFC 4648 section 3.2.
		This is the same as StdEncoding but omits padding characters.

	  var RawURLEncoding *Encoding
		RawURLEncoding is the unpadded alternate base64 encoding defined in RFC 4648.
		This is the same as URLEncoding but omits padding characters.

	  var StdEncoding *Encoding
		StdEncoding is the standard base64 encoding, as defined in RFC 4648.

	  var URLEncoding *Encoding
		URLEncoding is the alternate base64 encoding defined in RFC 4648.
		It is typically used in URLs and file names.

	/* one unexported ... *//* one unexported: */
	  var allowedEncoding map[string]struct{}
Package-Level Constants (total 10, in which 2 are exported)

	const NoPadding rune = -1
	const StdPadding rune = 61
	/* 8 unexporteds ... *//* 8 unexporteds: */
	const decLutSize = 48
	const encLutSize = 32
	const encodeIMAP = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+,"
	const encodeStd = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
	const encodeURL = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"
	const letterRange int8 = 26
	const minDecodeLen = 45
	const minEncodeLen = 28

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.