Add FeedIcon API call and update dependencies

vendor/golang.org/x/text/internal/export/idna/gen.go

@@ -100,7 +100,7 @@ func genTables() {
 	})
 
 	w := gen.NewCodeWriter()
-	defer w.WriteGoFile("tables.go", "idna")
+	defer w.WriteVersionedGoFile("tables.go", "idna")
 
 	gen.WriteUnicodeVersion(w)
 

vendor/golang.org/x/text/internal/export/idna/gen10.0.0_test.go

@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build go1.10
+
 package idna
 
 import (

vendor/golang.org/x/text/internal/export/idna/gen9.0.0_test.go

@@ -0,0 +1,84 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build !go1.10
+
+package idna
+
+import (
+	"testing"
+	"unicode"
+
+	"golang.org/x/text/internal/gen"
+	"golang.org/x/text/internal/testtext"
+	"golang.org/x/text/internal/ucd"
+)
+
+func TestTables(t *testing.T) {
+	testtext.SkipIfNotLong(t)
+
+	lookup := func(r rune) info {
+		v, _ := trie.lookupString(string(r))
+		return info(v)
+	}
+
+	ucd.Parse(gen.OpenUnicodeFile("idna", "", "IdnaMappingTable.txt"), func(p *ucd.Parser) {
+		r := p.Rune(0)
+		x := lookup(r)
+		if got, want := x.category(), catFromEntry(p); got != want {
+			t.Errorf("%U:category: got %x; want %x", r, got, want)
+		}
+
+		mapped := false
+		switch p.String(1) {
+		case "mapped", "disallowed_STD3_mapped", "deviation":
+			mapped = true
+		}
+		if x.isMapped() != mapped {
+			t.Errorf("%U:isMapped: got %v; want %v", r, x.isMapped(), mapped)
+		}
+		if !mapped {
+			return
+		}
+		want := string(p.Runes(2))
+		got := string(x.appendMapping(nil, string(r)))
+		if got != want {
+			t.Errorf("%U:mapping: got %+q; want %+q", r, got, want)
+		}
+
+		if x.isMapped() {
+			return
+		}
+		wantMark := unicode.In(r, unicode.Mark)
+		gotMark := x.isModifier()
+		if gotMark != wantMark {
+			t.Errorf("IsMark(%U) = %v; want %v", r, gotMark, wantMark)
+		}
+	})
+
+	ucd.Parse(gen.OpenUCDFile("UnicodeData.txt"), func(p *ucd.Parser) {
+		r := p.Rune(0)
+		x := lookup(r)
+		got := x.isViramaModifier()
+
+		const cccVirama = 9
+		want := p.Int(ucd.CanonicalCombiningClass) == cccVirama
+		if got != want {
+			t.Errorf("IsVirama(%U) = %v; want %v", r, got, want)
+		}
+	})
+
+	ucd.Parse(gen.OpenUCDFile("extracted/DerivedJoiningType.txt"), func(p *ucd.Parser) {
+		r := p.Rune(0)
+		x := lookup(r)
+		if x.isMapped() {
+			return
+		}
+		got := x.joinType()
+		want := joinType[p.String(1)]
+		if got != want {
+			t.Errorf("JoinType(%U) = %x; want %x", r, got, want)
+		}
+	})
+}

vendor/golang.org/x/text/internal/export/idna/idna10.0.0.go

@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build go1.10
 //go:generate go run gen.go gen_trieval.go gen_common.go
 
 // Package idna implements IDNA2008 using the compatibility processing

vendor/golang.org/x/text/internal/export/idna/idna10.0.0_test.go

@@ -0,0 +1,140 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build go1.10
+
+package idna
+
+import "testing"
+
+// TestLabelErrors tests strings returned in case of error. All results should
+// be identical to the reference implementation and can be verified at
+// http://unicode.org/cldr/utility/idna.jsp. The reference implementation,
+// however, seems to not display Bidi and ContextJ errors.
+//
+// In some cases the behavior of browsers is added as a comment. In all cases,
+// whenever a resolve search returns an error here, Chrome will treat the input
+// string as a search string (including those for Bidi and Context J errors),
+// unless noted otherwise.
+func TestLabelErrors(t *testing.T) {
+	encode := func(s string) string { s, _ = encode(acePrefix, s); return s }
+	type kind struct {
+		name string
+		f    func(string) (string, error)
+	}
+	punyA := kind{"PunycodeA", punycode.ToASCII}
+	resolve := kind{"ResolveA", Lookup.ToASCII}
+	display := kind{"ToUnicode", Display.ToUnicode}
+	p := New(VerifyDNSLength(true), MapForLookup(), BidiRule())
+	lengthU := kind{"CheckLengthU", p.ToUnicode}
+	lengthA := kind{"CheckLengthA", p.ToASCII}
+	p = New(MapForLookup(), StrictDomainName(false))
+	std3 := kind{"STD3", p.ToASCII}
+
+	testCases := []struct {
+		kind
+		input   string
+		want    string
+		wantErr string
+	}{
+		{lengthU, "", "", "A4"}, // From UTS 46 conformance test.
+		{lengthA, "", "", "A4"},
+
+		{lengthU, "xn--", "", "A4"},
+		{lengthU, "foo.xn--", "foo.", "A4"}, // TODO: is dropping xn-- correct?
+		{lengthU, "xn--.foo", ".foo", "A4"},
+		{lengthU, "foo.xn--.bar", "foo..bar", "A4"},
+
+		{display, "xn--", "", ""},
+		{display, "foo.xn--", "foo.", ""}, // TODO: is dropping xn-- correct?
+		{display, "xn--.foo", ".foo", ""},
+		{display, "foo.xn--.bar", "foo..bar", ""},
+
+		{lengthA, "a..b", "a..b", "A4"},
+		{punyA, ".b", ".b", ""},
+		// For backwards compatibility, the Punycode profile does not map runes.
+		{punyA, "\u3002b", "xn--b-83t", ""},
+		{punyA, "..b", "..b", ""},
+
+		{lengthA, ".b", ".b", "A4"},
+		{lengthA, "\u3002b", ".b", "A4"},
+		{lengthA, "..b", "..b", "A4"},
+		{lengthA, "b..", "b..", ""},
+
+		// Sharpened Bidi rules for Unicode 10.0.0. Apply for ALL labels in ANY
+		// of the labels is RTL.
+		{lengthA, "\ufe05\u3002\u3002\U0002603e\u1ce0", "..xn--t6f5138v", "A4"},
+		{lengthA, "FAX\u2a77\U0001d186\u3002\U0001e942\U000e0181\u180c", "", "B6"},
+
+		{resolve, "a..b", "a..b", ""},
+		// Note that leading dots are not stripped. This is to be consistent
+		// with the Punycode profile as well as the conformance test.
+		{resolve, ".b", ".b", ""},
+		{resolve, "\u3002b", ".b", ""},
+		{resolve, "..b", "..b", ""},
+		{resolve, "b..", "b..", ""},
+		{resolve, "\xed", "", "P1"},
+
+		// Raw punycode
+		{punyA, "", "", ""},
+		{punyA, "*.foo.com", "*.foo.com", ""},
+		{punyA, "Foo.com", "Foo.com", ""},
+
+		// STD3 rules
+		{display, "*.foo.com", "*.foo.com", "P1"},
+		{std3, "*.foo.com", "*.foo.com", ""},
+
+		// Don't map U+2490 (DIGIT NINE FULL STOP). This is the behavior of
+		// Chrome, Safari, and IE. Firefox will first map ⒐ to 9. and return
+		// lab9.be.
+		{resolve, "lab⒐be", "xn--labbe-zh9b", "P1"}, // encode("lab⒐be")
+		{display, "lab⒐be", "lab⒐be", "P1"},
+
+		{resolve, "plan⒐faß.de", "xn--planfass-c31e.de", "P1"}, // encode("plan⒐fass") + ".de"
+		{display, "Plan⒐faß.de", "plan⒐faß.de", "P1"},
+
+		// Chrome 54.0 recognizes the error and treats this input verbatim as a
+		// search string.
+		// Safari 10.0 (non-conform spec) decomposes "⒈" and computes the
+		// punycode on the result using transitional mapping.
+		// Firefox 49.0.1 goes haywire on this string and prints a bunch of what
+		// seems to be nested punycode encodings.
+		{resolve, "日本⒈co.ßßß.de", "xn--co-wuw5954azlb.ssssss.de", "P1"},
+		{display, "日本⒈co.ßßß.de", "日本⒈co.ßßß.de", "P1"},
+
+		{resolve, "a\u200Cb", "ab", ""},
+		{display, "a\u200Cb", "a\u200Cb", "C"},
+
+		{resolve, encode("a\u200Cb"), encode("a\u200Cb"), "C"},
+		{display, "a\u200Cb", "a\u200Cb", "C"},
+
+		{resolve, "grﻋﺮﺑﻲ.de", "xn--gr-gtd9a1b0g.de", "B"},
+		{
+			// Notice how the string gets transformed, even with an error.
+			// Chrome will use the original string if it finds an error, so not
+			// the transformed one.
+			display,
+			"gr\ufecb\ufeae\ufe91\ufef2.de",
+			"gr\u0639\u0631\u0628\u064a.de",
+			"B",
+		},
+
+		{resolve, "\u0671.\u03c3\u07dc", "xn--qib.xn--4xa21s", "B"}, // ٱ.σߜ
+		{display, "\u0671.\u03c3\u07dc", "\u0671.\u03c3\u07dc", "B"},
+
+		// normalize input
+		{resolve, "a\u0323\u0322", "xn--jta191l", ""}, // ạ̢
+		{display, "a\u0323\u0322", "\u1ea1\u0322", ""},
+
+		// Non-normalized strings are not normalized when they originate from
+		// punycode. Despite the error, Chrome, Safari and Firefox will attempt
+		// to look up the input punycode.
+		{resolve, encode("a\u0323\u0322") + ".com", "xn--a-tdbc.com", "V1"},
+		{display, encode("a\u0323\u0322") + ".com", "a\u0323\u0322.com", "V1"},
+	}
+
+	for _, tc := range testCases {
+		doTest(t, tc.f, tc.name, tc.input, tc.want, tc.wantErr)
+	}
+}

vendor/golang.org/x/text/internal/export/idna/idna9.0.0.go

@@ -0,0 +1,681 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build !go1.10
+//go:generate go run gen.go gen_trieval.go gen_common.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 http://www.unicode.org/reports/tr46.
+// See http://unicode.org/cldr/utility/idna.jsp for a visualization of the
+// differences between these two standards.
+package idna // import "golang.org/x/text/internal/export/idna"
+
+import (
+	"fmt"
+	"strings"
+	"unicode/utf8"
+
+	"golang.org/x/text/secure/bidirule"
+	"golang.org/x/text/unicode/norm"
+)
+
+// NOTE: Unlike common practice in Go APIs, the functions will return a
+// sanitized domain name in case of errors. Browsers sometimes use a partially
+// evaluated string as lookup.
+// TODO: the current error handling is, in my opinion, the least opinionated.
+// Other strategies are also viable, though:
+// Option 1) Return an empty string in case of error, but allow the user to
+//    specify explicitly which errors to ignore.
+// Option 2) Return the partially evaluated string if it is itself a valid
+//    string, otherwise return the empty string in case of error.
+// Option 3) Option 1 and 2.
+// Option 4) Always return an empty string for now and implement Option 1 as
+//    needed, and document that the return string may not be empty in case of
+//    error in the future.
+// I think Option 1 is best, but it is quite opinionated.
+
+// ToASCII is a wrapper for Punycode.ToASCII.
+func ToASCII(s string) (string, error) {
+	return Punycode.process(s, true)
+}
+
+// ToUnicode is a wrapper for Punycode.ToUnicode.
+func ToUnicode(s string) (string, error) {
+	return Punycode.process(s, false)
+}
+
+// An Option configures a Profile at creation time.
+type Option func(*options)
+
+// 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 Transitional(transitional bool) Option {
+	return func(o *options) { o.transitional = true }
+}
+
+// VerifyDNSLength sets whether a Profile should fail if any of the IDN parts
+// are longer than allowed by the RFC.
+func VerifyDNSLength(verify bool) Option {
+	return func(o *options) { o.verifyDNSLength = verify }
+}
+
+// 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 RemoveLeadingDots(remove bool) Option {
+	return func(o *options) { o.removeLeadingDots = remove }
+}
+
+// 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 ValidateLabels(enable bool) Option {
+	return func(o *options) {
+		// Don't override existing mappings, but set one that at least checks
+		// normalization if it is not set.
+		if o.mapping == nil && enable {
+			o.mapping = normalize
+		}
+		o.trie = trie
+		o.validateLabels = enable
+		o.fromPuny = validateFromPunycode
+	}
+}
+
+// StrictDomainName limits the set of permissable 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 StrictDomainName(use bool) Option {
+	return func(o *options) {
+		o.trie = trie
+		o.useSTD3Rules = use
+		o.fromPuny = validateFromPunycode
+	}
+}
+
+// NOTE: the following options pull in tables. The tables should not be linked
+// in as long as the options are not used.
+
+// BidiRule enables the Bidi rule as defined in RFC 5893. Any application
+// that relies on proper validation of labels should include this rule.
+func BidiRule() Option {
+	return func(o *options) { o.bidirule = bidirule.ValidString }
+}
+
+// ValidateForRegistration sets validation options to verify that a given IDN is
+// properly formatted for registration as defined by Section 4 of RFC 5891.
+func ValidateForRegistration() Option {
+	return func(o *options) {
+		o.mapping = validateRegistration
+		StrictDomainName(true)(o)
+		ValidateLabels(true)(o)
+		VerifyDNSLength(true)(o)
+		BidiRule()(o)
+	}
+}
+
+// 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 MapForLookup() Option {
+	return func(o *options) {
+		o.mapping = validateAndMap
+		StrictDomainName(true)(o)
+		ValidateLabels(true)(o)
+		RemoveLeadingDots(true)(o)
+	}
+}
+
+type options struct {
+	transitional      bool
+	useSTD3Rules      bool
+	validateLabels    bool
+	verifyDNSLength   bool
+	removeLeadingDots bool
+
+	trie *idnaTrie
+
+	// fromPuny calls validation rules when converting A-labels to U-labels.
+	fromPuny func(p *Profile, s string) error
+
+	// mapping implements a validation and mapping step as defined in RFC 5895
+	// or UTS 46, tailored to, for example, domain registration or lookup.
+	mapping func(p *Profile, s string) (string, error)
+
+	// bidirule, if specified, checks whether s conforms to the Bidi Rule
+	// defined in RFC 5893.
+	bidirule func(s string) bool
+}
+
+// A Profile defines the configuration of a IDNA mapper.
+type Profile struct {
+	options
+}
+
+func apply(o *options, opts []Option) {
+	for _, f := range opts {
+		f(o)
+	}
+}
+
+// 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 New(o ...Option) *Profile {
+	p := &Profile{}
+	apply(&p.options, o)
+	return p
+}
+
+// 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.
+func (p *Profile) ToASCII(s string) (string, error) {
+	return p.process(s, true)
+}
+
+// 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.
+func (p *Profile) ToUnicode(s string) (string, error) {
+	pp := *p
+	pp.transitional = false
+	return pp.process(s, false)
+}
+
+// String reports a string with a description of the profile for debugging
+// purposes. The string format may change with different versions.
+func (p *Profile) String() string {
+	s := ""
+	if p.transitional {
+		s = "Transitional"
+	} else {
+		s = "NonTransitional"
+	}
+	if p.useSTD3Rules {
+		s += ":UseSTD3Rules"
+	}
+	if p.validateLabels {
+		s += ":ValidateLabels"
+	}
+	if p.verifyDNSLength {
+		s += ":VerifyDNSLength"
+	}
+	return s
+}
+
+var (
+	// Punycode is a Profile that does raw punycode processing with a minimum
+	// of validation.
+	Punycode *Profile = punycode
+
+	// 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.
+	Lookup *Profile = lookup
+
+	// Display is the recommended profile for displaying domain names.
+	// The configuration of this profile may change over time.
+	Display *Profile = display
+
+	// Registration is the recommended profile for checking whether a given
+	// IDN is valid for registration, according to Section 4 of RFC 5891.
+	Registration *Profile = registration
+
+	punycode = &Profile{}
+	lookup   = &Profile{options{
+		transitional:      true,
+		useSTD3Rules:      true,
+		validateLabels:    true,
+		removeLeadingDots: true,
+		trie:              trie,
+		fromPuny:          validateFromPunycode,
+		mapping:           validateAndMap,
+		bidirule:          bidirule.ValidString,
+	}}
+	display = &Profile{options{
+		useSTD3Rules:      true,
+		validateLabels:    true,
+		removeLeadingDots: true,
+		trie:              trie,
+		fromPuny:          validateFromPunycode,
+		mapping:           validateAndMap,
+		bidirule:          bidirule.ValidString,
+	}}
+	registration = &Profile{options{
+		useSTD3Rules:    true,
+		validateLabels:  true,
+		verifyDNSLength: true,
+		trie:            trie,
+		fromPuny:        validateFromPunycode,
+		mapping:         validateRegistration,
+		bidirule:        bidirule.ValidString,
+	}}
+
+	// TODO: profiles
+	// Register: recommended for approving domain names: don't do any mappings
+	// but rather reject on invalid input. Bundle or block deviation characters.
+)
+
+type labelError struct{ label, code_ string }
+
+func (e labelError) code() string { return e.code_ }
+func (e labelError) Error() string {
+	return fmt.Sprintf("idna: invalid label %q", e.label)
+}
+
+type runeError rune
+
+func (e runeError) code() string { return "P1" }
+func (e runeError) Error() string {
+	return fmt.Sprintf("idna: disallowed rune %U", e)
+}
+
+// process implements the algorithm described in section 4 of UTS #46,
+// see http://www.unicode.org/reports/tr46.
+func (p *Profile) process(s string, toASCII bool) (string, error) {
+	var err error
+	if p.mapping != nil {
+		s, err = p.mapping(p, s)
+	}
+	// Remove leading empty labels.
+	if p.removeLeadingDots {
+		for ; len(s) > 0 && s[0] == '.'; s = s[1:] {
+		}
+	}
+	// It seems like we should only create this error on ToASCII, but the
+	// UTS 46 conformance tests suggests we should always check this.
+	if err == nil && p.verifyDNSLength && s == "" {
+		err = &labelError{s, "A4"}
+	}
+	labels := labelIter{orig: s}
+	for ; !labels.done(); labels.next() {
+		label := labels.label()
+		if label == "" {
+			// Empty labels are not okay. The label iterator skips the last
+			// label if it is empty.
+			if err == nil && p.verifyDNSLength {
+				err = &labelError{s, "A4"}
+			}
+			continue
+		}
+		if strings.HasPrefix(label, acePrefix) {
+			u, err2 := decode(label[len(acePrefix):])
+			if err2 != nil {
+				if err == nil {
+					err = err2
+				}
+				// Spec says keep the old label.
+				continue
+			}
+			labels.set(u)
+			if err == nil && p.validateLabels {
+				err = p.fromPuny(p, u)
+			}
+			if err == nil {
+				// This should be called on NonTransitional, according to the
+				// spec, but that currently does not have any effect. Use the
+				// original profile to preserve options.
+				err = p.validateLabel(u)
+			}
+		} else if err == nil {
+			err = p.validateLabel(label)
+		}
+	}
+	if toASCII {
+		for labels.reset(); !labels.done(); labels.next() {
+			label := labels.label()
+			if !ascii(label) {
+				a, err2 := encode(acePrefix, label)
+				if err == nil {
+					err = err2
+				}
+				label = a
+				labels.set(a)
+			}
+			n := len(label)
+			if p.verifyDNSLength && err == nil && (n == 0 || n > 63) {
+				err = &labelError{label, "A4"}
+			}
+		}
+	}
+	s = labels.result()
+	if toASCII && p.verifyDNSLength && err == nil {
+		// Compute the length of the domain name minus the root label and its dot.
+		n := len(s)
+		if n > 0 && s[n-1] == '.' {
+			n--
+		}
+		if len(s) < 1 || n > 253 {
+			err = &labelError{s, "A4"}
+		}
+	}
+	return s, err
+}
+
+func normalize(p *Profile, s string) (string, error) {
+	return norm.NFC.String(s), nil
+}
+
+func validateRegistration(p *Profile, s string) (string, error) {
+	if !norm.NFC.IsNormalString(s) {
+		return s, &labelError{s, "V1"}
+	}
+	for i := 0; i < len(s); {
+		v, sz := trie.lookupString(s[i:])
+		// Copy bytes not copied so far.
+		switch p.simplify(info(v).category()) {
+		// TODO: handle the NV8 defined in the Unicode idna data set to allow
+		// for strict conformance to IDNA2008.
+		case valid, deviation:
+		case disallowed, mapped, unknown, ignored:
+			r, _ := utf8.DecodeRuneInString(s[i:])
+			return s, runeError(r)
+		}
+		i += sz
+	}
+	return s, nil
+}
+
+func validateAndMap(p *Profile, s string) (string, error) {
+	var (
+		err error
+		b   []byte
+		k   int
+	)
+	for i := 0; i < len(s); {
+		v, sz := trie.lookupString(s[i:])
+		start := i
+		i += sz
+		// Copy bytes not copied so far.
+		switch p.simplify(info(v).category()) {
+		case valid:
+			continue
+		case disallowed:
+			if err == nil {
+				r, _ := utf8.DecodeRuneInString(s[start:])
+				err = runeError(r)
+			}
+			continue
+		case mapped, deviation:
+			b = append(b, s[k:start]...)
+			b = info(v).appendMapping(b, s[start:i])
+		case ignored:
+			b = append(b, s[k:start]...)
+			// drop the rune
+		case unknown:
+			b = append(b, s[k:start]...)
+			b = append(b, "\ufffd"...)
+		}
+		k = i
+	}
+	if k == 0 {
+		// No changes so far.
+		s = norm.NFC.String(s)
+	} else {
+		b = append(b, s[k:]...)
+		if norm.NFC.QuickSpan(b) != len(b) {
+			b = norm.NFC.Bytes(b)
+		}
+		// TODO: the punycode converters require strings as input.
+		s = string(b)
+	}
+	return s, err
+}
+
+// A labelIter allows iterating over domain name labels.
+type labelIter struct {
+	orig     string
+	slice    []string
+	curStart int
+	curEnd   int
+	i        int
+}
+
+func (l *labelIter) reset() {
+	l.curStart = 0
+	l.curEnd = 0
+	l.i = 0
+}
+
+func (l *labelIter) done() bool {
+	return l.curStart >= len(l.orig)
+}
+
+func (l *labelIter) result() string {
+	if l.slice != nil {
+		return strings.Join(l.slice, ".")
+	}
+	return l.orig
+}
+
+func (l *labelIter) label() string {
+	if l.slice != nil {
+		return l.slice[l.i]
+	}
+	p := strings.IndexByte(l.orig[l.curStart:], '.')
+	l.curEnd = l.curStart + p
+	if p == -1 {
+		l.curEnd = len(l.orig)
+	}
+	return l.orig[l.curStart:l.curEnd]
+}
+
+// next sets the value to the next label. It skips the last label if it is empty.
+func (l *labelIter) next() {
+	l.i++
+	if l.slice != nil {
+		if l.i >= len(l.slice) || l.i == len(l.slice)-1 && l.slice[l.i] == "" {
+			l.curStart = len(l.orig)
+		}
+	} else {
+		l.curStart = l.curEnd + 1
+		if l.curStart == len(l.orig)-1 && l.orig[l.curStart] == '.' {
+			l.curStart = len(l.orig)
+		}
+	}
+}
+
+func (l *labelIter) set(s string) {
+	if l.slice == nil {
+		l.slice = strings.Split(l.orig, ".")
+	}
+	l.slice[l.i] = s
+}
+
+// acePrefix is the ASCII Compatible Encoding prefix.
+const acePrefix = "xn--"
+
+func (p *Profile) simplify(cat category) category {
+	switch cat {
+	case disallowedSTD3Mapped:
+		if p.useSTD3Rules {
+			cat = disallowed
+		} else {
+			cat = mapped
+		}
+	case disallowedSTD3Valid:
+		if p.useSTD3Rules {
+			cat = disallowed
+		} else {
+			cat = valid
+		}
+	case deviation:
+		if !p.transitional {
+			cat = valid
+		}
+	case validNV8, validXV8:
+		// TODO: handle V2008
+		cat = valid
+	}
+	return cat
+}
+
+func validateFromPunycode(p *Profile, s string) error {
+	if !norm.NFC.IsNormalString(s) {
+		return &labelError{s, "V1"}
+	}
+	for i := 0; i < len(s); {
+		v, sz := trie.lookupString(s[i:])
+		if c := p.simplify(info(v).category()); c != valid && c != deviation {
+			return &labelError{s, "V6"}
+		}
+		i += sz
+	}
+	return nil
+}
+
+const (
+	zwnj = "\u200c"
+	zwj  = "\u200d"
+)
+
+type joinState int8
+
+const (
+	stateStart joinState = iota
+	stateVirama
+	stateBefore
+	stateBeforeVirama
+	stateAfter
+	stateFAIL
+)
+
+var joinStates = [][numJoinTypes]joinState{
+	stateStart: {
+		joiningL:   stateBefore,
+		joiningD:   stateBefore,
+		joinZWNJ:   stateFAIL,
+		joinZWJ:    stateFAIL,
+		joinVirama: stateVirama,
+	},
+	stateVirama: {
+		joiningL: stateBefore,
+		joiningD: stateBefore,
+	},
+	stateBefore: {
+		joiningL:   stateBefore,
+		joiningD:   stateBefore,
+		joiningT:   stateBefore,
+		joinZWNJ:   stateAfter,
+		joinZWJ:    stateFAIL,
+		joinVirama: stateBeforeVirama,
+	},
+	stateBeforeVirama: {
+		joiningL: stateBefore,
+		joiningD: stateBefore,
+		joiningT: stateBefore,
+	},
+	stateAfter: {
+		joiningL:   stateFAIL,
+		joiningD:   stateBefore,
+		joiningT:   stateAfter,
+		joiningR:   stateStart,
+		joinZWNJ:   stateFAIL,
+		joinZWJ:    stateFAIL,
+		joinVirama: stateAfter, // no-op as we can't accept joiners here
+	},
+	stateFAIL: {
+		0:          stateFAIL,
+		joiningL:   stateFAIL,
+		joiningD:   stateFAIL,
+		joiningT:   stateFAIL,
+		joiningR:   stateFAIL,
+		joinZWNJ:   stateFAIL,
+		joinZWJ:    stateFAIL,
+		joinVirama: stateFAIL,
+	},
+}
+
+// validateLabel validates the criteria from Section 4.1. Item 1, 4, and 6 are
+// already implicitly satisfied by the overall implementation.
+func (p *Profile) validateLabel(s string) error {
+	if s == "" {
+		if p.verifyDNSLength {
+			return &labelError{s, "A4"}
+		}
+		return nil
+	}
+	if p.bidirule != nil && !p.bidirule(s) {
+		return &labelError{s, "B"}
+	}
+	if !p.validateLabels {
+		return nil
+	}
+	trie := p.trie // p.validateLabels is only set if trie is set.
+	if len(s) > 4 && s[2] == '-' && s[3] == '-' {
+		return &labelError{s, "V2"}
+	}
+	if s[0] == '-' || s[len(s)-1] == '-' {
+		return &labelError{s, "V3"}
+	}
+	// TODO: merge the use of this in the trie.
+	v, sz := trie.lookupString(s)
+	x := info(v)
+	if x.isModifier() {
+		return &labelError{s, "V5"}
+	}
+	// Quickly return in the absence of zero-width (non) joiners.
+	if strings.Index(s, zwj) == -1 && strings.Index(s, zwnj) == -1 {
+		return nil
+	}
+	st := stateStart
+	for i := 0; ; {
+		jt := x.joinType()
+		if s[i:i+sz] == zwj {
+			jt = joinZWJ
+		} else if s[i:i+sz] == zwnj {
+			jt = joinZWNJ
+		}
+		st = joinStates[st][jt]
+		if x.isViramaModifier() {
+			st = joinStates[st][joinVirama]
+		}
+		if i += sz; i == len(s) {
+			break
+		}
+		v, sz = trie.lookupString(s[i:])
+		x = info(v)
+	}
+	if st == stateFAIL || st == stateAfter {
+		return &labelError{s, "C"}
+	}
+	return nil
+}
+
+func ascii(s string) bool {
+	for i := 0; i < len(s); i++ {
+		if s[i] >= utf8.RuneSelf {
+			return false
+		}
+	}
+	return true
+}

