package idna

Import Path
	vendor/golang.org/x/net/idna (on golang.org and go.dev)

Dependency Relation
	imports 7 packages, and imported by 3 packages

Involved Source Files

	   d➜ idna10.0.0.go
		Package idna implements IDNA2008 using the compatibility processing
		defined by UTS (Unicode Technical Standard) #46, which defines a standard to
		deal with the transition from IDNA2003.

		IDNA2008 (Internationalized Domain Names for Applications), is defined in RFC
		5890, RFC 5891, RFC 5892, RFC 5893 and RFC 5894.
		UTS #46 is defined in https://www.unicode.org/reports/tr46.
		See https://unicode.org/cldr/utility/idna.jsp for a visualization of the
		differences between these two standards.

	      punycode.go
	      tables13.0.0.go
	      trie.go
	      trieval.go
Package-Level Type Names (total 12, in which 2 are exported)

	/* sort exporteds by: alphabet | popularity */
	 type Option (func)
		An Option configures a Profile at creation time.

		As Outputs Of (at least 8, all are exported)
			func BidiRule() Option
			func MapForLookup() Option
			func RemoveLeadingDots(remove bool) Option
			func StrictDomainName(use bool) Option
			func Transitional(transitional bool) Option
			func ValidateForRegistration() Option
			func ValidateLabels(enable bool) Option
			func VerifyDNSLength(verify bool) Option
		As Inputs Of (at least 2, in which 1 are exported)
			func New(o ...Option) *Profile
			/* at least one unexported ... *//* at least one unexported: */
			func apply(o *options, opts []Option)

	 type Profile (struct)
		A Profile defines the configuration of an IDNA mapper.

		Fields (total 10, none are exported)
			/* 10 unexporteds ... *//* 10 unexporteds: */
			options options
			options.bidirule func(s string) bool
				bidirule, if specified, checks whether s conforms to the Bidi Rule
				defined in RFC 5893.

			options.fromPuny func(p *Profile, s string) error
				fromPuny calls validation rules when converting A-labels to U-labels.

			options.mapping func(p *Profile, s string) (mapped string, isBidi bool, err error)
				mapping implements a validation and mapping step as defined in RFC 5895
				or UTS 46, tailored to, for example, domain registration or lookup.

			options.removeLeadingDots bool
			options.transitional bool
			options.trie *idnaTrie
			options.useSTD3Rules bool
			options.validateLabels bool
			options.verifyDNSLength bool
		Methods (total 6, in which 3 are exported)
			(*T) String() string
				String reports a string with a description of the profile for debugging
				purposes. The string format may change with different versions.

			(*T) ToASCII(s string) (string, error)
				ToASCII converts a domain or domain label to its ASCII form. For example,
				ToASCII("bücher.example.com") is "xn--bcher-kva.example.com", and
				ToASCII("golang") is "golang". If an error is encountered it will return
				an error and a (partially) processed result.

			(*T) ToUnicode(s string) (string, error)
				ToUnicode converts a domain or domain label to its Unicode form. For example,
				ToUnicode("xn--bcher-kva.example.com") is "bücher.example.com", and
				ToUnicode("golang") is "golang". If an error is encountered it will return
				an error and a (partially) processed result.

			/* 3 unexporteds ... *//* 3 unexporteds: */
			(*T) process(s string, toASCII bool) (string, error)
				process implements the algorithm described in section 4 of UTS #46,
				see https://www.unicode.org/reports/tr46.

			(*T) simplify(cat category) category
			(*T) validateLabel(s string) (err error)
				validateLabel validates the criteria from Section 4.1. Item 1, 4, and 6 are
				already implicitly satisfied by the overall implementation.

		Implements (at least 4, in which 1 are exported)
			*T : fmt.Stringer
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			*T : context.stringer
			*T : os/signal.stringer
			*T : runtime.stringer
		As Outputs Of (at least one exported)
			func New(o ...Option) *Profile
		As Inputs Of (at least 4, none are exported)
			/* 4+ unexporteds ... *//* 4+ unexporteds: */
			func normalize(p *Profile, s string) (mapped string, isBidi bool, err error)
			func validateAndMap(p *Profile, s string) (vm string, bidi bool, err error)
			func validateFromPunycode(p *Profile, s string) error
			func validateRegistration(p *Profile, s string) (idem string, bidi bool, err error)
		As Types Of (total 8, in which 4 are exported)
			  var Display *Profile
			  var Lookup *Profile
			  var Punycode *Profile
			  var Registration *Profile
			/* 4 unexporteds ... *//* 4 unexporteds: */
			  var display *Profile
			  var lookup *Profile
			  var punycode *Profile
			  var registration *Profile

	/* 10 unexporteds ... *//* 10 unexporteds: */
	 type category uint16 (basic type)
		A category corresponds to a category defined in the IDNA mapping table.

		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func (*Profile).simplify(cat category) category
		As Inputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func (*Profile).simplify(cat category) category
		As Types Of (total 10, none are exported)
			/* 10 unexporteds ... *//* 10 unexporteds: */
			const deviation
			const disallowed
			const disallowedSTD3Mapped
			const disallowedSTD3Valid
			const ignored
			const mapped
			const unknown
			const valid
			const validNV8
			const validXV8

	 type idnaTrie (struct)
		idnaTrie. Total size: 30288 bytes (29.58 KiB). Checksum: c0cd84404a2f6f19.

		Methods (total 5, none are exported)
			/* 5 unexporteds ... *//* 5 unexporteds: */
			(*T) lookup(s []byte) (v uint16, sz int)
				lookup returns the trie value for the first UTF-8 encoding in s and
				the width in bytes of this encoding. The size will be 0 if s does not
				hold enough bytes to complete the encoding. len(s) must be greater than 0.

			(*T) lookupString(s string) (v uint16, sz int)
				lookupString returns the trie value for the first UTF-8 encoding in s and
				the width in bytes of this encoding. The size will be 0 if s does not
				hold enough bytes to complete the encoding. len(s) must be greater than 0.

			(*T) lookupStringUnsafe(s string) uint16
				lookupStringUnsafe returns the trie value for the first UTF-8 encoding in s.
				s must start with a full and valid UTF-8 encoded rune.

			(*T) lookupUnsafe(s []byte) uint16
				lookupUnsafe returns the trie value for the first UTF-8 encoding in s.
				s must start with a full and valid UTF-8 encoded rune.

			(*T) lookupValue(n uint32, b byte) uint16
				lookupValue determines the type of block n and looks up the value for b.

		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func newIdnaTrie(i int) *idnaTrie
		As Types Of (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			  var trie *idnaTrie

	 type info uint16 (basic type)
		info holds information from the IDNA mapping table for a single rune. It is
		the value returned by a trie lookup. In most cases, all information fits in
		a 16-bit value. For mappings, this value may contain an index into a slice
		with the mapped string. Such mappings can consist of the actual mapped value
		or an XOR pattern to be applied to the bytes of the UTF8 encoding of the
		input rune. This technique is used by the cases packages and reduces the
		table size significantly.

		The per-rune values have the following format:

		  if mapped {
		    if inlinedXOR {
		      15..13 inline XOR marker
		      12..11 unused
		      10..3  inline XOR mask
		    } else {
		      15..3  index into xor or mapping table
		    }
		  } else {
		      15..14 unused
		      13     mayNeedNorm
		      12..11 attributes
		      10..8  joining type
		       7..3  category type
		  }
		     2  use xor pattern
		  1..0  mapped category

		See the definitions below for a more detailed description of the various
		bits.

		Methods (total 7, none are exported)
			/* 7 unexporteds ... *//* 7 unexporteds: */
			( T) appendMapping(b []byte, s string) []byte
				appendMapping appends the mapping for the respective rune. isMapped must be
				true. A mapping is a categorization of a rune as defined in UTS #46.

			( T) category() category
			( T) isBidi(s string) bool
			( T) isMapped() bool
			( T) isModifier() bool
			( T) isViramaModifier() bool
			( T) joinType() info

	 type joinState int8 (basic type)

		As Types Of (total 6, none are exported)
			/* 6 unexporteds ... *//* 6 unexporteds: */
			const stateAfter
			const stateBefore
			const stateBeforeVirama
			const stateFAIL
			const stateStart
			const stateVirama

	 type labelError (struct)

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			code_ string
			label string
		Methods (total 2, in which 1 are exported)
			( T) Error() string
			/* one unexported ... *//* one unexported: */
			( T) code() string
		Implements (at least one exported)
			 T : error

	 type labelIter (struct)
		A labelIter allows iterating over domain name labels.

		Fields (total 5, none are exported)
			/* 5 unexporteds ... *//* 5 unexporteds: */
			curEnd int
			curStart int
			i int
			orig string
			slice []string
		Methods (total 6, none are exported)
			/* 6 unexporteds ... *//* 6 unexporteds: */
			(*T) done() bool
			(*T) label() string
			(*T) next()
				next sets the value to the next label. It skips the last label if it is empty.

			(*T) reset()
			(*T) result() string
			(*T) set(s string)

	 type options (struct)

		Fields (total 9, none are exported)
			/* 9 unexporteds ... *//* 9 unexporteds: */
			bidirule func(s string) bool
				bidirule, if specified, checks whether s conforms to the Bidi Rule
				defined in RFC 5893.

			fromPuny func(p *Profile, s string) error
				fromPuny calls validation rules when converting A-labels to U-labels.

			mapping func(p *Profile, s string) (mapped string, isBidi bool, err error)
				mapping implements a validation and mapping step as defined in RFC 5895
				or UTS 46, tailored to, for example, domain registration or lookup.

			removeLeadingDots bool
			transitional bool
			trie *idnaTrie
			useSTD3Rules bool
			validateLabels bool
			verifyDNSLength bool
		As Inputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func apply(o *options, opts []Option)

	 type runeError rune (basic type)

		Methods (total 2, in which 1 are exported)
			( T) Error() string
			/* one unexported ... *//* one unexported: */
			( T) code() string
		Implements (at least one exported)
			 T : error

	 type sparseBlocks (struct)

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			offset []uint16
			values []valueRange
		Methods (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			(*T) lookup(n uint32, b byte) uint16
				lookup determines the type of block n and looks up the value for b.
				For n < t.cutoff, the block is a simple lookup table. Otherwise, the block
				is a list of ranges with an accompanying value. Given a matching range r,
				the value for b is by r.value + (b - r.lo) * stride.

		As Types Of (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			  var idnaSparse

	 type valueRange (struct)

		Fields (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			hi byte
				// header: lo:n

			lo byte
				// header: lo:n

			value uint16
				// header: value:stride



Package-Level Functions (total 24, in which 11 are exported)

	 func BidiRule() Option
		BidiRule enables the Bidi rule as defined in RFC 5893. Any application
		that relies on proper validation of labels should include this rule.

	 func MapForLookup() Option
		MapForLookup sets validation and mapping options such that a given IDN is
		transformed for domain name lookup according to the requirements set out in
		Section 5 of RFC 5891. The mappings follow the recommendations of RFC 5894,
		RFC 5895 and UTS 46. It does not add the Bidi Rule. Use the BidiRule option
		to add this check.

		The mappings include normalization and mapping case, width and other
		compatibility mappings.

	 func New(o ...Option) *Profile
		New creates a new Profile.

		With no options, the returned Profile is the most permissive and equals the
		Punycode Profile. Options can be passed to further restrict the Profile. The
		MapForLookup and ValidateForRegistration options set a collection of options,
		for lookup and registration purposes respectively, which can be tailored by
		adding more fine-grained options, where later options override earlier
		options.

	 func RemoveLeadingDots(remove bool) Option
		RemoveLeadingDots removes leading label separators. Leading runes that map to
		dots, such as U+3002 IDEOGRAPHIC FULL STOP, are removed as well.

		This is the behavior suggested by the UTS #46 and is adopted by some
		browsers.

	 func StrictDomainName(use bool) Option
		StrictDomainName limits the set of permissible ASCII characters to those
		allowed in domain names as defined in RFC 1034 (A-Z, a-z, 0-9 and the
		hyphen). This is set by default for MapForLookup and ValidateForRegistration.

		This option is useful, for instance, for browsers that allow characters
		outside this range, for example a '_' (U+005F LOW LINE). See
		http://www.rfc-editor.org/std/std3.txt for more details This option
		corresponds to the UseSTD3ASCIIRules option in UTS #46.

	 func ToASCII(s string) (string, error)
		ToASCII is a wrapper for Punycode.ToASCII.

	 func ToUnicode(s string) (string, error)
		ToUnicode is a wrapper for Punycode.ToUnicode.

	 func Transitional(transitional bool) Option
		Transitional sets a Profile to use the Transitional mapping as defined in UTS
		#46. This will cause, for example, "ß" to be mapped to "ss". Using the
		transitional mapping provides a compromise between IDNA2003 and IDNA2008
		compatibility. It is used by most browsers when resolving domain names. This
		option is only meaningful if combined with MapForLookup.

	 func ValidateForRegistration() Option
		ValidateForRegistration sets validation options to verify that a given IDN is
		properly formatted for registration as defined by Section 4 of RFC 5891.

	 func ValidateLabels(enable bool) Option
		ValidateLabels sets whether to check the mandatory label validation criteria
		as defined in Section 5.4 of RFC 5891. This includes testing for correct use
		of hyphens ('-'), normalization, validity of runes, and the context rules.

	 func VerifyDNSLength(verify bool) Option
		VerifyDNSLength sets whether a Profile should fail if any of the IDN parts
		are longer than allowed by the RFC.

	/* 13 unexporteds ... *//* 13 unexporteds: */
	 func adapt(delta, numPoints int32, firstTime bool) int32
		adapt is the bias adaptation function specified in section 6.1.

	 func apply(o *options, opts []Option)
	 func ascii(s string) bool
	 func decode(encoded string) (string, error)
		decode decodes a string as specified in section 6.2.

	 func decodeDigit(x byte) (digit int32, ok bool)
	 func encode(prefix, s string) (string, error)
		encode encodes a string as specified in section 6.3 and prepends prefix to
		the result.

		The "while h < length(input)" line in the specification becomes "for
		remaining != 0" in the Go code, because len(s) in Go is in bytes, not runes.

	 func encodeDigit(digit int32) byte
	 func newIdnaTrie(i int) *idnaTrie
	 func normalize(p *Profile, s string) (mapped string, isBidi bool, err error)
	 func punyError(s string) error
	 func validateAndMap(p *Profile, s string) (vm string, bidi bool, err error)
	 func validateFromPunycode(p *Profile, s string) error
	 func validateRegistration(p *Profile, s string) (idem string, bidi bool, err error)
Package-Level Variables (total 17, in which 4 are exported)

	  var Display *Profile
		Display is the recommended profile for displaying domain names.
		The configuration of this profile may change over time.

	  var Lookup *Profile
		Lookup is the recommended profile for looking up domain names, according
		to Section 5 of RFC 5891. The exact configuration of this profile may
		change over time.

	  var Punycode *Profile
		Punycode is a Profile that does raw punycode processing with a minimum
		of validation.

	  var Registration *Profile
		Registration is the recommended profile for checking whether a given
		IDN is valid for registration, according to Section 4 of RFC 5891.

	/* 13 unexporteds ... *//* 13 unexporteds: */
	  var display *Profile
	  var idnaIndex [2368]uint16
		idnaIndex: 37 blocks, 2368 entries, 4736 bytes
		Block 0 is the zero block.

	  var idnaSparse sparseBlocks
	  var idnaSparseOffset []uint16
		idnaSparseOffset: 292 entries, 584 bytes

	  var idnaSparseValues [2146]valueRange
		idnaSparseValues: 2146 entries, 8584 bytes

	  var idnaValues [8192]uint16
		idnaValues: 128 blocks, 8192 entries, 16384 bytes
		The third block is the zero block.

	  var joinStates [][8]joinState
	  var lookup *Profile
	  var mappings string
	  var punycode *Profile
	  var registration *Profile
	  var trie *idnaTrie
		Don't use newIdnaTrie to avoid unconditional linking in of the table.

	  var xorData string
Package-Level Constants (total 47, in which 1 are exported)

	const UnicodeVersion = "13.0.0"
		UnicodeVersion is the Unicode version from which the tables in this package are derived.

	/* 46 unexporteds ... *//* 46 unexporteds: */
	const acePrefix = "xn--"
		acePrefix is the ASCII Compatible Encoding prefix.

	const attributesMask = 6144
		Attributes

	const base int32 = 36
		These parameter values are specified in section 5.

		All computation is done with int32s, so that overflow behavior is identical
		regardless of whether int is 32-bit or 64-bit.

	const catBigMask = 248
	const catSmallMask = 3
	const damp int32 = 700
		These parameter values are specified in section 5.

		All computation is done with int32s, so that overflow behavior is identical
		regardless of whether int is 32-bit or 64-bit.

	const deviation category = 3
	const disallowed category = 64
	const disallowedSTD3Mapped category = 2
	const disallowedSTD3Valid category = 128
	const ignored category = 192
	const indexShift = 3
	const initialBias int32 = 72
		These parameter values are specified in section 5.

		All computation is done with int32s, so that overflow behavior is identical
		regardless of whether int is 32-bit or 64-bit.

	const initialN int32 = 128
		These parameter values are specified in section 5.

		All computation is done with int32s, so that overflow behavior is identical
		regardless of whether int is 32-bit or 64-bit.

	const inlineXOR = 57344 // These bits are set if the XOR pattern is inlined.
	const joiningD = 2
		join types and additional rune information

	const joiningL = 1
		join types and additional rune information

	const joiningR = 4
		join types and additional rune information

	const joiningT = 3
		join types and additional rune information

	const joinMask = 7
	const joinShift = 8
	const joinVirama = 7
		join types and additional rune information

	const joinZWJ = 5
		the following types are derived during processing

	const joinZWNJ = 6
		join types and additional rune information

	const mapped category = 1
	const mayNeedNorm = 8192
	const modifier = 4096
	const numJoinTypes = 8
		join types and additional rune information

	const rtl = 2048
	const skew int32 = 38
		These parameter values are specified in section 5.

		All computation is done with int32s, so that overflow behavior is identical
		regardless of whether int is 32-bit or 64-bit.

	const stateAfter joinState = 4
	const stateBefore joinState = 2
	const stateBeforeVirama joinState = 3
	const stateFAIL joinState = 5
	const stateStart joinState = 0
	const stateVirama joinState = 1
	const tmax int32 = 26
		These parameter values are specified in section 5.

		All computation is done with int32s, so that overflow behavior is identical
		regardless of whether int is 32-bit or 64-bit.

	const tmin int32 = 1
		These parameter values are specified in section 5.

		All computation is done with int32s, so that overflow behavior is identical
		regardless of whether int is 32-bit or 64-bit.

	const unknown category = 0 // not currently defined in unicode.
	const valid category = 8
	const validNV8 category = 24
	const validXV8 category = 40
	const viramaModifier = 6144
	const xorBit = 4 // interpret the index as an xor pattern
	const zwj = "\u200d"
	const zwnj = "\u200c"

The pages are generated with Golds v0.3.2. (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.