vendor/golang.org/x/text/internal/export/idna/idna9.0.0_test.go

@@ -0,0 +1,136 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build !go1.10
+
+package idna
+
+import "testing"
+
+// TestLabelErrors tests strings returned in case of error. All results should
+// be identical to the reference implementation and can be verified at
+// http://unicode.org/cldr/utility/idna.jsp. The reference implementation,
+// however, seems to not display Bidi and ContextJ errors.
+//
+// In some cases the behavior of browsers is added as a comment. In all cases,
+// whenever a resolve search returns an error here, Chrome will treat the input
+// string as a search string (including those for Bidi and Context J errors),
+// unless noted otherwise.
+func TestLabelErrors(t *testing.T) {
+	encode := func(s string) string { s, _ = encode(acePrefix, s); return s }
+	type kind struct {
+		name string
+		f    func(string) (string, error)
+	}
+	punyA := kind{"PunycodeA", punycode.ToASCII}
+	resolve := kind{"ResolveA", Lookup.ToASCII}
+	display := kind{"ToUnicode", Display.ToUnicode}
+	p := New(VerifyDNSLength(true), MapForLookup(), BidiRule())
+	lengthU := kind{"CheckLengthU", p.ToUnicode}
+	lengthA := kind{"CheckLengthA", p.ToASCII}
+	p = New(MapForLookup(), StrictDomainName(false))
+	std3 := kind{"STD3", p.ToASCII}
+
+	testCases := []struct {
+		kind
+		input   string
+		want    string
+		wantErr string
+	}{
+		{lengthU, "", "", "A4"}, // From UTS 46 conformance test.
+		{lengthA, "", "", "A4"},
+
+		{lengthU, "xn--", "", "A4"},
+		{lengthU, "foo.xn--", "foo.", "A4"}, // TODO: is dropping xn-- correct?
+		{lengthU, "xn--.foo", ".foo", "A4"},
+		{lengthU, "foo.xn--.bar", "foo..bar", "A4"},
+
+		{display, "xn--", "", ""},
+		{display, "foo.xn--", "foo.", ""}, // TODO: is dropping xn-- correct?
+		{display, "xn--.foo", ".foo", ""},
+		{display, "foo.xn--.bar", "foo..bar", ""},
+
+		{lengthA, "a..b", "a..b", "A4"},
+		{punyA, ".b", ".b", ""},
+		// For backwards compatibility, the Punycode profile does not map runes.
+		{punyA, "\u3002b", "xn--b-83t", ""},
+		{punyA, "..b", "..b", ""},
+		// Only strip leading empty labels for certain profiles. Stripping
+		// leading empty labels here but not for "empty" punycode above seems
+		// inconsistent, but seems to be applied by both the conformance test
+		// and Chrome. So we turn it off by default, support it as an option,
+		// and enable it in profiles where it seems commonplace.
+		{lengthA, ".b", "b", ""},
+		{lengthA, "\u3002b", "b", ""},
+		{lengthA, "..b", "b", ""},
+		{lengthA, "b..", "b..", ""},
+
+		{resolve, "a..b", "a..b", ""},
+		{resolve, ".b", "b", ""},
+		{resolve, "\u3002b", "b", ""},
+		{resolve, "..b", "b", ""},
+		{resolve, "b..", "b..", ""},
+
+		// Raw punycode
+		{punyA, "", "", ""},
+		{punyA, "*.foo.com", "*.foo.com", ""},
+		{punyA, "Foo.com", "Foo.com", ""},
+
+		// STD3 rules
+		{display, "*.foo.com", "*.foo.com", "P1"},
+		{std3, "*.foo.com", "*.foo.com", ""},
+
+		// Don't map U+2490 (DIGIT NINE FULL STOP). This is the behavior of
+		// Chrome, Safari, and IE. Firefox will first map ⒐ to 9. and return
+		// lab9.be.
+		{resolve, "lab⒐be", "xn--labbe-zh9b", "P1"}, // encode("lab⒐be")
+		{display, "lab⒐be", "lab⒐be", "P1"},
+
+		{resolve, "plan⒐faß.de", "xn--planfass-c31e.de", "P1"}, // encode("plan⒐fass") + ".de"
+		{display, "Plan⒐faß.de", "plan⒐faß.de", "P1"},
+
+		// Chrome 54.0 recognizes the error and treats this input verbatim as a
+		// search string.
+		// Safari 10.0 (non-conform spec) decomposes "⒈" and computes the
+		// punycode on the result using transitional mapping.
+		// Firefox 49.0.1 goes haywire on this string and prints a bunch of what
+		// seems to be nested punycode encodings.
+		{resolve, "日本⒈co.ßßß.de", "xn--co-wuw5954azlb.ssssss.de", "P1"},
+		{display, "日本⒈co.ßßß.de", "日本⒈co.ßßß.de", "P1"},
+
+		{resolve, "a\u200Cb", "ab", ""},
+		{display, "a\u200Cb", "a\u200Cb", "C"},
+
+		{resolve, encode("a\u200Cb"), encode("a\u200Cb"), "C"},
+		{display, "a\u200Cb", "a\u200Cb", "C"},
+
+		{resolve, "grﻋﺮﺑﻲ.de", "xn--gr-gtd9a1b0g.de", "B"},
+		{
+			// Notice how the string gets transformed, even with an error.
+			// Chrome will use the original string if it finds an error, so not
+			// the transformed one.
+			display,
+			"gr\ufecb\ufeae\ufe91\ufef2.de",
+			"gr\u0639\u0631\u0628\u064a.de",
+			"B",
+		},
+
+		{resolve, "\u0671.\u03c3\u07dc", "xn--qib.xn--4xa21s", "B"}, // ٱ.σߜ
+		{display, "\u0671.\u03c3\u07dc", "\u0671.\u03c3\u07dc", "B"},
+
+		// normalize input
+		{resolve, "a\u0323\u0322", "xn--jta191l", ""}, // ạ̢
+		{display, "a\u0323\u0322", "\u1ea1\u0322", ""},
+
+		// Non-normalized strings are not normalized when they originate from
+		// punycode. Despite the error, Chrome, Safari and Firefox will attempt
+		// to look up the input punycode.
+		{resolve, encode("a\u0323\u0322") + ".com", "xn--a-tdbc.com", "V1"},
+		{display, encode("a\u0323\u0322") + ".com", "a\u0323\u0322.com", "V1"},
+	}
+
+	for _, tc := range testCases {
+		doTest(t, tc.f, tc.name, tc.input, tc.want, tc.wantErr)
+	}
+}

vendor/golang.org/x/text/internal/export/idna/idna_test.go

@@ -101,137 +101,6 @@ func doTest(t *testing.T, f func(string) (string, error), name, input, want, err
 	})
 }
 
-// TestLabelErrors tests strings returned in case of error. All results should
-// be identical to the reference implementation and can be verified at
-// http://unicode.org/cldr/utility/idna.jsp. The reference implementation,
-// however, seems to not display Bidi and ContextJ errors.
-//
-// In some cases the behavior of browsers is added as a comment. In all cases,
-// whenever a resolve search returns an error here, Chrome will treat the input
-// string as a search string (including those for Bidi and Context J errors),
-// unless noted otherwise.
-func TestLabelErrors(t *testing.T) {
-	encode := func(s string) string { s, _ = encode(acePrefix, s); return s }
-	type kind struct {
-		name string
-		f    func(string) (string, error)
-	}
-	punyA := kind{"PunycodeA", punycode.ToASCII}
-	resolve := kind{"ResolveA", Lookup.ToASCII}
-	display := kind{"ToUnicode", Display.ToUnicode}
-	p := New(VerifyDNSLength(true), MapForLookup(), BidiRule())
-	lengthU := kind{"CheckLengthU", p.ToUnicode}
-	lengthA := kind{"CheckLengthA", p.ToASCII}
-	p = New(MapForLookup(), StrictDomainName(false))
-	std3 := kind{"STD3", p.ToASCII}
-
-	testCases := []struct {
-		kind
-		input   string
-		want    string
-		wantErr string
-	}{
-		{lengthU, "", "", "A4"}, // From UTS 46 conformance test.
-		{lengthA, "", "", "A4"},
-
-		{lengthU, "xn--", "", "A4"},
-		{lengthU, "foo.xn--", "foo.", "A4"}, // TODO: is dropping xn-- correct?
-		{lengthU, "xn--.foo", ".foo", "A4"},
-		{lengthU, "foo.xn--.bar", "foo..bar", "A4"},
-
-		{display, "xn--", "", ""},
-		{display, "foo.xn--", "foo.", ""}, // TODO: is dropping xn-- correct?
-		{display, "xn--.foo", ".foo", ""},
-		{display, "foo.xn--.bar", "foo..bar", ""},
-
-		{lengthA, "a..b", "a..b", "A4"},
-		{punyA, ".b", ".b", ""},
-		// For backwards compatibility, the Punycode profile does not map runes.
-		{punyA, "\u3002b", "xn--b-83t", ""},
-		{punyA, "..b", "..b", ""},
-
-		{lengthA, ".b", ".b", "A4"},
-		{lengthA, "\u3002b", ".b", "A4"},
-		{lengthA, "..b", "..b", "A4"},
-		{lengthA, "b..", "b..", ""},
-
-		// Sharpened Bidi rules for Unicode 10.0.0. Apply for ALL labels in ANY
-		// of the labels is RTL.
-		{lengthA, "\ufe05\u3002\u3002\U0002603e\u1ce0", "..xn--t6f5138v", "A4"},
-		{lengthA, "FAX\u2a77\U0001d186\u3002\U0001e942\U000e0181\u180c", "", "B6"},
-
-		{resolve, "a..b", "a..b", ""},
-		// Note that leading dots are not stripped. This is to be consistent
-		// with the Punycode profile as well as the conformance test.
-		{resolve, ".b", ".b", ""},
-		{resolve, "\u3002b", ".b", ""},
-		{resolve, "..b", "..b", ""},
-		{resolve, "b..", "b..", ""},
-		{resolve, "\xed", "", "P1"},
-
-		// Raw punycode
-		{punyA, "", "", ""},
-		{punyA, "*.foo.com", "*.foo.com", ""},
-		{punyA, "Foo.com", "Foo.com", ""},
-
-		// STD3 rules
-		{display, "*.foo.com", "*.foo.com", "P1"},
-		{std3, "*.foo.com", "*.foo.com", ""},
-
-		// Don't map U+2490 (DIGIT NINE FULL STOP). This is the behavior of
-		// Chrome, Safari, and IE. Firefox will first map ⒐ to 9. and return
-		// lab9.be.
-		{resolve, "lab⒐be", "xn--labbe-zh9b", "P1"}, // encode("lab⒐be")
-		{display, "lab⒐be", "lab⒐be", "P1"},
-
-		{resolve, "plan⒐faß.de", "xn--planfass-c31e.de", "P1"}, // encode("plan⒐fass") + ".de"
-		{display, "Plan⒐faß.de", "plan⒐faß.de", "P1"},
-
-		// Chrome 54.0 recognizes the error and treats this input verbatim as a
-		// search string.
-		// Safari 10.0 (non-conform spec) decomposes "⒈" and computes the
-		// punycode on the result using transitional mapping.
-		// Firefox 49.0.1 goes haywire on this string and prints a bunch of what
-		// seems to be nested punycode encodings.
-		{resolve, "日本⒈co.ßßß.de", "xn--co-wuw5954azlb.ssssss.de", "P1"},
-		{display, "日本⒈co.ßßß.de", "日本⒈co.ßßß.de", "P1"},
-
-		{resolve, "a\u200Cb", "ab", ""},
-		{display, "a\u200Cb", "a\u200Cb", "C"},
-
-		{resolve, encode("a\u200Cb"), encode("a\u200Cb"), "C"},
-		{display, "a\u200Cb", "a\u200Cb", "C"},
-
-		{resolve, "grﻋﺮﺑﻲ.de", "xn--gr-gtd9a1b0g.de", "B"},
-		{
-			// Notice how the string gets transformed, even with an error.
-			// Chrome will use the original string if it finds an error, so not
-			// the transformed one.
-			display,
-			"gr\ufecb\ufeae\ufe91\ufef2.de",
-			"gr\u0639\u0631\u0628\u064a.de",
-			"B",
-		},
-
-		{resolve, "\u0671.\u03c3\u07dc", "xn--qib.xn--4xa21s", "B"}, // ٱ.σߜ
-		{display, "\u0671.\u03c3\u07dc", "\u0671.\u03c3\u07dc", "B"},
-
-		// normalize input
-		{resolve, "a\u0323\u0322", "xn--jta191l", ""}, // ạ̢
-		{display, "a\u0323\u0322", "\u1ea1\u0322", ""},
-
-		// Non-normalized strings are not normalized when they originate from
-		// punycode. Despite the error, Chrome, Safari and Firefox will attempt
-		// to look up the input punycode.
-		{resolve, encode("a\u0323\u0322") + ".com", "xn--a-tdbc.com", "V1"},
-		{display, encode("a\u0323\u0322") + ".com", "a\u0323\u0322.com", "V1"},
-	}
-
-	for _, tc := range testCases {
-		doTest(t, tc.f, tc.name, tc.input, tc.want, tc.wantErr)
-	}
-}
-
 func TestConformance(t *testing.T) {
 	testtext.SkipIfNotLong(t)
 

vendor/golang.org/x/text/internal/export/idna/tables10.0.0.go

@@ -1,5 +1,7 @@
 // Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
 
+// +build go1.10
+
 package idna
 
 // UnicodeVersion is the Unicode version from which the tables in this package are derived.