vendor: Update vendoring for the exec client and server implementations

Signed-off-by: Jacek J. Łakis <jacek.lakis@intel.com>
Signed-off-by: Samuel Ortiz <sameo@linux.intel.com>

vendor/golang.org/x/text/language/Makefile

@@ -0,0 +1,16 @@
+# Copyright 2013 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.
+
+CLEANFILES+=maketables
+
+maketables: maketables.go
+	go build $^
+
+tables:	maketables
+	./maketables > tables.go
+	gofmt -w -s tables.go
+
+# Build (but do not run) maketables during testing,
+# just to make sure it still compiles.
+testshort: maketables

vendor/golang.org/x/text/language/common.go

@@ -0,0 +1,16 @@
+// This file was generated by go generate; DO NOT EDIT
+
+package language
+
+// This file contains code common to the maketables.go and the package code.
+
+// langAliasType is the type of an alias in langAliasMap.
+type langAliasType int8
+
+const (
+	langDeprecated langAliasType = iota
+	langMacro
+	langLegacy
+
+	langAliasTypeUnknown langAliasType = -1
+)

vendor/golang.org/x/text/language/coverage.go

@@ -0,0 +1,197 @@
+// Copyright 2014 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.
+
+package language
+
+import (
+	"fmt"
+	"sort"
+)
+
+// The Coverage interface is used to define the level of coverage of an
+// internationalization service. Note that not all types are supported by all
+// services. As lists may be generated on the fly, it is recommended that users
+// of a Coverage cache the results.
+type Coverage interface {
+	// Tags returns the list of supported tags.
+	Tags() []Tag
+
+	// BaseLanguages returns the list of supported base languages.
+	BaseLanguages() []Base
+
+	// Scripts returns the list of supported scripts.
+	Scripts() []Script
+
+	// Regions returns the list of supported regions.
+	Regions() []Region
+}
+
+var (
+	// Supported defines a Coverage that lists all supported subtags. Tags
+	// always returns nil.
+	Supported Coverage = allSubtags{}
+)
+
+// TODO:
+// - Support Variants, numbering systems.
+// - CLDR coverage levels.
+// - Set of common tags defined in this package.
+
+type allSubtags struct{}
+
+// Regions returns the list of supported regions. As all regions are in a
+// consecutive range, it simply returns a slice of numbers in increasing order.
+// The "undefined" region is not returned.
+func (s allSubtags) Regions() []Region {
+	reg := make([]Region, numRegions)
+	for i := range reg {
+		reg[i] = Region{regionID(i + 1)}
+	}
+	return reg
+}
+
+// Scripts returns the list of supported scripts. As all scripts are in a
+// consecutive range, it simply returns a slice of numbers in increasing order.
+// The "undefined" script is not returned.
+func (s allSubtags) Scripts() []Script {
+	scr := make([]Script, numScripts)
+	for i := range scr {
+		scr[i] = Script{scriptID(i + 1)}
+	}
+	return scr
+}
+
+// BaseLanguages returns the list of all supported base languages. It generates
+// the list by traversing the internal structures.
+func (s allSubtags) BaseLanguages() []Base {
+	base := make([]Base, 0, numLanguages)
+	for i := 0; i < langNoIndexOffset; i++ {
+		// We included "und" already for the value 0.
+		if i != nonCanonicalUnd {
+			base = append(base, Base{langID(i)})
+		}
+	}
+	i := langNoIndexOffset
+	for _, v := range langNoIndex {
+		for k := 0; k < 8; k++ {
+			if v&1 == 1 {
+				base = append(base, Base{langID(i)})
+			}
+			v >>= 1
+			i++
+		}
+	}
+	return base
+}
+
+// Tags always returns nil.
+func (s allSubtags) Tags() []Tag {
+	return nil
+}
+
+// coverage is used used by NewCoverage which is used as a convenient way for
+// creating Coverage implementations for partially defined data. Very often a
+// package will only need to define a subset of slices. coverage provides a
+// convenient way to do this. Moreover, packages using NewCoverage, instead of
+// their own implementation, will not break if later new slice types are added.
+type coverage struct {
+	tags    func() []Tag
+	bases   func() []Base
+	scripts func() []Script
+	regions func() []Region
+}
+
+func (s *coverage) Tags() []Tag {
+	if s.tags == nil {
+		return nil
+	}
+	return s.tags()
+}
+
+// bases implements sort.Interface and is used to sort base languages.
+type bases []Base
+
+func (b bases) Len() int {
+	return len(b)
+}
+
+func (b bases) Swap(i, j int) {
+	b[i], b[j] = b[j], b[i]
+}
+
+func (b bases) Less(i, j int) bool {
+	return b[i].langID < b[j].langID
+}
+
+// BaseLanguages returns the result from calling s.bases if it is specified or
+// otherwise derives the set of supported base languages from tags.
+func (s *coverage) BaseLanguages() []Base {
+	if s.bases == nil {
+		tags := s.Tags()
+		if len(tags) == 0 {
+			return nil
+		}
+		a := make([]Base, len(tags))
+		for i, t := range tags {
+			a[i] = Base{langID(t.lang)}
+		}
+		sort.Sort(bases(a))
+		k := 0
+		for i := 1; i < len(a); i++ {
+			if a[k] != a[i] {
+				k++
+				a[k] = a[i]
+			}
+		}
+		return a[:k+1]
+	}
+	return s.bases()
+}
+
+func (s *coverage) Scripts() []Script {
+	if s.scripts == nil {
+		return nil
+	}
+	return s.scripts()
+}
+
+func (s *coverage) Regions() []Region {
+	if s.regions == nil {
+		return nil
+	}
+	return s.regions()
+}
+
+// NewCoverage returns a Coverage for the given lists. It is typically used by
+// packages providing internationalization services to define their level of
+// coverage. A list may be of type []T or func() []T, where T is either Tag,
+// Base, Script or Region. The returned Coverage derives the value for Bases
+// from Tags if no func or slice for []Base is specified. For other unspecified
+// types the returned Coverage will return nil for the respective methods.
+func NewCoverage(list ...interface{}) Coverage {
+	s := &coverage{}
+	for _, x := range list {
+		switch v := x.(type) {
+		case func() []Base:
+			s.bases = v
+		case func() []Script:
+			s.scripts = v
+		case func() []Region:
+			s.regions = v
+		case func() []Tag:
+			s.tags = v
+		case []Base:
+			s.bases = func() []Base { return v }
+		case []Script:
+			s.scripts = func() []Script { return v }
+		case []Region:
+			s.regions = func() []Region { return v }
+		case []Tag:
+			s.tags = func() []Tag { return v }
+		default:
+			panic(fmt.Sprintf("language: unsupported set type %T", v))
+		}
+	}
+	return s
+}

vendor/golang.org/x/text/language/coverage_test.go

@@ -0,0 +1,154 @@
+// Copyright 2014 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.
+
+package language
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+func TestSupported(t *testing.T) {
+	// To prove the results are correct for a type, we test that the number of
+	// results is identical to the number of results on record, that all results
+	// are distinct and that all results are valid.
+	tests := map[string]int{
+		"BaseLanguages": numLanguages,
+		"Scripts":       numScripts,
+		"Regions":       numRegions,
+		"Tags":          0,
+	}
+	sup := reflect.ValueOf(Supported)
+	for name, num := range tests {
+		v := sup.MethodByName(name).Call(nil)[0]
+		if n := v.Len(); n != num {
+			t.Errorf("len(%s()) was %d; want %d", name, n, num)
+		}
+		dup := make(map[string]bool)
+		for i := 0; i < v.Len(); i++ {
+			x := v.Index(i).Interface()
+			// An invalid value will either cause a crash or result in a
+			// duplicate when passed to Sprint.
+			s := fmt.Sprint(x)
+			if dup[s] {
+				t.Errorf("%s: duplicate entry %q", name, s)
+			}
+			dup[s] = true
+		}
+		if len(dup) != v.Len() {
+			t.Errorf("%s: # unique entries was %d; want %d", name, len(dup), v.Len())
+		}
+	}
+}
+
+func TestNewCoverage(t *testing.T) {
+	bases := []Base{Base{0}, Base{3}, Base{7}}
+	scripts := []Script{Script{11}, Script{17}, Script{23}}
+	regions := []Region{Region{101}, Region{103}, Region{107}}
+	tags := []Tag{Make("pt"), Make("en"), Make("en-GB"), Make("en-US"), Make("pt-PT")}
+	fbases := func() []Base { return bases }
+	fscripts := func() []Script { return scripts }
+	fregions := func() []Region { return regions }
+	ftags := func() []Tag { return tags }
+
+	tests := []struct {
+		desc    string
+		list    []interface{}
+		bases   []Base
+		scripts []Script
+		regions []Region
+		tags    []Tag
+	}{
+		{
+			desc: "empty",
+		},
+		{
+			desc:  "bases",
+			list:  []interface{}{bases},
+			bases: bases,
+		},
+		{
+			desc:    "scripts",
+			list:    []interface{}{scripts},
+			scripts: scripts,
+		},
+		{
+			desc:    "regions",
+			list:    []interface{}{regions},
+			regions: regions,
+		},
+		{
+			desc:  "bases derives from tags",
+			list:  []interface{}{tags},
+			bases: []Base{Base{_en}, Base{_pt}},
+			tags:  tags,
+		},
+		{
+			desc:  "tags and bases",
+			list:  []interface{}{tags, bases},
+			bases: bases,
+			tags:  tags,
+		},
+		{
+			desc:    "fully specified",
+			list:    []interface{}{tags, bases, scripts, regions},
+			bases:   bases,
+			scripts: scripts,
+			regions: regions,
+			tags:    tags,
+		},
+		{
+			desc:  "bases func",
+			list:  []interface{}{fbases},
+			bases: bases,
+		},
+		{
+			desc:    "scripts func",
+			list:    []interface{}{fscripts},
+			scripts: scripts,
+		},
+		{
+			desc:    "regions func",
+			list:    []interface{}{fregions},
+			regions: regions,
+		},
+		{
+			desc:  "tags func",
+			list:  []interface{}{ftags},
+			bases: []Base{Base{_en}, Base{_pt}},
+			tags:  tags,
+		},
+		{
+			desc:  "tags and bases",
+			list:  []interface{}{ftags, fbases},
+			bases: bases,
+			tags:  tags,
+		},
+		{
+			desc:    "fully specified",
+			list:    []interface{}{ftags, fbases, fscripts, fregions},
+			bases:   bases,
+			scripts: scripts,
+			regions: regions,
+			tags:    tags,
+		},
+	}
+
+	for i, tt := range tests {
+		l := NewCoverage(tt.list...)
+		if a := l.BaseLanguages(); !reflect.DeepEqual(a, tt.bases) {
+			t.Errorf("%d:%s: BaseLanguages was %v; want %v", i, tt.desc, a, tt.bases)
+		}
+		if a := l.Scripts(); !reflect.DeepEqual(a, tt.scripts) {
+			t.Errorf("%d:%s: Scripts was %v; want %v", i, tt.desc, a, tt.scripts)
+		}
+		if a := l.Regions(); !reflect.DeepEqual(a, tt.regions) {
+			t.Errorf("%d:%s: Regions was %v; want %v", i, tt.desc, a, tt.regions)
+		}
+		if a := l.Tags(); !reflect.DeepEqual(a, tt.tags) {
+			t.Errorf("%d:%s: Tags was %v; want %v", i, tt.desc, a, tt.tags)
+		}
+	}
+}

vendor/golang.org/x/text/language/data_test.go

@@ -0,0 +1,416 @@
+// Copyright 2013 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.
+
+package language
+
+type matchTest struct {
+	comment   string
+	supported string
+	test      []struct{ match, desired string }
+}
+
+var matchTests = []matchTest{
+	{
+		"basics",
+		"fr, en-GB, en",
+		[]struct{ match, desired string }{
+			{"en-GB", "en-GB"},
+			{"en", "en-US"},
+			{"fr", "fr-FR"},
+			{"fr", "ja-JP"},
+		},
+	},
+	{
+		"script fallbacks",
+		"zh-CN, zh-TW, iw",
+		[]struct{ match, desired string }{
+			{"zh-TW", "zh-Hant"},
+			{"zh-CN", "zh"},
+			{"zh-CN", "zh-Hans-CN"},
+			{"zh-TW", "zh-Hant-HK"},
+			{"iw", "he-IT"},
+		},
+	},
+	{
+		"language-specific script fallbacks 1",
+		"en, sr, nl",
+		[]struct{ match, desired string }{
+			{"sr", "sr-Latn"},
+			{"en", "sh"},
+			{"en", "hr"},
+			{"en", "bs"},
+			{"en", "nl-Cyrl"},
+		},
+	},
+	{
+		"language-specific script fallbacks 2",
+		"en, sh",
+		[]struct{ match, desired string }{
+			{"sh", "sr"},
+			{"sh", "sr-Cyrl"},
+			{"sh", "hr"},
+		},
+	},
+	{
+		"both deprecated and not",
+		"fil, tl, iw, he",
+		[]struct{ match, desired string }{
+			{"he", "he-IT"},
+			{"he", "he"},
+			{"iw", "iw"},
+			{"fil", "fil-IT"},
+			{"fil", "fil"},
+			{"tl", "tl"},
+		},
+	},
+	{
+		"nearby languages",
+		"en, fil, ro, nn",
+		[]struct{ match, desired string }{
+			{"fil", "tl"},
+			{"ro", "mo"},
+			{"nn", "nb"},
+			{"en", "ja"}, // make sure default works
+		},
+	},
+	{
+		"nearby languages: Nynorsk to Bokmål",
+		"en, nb",
+		[]struct{ match, desired string }{
+			{"nb", "nn"},
+		},
+	},
+	{
+		"nearby languages: Danish does not match nn",
+		"en, nn",
+		[]struct{ match, desired string }{
+			{"en", "da"},
+		},
+	},
+	{
+		"nearby languages: Danish matches no",
+		"en, no",
+		[]struct{ match, desired string }{
+			{"no", "da"},
+		},
+	},
+	{
+		"nearby languages: Danish matches nb",
+		"en, nb",
+		[]struct{ match, desired string }{
+			{"nb", "da"},
+		},
+	},
+	{
+		"prefer matching languages over language variants.",
+		"nn, en-GB",
+		[]struct{ match, desired string }{
+			{"en-GB", "no, en-US"},
+			{"en-GB", "nb, en-US"},
+		},
+	},
+	{
+		"deprecated version is closer than same language with other differences",
+		"nl, he, en-GB",
+		[]struct{ match, desired string }{
+			{"he", "iw, en-US"},
+		},
+	},
+	{
+		"macro equivalent is closer than same language with other differences",
+		"nl, zh, en-GB, no",
+		[]struct{ match, desired string }{
+			{"zh", "cmn, en-US"},
+			{"no", "nb, en-US"},
+		},
+	},
+	{
+		"legacy equivalent is closer than same language with other differences",
+		"nl, fil, en-GB",
+		[]struct{ match, desired string }{
+			{"fil", "tl, en-US"},
+		},
+	},
+	{
+		"exact over equivalent",
+		"en, ro, mo, ro-MD",
+		[]struct{ match, desired string }{
+			{"ro", "ro"},
+			{"mo", "mo"},
+			{"ro-MD", "ro-MD"},
+		},
+	},
+	{
+		"maximization of legacy",
+		"sr-Cyrl, sr-Latn, ro, ro-MD",
+		[]struct{ match, desired string }{
+			{"sr-Latn", "sh"},
+			{"ro-MD", "mo"},
+		},
+	},
+	{
+		"empty",
+		"",
+		[]struct{ match, desired string }{
+			{"und", "fr"},
+			{"und", "en"},
+		},
+	},
+	{
+		"private use subtags",
+		"fr, en-GB, x-bork, es-ES, es-419",
+		[]struct{ match, desired string }{
+			{"fr", "x-piglatin"},
+			{"x-bork", "x-bork"},
+		},
+	},
+	{
+		"grandfathered codes",
+		"fr, i-klingon, en-Latn-US",
+		[]struct{ match, desired string }{
+			{"en-Latn-US", "en-GB-oed"},
+			{"tlh", "i-klingon"},
+		},
+	},
+	{
+		"exact match",
+		"fr, en-GB, ja, es-ES, es-MX",
+		[]struct{ match, desired string }{
+			{"ja", "ja, de"},
+		},
+	},
+	{
+		"simple variant match",
+		"fr, en-GB, ja, es-ES, es-MX",
+		[]struct{ match, desired string }{
+			// Intentionally avoiding a perfect-match or two candidates for variant matches.
+			{"en-GB", "de, en-US"},
+			// Fall back.
+			{"fr", "de, zh"},
+		},
+	},
+	{
+		"best match for traditional Chinese",
+		// Scenario: An application that only supports Simplified Chinese (and some
+		// other languages), but does not support Traditional Chinese. zh-Hans-CN
+		// could be replaced with zh-CN, zh, or zh-Hans, it wouldn't make much of
+		// a difference.
+		"fr, zh-Hans-CN, en-US",
+		[]struct{ match, desired string }{
+			{"zh-Hans-CN", "zh-TW"},
+			{"zh-Hans-CN", "zh-Hant"},
+			// One can avoid a zh-Hant to zh-Hans match by including a second language
+			// preference which is a better match.
+			{"en-US", "zh-TW, en"},
+			{"en-US", "zh-Hant-CN, en"},
+			{"zh-Hans-CN", "zh-Hans, en"},
+		},
+	},
+	// More specific region and script tie-breakers.
+	{
+		"more specific script should win in case regions are identical",
+		"af, af-Latn, af-Arab",
+		[]struct{ match, desired string }{
+			{"af", "af"},
+			{"af", "af-ZA"},
+			{"af-Latn", "af-Latn-ZA"},
+			{"af-Latn", "af-Latn"},
+		},
+	},
+	{
+		"more specific region should win",
+		"nl, nl-NL, nl-BE",
+		[]struct{ match, desired string }{
+			{"nl", "nl"},
+			{"nl", "nl-Latn"},
+			{"nl-NL", "nl-Latn-NL"},
+			{"nl-NL", "nl-NL"},
+		},
+	},
+	{
+		"more specific region wins over more specific script",
+		"nl, nl-Latn, nl-NL, nl-BE",
+		[]struct{ match, desired string }{
+			{"nl", "nl"},
+			{"nl-Latn", "nl-Latn"},
+			{"nl-NL", "nl-NL"},
+			{"nl-NL", "nl-Latn-NL"},
+		},
+	},
+	// Region distance tie-breakers.
+	{
+		"region distance Portuguese",
+		"pt, pt-PT",
+		[]struct{ match, desired string }{
+			{"pt-PT", "pt-ES"},
+		},
+	},
+	{
+		"region distance French",
+		"en, fr, fr-CA, fr-CH",
+		[]struct{ match, desired string }{
+			{"fr-CA", "fr-US"},
+		},
+	},
+	{
+		"region distance German",
+		"de-AT, de-DE, de-CH",
+		[]struct{ match, desired string }{
+			{"de-DE", "de"},
+		},
+	},
+	{
+		"en-AU is closer to en-GB than to en (which is en-US)",
+		"en, en-GB, es-ES, es-419",
+		[]struct{ match, desired string }{
+			{"en-GB", "en-AU"},
+			{"es-419", "es-MX"},
+			{"es-ES", "es-PT"},
+		},
+	},
+	// Test exceptions with "und".
+	// When the undefined language doesn't match anything in the list, return the default, as usual.
+	// max("und") = "en-Latn-US", and since matching is based on maximized tags, the undefined
+	// language would normally match English.  But that would produce the counterintuitive results.
+	// Matching "und" to "it,en" would be "en" matching "en" to "it,und" would be "und".
+	// To avoid this max("und") is defined as "und"
+	{
+		"undefined",
+		"it, fr",
+		[]struct{ match, desired string }{
+			{"it", "und"},
+		},
+	},
+	{
+		"und does not match en",
+		"it, en",
+		[]struct{ match, desired string }{
+			{"it", "und"},
+		},
+	},
+	{
+		"undefined in priority list",
+		"it, und",
+		[]struct{ match, desired string }{
+			{"und", "und"},
+			{"it", "en"},
+		},
+	},
+	// Undefined scripts and regions.
+	{
+		"undefined",
+		"it, fr, zh",
+		[]struct{ match, desired string }{
+			{"fr", "und-FR"},
+			{"zh", "und-CN"},
+			{"zh", "und-Hans"},
+			{"zh", "und-Hant"},
+			{"it", "und-Latn"},
+		},
+	},
+	// Early termination conditions: do not consider all desired strings if
+	// a match is good enough.
+	{
+		"match on maximized tag",
+		"fr, en-GB, ja, es-ES, es-MX",
+		[]struct{ match, desired string }{
+			// ja-JP matches ja on likely subtags, and it's listed first,
+			// thus it wins over the second preference en-GB.
+			{"ja", "ja-JP, en-GB"},
+			{"ja", "ja-Jpan-JP, en-GB"},
+		},
+	},
+	{
+		"pick best maximized tag",
+		"ja, ja-Jpan-US, ja-JP, en, ru",
+		[]struct{ match, desired string }{
+			{"ja", "ja-Jpan, ru"},
+			{"ja-JP", "ja-JP, ru"},
+			{"ja-Jpan-US", "ja-US, ru"},
+		},
+	},
+	{
+		"termination: pick best maximized match",
+		"ja, ja-Jpan, ja-JP, en, ru",
+		[]struct{ match, desired string }{
+			{"ja-JP", "ja-Jpan-JP, ru"},
+			{"ja-Jpan", "ja-Jpan, ru"},
+		},
+	},
+	{
+		"no match on maximized",
+		"en, de, fr, ja",
+		[]struct{ match, desired string }{
+			// de maximizes to de-DE.
+			// Pick the exact match for the secondary language instead.
+			{"fr", "de-CH, fr"},
+		},
+	},
+
+	// Test that the CLDR parent relations are correctly preserved by the matcher.
+	// These matches may change for different CLDR versions.
+	{
+		"parent relation preserved",
+		"en, en-US, en-GB, es, es-419, pt, pt-BR, pt-PT, zh,  zh-Hant, zh-Hant-HK",
+		[]struct{ match, desired string }{
+			{"en-GB", "en-150"},
+			{"en-GB", "en-AU"},
+			{"en-GB", "en-BE"},
+			{"en-GB", "en-GG"},
+			{"en-GB", "en-GI"},
+			{"en-GB", "en-HK"},
+			{"en-GB", "en-IE"},
+			{"en-GB", "en-IM"},
+			{"en-GB", "en-IN"},
+			{"en-GB", "en-JE"},
+			{"en-GB", "en-MT"},
+			{"en-GB", "en-NZ"},
+			{"en-GB", "en-PK"},
+			{"en-GB", "en-SG"},
+			{"en-GB", "en-DE"},
+			{"en-GB", "en-MT"},
+			{"es-419", "es-AR"},
+			{"es-419", "es-BO"},
+			{"es-419", "es-CL"},
+			{"es-419", "es-CO"},
+			{"es-419", "es-CR"},
+			{"es-419", "es-CU"},
+			{"es-419", "es-DO"},
+			{"es-419", "es-EC"},
+			{"es-419", "es-GT"},
+			{"es-419", "es-HN"},
+			{"es-419", "es-MX"},
+			{"es-419", "es-NI"},
+			{"es-419", "es-PA"},
+			{"es-419", "es-PE"},
+			{"es-419", "es-PR"},
+			{"es-419", "es-PY"},
+			{"es-419", "es-SV"},
+			{"es-419", "es-US"},
+			{"es-419", "es-UY"},
+			{"es-419", "es-VE"},
+			{"pt-PT", "pt-AO"},
+			{"pt-PT", "pt-CV"},
+			{"pt-PT", "pt-GW"},
+			{"pt-PT", "pt-MO"},
+			{"pt-PT", "pt-MZ"},
+			{"pt-PT", "pt-ST"},
+			{"pt-PT", "pt-TL"},
+			// TODO for CLDR 24+
+			// - en-001
+			// - {"zh-Hant-HK", "zh-Hant-MO"},
+		},
+	},
+	// Options and variants are inherited from user-defined settings.
+	{
+		"preserve Unicode extension",
+		"en, de, sl-nedis",
+		[]struct{ match, desired string }{
+			{"de-u-co-phonebk", "de-FR-u-co-phonebk"},
+			{"sl-nedis-u-cu-eur", "sl-nedis-u-cu-eur"},
+			{"sl-nedis-u-cu-eur", "sl-u-cu-eur"},
+			{"sl-nedis-u-cu-eur", "sl-HR-nedis-u-cu-eur"},
+		},
+	},
+}

vendor/golang.org/x/text/language/display/dict.go

@@ -0,0 +1,92 @@
+// Copyright 2014 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.
+
+package display
+
+// This file contains sets of data for specific languages. Users can use these
+// to create smaller collections of supported languages and reduce total table
+// size.
+
+// The variable names defined here correspond to those in package language.
+
+var (
+	Afrikaans            *Dictionary = &af        // af
+	Amharic              *Dictionary = &am        // am
+	Arabic               *Dictionary = &ar        // ar
+	ModernStandardArabic *Dictionary = Arabic     // ar-001
+	Azerbaijani          *Dictionary = &az        // az
+	Bulgarian            *Dictionary = &bg        // bg
+	Bengali              *Dictionary = &bn        // bn
+	Catalan              *Dictionary = &ca        // ca
+	Czech                *Dictionary = &cs        // cs
+	Danish               *Dictionary = &da        // da
+	German               *Dictionary = &de        // de
+	Greek                *Dictionary = &el        // el
+	English              *Dictionary = &en        // en
+	AmericanEnglish      *Dictionary = English    // en-US
+	BritishEnglish       *Dictionary = English    // en-GB
+	Spanish              *Dictionary = &es        // es
+	EuropeanSpanish      *Dictionary = Spanish    // es-ES
+	LatinAmericanSpanish *Dictionary = Spanish    // es-419
+	Estonian             *Dictionary = &et        // et
+	Persian              *Dictionary = &fa        // fa
+	Finnish              *Dictionary = &fi        // fi
+	Filipino             *Dictionary = &fil       // fil
+	French               *Dictionary = &fr        // fr
+	Gujarati             *Dictionary = &gu        // gu
+	Hebrew               *Dictionary = &he        // he
+	Hindi                *Dictionary = &hi        // hi
+	Croatian             *Dictionary = &hr        // hr
+	Hungarian            *Dictionary = &hu        // hu
+	Armenian             *Dictionary = &hy        // hy
+	Indonesian           *Dictionary = &id        // id
+	Icelandic            *Dictionary = &is        // is
+	Italian              *Dictionary = &it        // it
+	Japanese             *Dictionary = &ja        // ja
+	Georgian             *Dictionary = &ka        // ka
+	Kazakh               *Dictionary = &kk        // kk
+	Khmer                *Dictionary = &km        // km
+	Kannada              *Dictionary = &kn        // kn
+	Korean               *Dictionary = &ko        // ko
+	Kirghiz              *Dictionary = &ky        // ky
+	Lao                  *Dictionary = &lo        // lo
+	Lithuanian           *Dictionary = &lt        // lt
+	Latvian              *Dictionary = &lv        // lv
+	Macedonian           *Dictionary = &mk        // mk
+	Malayalam            *Dictionary = &ml        // ml
+	Mongolian            *Dictionary = &mn        // mn
+	Marathi              *Dictionary = &mr        // mr
+	Malay                *Dictionary = &ms        // ms
+	Burmese              *Dictionary = &my        // my
+	Nepali               *Dictionary = &ne        // ne
+	Dutch                *Dictionary = &nl        // nl
+	Norwegian            *Dictionary = &no        // no
+	Punjabi              *Dictionary = &pa        // pa
+	Polish               *Dictionary = &pl        // pl
+	Portuguese           *Dictionary = &pt        // pt
+	BrazilianPortuguese  *Dictionary = Portuguese // pt-BR
+	EuropeanPortuguese   *Dictionary = &ptPT      // pt-PT
+	Romanian             *Dictionary = &ro        // ro
+	Russian              *Dictionary = &ru        // ru
+	Sinhala              *Dictionary = &si        // si
+	Slovak               *Dictionary = &sk        // sk
+	Slovenian            *Dictionary = &sl        // sl
+	Albanian             *Dictionary = &sq        // sq
+	Serbian              *Dictionary = &sr        // sr
+	SerbianLatin         *Dictionary = &srLatn    // sr
+	Swedish              *Dictionary = &sv        // sv
+	Swahili              *Dictionary = &sw        // sw
+	Tamil                *Dictionary = &ta        // ta
+	Telugu               *Dictionary = &te        // te
+	Thai                 *Dictionary = &th        // th
+	Turkish              *Dictionary = &tr        // tr
+	Ukrainian            *Dictionary = &uk        // uk
+	Urdu                 *Dictionary = &ur        // ur
+	Uzbek                *Dictionary = &uz        // uz
+	Vietnamese           *Dictionary = &vi        // vi
+	Chinese              *Dictionary = &zh        // zh
+	SimplifiedChinese    *Dictionary = Chinese    // zh-Hans
+	TraditionalChinese   *Dictionary = &zhHant    // zh-Hant
+	Zulu                 *Dictionary = &zu        // zu
+)

vendor/golang.org/x/text/language/display/dict_test.go

@@ -0,0 +1,39 @@
+// Copyright 2015 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.
+
+package display
+
+import (
+	"fmt"
+	"testing"
+
+	"golang.org/x/text/internal/testtext"
+)
+
+func TestLinking(t *testing.T) {
+	base := getSize(t, `display.Tags(language.English).Name(language.English)`)
+	compact := getSize(t, `display.English.Languages().Name(language.English)`)
+
+	if d := base - compact; d < 1.5*1024*1024 {
+		t.Errorf("size(base)-size(compact) was %d; want > 1.5MB", base, compact)
+	}
+}
+
+func getSize(t *testing.T, main string) int {
+	size, err := testtext.CodeSize(fmt.Sprintf(body, main))
+	if err != nil {
+		t.Skipf("skipping link size test; binary size could not be determined: %v", err)
+	}
+	return size
+}
+
+const body = `package main
+import (
+	"golang.org/x/text/language"
+	"golang.org/x/text/language/display"
+)
+func main() {
+	%s
+}
+`

vendor/golang.org/x/text/language/display/display.go

@@ -0,0 +1,343 @@
+// Copyright 2014 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.
+
+//go:generate go run maketables.go -output tables.go
+
+// Package display provides display names for languages, scripts and regions in
+// a requested language.
+//
+// The data is based on CLDR's localeDisplayNames. It includes the names of the
+// draft level "contributed" or "approved". The resulting tables are quite
+// large. The display package is designed so that users can reduce the linked-in
+// table sizes by cherry picking the languages one wishes to support. There is a
+// Dictionary defined for a selected set of common languages for this purpose.
+package display // import "golang.org/x/text/language/display"
+
+import (
+	"strings"
+
+	"golang.org/x/text/language"
+)
+
+/*
+TODO:
+All fairly low priority at the moment:
+  - Include alternative and variants as an option (using func options).
+  - Option for returning the empty string for undefined values.
+  - Support variants, currencies, time zones, option names and other data
+    provided in CLDR.
+  - Do various optimizations:
+    - Reduce size of offset tables.
+    - Consider compressing infrequently used languages and decompress on demand.
+*/
+
+// A Namer is used to get the name for a given value, such as a Tag, Language,
+// Script or Region.
+type Namer interface {
+	// Name returns a display string for the given value. A Namer returns an
+	// empty string for values it does not support. A Namer may support naming
+	// an unspecified value. For example, when getting the name for a region for
+	// a tag that does not have a defined Region, it may return the name for an
+	// unknown region. It is up to the user to filter calls to Name for values
+	// for which one does not want to have a name string.
+	Name(x interface{}) string
+}
+
+var (
+	// Supported lists the languages for which names are defined.
+	Supported language.Coverage
+
+	// The set of all possible values for which names are defined. Note that not
+	// all Namer implementations will cover all the values of a given type.
+	// A Namer will return the empty string for unsupported values.
+	Values language.Coverage
+
+	matcher language.Matcher
+)
+
+func init() {
+	tags := make([]language.Tag, numSupported)
+	s := supported
+	for i := range tags {
+		p := strings.IndexByte(s, '|')
+		tags[i] = language.Raw.Make(s[:p])
+		s = s[p+1:]
+	}
+	matcher = language.NewMatcher(tags)
+	Supported = language.NewCoverage(tags)
+
+	Values = language.NewCoverage(langTagSet.Tags, supportedScripts, supportedRegions)
+}
+
+// Languages returns a Namer for naming languages. It returns nil if there is no
+// data for the given tag. The type passed to Name must be either language.Base
+// or language.Tag. Note that the result may differ between passing a tag or its
+// base language. For example, for English, passing "nl-BE" would return Flemish
+// whereas passing "nl" returns "Dutch".
+func Languages(t language.Tag) Namer {
+	if _, index, conf := matcher.Match(t); conf != language.No {
+		return languageNamer(index)
+	}
+	return nil
+}
+
+type languageNamer int
+
+func (n languageNamer) name(i int) string {
+	return lookup(langHeaders[:], int(n), i)
+}
+
+// Name implements the Namer interface for language names.
+func (n languageNamer) Name(x interface{}) string {
+	return nameLanguage(n, x)
+}
+
+// nonEmptyIndex walks up the parent chain until a non-empty header is found.
+// It returns -1 if no index could be found.
+func nonEmptyIndex(h []header, index int) int {
+	for ; index != -1 && h[index].data == ""; index = int(parents[index]) {
+	}
+	return index
+}
+
+// Scripts returns a Namer for naming scripts. It returns nil if there is no
+// data for the given tag. The type passed to Name must be either a
+// language.Script or a language.Tag. It will not attempt to infer a script for
+// tags with an unspecified script.
+func Scripts(t language.Tag) Namer {
+	if _, index, conf := matcher.Match(t); conf != language.No {
+		if index = nonEmptyIndex(scriptHeaders[:], index); index != -1 {
+			return scriptNamer(index)
+		}
+	}
+	return nil
+}
+
+type scriptNamer int
+
+func (n scriptNamer) name(i int) string {
+	return lookup(scriptHeaders[:], int(n), i)
+}
+
+// Name implements the Namer interface for script names.
+func (n scriptNamer) Name(x interface{}) string {
+	return nameScript(n, x)
+}
+
+// Regions returns a Namer for naming regions. It returns nil if there is no
+// data for the given tag. The type passed to Name must be either a
+// language.Region or a language.Tag. It will not attempt to infer a region for
+// tags with an unspecified region.
+func Regions(t language.Tag) Namer {
+	if _, index, conf := matcher.Match(t); conf != language.No {
+		if index = nonEmptyIndex(regionHeaders[:], index); index != -1 {
+			return regionNamer(index)
+		}
+	}
+	return nil
+}
+
+type regionNamer int
+
+func (n regionNamer) name(i int) string {
+	return lookup(regionHeaders[:], int(n), i)
+}
+
+// Name implements the Namer interface for region names.
+func (n regionNamer) Name(x interface{}) string {
+	return nameRegion(n, x)
+}
+
+// Tags returns a Namer for giving a full description of a tag. The names of
+// scripts and regions that are not already implied by the language name will
+// in appended within parentheses. It returns nil if there is not data for the
+// given tag. The type passed to Name must be a tag.
+func Tags(t language.Tag) Namer {
+	if _, index, conf := matcher.Match(t); conf != language.No {
+		return tagNamer(index)
+	}
+	return nil
+}
+
+type tagNamer int
+
+// Name implements the Namer interface for tag names.
+func (n tagNamer) Name(x interface{}) string {
+	return nameTag(languageNamer(n), scriptNamer(n), regionNamer(n), x)
+}
+
+// lookup finds the name for an entry in a global table, traversing the
+// inheritance hierarchy if needed.
+func lookup(table []header, dict, want int) string {
+	for dict != -1 {
+		if s := table[dict].name(want); s != "" {
+			return s
+		}
+		dict = int(parents[dict])
+	}
+	return ""
+}
+
+// A Dictionary holds a collection of Namers for a single language. One can
+// reduce the amount of data linked in to a binary by only referencing
+// Dictionaries for the languages one needs to support instead of using the
+// generic Namer factories.
+type Dictionary struct {
+	parent *Dictionary
+	lang   header
+	script header
+	region header
+}
+
+// Tags returns a Namer for giving a full description of a tag. The names of
+// scripts and regions that are not already implied by the language name will
+// in appended within parentheses. It returns nil if there is not data for the
+// given tag. The type passed to Name must be a tag.
+func (d *Dictionary) Tags() Namer {
+	return dictTags{d}
+}
+
+type dictTags struct {
+	d *Dictionary
+}
+
+// Name implements the Namer interface for tag names.
+func (n dictTags) Name(x interface{}) string {
+	return nameTag(dictLanguages{n.d}, dictScripts{n.d}, dictRegions{n.d}, x)
+}
+
+// Languages returns a Namer for naming languages. It returns nil if there is no
+// data for the given tag. The type passed to Name must be either language.Base
+// or language.Tag. Note that the result may differ between passing a tag or its
+// base language. For example, for English, passing "nl-BE" would return Flemish
+// whereas passing "nl" returns "Dutch".
+func (d *Dictionary) Languages() Namer {
+	return dictLanguages{d}
+}
+
+type dictLanguages struct {
+	d *Dictionary
+}
+
+func (n dictLanguages) name(i int) string {
+	for d := n.d; d != nil; d = d.parent {
+		if s := d.lang.name(i); s != "" {
+			return s
+		}
+	}
+	return ""
+}
+
+// Name implements the Namer interface for language names.
+func (n dictLanguages) Name(x interface{}) string {
+	return nameLanguage(n, x)
+}
+
+// Scripts returns a Namer for naming scripts. It returns nil if there is no
+// data for the given tag. The type passed to Name must be either a
+// language.Script or a language.Tag. It will not attempt to infer a script for
+// tags with an unspecified script.
+func (d *Dictionary) Scripts() Namer {
+	return dictScripts{d}
+}
+
+type dictScripts struct {
+	d *Dictionary
+}
+
+func (n dictScripts) name(i int) string {
+	for d := n.d; d != nil; d = d.parent {
+		if s := d.script.name(i); s != "" {
+			return s
+		}
+	}
+	return ""
+}
+
+// Name implements the Namer interface for script names.
+func (n dictScripts) Name(x interface{}) string {
+	return nameScript(n, x)
+}
+
+// Regions returns a Namer for naming regions. It returns nil if there is no
+// data for the given tag. The type passed to Name must be either a
+// language.Region or a language.Tag. It will not attempt to infer a region for
+// tags with an unspecified region.
+func (d *Dictionary) Regions() Namer {
+	return dictRegions{d}
+}
+
+type dictRegions struct {
+	d *Dictionary
+}
+
+func (n dictRegions) name(i int) string {
+	for d := n.d; d != nil; d = d.parent {
+		if s := d.region.name(i); s != "" {
+			return s
+		}
+	}
+	return ""
+}
+
+// Name implements the Namer interface for region names.
+func (n dictRegions) Name(x interface{}) string {
+	return nameRegion(n, x)
+}
+
+// A SelfNamer implements a Namer that returns the name of language in this same
+// language. It provides a very compact mechanism to provide a comprehensive
+// list of languages to users in their native language.
+type SelfNamer struct {
+	// Supported defines the values supported by this Namer.
+	Supported language.Coverage
+}
+
+var (
+	// Self is a shared instance of a SelfNamer.
+	Self *SelfNamer = &self
+
+	self = SelfNamer{language.NewCoverage(selfTagSet.Tags)}
+)
+
+// Name returns the name of a given language tag in the language identified by
+// this tag. It supports both the language.Base and language.Tag types.
+func (n SelfNamer) Name(x interface{}) string {
+	t, _ := language.All.Compose(x)
+	base, scr, reg := t.Raw()
+	baseScript := language.Script{}
+	if (scr == language.Script{} && reg != language.Region{}) {
+		// For looking up in the self dictionary, we need to select the
+		// maximized script. This is even the case if the script isn't
+		// specified.
+		s1, _ := t.Script()
+		if baseScript = getScript(base); baseScript != s1 {
+			scr = s1
+		}
+	}
+
+	i, scr, reg := selfTagSet.index(base, scr, reg)
+	if i == -1 {
+		return ""
+	}
+
+	// Only return the display name if the script matches the expected script.
+	if (scr != language.Script{}) {
+		if (baseScript == language.Script{}) {
+			baseScript = getScript(base)
+		}
+		if baseScript != scr {
+			return ""
+		}
+	}
+
+	return selfHeaders[0].name(i)
+}
+
+// getScript returns the maximized script for a base language.
+func getScript(b language.Base) language.Script {
+	tag, _ := language.Raw.Compose(b)
+	scr, _ := tag.Script()
+	return scr
+}

vendor/golang.org/x/text/language/display/display_test.go

@@ -0,0 +1,651 @@
+// Copyright 2014 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.
+
+package display
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+	"unicode"
+
+	"golang.org/x/text/internal/testtext"
+	"golang.org/x/text/language"
+)
+
+// TODO: test that tables are properly dropped by the linker for various use
+// cases.
+
+var (
+	firstLang2aa  = language.MustParseBase("aa")
+	lastLang2zu   = language.MustParseBase("zu")
+	firstLang3ace = language.MustParseBase("ace")
+	lastLang3zza  = language.MustParseBase("zza")
+	firstTagAr001 = language.MustParse("ar-001")
+	lastTagZhHant = language.MustParse("zh-Hant")
+)
+
+// TestValues tests that for all languages, regions, and scripts in Values, at
+// least one language has a name defined for it by checking it exists in
+// English, which is assumed to be the most comprehensive. It is also tested
+// that a Namer returns "" for unsupported values.
+func TestValues(t *testing.T) {
+	type testcase struct {
+		kind string
+		n    Namer
+	}
+	// checkDefined checks that a value exists in a Namer.
+	checkDefined := func(x interface{}, namers []testcase) {
+		for _, n := range namers {
+			testtext.Run(t, fmt.Sprintf("%s.Name(%s)", n.kind, x), func(t *testing.T) {
+				if n.n.Name(x) == "" {
+					// As of version 28 there is no data for az-Arab in English,
+					// although there is useful data in other languages.
+					if x.(fmt.Stringer).String() == "az-Arab" {
+						return
+					}
+					t.Errorf("supported but no result")
+				}
+			})
+		}
+	}
+	// checkUnsupported checks that a value does not exist in a Namer.
+	checkUnsupported := func(x interface{}, namers []testcase) {
+		for _, n := range namers {
+			if got := n.n.Name(x); got != "" {
+				t.Fatalf("%s.Name(%s): unsupported tag gave non-empty result: %q", n.kind, x, got)
+			}
+		}
+	}
+
+	tags := map[language.Tag]bool{}
+	namers := []testcase{
+		{"Languages(en)", Languages(language.English)},
+		{"Tags(en)", Tags(language.English)},
+		{"English.Languages()", English.Languages()},
+		{"English.Tags()", English.Tags()},
+	}
+	for _, tag := range Values.Tags() {
+		checkDefined(tag, namers)
+		tags[tag] = true
+	}
+	for _, base := range language.Supported.BaseLanguages() {
+		tag, _ := language.All.Compose(base)
+		if !tags[tag] {
+			checkUnsupported(tag, namers)
+		}
+	}
+
+	regions := map[language.Region]bool{}
+	namers = []testcase{
+		{"Regions(en)", Regions(language.English)},
+		{"English.Regions()", English.Regions()},
+	}
+	for _, r := range Values.Regions() {
+		checkDefined(r, namers)
+		regions[r] = true
+	}
+	for _, r := range language.Supported.Regions() {
+		if r = r.Canonicalize(); !regions[r] {
+			checkUnsupported(r, namers)
+		}
+	}
+
+	scripts := map[language.Script]bool{}
+	namers = []testcase{
+		{"Scripts(en)", Scripts(language.English)},
+		{"English.Scripts()", English.Scripts()},
+	}
+	for _, s := range Values.Scripts() {
+		checkDefined(s, namers)
+		scripts[s] = true
+	}
+	for _, s := range language.Supported.Scripts() {
+		// Canonicalize the script.
+		tag, _ := language.DeprecatedScript.Compose(s)
+		if _, s, _ = tag.Raw(); !scripts[s] {
+			checkUnsupported(s, namers)
+		}
+	}
+}
+
+// TestSupported tests that we have at least some Namers for languages that we
+// claim to support. To test the claims in the documentation, it also verifies
+// that if a Namer is returned, it will have at least some data.
+func TestSupported(t *testing.T) {
+	supportedTags := Supported.Tags()
+	if len(supportedTags) != numSupported {
+		t.Errorf("number of supported was %d; want %d", len(supportedTags), numSupported)
+	}
+
+	namerFuncs := []struct {
+		kind string
+		fn   func(language.Tag) Namer
+	}{
+		{"Tags", Tags},
+		{"Languages", Languages},
+		{"Regions", Regions},
+		{"Scripts", Scripts},
+	}
+
+	// Verify that we have at least one Namer for all tags we claim to support.
+	tags := make(map[language.Tag]bool)
+	for _, tag := range supportedTags {
+		// Test we have at least one Namer for this supported Tag.
+		found := false
+		for _, kind := range namerFuncs {
+			if defined(t, kind.kind, kind.fn(tag), tag) {
+				found = true
+			}
+		}
+		if !found {
+			t.Errorf("%s: supported, but no data available", tag)
+		}
+		if tags[tag] {
+			t.Errorf("%s: included in Supported.Tags more than once", tag)
+		}
+		tags[tag] = true
+	}
+
+	// Verify that we have no Namers for tags we don't claim to support.
+	for _, base := range language.Supported.BaseLanguages() {
+		tag, _ := language.All.Compose(base)
+		// Skip tags that are supported after matching.
+		if _, _, conf := matcher.Match(tag); conf != language.No {
+			continue
+		}
+		// Test there are no Namers for this tag.
+		for _, kind := range namerFuncs {
+			if defined(t, kind.kind, kind.fn(tag), tag) {
+				t.Errorf("%[1]s(%[2]s) returns a Namer, but %[2]s is not in the set of supported Tags.", kind.kind, tag)
+			}
+		}
+	}
+}
+
+// defined reports whether n is a proper Namer, which means it is non-nil and
+// must have at least one non-empty value.
+func defined(t *testing.T, kind string, n Namer, tag language.Tag) bool {
+	if n == nil {
+		return false
+	}
+	switch kind {
+	case "Tags":
+		for _, t := range Values.Tags() {
+			if n.Name(t) != "" {
+				return true
+			}
+		}
+	case "Languages":
+		for _, t := range Values.BaseLanguages() {
+			if n.Name(t) != "" {
+				return true
+			}
+		}
+	case "Regions":
+		for _, t := range Values.Regions() {
+			if n.Name(t) != "" {
+				return true
+			}
+		}
+	case "Scripts":
+		for _, t := range Values.Scripts() {
+			if n.Name(t) != "" {
+				return true
+			}
+		}
+	}
+	t.Errorf("%s(%s) returns non-nil Namer without content", kind, tag)
+	return false
+}
+
+func TestCoverage(t *testing.T) {
+	en := language.English
+	tests := []struct {
+		n Namer
+		x interface{}
+	}{
+		{Languages(en), Values.Tags()},
+		{Scripts(en), Values.Scripts()},
+		{Regions(en), Values.Regions()},
+	}
+	for i, tt := range tests {
+		uniq := make(map[string]interface{})
+
+		v := reflect.ValueOf(tt.x)
+		for j := 0; j < v.Len(); j++ {
+			x := v.Index(j).Interface()
+			// As of version 28 there is no data for az-Arab in English,
+			// although there is useful data in other languages.
+			if x.(fmt.Stringer).String() == "az-Arab" {
+				continue
+			}
+			s := tt.n.Name(x)
+			if s == "" {
+				t.Errorf("%d:%d:%s: missing content", i, j, x)
+			} else if uniq[s] != nil {
+				t.Errorf("%d:%d:%s: identical return value %q for %v and %v", i, j, x, s, x, uniq[s])
+			}
+			uniq[s] = x
+		}
+	}
+}
+
+// TestUpdate tests whether dictionary entries for certain languages need to be
+// updated. For some languages, some of the headers may be empty or they may be
+// identical to the parent. This code detects if such entries need to be updated
+// after a table update.
+func TestUpdate(t *testing.T) {
+	tests := []struct {
+		d   *Dictionary
+		tag string
+	}{
+		{ModernStandardArabic, "ar-001"},
+		{AmericanEnglish, "en-US"},
+		{EuropeanSpanish, "es-ES"},
+		{BrazilianPortuguese, "pt-BR"},
+		{SimplifiedChinese, "zh-Hans"},
+	}
+
+	for _, tt := range tests {
+		_, i, _ := matcher.Match(language.MustParse(tt.tag))
+		if !reflect.DeepEqual(tt.d.lang, langHeaders[i]) {
+			t.Errorf("%s: lang table update needed", tt.tag)
+		}
+		if !reflect.DeepEqual(tt.d.script, scriptHeaders[i]) {
+			t.Errorf("%s: script table update needed", tt.tag)
+		}
+		if !reflect.DeepEqual(tt.d.region, regionHeaders[i]) {
+			t.Errorf("%s: region table update needed", tt.tag)
+		}
+	}
+}
+
+func TestIndex(t *testing.T) {
+	notIn := []string{"aa", "xx", "zz", "aaa", "xxx", "zzz", "Aaaa", "Xxxx", "Zzzz"}
+	tests := []tagIndex{
+		{
+			"",
+			"",
+			"",
+		},
+		{
+			"bb",
+			"",
+			"",
+		},
+		{
+			"",
+			"bbb",
+			"",
+		},
+		{
+			"",
+			"",
+			"Bbbb",
+		},
+		{
+			"bb",
+			"bbb",
+			"Bbbb",
+		},
+		{
+			"bbccddyy",
+			"bbbcccdddyyy",
+			"BbbbCcccDdddYyyy",
+		},
+	}
+	for i, tt := range tests {
+		// Create the test set from the tagIndex.
+		cnt := 0
+		for sz := 2; sz <= 4; sz++ {
+			a := tt[sz-2]
+			for j := 0; j < len(a); j += sz {
+				s := a[j : j+sz]
+				if idx := tt.index(s); idx != cnt {
+					t.Errorf("%d:%s: index was %d; want %d", i, s, idx, cnt)
+				}
+				cnt++
+			}
+		}
+		if n := tt.len(); n != cnt {
+			t.Errorf("%d: len was %d; want %d", i, n, cnt)
+		}
+		for _, x := range notIn {
+			if idx := tt.index(x); idx != -1 {
+				t.Errorf("%d:%s: index was %d; want -1", i, x, idx)
+			}
+		}
+	}
+}
+
+func TestTag(t *testing.T) {
+	tests := []struct {
+		dict string
+		tag  string
+		name string
+	}{
+		{"agq", "sr", ""}, // sr is in Value.Languages(), but is not supported by agq.
+		{"nl", "nl", "Nederlands"},
+		// CLDR 30 dropped Vlaams as the word for nl-BE. It is still called
+		// Flemish in English, though. TODO: check if this is a CLDR bug.
+		// {"nl", "nl-BE", "Vlaams"},
+		{"nl", "nl-BE", "Nederlands (België)"},
+		{"nl", "vls", "West-Vlaams"},
+		{"en", "nl-BE", "Flemish"},
+		{"en", "en", "English"},
+		{"en", "en-GB", "British English"},
+		{"en", "en-US", "American English"}, // American English in CLDR 24+
+		{"ru", "ru", "русский"},
+		{"ru", "ru-RU", "русский (Россия)"},
+		{"ru", "ru-Cyrl", "русский (кириллица)"},
+		{"en", lastLang2zu.String(), "Zulu"},
+		{"en", firstLang2aa.String(), "Afar"},
+		{"en", lastLang3zza.String(), "Zaza"},
+		{"en", firstLang3ace.String(), "Achinese"},
+		{"en", firstTagAr001.String(), "Modern Standard Arabic"},
+		{"en", lastTagZhHant.String(), "Traditional Chinese"},
+		{"en", "aaa", ""},
+		{"en", "zzj", ""},
+		// If full tag doesn't match, try without script or region.
+		{"en", "aa-Hans", "Afar (Simplified Han)"},
+		{"en", "af-Arab", "Afrikaans (Arabic)"},
+		{"en", "zu-Cyrl", "Zulu (Cyrillic)"},
+		{"en", "aa-GB", "Afar (United Kingdom)"},
+		{"en", "af-NA", "Afrikaans (Namibia)"},
+		{"en", "zu-BR", "Zulu (Brazil)"},
+		// Correct inheritance and language selection.
+		{"zh", "zh-TW", "中文 (台湾)"},
+		{"zh", "zh-Hant-TW", "繁体中文 (台湾)"},
+		{"zh-Hant", "zh-TW", "中文 (台灣)"},
+		{"zh-Hant", "zh-Hant-TW", "繁體中文 (台灣)"},
+		// Some rather arbitrary interpretations for Serbian. This is arguably
+		// correct and consistent with the way zh-[Hant-]TW is handled. It will
+		// also give results more in line with the expectations if users
+		// explicitly use "sh".
+		{"sr-Latn", "sr-ME", "srpski (Crna Gora)"},
+		{"sr-Latn", "sr-Latn-ME", "srpskohrvatski (Crna Gora)"},
+		// Double script and region
+		{"nl", "en-Cyrl-BE", "Engels (Cyrillisch, België)"},
+		// Canonical equivalents.
+		{"ro", "ro-MD", "moldovenească"},
+		{"ro", "mo", "moldovenească"},
+	}
+	for i, tt := range tests {
+		d := Tags(language.MustParse(tt.dict))
+		if n := d.Name(language.Raw.MustParse(tt.tag)); n != tt.name {
+			// There are inconsistencies w.r.t. capitalization in the tests
+			// due to CLDR's update procedure which treats modern and other
+			// languages differently.
+			// See http://unicode.org/cldr/trac/ticket/8051.
+			// TODO: use language capitalization to sanitize the strings.
+			t.Errorf("%d:%s:%s: was %q; want %q", i, tt.dict, tt.tag, n, tt.name)
+		}
+	}
+}
+
+func TestLanguage(t *testing.T) {
+	tests := []struct {
+		dict string
+		tag  string
+		name string
+	}{
+		{"agq", "sr", ""}, // sr is in Value.Languages(), but is not supported by agq.
+		// CLDR 30 dropped Vlaams as the word for nl-BE. It is still called
+		// Flemish in English, though. TODO: this is probably incorrect.
+		// West-Vlaams (vls) is not Vlaams. West-Vlaams could be considered its
+		// own language, whereas Vlaams is generally Dutch. So expect to have
+		// to change these tests back.
+		{"nl", "nl", "Nederlands"},
+		{"nl", "vls", "West-Vlaams"},
+		{"nl", "nl-BE", "Nederlands"},
+		{"en", "pt", "Portuguese"},
+		{"en", "pt-PT", "European Portuguese"},
+		{"en", "pt-BR", "Brazilian Portuguese"},
+		{"en", "en", "English"},
+		{"en", "en-GB", "British English"},
+		{"en", "en-US", "American English"}, // American English in CLDR 24+
+		{"en", lastLang2zu.String(), "Zulu"},
+		{"en", firstLang2aa.String(), "Afar"},
+		{"en", lastLang3zza.String(), "Zaza"},
+		{"en", firstLang3ace.String(), "Achinese"},
+		{"en", firstTagAr001.String(), "Modern Standard Arabic"},
+		{"en", lastTagZhHant.String(), "Traditional Chinese"},
+		{"en", "aaa", ""},
+		{"en", "zzj", ""},
+		// If full tag doesn't match, try without script or region.
+		{"en", "aa-Hans", "Afar"},
+		{"en", "af-Arab", "Afrikaans"},
+		{"en", "zu-Cyrl", "Zulu"},
+		{"en", "aa-GB", "Afar"},
+		{"en", "af-NA", "Afrikaans"},
+		{"en", "zu-BR", "Zulu"},
+		{"agq", "zh-Hant", ""},
+		// Canonical equivalents.
+		{"ro", "ro-MD", "moldovenească"},
+		{"ro", "mo", "moldovenească"},
+		{"en", "sh", "Serbo-Croatian"},
+		{"en", "sr-Latn", "Serbo-Croatian"},
+		{"en", "sr", "Serbian"},
+		{"en", "sr-ME", "Serbian"},
+		{"en", "sr-Latn-ME", "Serbo-Croatian"}, // See comments in TestTag.
+	}
+	for i, tt := range tests {
+		testtext.Run(t, tt.dict+"/"+tt.tag, func(t *testing.T) {
+			d := Languages(language.Raw.MustParse(tt.dict))
+			if n := d.Name(language.Raw.MustParse(tt.tag)); n != tt.name {
+				t.Errorf("%d:%s:%s: was %q; want %q", i, tt.dict, tt.tag, n, tt.name)
+			}
+			if len(tt.tag) <= 3 {
+				if n := d.Name(language.MustParseBase(tt.tag)); n != tt.name {
+					t.Errorf("%d:%s:base(%s): was %q; want %q", i, tt.dict, tt.tag, n, tt.name)
+				}
+			}
+		})
+	}
+}
+
+func TestScript(t *testing.T) {
+	tests := []struct {
+		dict string
+		scr  string
+		name string
+	}{
+		{"nl", "Arab", "Arabisch"},
+		{"en", "Arab", "Arabic"},
+		{"en", "Zzzz", "Unknown Script"},
+		{"zh-Hant", "Hang", "韓文字"},
+		{"zh-Hant-HK", "Hang", "韓文字"},
+		{"zh", "Arab", "阿拉伯文"},
+		{"zh-Hans-HK", "Arab", "阿拉伯文"}, // same as zh
+		{"zh-Hant", "Arab", "阿拉伯文"},
+		{"zh-Hant-HK", "Arab", "阿拉伯文"}, // same as zh
+		// Canonicalized form
+		{"en", "Qaai", "Inherited"},    // deprecated script, now is Zinh
+		{"en", "sh", "Unknown Script"}, // sh canonicalizes to sr-Latn
+		{"en", "en", "Unknown Script"},
+		// Don't introduce scripts with canonicalization.
+		{"en", "sh", "Unknown Script"}, // sh canonicalizes to sr-Latn
+	}
+	for i, tt := range tests {
+		d := Scripts(language.MustParse(tt.dict))
+		var x interface{}
+		if unicode.IsUpper(rune(tt.scr[0])) {
+			x = language.MustParseScript(tt.scr)
+			tag, _ := language.Raw.Compose(x)
+			if n := d.Name(tag); n != tt.name {
+				t.Errorf("%d:%s:%s: was %q; want %q", i, tt.dict, tt.scr, n, tt.name)
+			}
+		} else {
+			x = language.Raw.MustParse(tt.scr)
+		}
+		if n := d.Name(x); n != tt.name {
+			t.Errorf("%d:%s:%s: was %q; want %q", i, tt.dict, tt.scr, n, tt.name)
+		}
+	}
+}
+
+func TestRegion(t *testing.T) {
+	tests := []struct {
+		dict string
+		reg  string
+		name string
+	}{
+		{"nl", "NL", "Nederland"},
+		{"en", "US", "United States"},
+		{"en", "ZZ", "Unknown Region"},
+		{"en", "UM", "U.S. Outlying Islands"},
+		{"en-GB", "UM", "U.S. Outlying Islands"},
+		{"en-GB", "NL", "Netherlands"},
+		// Canonical equivalents
+		{"en", "UK", "United Kingdom"},
+		// No region
+		{"en", "pt", "Unknown Region"},
+		{"en", "und", "Unknown Region"},
+		// Don't introduce regions with canonicalization.
+		{"en", "mo", "Unknown Region"},
+	}
+	for i, tt := range tests {
+		d := Regions(language.MustParse(tt.dict))
+		var x interface{}
+		if unicode.IsUpper(rune(tt.reg[0])) {
+			// Region
+			x = language.MustParseRegion(tt.reg)
+			tag, _ := language.Raw.Compose(x)
+			if n := d.Name(tag); n != tt.name {
+				t.Errorf("%d:%s:%s: was %q; want %q", i, tt.dict, tt.reg, n, tt.name)
+			}
+		} else {
+			// Tag
+			x = language.Raw.MustParse(tt.reg)
+		}
+		if n := d.Name(x); n != tt.name {
+			t.Errorf("%d:%s:%s: was %q; want %q", i, tt.dict, tt.reg, n, tt.name)
+		}
+	}
+}
+
+func TestSelf(t *testing.T) {
+	tests := []struct {
+		tag  string
+		name string
+	}{
+		{"nl", "Nederlands"},
+		// CLDR 30 dropped Vlaams as the word for nl-BE. It is still called
+		// Flemish in English, though. TODO: check if this is a CLDR bug.
+		// {"nl-BE", "Vlaams"},
+		{"nl-BE", "Nederlands"},
+		{"en-GB", "British English"},
+		{lastLang2zu.String(), "isiZulu"},
+		{firstLang2aa.String(), ""},  // not defined
+		{lastLang3zza.String(), ""},  // not defined
+		{firstLang3ace.String(), ""}, // not defined
+		{firstTagAr001.String(), "العربية الرسمية الحديثة"},
+		{"ar", "العربية"},
+		{lastTagZhHant.String(), "繁體中文"},
+		{"aaa", ""},
+		{"zzj", ""},
+		// Drop entries that are not in the requested script, even if there is
+		// an entry for the language.
+		{"aa-Hans", ""},
+		{"af-Arab", ""},
+		{"zu-Cyrl", ""},
+		// Append the country name in the language of the matching language.
+		{"af-NA", "Afrikaans"},
+		{"zh", "中文"},
+		// zh-TW should match zh-Hant instead of zh!
+		{"zh-TW", "繁體中文"},
+		{"zh-Hant", "繁體中文"},
+		{"zh-Hans", "简体中文"},
+		{"zh-Hant-TW", "繁體中文"},
+		{"zh-Hans-TW", "简体中文"},
+		// Take the entry for sr which has the matching script.
+		// TODO: Capitalization changed as of CLDR 26, but change seems
+		// arbitrary. Revisit capitalization with revision 27. See
+		// http://unicode.org/cldr/trac/ticket/8051.
+		{"sr", "српски"},
+		// TODO: sr-ME should show up as Serbian or Montenegrin, not Serbo-
+		// Croatian. This is an artifact of the current algorithm, which is the
+		// way it is to have the preferred behavior for other languages such as
+		// Chinese. We can hardwire this case in the table generator or package
+		// code, but we first check if CLDR can be updated.
+		// {"sr-ME", "Srpski"}, // Is Srpskohrvatski
+		{"sr-Latn-ME", "srpskohrvatski"},
+		{"sr-Cyrl-ME", "српски"},
+		{"sr-NL", "српски"},
+		// Canonical equivalents.
+		{"ro-MD", "moldovenească"},
+		{"mo", "moldovenească"},
+		// NOTE: kk is defined, but in Cyrillic script. For China, Arab is the
+		// dominant script. We do not have data for kk-Arab and we chose to not
+		// fall back in such cases.
+		{"kk-CN", ""},
+	}
+	for i, tt := range tests {
+		d := Self
+		if n := d.Name(language.Raw.MustParse(tt.tag)); n != tt.name {
+			t.Errorf("%d:%s: was %q; want %q", i, tt.tag, n, tt.name)
+		}
+	}
+}
+
+func TestDictionaryLang(t *testing.T) {
+	tests := []struct {
+		d    *Dictionary
+		tag  string
+		name string
+	}{
+		{English, "en", "English"},
+		{Portuguese, "af", "africâner"},
+		{EuropeanPortuguese, "af", "africanês"},
+		{English, "nl-BE", "Flemish"},
+	}
+	for i, test := range tests {
+		tag := language.MustParse(test.tag)
+		if got := test.d.Tags().Name(tag); got != test.name {
+			t.Errorf("%d:%v: got %s; want %s", i, tag, got, test.name)
+		}
+		if base, _ := language.Compose(tag.Base()); base == tag {
+			if got := test.d.Languages().Name(base); got != test.name {
+				t.Errorf("%d:%v: got %s; want %s", i, tag, got, test.name)
+			}
+		}
+	}
+}
+
+func TestDictionaryRegion(t *testing.T) {
+	tests := []struct {
+		d      *Dictionary
+		region string
+		name   string
+	}{
+		{English, "FR", "France"},
+		{Portuguese, "009", "Oceania"},
+		{EuropeanPortuguese, "009", "Oceânia"},
+	}
+	for i, test := range tests {
+		tag := language.MustParseRegion(test.region)
+		if got := test.d.Regions().Name(tag); got != test.name {
+			t.Errorf("%d:%v: got %s; want %s", i, tag, got, test.name)
+		}
+	}
+}
+
+func TestDictionaryScript(t *testing.T) {
+	tests := []struct {
+		d      *Dictionary
+		script string
+		name   string
+	}{
+		{English, "Cyrl", "Cyrillic"},
+		{Portuguese, "Gujr", "gujerati"},
+		{EuropeanPortuguese, "Gujr", "guzerate"},
+	}
+	for i, test := range tests {
+		tag := language.MustParseScript(test.script)
+		if got := test.d.Scripts().Name(tag); got != test.name {
+			t.Errorf("%d:%v: got %s; want %s", i, tag, got, test.name)
+		}
+	}
+}

vendor/golang.org/x/text/language/display/examples_test.go

@@ -0,0 +1,98 @@
+// Copyright 2014 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.
+
+package display_test
+
+import (
+	"fmt"
+
+	"golang.org/x/text/language"
+	"golang.org/x/text/language/display"
+)
+
+func ExampleNamer() {
+	supported := []string{
+		"en-US", "en-GB", "ja", "zh", "zh-Hans", "zh-Hant", "pt", "pt-PT", "ko", "ar", "el", "ru", "uk", "pa",
+	}
+
+	en := display.English.Languages()
+
+	for _, s := range supported {
+		t := language.MustParse(s)
+		fmt.Printf("%-20s (%s)\n", en.Name(t), display.Self.Name(t))
+	}
+
+	// Output:
+	// American English     (American English)
+	// British English      (British English)
+	// Japanese             (日本語)
+	// Chinese              (中文)
+	// Simplified Chinese   (简体中文)
+	// Traditional Chinese  (繁體中文)
+	// Portuguese           (português)
+	// European Portuguese  (português europeu)
+	// Korean               (한국어)
+	// Arabic               (العربية)
+	// Greek                (Ελληνικά)
+	// Russian              (русский)
+	// Ukrainian            (українська)
+	// Punjabi              (ਪੰਜਾਬੀ)
+}
+
+func ExampleTags() {
+	n := display.Tags(language.English)
+	fmt.Println(n.Name(language.Make("nl")))
+	fmt.Println(n.Name(language.Make("nl-BE")))
+	fmt.Println(n.Name(language.Make("nl-CW")))
+	fmt.Println(n.Name(language.Make("nl-Arab")))
+	fmt.Println(n.Name(language.Make("nl-Cyrl-RU")))
+
+	// Output:
+	// Dutch
+	// Flemish
+	// Dutch (Curaçao)
+	// Dutch (Arabic)
+	// Dutch (Cyrillic, Russia)
+}
+
+// ExampleDictionary shows how to reduce the amount of data linked into your
+// binary by only using the predefined Dictionary variables of the languages you
+// wish to support.
+func ExampleDictionary() {
+	tags := []language.Tag{
+		language.English,
+		language.German,
+		language.Japanese,
+		language.Russian,
+	}
+	dicts := []*display.Dictionary{
+		display.English,
+		display.German,
+		display.Japanese,
+		display.Russian,
+	}
+
+	m := language.NewMatcher(tags)
+
+	getDict := func(t language.Tag) *display.Dictionary {
+		_, i, confidence := m.Match(t)
+		// Skip this check if you want to support a fall-back language, which
+		// will be the first one passed to NewMatcher.
+		if confidence == language.No {
+			return nil
+		}
+		return dicts[i]
+	}
+
+	// The matcher will match Swiss German to German.
+	n := getDict(language.Make("gsw")).Languages()
+	fmt.Println(n.Name(language.German))
+	fmt.Println(n.Name(language.Make("de-CH")))
+	fmt.Println(n.Name(language.Make("gsw")))
+
+	// Output:
+	// Deutsch
+	// Schweizer Hochdeutsch
+	// Schweizerdeutsch
+}

vendor/golang.org/x/text/language/display/lookup.go

@@ -0,0 +1,251 @@
+// Copyright 2014 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.
+
+package display
+
+// This file contains common lookup code that is shared between the various
+// implementations of Namer and Dictionaries.
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+
+	"golang.org/x/text/language"
+)
+
+type namer interface {
+	// name gets the string for the given index. It should walk the
+	// inheritance chain if a value is not present in the base index.
+	name(idx int) string
+}
+
+func nameLanguage(n namer, x interface{}) string {
+	t, _ := language.All.Compose(x)
+	for {
+		i, _, _ := langTagSet.index(t.Raw())
+		if s := n.name(i); s != "" {
+			return s
+		}
+		if t = t.Parent(); t == language.Und {
+			return ""
+		}
+	}
+}
+
+func nameScript(n namer, x interface{}) string {
+	t, _ := language.DeprecatedScript.Compose(x)
+	_, s, _ := t.Raw()
+	return n.name(scriptIndex.index(s.String()))
+}
+
+func nameRegion(n namer, x interface{}) string {
+	t, _ := language.DeprecatedRegion.Compose(x)
+	_, _, r := t.Raw()
+	return n.name(regionIndex.index(r.String()))
+}
+
+func nameTag(langN, scrN, regN namer, x interface{}) string {
+	t, ok := x.(language.Tag)
+	if !ok {
+		return ""
+	}
+	const form = language.All &^ language.SuppressScript
+	if c, err := form.Canonicalize(t); err == nil {
+		t = c
+	}
+	_, sRaw, rRaw := t.Raw()
+	i, scr, reg := langTagSet.index(t.Raw())
+	for i != -1 {
+		if str := langN.name(i); str != "" {
+			if hasS, hasR := (scr != language.Script{}), (reg != language.Region{}); hasS || hasR {
+				ss, sr := "", ""
+				if hasS {
+					ss = scrN.name(scriptIndex.index(scr.String()))
+				}
+				if hasR {
+					sr = regN.name(regionIndex.index(reg.String()))
+				}
+				// TODO: use patterns in CLDR or at least confirm they are the
+				// same for all languages.
+				if ss != "" && sr != "" {
+					return fmt.Sprintf("%s (%s, %s)", str, ss, sr)
+				}
+				if ss != "" || sr != "" {
+					return fmt.Sprintf("%s (%s%s)", str, ss, sr)
+				}
+			}
+			return str
+		}
+		scr, reg = sRaw, rRaw
+		if t = t.Parent(); t == language.Und {
+			return ""
+		}
+		i, _, _ = langTagSet.index(t.Raw())
+	}
+	return ""
+}
+
+// header contains the data and indexes for a single namer.
+// data contains a series of strings concatenated into one. index contains the
+// offsets for a string in data. For example, consider a header that defines
+// strings for the languages de, el, en, fi, and nl:
+//
+// 		header{
+// 			data: "GermanGreekEnglishDutch",
+//  		index: []uint16{ 0, 6, 11, 18, 18, 23 },
+// 		}
+//
+// For a language with index i, the string is defined by
+// data[index[i]:index[i+1]]. So the number of elements in index is always one
+// greater than the number of languages for which header defines a value.
+// A string for a language may be empty, which means the name is undefined. In
+// the above example, the name for fi (Finnish) is undefined.
+type header struct {
+	data  string
+	index []uint16
+}
+
+// name looks up the name for a tag in the dictionary, given its index.
+func (h *header) name(i int) string {
+	if 0 <= i && i < len(h.index)-1 {
+		return h.data[h.index[i]:h.index[i+1]]
+	}
+	return ""
+}
+
+// tagSet is used to find the index of a language in a set of tags.
+type tagSet struct {
+	single tagIndex
+	long   []string
+}
+
+var (
+	langTagSet = tagSet{
+		single: langIndex,
+		long:   langTagsLong,
+	}
+
+	// selfTagSet is used for indexing the language strings in their own
+	// language.
+	selfTagSet = tagSet{
+		single: selfIndex,
+		long:   selfTagsLong,
+	}
+
+	zzzz = language.MustParseScript("Zzzz")
+	zz   = language.MustParseRegion("ZZ")
+)
+
+// index returns the index of the tag for the given base, script and region or
+// its parent if the tag is not available. If the match is for a parent entry,
+// the excess script and region are returned.
+func (ts *tagSet) index(base language.Base, scr language.Script, reg language.Region) (int, language.Script, language.Region) {
+	lang := base.String()
+	index := -1
+	if (scr != language.Script{} || reg != language.Region{}) {
+		if scr == zzzz {
+			scr = language.Script{}
+		}
+		if reg == zz {
+			reg = language.Region{}
+		}
+
+		i := sort.SearchStrings(ts.long, lang)
+		// All entries have either a script or a region and not both.
+		scrStr, regStr := scr.String(), reg.String()
+		for ; i < len(ts.long) && strings.HasPrefix(ts.long[i], lang); i++ {
+			if s := ts.long[i][len(lang)+1:]; s == scrStr {
+				scr = language.Script{}
+				index = i + ts.single.len()
+				break
+			} else if s == regStr {
+				reg = language.Region{}
+				index = i + ts.single.len()
+				break
+			}
+		}
+	}
+	if index == -1 {
+		index = ts.single.index(lang)
+	}
+	return index, scr, reg
+}
+
+func (ts *tagSet) Tags() []language.Tag {
+	tags := make([]language.Tag, 0, ts.single.len()+len(ts.long))
+	ts.single.keys(func(s string) {
+		tags = append(tags, language.Raw.MustParse(s))
+	})
+	for _, s := range ts.long {
+		tags = append(tags, language.Raw.MustParse(s))
+	}
+	return tags
+}
+
+func supportedScripts() []language.Script {
+	scr := make([]language.Script, 0, scriptIndex.len())
+	scriptIndex.keys(func(s string) {
+		scr = append(scr, language.MustParseScript(s))
+	})
+	return scr
+}
+
+func supportedRegions() []language.Region {
+	reg := make([]language.Region, 0, regionIndex.len())
+	regionIndex.keys(func(s string) {
+		reg = append(reg, language.MustParseRegion(s))
+	})
+	return reg
+}
+
+// tagIndex holds a concatenated lists of subtags of length 2 to 4, one string
+// for each length, which can be used in combination with binary search to get
+// the index associated with a tag.
+// For example, a tagIndex{
+//   "arenesfrruzh",  // 6 2-byte tags.
+//   "barwae",        // 2 3-byte tags.
+//   "",
+// }
+// would mean that the 2-byte tag "fr" had an index of 3, and the 3-byte tag
+// "wae" had an index of 7.
+type tagIndex [3]string
+
+func (t *tagIndex) index(s string) int {
+	sz := len(s)
+	if sz < 2 || 4 < sz {
+		return -1
+	}
+	a := t[sz-2]
+	index := sort.Search(len(a)/sz, func(i int) bool {
+		p := i * sz
+		return a[p:p+sz] >= s
+	})
+	p := index * sz
+	if end := p + sz; end > len(a) || a[p:end] != s {
+		return -1
+	}
+	// Add the number of tags for smaller sizes.
+	for i := 0; i < sz-2; i++ {
+		index += len(t[i]) / (i + 2)
+	}
+	return index
+}
+
+// len returns the number of tags that are contained in the tagIndex.
+func (t *tagIndex) len() (n int) {
+	for i, s := range t {
+		n += len(s) / (i + 2)
+	}
+	return n
+}
+
+// keys calls f for each tag.
+func (t *tagIndex) keys(f func(key string)) {
+	for i, s := range *t {
+		for ; s != ""; s = s[i+2:] {
+			f(s[:i+2])
+		}
+	}
+}

vendor/golang.org/x/text/language/display/maketables.go

@@ -0,0 +1,596 @@
+// Copyright 2014 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 ignore
+
+// Generator for display name tables.
+
+package main
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"log"
+	"reflect"
+	"sort"
+	"strings"
+
+	"golang.org/x/text/internal/gen"
+	"golang.org/x/text/language"
+	"golang.org/x/text/unicode/cldr"
+)
+
+var (
+	test = flag.Bool("test", false,
+		"test existing tables; can be used to compare web data with package data.")
+	outputFile = flag.String("output", "tables.go", "output file")
+
+	stats = flag.Bool("stats", false, "prints statistics to stderr")
+
+	short = flag.Bool("short", false, `Use "short" alternatives, when available.`)
+	draft = flag.String("draft",
+		"contributed",
+		`Minimal draft requirements (approved, contributed, provisional, unconfirmed).`)
+	pkg = flag.String("package",
+		"display",
+		"the name of the package in which the generated file is to be included")
+
+	tags = newTagSet("tags",
+		[]language.Tag{},
+		"space-separated list of tags to include or empty for all")
+	dict = newTagSet("dict",
+		dictTags(),
+		"space-separated list or tags for which to include a Dictionary. "+
+			`"" means the common list from go.text/language.`)
+)
+
+func dictTags() (tag []language.Tag) {
+	// TODO: replace with language.Common.Tags() once supported.
+	const str = "af am ar ar-001 az bg bn ca cs da de el en en-US en-GB " +
+		"es es-ES es-419 et fa fi fil fr fr-CA gu he hi hr hu hy id is it ja " +
+		"ka kk km kn ko ky lo lt lv mk ml mn mr ms my ne nl no pa pl pt pt-BR " +
+		"pt-PT ro ru si sk sl sq sr sr-Latn sv sw ta te th tr uk ur uz vi " +
+		"zh zh-Hans zh-Hant zu"
+
+	for _, s := range strings.Split(str, " ") {
+		tag = append(tag, language.MustParse(s))
+	}
+	return tag
+}
+
+func main() {
+	gen.Init()
+
+	// Read the CLDR zip file.
+	r := gen.OpenCLDRCoreZip()
+	defer r.Close()
+
+	d := &cldr.Decoder{}
+	d.SetDirFilter("main", "supplemental")
+	d.SetSectionFilter("localeDisplayNames")
+	data, err := d.DecodeZip(r)
+	if err != nil {
+		log.Fatalf("DecodeZip: %v", err)
+	}
+
+	w := gen.NewCodeWriter()
+	defer w.WriteGoFile(*outputFile, "display")
+
+	gen.WriteCLDRVersion(w)
+
+	b := builder{
+		w:     w,
+		data:  data,
+		group: make(map[string]*group),
+	}
+	b.generate()
+}
+
+const tagForm = language.All
+
+// tagSet is used to parse command line flags of tags. It implements the
+// flag.Value interface.
+type tagSet map[language.Tag]bool
+
+func newTagSet(name string, tags []language.Tag, usage string) tagSet {
+	f := tagSet(make(map[language.Tag]bool))
+	for _, t := range tags {
+		f[t] = true
+	}
+	flag.Var(f, name, usage)
+	return f
+}
+
+// String implements the String method of the flag.Value interface.
+func (f tagSet) String() string {
+	tags := []string{}
+	for t := range f {
+		tags = append(tags, t.String())
+	}
+	sort.Strings(tags)
+	return strings.Join(tags, " ")
+}
+
+// Set implements Set from the flag.Value interface.
+func (f tagSet) Set(s string) error {
+	if s != "" {
+		for _, s := range strings.Split(s, " ") {
+			if s != "" {
+				tag, err := tagForm.Parse(s)
+				if err != nil {
+					return err
+				}
+				f[tag] = true
+			}
+		}
+	}
+	return nil
+}
+
+func (f tagSet) contains(t language.Tag) bool {
+	if len(f) == 0 {
+		return true
+	}
+	return f[t]
+}
+
+// builder is used to create all tables with display name information.
+type builder struct {
+	w *gen.CodeWriter
+
+	data *cldr.CLDR
+
+	fromLocs []string
+
+	// destination tags for the current locale.
+	toTags     []string
+	toTagIndex map[string]int
+
+	// list of supported tags
+	supported []language.Tag
+
+	// key-value pairs per group
+	group map[string]*group
+
+	// statistics
+	sizeIndex int // total size of all indexes of headers
+	sizeData  int // total size of all data of headers
+	totalSize int
+}
+
+type group struct {
+	// Maps from a given language to the Namer data for this language.
+	lang    map[language.Tag]keyValues
+	headers []header
+
+	toTags        []string
+	threeStart    int
+	fourPlusStart int
+}
+
+// set sets the typ to the name for locale loc.
+func (g *group) set(t language.Tag, typ, name string) {
+	kv := g.lang[t]
+	if kv == nil {
+		kv = make(keyValues)
+		g.lang[t] = kv
+	}
+	if kv[typ] == "" {
+		kv[typ] = name
+	}
+}
+
+type keyValues map[string]string
+
+type header struct {
+	tag   language.Tag
+	data  string
+	index []uint16
+}
+
+var versionInfo = `// Version is deprecated. Use CLDRVersion.
+const Version = %#v
+
+`
+
+var self = language.MustParse("mul")
+
+// generate builds and writes all tables.
+func (b *builder) generate() {
+	fmt.Fprintf(b.w, versionInfo, cldr.Version)
+
+	b.filter()
+	b.setData("lang", func(g *group, loc language.Tag, ldn *cldr.LocaleDisplayNames) {
+		if ldn.Languages != nil {
+			for _, v := range ldn.Languages.Language {
+				tag := tagForm.MustParse(v.Type)
+				if tags.contains(tag) {
+					g.set(loc, tag.String(), v.Data())
+				}
+			}
+		}
+	})
+	b.setData("script", func(g *group, loc language.Tag, ldn *cldr.LocaleDisplayNames) {
+		if ldn.Scripts != nil {
+			for _, v := range ldn.Scripts.Script {
+				code := language.MustParseScript(v.Type)
+				if code.IsPrivateUse() { // Qaaa..Qabx
+					// TODO: data currently appears to be very meager.
+					// Reconsider if we have data for English.
+					if loc == language.English {
+						log.Fatal("Consider including data for private use scripts.")
+					}
+					continue
+				}
+				g.set(loc, code.String(), v.Data())
+			}
+		}
+	})
+	b.setData("region", func(g *group, loc language.Tag, ldn *cldr.LocaleDisplayNames) {
+		if ldn.Territories != nil {
+			for _, v := range ldn.Territories.Territory {
+				g.set(loc, language.MustParseRegion(v.Type).String(), v.Data())
+			}
+		}
+	})
+
+	b.makeSupported()
+
+	b.writeParents()
+
+	b.writeGroup("lang")
+	b.writeGroup("script")
+	b.writeGroup("region")
+
+	b.w.WriteConst("numSupported", len(b.supported))
+	buf := bytes.Buffer{}
+	for _, tag := range b.supported {
+		fmt.Fprint(&buf, tag.String(), "|")
+	}
+	b.w.WriteConst("supported", buf.String())
+
+	b.writeDictionaries()
+
+	b.supported = []language.Tag{self}
+
+	// Compute the names of locales in their own language. Some of these names
+	// may be specified in their parent locales. We iterate the maximum depth
+	// of the parent three times to match successive parents of tags until a
+	// possible match is found.
+	for i := 0; i < 4; i++ {
+		b.setData("self", func(g *group, tag language.Tag, ldn *cldr.LocaleDisplayNames) {
+			parent := tag
+			if b, s, r := tag.Raw(); i > 0 && (s != language.Script{} && r == language.Region{}) {
+				parent, _ = language.Raw.Compose(b)
+			}
+			if ldn.Languages != nil {
+				for _, v := range ldn.Languages.Language {
+					key := tagForm.MustParse(v.Type)
+					saved := key
+					if key == parent {
+						g.set(self, tag.String(), v.Data())
+					}
+					for k := 0; k < i; k++ {
+						key = key.Parent()
+					}
+					if key == tag {
+						g.set(self, saved.String(), v.Data()) // set does not overwrite a value.
+					}
+				}
+			}
+		})
+	}
+
+	b.writeGroup("self")
+}
+
+func (b *builder) setData(name string, f func(*group, language.Tag, *cldr.LocaleDisplayNames)) {
+	b.sizeIndex = 0
+	b.sizeData = 0
+	b.toTags = nil
+	b.fromLocs = nil
+	b.toTagIndex = make(map[string]int)
+
+	g := b.group[name]
+	if g == nil {
+		g = &group{lang: make(map[language.Tag]keyValues)}
+		b.group[name] = g
+	}
+	for _, loc := range b.data.Locales() {
+		// We use RawLDML instead of LDML as we are managing our own inheritance
+		// in this implementation.
+		ldml := b.data.RawLDML(loc)
+
+		// We do not support the POSIX variant (it is not a supported BCP 47
+		// variant). This locale also doesn't happen to contain any data, so
+		// we'll skip it by checking for this.
+		tag, err := tagForm.Parse(loc)
+		if err != nil {
+			if ldml.LocaleDisplayNames != nil {
+				log.Fatalf("setData: %v", err)
+			}
+			continue
+		}
+		if ldml.LocaleDisplayNames != nil && tags.contains(tag) {
+			f(g, tag, ldml.LocaleDisplayNames)
+		}
+	}
+}
+
+func (b *builder) filter() {
+	filter := func(s *cldr.Slice) {
+		if *short {
+			s.SelectOnePerGroup("alt", []string{"short", ""})
+		} else {
+			s.SelectOnePerGroup("alt", []string{"stand-alone", ""})
+		}
+		d, err := cldr.ParseDraft(*draft)
+		if err != nil {
+			log.Fatalf("filter: %v", err)
+		}
+		s.SelectDraft(d)
+	}
+	for _, loc := range b.data.Locales() {
+		if ldn := b.data.RawLDML(loc).LocaleDisplayNames; ldn != nil {
+			if ldn.Languages != nil {
+				s := cldr.MakeSlice(&ldn.Languages.Language)
+				if filter(&s); len(ldn.Languages.Language) == 0 {
+					ldn.Languages = nil
+				}
+			}
+			if ldn.Scripts != nil {
+				s := cldr.MakeSlice(&ldn.Scripts.Script)
+				if filter(&s); len(ldn.Scripts.Script) == 0 {
+					ldn.Scripts = nil
+				}
+			}
+			if ldn.Territories != nil {
+				s := cldr.MakeSlice(&ldn.Territories.Territory)
+				if filter(&s); len(ldn.Territories.Territory) == 0 {
+					ldn.Territories = nil
+				}
+			}
+		}
+	}
+}
+
+// makeSupported creates a list of all supported locales.
+func (b *builder) makeSupported() {
+	// tags across groups
+	for _, g := range b.group {
+		for t, _ := range g.lang {
+			b.supported = append(b.supported, t)
+		}
+	}
+	b.supported = b.supported[:unique(tagsSorter(b.supported))]
+
+}
+
+type tagsSorter []language.Tag
+
+func (a tagsSorter) Len() int           { return len(a) }
+func (a tagsSorter) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
+func (a tagsSorter) Less(i, j int) bool { return a[i].String() < a[j].String() }
+
+func (b *builder) writeGroup(name string) {
+	g := b.group[name]
+
+	for _, kv := range g.lang {
+		for t, _ := range kv {
+			g.toTags = append(g.toTags, t)
+		}
+	}
+	g.toTags = g.toTags[:unique(tagsBySize(g.toTags))]
+
+	// Allocate header per supported value.
+	g.headers = make([]header, len(b.supported))
+	for i, sup := range b.supported {
+		kv, ok := g.lang[sup]
+		if !ok {
+			g.headers[i].tag = sup
+			continue
+		}
+		data := []byte{}
+		index := make([]uint16, len(g.toTags), len(g.toTags)+1)
+		for j, t := range g.toTags {
+			index[j] = uint16(len(data))
+			data = append(data, kv[t]...)
+		}
+		index = append(index, uint16(len(data)))
+
+		// Trim the tail of the index.
+		// TODO: indexes can be reduced in size quite a bit more.
+		n := len(index)
+		for ; n >= 2 && index[n-2] == index[n-1]; n-- {
+		}
+		index = index[:n]
+
+		// Workaround for a bug in CLDR 26.
+		// See http://unicode.org/cldr/trac/ticket/8042.
+		if cldr.Version == "26" && sup.String() == "hsb" {
+			data = bytes.Replace(data, []byte{'"'}, nil, 1)
+		}
+		g.headers[i] = header{sup, string(data), index}
+	}
+	g.writeTable(b.w, name)
+}
+
+type tagsBySize []string
+
+func (l tagsBySize) Len() int      { return len(l) }
+func (l tagsBySize) Swap(i, j int) { l[i], l[j] = l[j], l[i] }
+func (l tagsBySize) Less(i, j int) bool {
+	a, b := l[i], l[j]
+	// Sort single-tag entries based on size first. Otherwise alphabetic.
+	if len(a) != len(b) && (len(a) <= 4 || len(b) <= 4) {
+		return len(a) < len(b)
+	}
+	return a < b
+}
+
+// parentIndices returns slice a of len(tags) where tags[a[i]] is the parent
+// of tags[i].
+func parentIndices(tags []language.Tag) []int16 {
+	index := make(map[language.Tag]int16)
+	for i, t := range tags {
+		index[t] = int16(i)
+	}
+
+	// Construct default parents.
+	parents := make([]int16, len(tags))
+	for i, t := range tags {
+		parents[i] = -1
+		for t = t.Parent(); t != language.Und; t = t.Parent() {
+			if j, ok := index[t]; ok {
+				parents[i] = j
+				break
+			}
+		}
+	}
+	return parents
+}
+
+func (b *builder) writeParents() {
+	parents := parentIndices(b.supported)
+	fmt.Fprintf(b.w, "var parents = ")
+	b.w.WriteArray(parents)
+}
+
+// writeKeys writes keys to a special index used by the display package.
+// tags are assumed to be sorted by length.
+func writeKeys(w *gen.CodeWriter, name string, keys []string) {
+	w.Size += int(3 * reflect.TypeOf("").Size())
+	w.WriteComment("Number of keys: %d", len(keys))
+	fmt.Fprintf(w, "var (\n\t%sIndex = tagIndex{\n", name)
+	for i := 2; i <= 4; i++ {
+		sub := []string{}
+		for _, t := range keys {
+			if len(t) != i {
+				break
+			}
+			sub = append(sub, t)
+		}
+		s := strings.Join(sub, "")
+		w.WriteString(s)
+		fmt.Fprintf(w, ",\n")
+		keys = keys[len(sub):]
+	}
+	fmt.Fprintln(w, "\t}")
+	if len(keys) > 0 {
+		w.Size += int(reflect.TypeOf([]string{}).Size())
+		fmt.Fprintf(w, "\t%sTagsLong = ", name)
+		w.WriteSlice(keys)
+	}
+	fmt.Fprintln(w, ")\n")
+}
+
+// identifier creates an identifier from the given tag.
+func identifier(t language.Tag) string {
+	return strings.Replace(t.String(), "-", "", -1)
+}
+
+func (h *header) writeEntry(w *gen.CodeWriter, name string) {
+	if len(dict) > 0 && dict.contains(h.tag) {
+		fmt.Fprintf(w, "\t{ // %s\n", h.tag)
+		fmt.Fprintf(w, "\t\t%[1]s%[2]sStr,\n\t\t%[1]s%[2]sIdx,\n", identifier(h.tag), name)
+		fmt.Fprintln(w, "\t},")
+	} else if len(h.data) == 0 {
+		fmt.Fprintln(w, "\t\t{}, //", h.tag)
+	} else {
+		fmt.Fprintf(w, "\t{ // %s\n", h.tag)
+		w.WriteString(h.data)
+		fmt.Fprintln(w, ",")
+		w.WriteSlice(h.index)
+		fmt.Fprintln(w, ",\n\t},")
+	}
+}
+
+// write the data for the given header as single entries. The size for this data
+// was already accounted for in writeEntry.
+func (h *header) writeSingle(w *gen.CodeWriter, name string) {
+	if len(dict) > 0 && dict.contains(h.tag) {
+		tag := identifier(h.tag)
+		w.WriteConst(tag+name+"Str", h.data)
+
+		// Note that we create a slice instead of an array. If we use an array
+		// we need to refer to it as a[:] in other tables, which will cause the
+		// array to always be included by the linker. See Issue 7651.
+		w.WriteVar(tag+name+"Idx", h.index)
+	}
+}
+
+// WriteTable writes an entry for a single Namer.
+func (g *group) writeTable(w *gen.CodeWriter, name string) {
+	start := w.Size
+	writeKeys(w, name, g.toTags)
+	w.Size += len(g.headers) * int(reflect.ValueOf(g.headers[0]).Type().Size())
+
+	fmt.Fprintf(w, "var %sHeaders = [%d]header{\n", name, len(g.headers))
+
+	title := strings.Title(name)
+	for _, h := range g.headers {
+		h.writeEntry(w, title)
+	}
+	fmt.Fprintln(w, "}\n")
+
+	for _, h := range g.headers {
+		h.writeSingle(w, title)
+	}
+	n := w.Size - start
+	fmt.Fprintf(w, "// Total size for %s: %d bytes (%d KB)\n\n", name, n, n/1000)
+}
+
+func (b *builder) writeDictionaries() {
+	fmt.Fprintln(b.w, "// Dictionary entries of frequent languages")
+	fmt.Fprintln(b.w, "var (")
+	parents := parentIndices(b.supported)
+
+	for i, t := range b.supported {
+		if dict.contains(t) {
+			ident := identifier(t)
+			fmt.Fprintf(b.w, "\t%s = Dictionary{ // %s\n", ident, t)
+			if p := parents[i]; p == -1 {
+				fmt.Fprintln(b.w, "\t\tnil,")
+			} else {
+				fmt.Fprintf(b.w, "\t\t&%s,\n", identifier(b.supported[p]))
+			}
+			fmt.Fprintf(b.w, "\t\theader{%[1]sLangStr, %[1]sLangIdx},\n", ident)
+			fmt.Fprintf(b.w, "\t\theader{%[1]sScriptStr, %[1]sScriptIdx},\n", ident)
+			fmt.Fprintf(b.w, "\t\theader{%[1]sRegionStr, %[1]sRegionIdx},\n", ident)
+			fmt.Fprintln(b.w, "\t}")
+		}
+	}
+	fmt.Fprintln(b.w, ")")
+
+	var s string
+	var a []uint16
+	sz := reflect.TypeOf(s).Size()
+	sz += reflect.TypeOf(a).Size()
+	sz *= 3
+	sz += reflect.TypeOf(&a).Size()
+	n := int(sz) * len(dict)
+	fmt.Fprintf(b.w, "// Total size for %d entries: %d bytes (%d KB)\n\n", len(dict), n, n/1000)
+
+	b.w.Size += n
+}
+
+// unique sorts the given lists and removes duplicate entries by swapping them
+// past position k, where k is the number of unique values. It returns k.
+func unique(a sort.Interface) int {
+	if a.Len() == 0 {
+		return 0
+	}
+	sort.Sort(a)
+	k := 1
+	for i := 1; i < a.Len(); i++ {
+		if a.Less(k-1, i) {
+			if k != i {
+				a.Swap(k, i)
+			}
+			k++
+		}
+	}
+	return k
+}

vendor/golang.org/x/text/language/examples_test.go

@@ -0,0 +1,396 @@
+// Copyright 2013 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.
+
+package language_test
+
+import (
+	"fmt"
+
+	"golang.org/x/text/language"
+)
+
+func ExampleCanonType() {
+	p := func(id string) {
+		fmt.Printf("Default(%s) -> %s\n", id, language.Make(id))
+		fmt.Printf("BCP47(%s) -> %s\n", id, language.BCP47.Make(id))
+		fmt.Printf("Macro(%s) -> %s\n", id, language.Macro.Make(id))
+		fmt.Printf("All(%s) -> %s\n", id, language.All.Make(id))
+	}
+	p("en-Latn")
+	p("sh")
+	p("zh-cmn")
+	p("bjd")
+	p("iw-Latn-fonipa-u-cu-usd")
+	// Output:
+	// Default(en-Latn) -> en-Latn
+	// BCP47(en-Latn) -> en
+	// Macro(en-Latn) -> en-Latn
+	// All(en-Latn) -> en
+	// Default(sh) -> sr-Latn
+	// BCP47(sh) -> sh
+	// Macro(sh) -> sh
+	// All(sh) -> sr-Latn
+	// Default(zh-cmn) -> cmn
+	// BCP47(zh-cmn) -> cmn
+	// Macro(zh-cmn) -> zh
+	// All(zh-cmn) -> zh
+	// Default(bjd) -> drl
+	// BCP47(bjd) -> drl
+	// Macro(bjd) -> bjd
+	// All(bjd) -> drl
+	// Default(iw-Latn-fonipa-u-cu-usd) -> he-Latn-fonipa-u-cu-usd
+	// BCP47(iw-Latn-fonipa-u-cu-usd) -> he-Latn-fonipa-u-cu-usd
+	// Macro(iw-Latn-fonipa-u-cu-usd) -> iw-Latn-fonipa-u-cu-usd
+	// All(iw-Latn-fonipa-u-cu-usd) -> he-Latn-fonipa-u-cu-usd
+}
+
+func ExampleTag_Base() {
+	fmt.Println(language.Make("und").Base())
+	fmt.Println(language.Make("und-US").Base())
+	fmt.Println(language.Make("und-NL").Base())
+	fmt.Println(language.Make("und-419").Base()) // Latin America
+	fmt.Println(language.Make("und-ZZ").Base())
+	// Output:
+	// en Low
+	// en High
+	// nl High
+	// es Low
+	// en Low
+}
+
+func ExampleTag_Script() {
+	en := language.Make("en")
+	sr := language.Make("sr")
+	sr_Latn := language.Make("sr_Latn")
+	fmt.Println(en.Script())
+	fmt.Println(sr.Script())
+	// Was a script explicitly specified?
+	_, c := sr.Script()
+	fmt.Println(c == language.Exact)
+	_, c = sr_Latn.Script()
+	fmt.Println(c == language.Exact)
+	// Output:
+	// Latn High
+	// Cyrl Low
+	// false
+	// true
+}
+
+func ExampleTag_Region() {
+	ru := language.Make("ru")
+	en := language.Make("en")
+	fmt.Println(ru.Region())
+	fmt.Println(en.Region())
+	// Output:
+	// RU Low
+	// US Low
+}
+
+func ExampleRegion_TLD() {
+	us := language.MustParseRegion("US")
+	gb := language.MustParseRegion("GB")
+	uk := language.MustParseRegion("UK")
+	bu := language.MustParseRegion("BU")
+
+	fmt.Println(us.TLD())
+	fmt.Println(gb.TLD())
+	fmt.Println(uk.TLD())
+	fmt.Println(bu.TLD())
+
+	fmt.Println(us.Canonicalize().TLD())
+	fmt.Println(gb.Canonicalize().TLD())
+	fmt.Println(uk.Canonicalize().TLD())
+	fmt.Println(bu.Canonicalize().TLD())
+	// Output:
+	// US <nil>
+	// UK <nil>
+	// UK <nil>
+	// ZZ language: region is not a valid ccTLD
+	// US <nil>
+	// UK <nil>
+	// UK <nil>
+	// MM <nil>
+}
+
+func ExampleCompose() {
+	nl, _ := language.ParseBase("nl")
+	us, _ := language.ParseRegion("US")
+	de := language.Make("de-1901-u-co-phonebk")
+	jp := language.Make("ja-JP")
+	fi := language.Make("fi-x-ing")
+
+	u, _ := language.ParseExtension("u-nu-arabic")
+	x, _ := language.ParseExtension("x-piglatin")
+
+	// Combine a base language and region.
+	fmt.Println(language.Compose(nl, us))
+	// Combine a base language and extension.
+	fmt.Println(language.Compose(nl, x))
+	// Replace the region.
+	fmt.Println(language.Compose(jp, us))
+	// Combine several tags.
+	fmt.Println(language.Compose(us, nl, u))
+
+	// Replace the base language of a tag.
+	fmt.Println(language.Compose(de, nl))
+	fmt.Println(language.Compose(de, nl, u))
+	// Remove the base language.
+	fmt.Println(language.Compose(de, language.Base{}))
+	// Remove all variants.
+	fmt.Println(language.Compose(de, []language.Variant{}))
+	// Remove all extensions.
+	fmt.Println(language.Compose(de, []language.Extension{}))
+	fmt.Println(language.Compose(fi, []language.Extension{}))
+	// Remove all variants and extensions.
+	fmt.Println(language.Compose(de.Raw()))
+
+	// An error is gobbled or returned if non-nil.
+	fmt.Println(language.Compose(language.ParseRegion("ZA")))
+	fmt.Println(language.Compose(language.ParseRegion("HH")))
+
+	// Compose uses the same Default canonicalization as Make.
+	fmt.Println(language.Compose(language.Raw.Parse("en-Latn-UK")))
+
+	// Call compose on a different CanonType for different results.
+	fmt.Println(language.All.Compose(language.Raw.Parse("en-Latn-UK")))
+
+	// Output:
+	// nl-US <nil>
+	// nl-x-piglatin <nil>
+	// ja-US <nil>
+	// nl-US-u-nu-arabic <nil>
+	// nl-1901-u-co-phonebk <nil>
+	// nl-1901-u-nu-arabic <nil>
+	// und-1901-u-co-phonebk <nil>
+	// de-u-co-phonebk <nil>
+	// de-1901 <nil>
+	// fi <nil>
+	// de <nil>
+	// und-ZA <nil>
+	// und language: subtag "HH" is well-formed but unknown
+	// en-Latn-GB <nil>
+	// en-GB <nil>
+}
+
+func ExampleParse_errors() {
+	for _, s := range []string{"Foo", "Bar", "Foobar"} {
+		_, err := language.Parse(s)
+		if err != nil {
+			if inv, ok := err.(language.ValueError); ok {
+				fmt.Println(inv.Subtag())
+			} else {
+				fmt.Println(s)
+			}
+		}
+	}
+	for _, s := range []string{"en", "aa-Uuuu", "AC", "ac-u"} {
+		_, err := language.Parse(s)
+		switch e := err.(type) {
+		case language.ValueError:
+			fmt.Printf("%s: culprit %q\n", s, e.Subtag())
+		case nil:
+			// No error.
+		default:
+			// A syntax error.
+			fmt.Printf("%s: ill-formed\n", s)
+		}
+	}
+	// Output:
+	// foo
+	// Foobar
+	// aa-Uuuu: culprit "Uuuu"
+	// AC: culprit "ac"
+	// ac-u: ill-formed
+}
+
+func ExampleParent() {
+	p := func(tag string) {
+		fmt.Printf("parent(%v): %v\n", tag, language.Make(tag).Parent())
+	}
+	p("zh-CN")
+
+	// Australian English inherits from World English.
+	p("en-AU")
+
+	// If the tag has a different maximized script from its parent, a tag with
+	// this maximized script is inserted. This allows different language tags
+	// which have the same base language and script in common to inherit from
+	// a common set of settings.
+	p("zh-HK")
+
+	// If the maximized script of the parent is not identical, CLDR will skip
+	// inheriting from it, as it means there will not be many entries in common
+	// and inheriting from it is nonsensical.
+	p("zh-Hant")
+
+	// The parent of a tag with variants and extensions is the tag with all
+	// variants and extensions removed.
+	p("de-1994-u-co-phonebk")
+
+	// Remove default script.
+	p("de-Latn-LU")
+
+	// Output:
+	// parent(zh-CN): zh
+	// parent(en-AU): en-001
+	// parent(zh-HK): zh-Hant
+	// parent(zh-Hant): und
+	// parent(de-1994-u-co-phonebk): de
+	// parent(de-Latn-LU): de
+}
+
+// ExampleMatcher_bestMatch gives some examples of getting the best match of
+// a set of tags to any of the tags of given set.
+func ExampleMatcher() {
+	// This is the set of tags from which we want to pick the best match. These
+	// can be, for example, the supported languages for some package.
+	tags := []language.Tag{
+		language.English,
+		language.BritishEnglish,
+		language.French,
+		language.Afrikaans,
+		language.BrazilianPortuguese,
+		language.EuropeanPortuguese,
+		language.Croatian,
+		language.SimplifiedChinese,
+		language.Raw.Make("iw-IL"),
+		language.Raw.Make("iw"),
+		language.Raw.Make("he"),
+	}
+	m := language.NewMatcher(tags)
+
+	// A simple match.
+	fmt.Println(m.Match(language.Make("fr")))
+
+	// Australian English is closer to British than American English.
+	fmt.Println(m.Match(language.Make("en-AU")))
+
+	// Default to the first tag passed to the Matcher if there is no match.
+	fmt.Println(m.Match(language.Make("ar")))
+
+	// Get the default tag.
+	fmt.Println(m.Match())
+
+	fmt.Println("----")
+
+	// Croatian speakers will likely understand Serbian written in Latin script.
+	fmt.Println(m.Match(language.Make("sr-Latn")))
+
+	// We match SimplifiedChinese, but with Low confidence.
+	fmt.Println(m.Match(language.TraditionalChinese))
+
+	// Serbian in Latin script is a closer match to Croatian than Traditional
+	// Chinese to Simplified Chinese.
+	fmt.Println(m.Match(language.TraditionalChinese, language.Make("sr-Latn")))
+
+	fmt.Println("----")
+
+	// In case a multiple variants of a language are available, the most spoken
+	// variant is typically returned.
+	fmt.Println(m.Match(language.Portuguese))
+
+	// Pick the first value passed to Match in case of a tie.
+	fmt.Println(m.Match(language.Dutch, language.Make("fr-BE"), language.Make("af-NA")))
+	fmt.Println(m.Match(language.Dutch, language.Make("af-NA"), language.Make("fr-BE")))
+
+	fmt.Println("----")
+
+	// If a Matcher is initialized with a language and it's deprecated version,
+	// it will distinguish between them.
+	fmt.Println(m.Match(language.Raw.Make("iw")))
+
+	// However, for non-exact matches, it will treat deprecated versions as
+	// equivalent and consider other factors first.
+	fmt.Println(m.Match(language.Raw.Make("he-IL")))
+
+	fmt.Println("----")
+
+	// User settings passed to the Unicode extension are ignored for matching
+	// and preserved in the returned tag.
+	fmt.Println(m.Match(language.Make("de-u-co-phonebk"), language.Make("fr-u-cu-frf")))
+
+	// Even if the matching language is different.
+	fmt.Println(m.Match(language.Make("de-u-co-phonebk"), language.Make("br-u-cu-frf")))
+
+	// If there is no matching language, the options of the first preferred tag are used.
+	fmt.Println(m.Match(language.Make("de-u-co-phonebk")))
+
+	// Output:
+	// fr 2 Exact
+	// en-GB 1 High
+	// en 0 No
+	// en 0 No
+	// ----
+	// hr 6 High
+	// zh-Hans 7 Low
+	// hr 6 High
+	// ----
+	// pt-BR 4 High
+	// fr 2 High
+	// af 3 High
+	// ----
+	// iw 9 Exact
+	// iw-IL 8 Exact
+	// ----
+	// fr-u-cu-frf 2 Exact
+	// fr-u-cu-frf 2 High
+	// en-u-co-phonebk 0 No
+}
+
+func ExampleComprehends() {
+	// Various levels of comprehensibility.
+	fmt.Println(language.Comprehends(language.English, language.English))
+	fmt.Println(language.Comprehends(language.AmericanEnglish, language.BritishEnglish))
+
+	// An explicit Und results in no match.
+	fmt.Println(language.Comprehends(language.English, language.Und))
+
+	fmt.Println("----")
+
+	// There is usually no mutual comprehensibility between different scripts.
+	fmt.Println(language.Comprehends(language.Make("en-Dsrt"), language.English))
+
+	// One exception is for Traditional versus Simplified Chinese, albeit with
+	// a low confidence.
+	fmt.Println(language.Comprehends(language.TraditionalChinese, language.SimplifiedChinese))
+
+	fmt.Println("----")
+
+	// A Swiss German speaker will often understand High German.
+	fmt.Println(language.Comprehends(language.Make("gsw"), language.Make("de")))
+
+	// The converse is not generally the case.
+	fmt.Println(language.Comprehends(language.Make("de"), language.Make("gsw")))
+
+	// Output:
+	// Exact
+	// High
+	// No
+	// ----
+	// No
+	// Low
+	// ----
+	// High
+	// No
+}
+
+func ExampleTag_values() {
+	us := language.MustParseRegion("US")
+	en := language.MustParseBase("en")
+
+	lang, _, region := language.AmericanEnglish.Raw()
+	fmt.Println(lang == en, region == us)
+
+	lang, _, region = language.BritishEnglish.Raw()
+	fmt.Println(lang == en, region == us)
+
+	// Tags can be compared for exact equivalence using '=='.
+	en_us, _ := language.Compose(en, us)
+	fmt.Println(en_us == language.AmericanEnglish)
+
+	// Output:
+	// true true
+	// true false
+	// true
+}

vendor/golang.org/x/text/language/gen_common.go

@@ -0,0 +1,20 @@
+// Copyright 2014 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 ignore
+
+package main
+
+// This file contains code common to the maketables.go and the package code.
+
+// langAliasType is the type of an alias in langAliasMap.
+type langAliasType int8
+
+const (
+	langDeprecated langAliasType = iota
+	langMacro
+	langLegacy
+
+	langAliasTypeUnknown langAliasType = -1
+)

vendor/golang.org/x/text/language/gen_index.go

@@ -0,0 +1,162 @@
+// Copyright 2015 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 ignore
+
+package main
+
+// This file generates derivative tables based on the language package itself.
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"reflect"
+	"sort"
+	"strings"
+
+	"golang.org/x/text/internal/gen"
+	"golang.org/x/text/language"
+	"golang.org/x/text/unicode/cldr"
+)
+
+var (
+	test = flag.Bool("test", false,
+		"test existing tables; can be used to compare web data with package data.")
+
+	draft = flag.String("draft",
+		"contributed",
+		`Minimal draft requirements (approved, contributed, provisional, unconfirmed).`)
+)
+
+func main() {
+	gen.Init()
+
+	// Read the CLDR zip file.
+	r := gen.OpenCLDRCoreZip()
+	defer r.Close()
+
+	d := &cldr.Decoder{}
+	data, err := d.DecodeZip(r)
+	if err != nil {
+		log.Fatalf("DecodeZip: %v", err)
+	}
+
+	w := gen.NewCodeWriter()
+	defer func() {
+		buf := &bytes.Buffer{}
+
+		if _, err = w.WriteGo(buf, "language"); err != nil {
+			log.Fatalf("Error formatting file index.go: %v", err)
+		}
+
+		// Since we're generating a table for our own package we need to rewrite
+		// doing the equivalent of go fmt -r 'language.b -> b'. Using
+		// bytes.Replace will do.
+		out := bytes.Replace(buf.Bytes(), []byte("language."), nil, -1)
+		if err := ioutil.WriteFile("index.go", out, 0600); err != nil {
+			log.Fatalf("Could not create file index.go: %v", err)
+		}
+	}()
+
+	m := map[language.Tag]bool{}
+	for _, lang := range data.Locales() {
+		// We include all locales unconditionally to be consistent with en_US.
+		// We want en_US, even though it has no data associated with it.
+
+		// TODO: put any of the languages for which no data exists at the end
+		// of the index. This allows all components based on ICU to use that
+		// as the cutoff point.
+		// if x := data.RawLDML(lang); false ||
+		// 	x.LocaleDisplayNames != nil ||
+		// 	x.Characters != nil ||
+		// 	x.Delimiters != nil ||
+		// 	x.Measurement != nil ||
+		// 	x.Dates != nil ||
+		// 	x.Numbers != nil ||
+		// 	x.Units != nil ||
+		// 	x.ListPatterns != nil ||
+		// 	x.Collations != nil ||
+		// 	x.Segmentations != nil ||
+		// 	x.Rbnf != nil ||
+		// 	x.Annotations != nil ||
+		// 	x.Metadata != nil {
+
+		// TODO: support POSIX natively, albeit non-standard.
+		tag := language.Make(strings.Replace(lang, "_POSIX", "-u-va-posix", 1))
+		m[tag] = true
+		// }
+	}
+	// Include locales for plural rules, which uses a different structure.
+	for _, plurals := range data.Supplemental().Plurals {
+		for _, rules := range plurals.PluralRules {
+			for _, lang := range strings.Split(rules.Locales, " ") {
+				m[language.Make(lang)] = true
+			}
+		}
+	}
+
+	var core, special []language.Tag
+
+	for t := range m {
+		if x := t.Extensions(); len(x) != 0 && fmt.Sprint(x) != "[u-va-posix]" {
+			log.Fatalf("Unexpected extension %v in %v", x, t)
+		}
+		if len(t.Variants()) == 0 && len(t.Extensions()) == 0 {
+			core = append(core, t)
+		} else {
+			special = append(special, t)
+		}
+	}
+
+	w.WriteComment(`
+	NumCompactTags is the number of common tags. The maximum tag is
+	NumCompactTags-1.`)
+	w.WriteConst("NumCompactTags", len(core)+len(special))
+
+	sort.Sort(byAlpha(special))
+	w.WriteVar("specialTags", special)
+
+	// TODO: order by frequency?
+	sort.Sort(byAlpha(core))
+
+	// Size computations are just an estimate.
+	w.Size += int(reflect.TypeOf(map[uint32]uint16{}).Size())
+	w.Size += len(core) * 6 // size of uint32 and uint16
+
+	fmt.Fprintln(w)
+	fmt.Fprintln(w, "var coreTags = map[uint32]uint16{")
+	fmt.Fprintln(w, "0x0: 0, // und")
+	i := len(special) + 1 // Und and special tags already written.
+	for _, t := range core {
+		if t == language.Und {
+			continue
+		}
+		fmt.Fprint(w.Hash, t, i)
+		b, s, r := t.Raw()
+		fmt.Fprintf(w, "0x%s%s%s: %d, // %s\n",
+			getIndex(b, 3), // 3 is enough as it is guaranteed to be a compact number
+			getIndex(s, 2),
+			getIndex(r, 3),
+			i, t)
+		i++
+	}
+	fmt.Fprintln(w, "}")
+}
+
+// getIndex prints the subtag type and extracts its index of size nibble.
+// If the index is less than n nibbles, the result is prefixed with 0s.
+func getIndex(x interface{}, n int) string {
+	s := fmt.Sprintf("%#v", x) // s is of form Type{typeID: 0x00}
+	s = s[strings.Index(s, "0x")+2 : len(s)-1]
+	return strings.Repeat("0", n-len(s)) + s
+}
+
+type byAlpha []language.Tag
+
+func (a byAlpha) Len() int           { return len(a) }
+func (a byAlpha) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
+func (a byAlpha) Less(i, j int) bool { return a[i].String() < a[j].String() }

vendor/golang.org/x/text/language/go1_1.go

@@ -0,0 +1,38 @@
+// Copyright 2013 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.2
+
+package language
+
+import "sort"
+
+func sortStable(s sort.Interface) {
+	ss := stableSort{
+		s:   s,
+		pos: make([]int, s.Len()),
+	}
+	for i := range ss.pos {
+		ss.pos[i] = i
+	}
+	sort.Sort(&ss)
+}
+
+type stableSort struct {
+	s   sort.Interface
+	pos []int
+}
+
+func (s *stableSort) Len() int {
+	return len(s.pos)
+}
+
+func (s *stableSort) Less(i, j int) bool {
+	return s.s.Less(i, j) || !s.s.Less(j, i) && s.pos[i] < s.pos[j]
+}
+
+func (s *stableSort) Swap(i, j int) {
+	s.s.Swap(i, j)
+	s.pos[i], s.pos[j] = s.pos[j], s.pos[i]
+}

vendor/golang.org/x/text/language/go1_2.go

@@ -0,0 +1,11 @@
+// Copyright 2013 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.2
+
+package language
+
+import "sort"
+
+var sortStable = sort.Stable

vendor/golang.org/x/text/language/httpexample_test.go

@@ -0,0 +1,48 @@
+// 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.
+
+package language_test
+
+import (
+	"fmt"
+	"net/http"
+	"strings"
+
+	"golang.org/x/text/language"
+)
+
+// matcher is a language.Matcher configured for all supported languages.
+var matcher = language.NewMatcher([]language.Tag{
+	language.BritishEnglish,
+	language.Norwegian,
+	language.German,
+})
+
+// handler is a http.HandlerFunc.
+func handler(w http.ResponseWriter, r *http.Request) {
+	t, q, err := language.ParseAcceptLanguage(r.Header.Get("Accept-Language"))
+	// We ignore the error: the default language will be selected for t == nil.
+	tag, _, _ := matcher.Match(t...)
+	fmt.Printf("%5v (t: %6v; q: %3v; err: %v)\n", tag, t, q, err)
+}
+
+func ExampleParseAcceptLanguage() {
+	for _, al := range []string{
+		"nn;q=0.3, en-us;q=0.8, en,",
+		"gsw, en;q=0.7, en-US;q=0.8",
+		"gsw, nl, da",
+		"invalid",
+	} {
+		// Create dummy request with Accept-Language set and pass it to handler.
+		r, _ := http.NewRequest("GET", "example.com", strings.NewReader("Hello"))
+		r.Header.Set("Accept-Language", al)
+		handler(nil, r)
+	}
+
+	// Output:
+	// en-GB (t: [    en  en-US     nn]; q: [  1 0.8 0.3]; err: <nil>)
+	// en-GB (t: [   gsw  en-US     en]; q: [  1 0.8 0.7]; err: <nil>)
+	//    de (t: [   gsw     nl     da]; q: [  1   1   1]; err: <nil>)
+	// en-GB (t: []; q: []; err: language: tag is not well-formed)
+}

vendor/golang.org/x/text/language/index.go

@@ -0,0 +1,767 @@
+// This file was generated by go generate; DO NOT EDIT
+
+package language
+
+// NumCompactTags is the number of common tags. The maximum tag is
+// NumCompactTags-1.
+const NumCompactTags = 752
+
+var specialTags = []Tag{ // 2 elements
+	0: {lang: 0xd5, region: 0x6d, script: 0x0, pVariant: 0x5, pExt: 0xe, str: "ca-ES-valencia"},
+	1: {lang: 0x134, region: 0x134, script: 0x0, pVariant: 0x5, pExt: 0x5, str: "en-US-u-va-posix"},
+} // Size: 72 bytes
+
+var coreTags = map[uint32]uint16{
+	0x0:        0,   // und
+	0x01500000: 3,   // af
+	0x015000d1: 4,   // af-NA
+	0x01500160: 5,   // af-ZA
+	0x01b00000: 6,   // agq
+	0x01b00051: 7,   // agq-CM
+	0x02000000: 8,   // ak
+	0x0200007f: 9,   // ak-GH
+	0x02600000: 10,  // am
+	0x0260006e: 11,  // am-ET
+	0x03900000: 12,  // ar
+	0x03900001: 13,  // ar-001
+	0x03900022: 14,  // ar-AE
+	0x03900038: 15,  // ar-BH
+	0x03900061: 16,  // ar-DJ
+	0x03900066: 17,  // ar-DZ
+	0x0390006a: 18,  // ar-EG
+	0x0390006b: 19,  // ar-EH
+	0x0390006c: 20,  // ar-ER
+	0x03900096: 21,  // ar-IL
+	0x0390009a: 22,  // ar-IQ
+	0x039000a0: 23,  // ar-JO
+	0x039000a7: 24,  // ar-KM
+	0x039000ab: 25,  // ar-KW
+	0x039000af: 26,  // ar-LB
+	0x039000b8: 27,  // ar-LY
+	0x039000b9: 28,  // ar-MA
+	0x039000c8: 29,  // ar-MR
+	0x039000e0: 30,  // ar-OM
+	0x039000ec: 31,  // ar-PS
+	0x039000f2: 32,  // ar-QA
+	0x03900107: 33,  // ar-SA
+	0x0390010a: 34,  // ar-SD
+	0x03900114: 35,  // ar-SO
+	0x03900116: 36,  // ar-SS
+	0x0390011b: 37,  // ar-SY
+	0x0390011f: 38,  // ar-TD
+	0x03900127: 39,  // ar-TN
+	0x0390015d: 40,  // ar-YE
+	0x03f00000: 41,  // ars
+	0x04200000: 42,  // as
+	0x04200098: 43,  // as-IN
+	0x04300000: 44,  // asa
+	0x0430012e: 45,  // asa-TZ
+	0x04700000: 46,  // ast
+	0x0470006d: 47,  // ast-ES
+	0x05700000: 48,  // az
+	0x0571e000: 49,  // az-Cyrl
+	0x0571e031: 50,  // az-Cyrl-AZ
+	0x05752000: 51,  // az-Latn
+	0x05752031: 52,  // az-Latn-AZ
+	0x05d00000: 53,  // bas
+	0x05d00051: 54,  // bas-CM
+	0x07000000: 55,  // be
+	0x07000046: 56,  // be-BY
+	0x07400000: 57,  // bem
+	0x07400161: 58,  // bem-ZM
+	0x07800000: 59,  // bez
+	0x0780012e: 60,  // bez-TZ
+	0x07d00000: 61,  // bg
+	0x07d00037: 62,  // bg-BG
+	0x08100000: 63,  // bh
+	0x09e00000: 64,  // bm
+	0x09e000c2: 65,  // bm-ML
+	0x0a300000: 66,  // bn
+	0x0a300034: 67,  // bn-BD
+	0x0a300098: 68,  // bn-IN
+	0x0a700000: 69,  // bo
+	0x0a700052: 70,  // bo-CN
+	0x0a700098: 71,  // bo-IN
+	0x0b000000: 72,  // br
+	0x0b000077: 73,  // br-FR
+	0x0b300000: 74,  // brx
+	0x0b300098: 75,  // brx-IN
+	0x0b500000: 76,  // bs
+	0x0b51e000: 77,  // bs-Cyrl
+	0x0b51e032: 78,  // bs-Cyrl-BA
+	0x0b552000: 79,  // bs-Latn
+	0x0b552032: 80,  // bs-Latn-BA
+	0x0d500000: 81,  // ca
+	0x0d500021: 82,  // ca-AD
+	0x0d50006d: 83,  // ca-ES
+	0x0d500077: 84,  // ca-FR
+	0x0d50009d: 85,  // ca-IT
+	0x0da00000: 86,  // ce
+	0x0da00105: 87,  // ce-RU
+	0x0dd00000: 88,  // cgg
+	0x0dd00130: 89,  // cgg-UG
+	0x0e300000: 90,  // chr
+	0x0e300134: 91,  // chr-US
+	0x0e700000: 92,  // ckb
+	0x0e70009a: 93,  // ckb-IQ
+	0x0e70009b: 94,  // ckb-IR
+	0x0f600000: 95,  // cs
+	0x0f60005d: 96,  // cs-CZ
+	0x0fa00000: 97,  // cu
+	0x0fa00105: 98,  // cu-RU
+	0x0fc00000: 99,  // cy
+	0x0fc0007a: 100, // cy-GB
+	0x0fd00000: 101, // da
+	0x0fd00062: 102, // da-DK
+	0x0fd00081: 103, // da-GL
+	0x10400000: 104, // dav
+	0x104000a3: 105, // dav-KE
+	0x10900000: 106, // de
+	0x1090002d: 107, // de-AT
+	0x10900035: 108, // de-BE
+	0x1090004d: 109, // de-CH
+	0x1090005f: 110, // de-DE
+	0x1090009d: 111, // de-IT
+	0x109000b1: 112, // de-LI
+	0x109000b6: 113, // de-LU
+	0x11300000: 114, // dje
+	0x113000d3: 115, // dje-NE
+	0x11b00000: 116, // dsb
+	0x11b0005f: 117, // dsb-DE
+	0x12000000: 118, // dua
+	0x12000051: 119, // dua-CM
+	0x12400000: 120, // dv
+	0x12700000: 121, // dyo
+	0x12700113: 122, // dyo-SN
+	0x12900000: 123, // dz
+	0x12900042: 124, // dz-BT
+	0x12b00000: 125, // ebu
+	0x12b000a3: 126, // ebu-KE
+	0x12c00000: 127, // ee
+	0x12c0007f: 128, // ee-GH
+	0x12c00121: 129, // ee-TG
+	0x13100000: 130, // el
+	0x1310005c: 131, // el-CY
+	0x13100086: 132, // el-GR
+	0x13400000: 133, // en
+	0x13400001: 134, // en-001
+	0x1340001a: 135, // en-150
+	0x13400024: 136, // en-AG
+	0x13400025: 137, // en-AI
+	0x1340002c: 138, // en-AS
+	0x1340002d: 139, // en-AT
+	0x1340002e: 140, // en-AU
+	0x13400033: 141, // en-BB
+	0x13400035: 142, // en-BE
+	0x13400039: 143, // en-BI
+	0x1340003c: 144, // en-BM
+	0x13400041: 145, // en-BS
+	0x13400045: 146, // en-BW
+	0x13400047: 147, // en-BZ
+	0x13400048: 148, // en-CA
+	0x13400049: 149, // en-CC
+	0x1340004d: 150, // en-CH
+	0x1340004f: 151, // en-CK
+	0x13400051: 152, // en-CM
+	0x1340005b: 153, // en-CX
+	0x1340005c: 154, // en-CY
+	0x1340005f: 155, // en-DE
+	0x13400060: 156, // en-DG
+	0x13400062: 157, // en-DK
+	0x13400063: 158, // en-DM
+	0x1340006c: 159, // en-ER
+	0x13400071: 160, // en-FI
+	0x13400072: 161, // en-FJ
+	0x13400073: 162, // en-FK
+	0x13400074: 163, // en-FM
+	0x1340007a: 164, // en-GB
+	0x1340007b: 165, // en-GD
+	0x1340007e: 166, // en-GG
+	0x1340007f: 167, // en-GH
+	0x13400080: 168, // en-GI
+	0x13400082: 169, // en-GM
+	0x13400089: 170, // en-GU
+	0x1340008b: 171, // en-GY
+	0x1340008c: 172, // en-HK
+	0x13400095: 173, // en-IE
+	0x13400096: 174, // en-IL
+	0x13400097: 175, // en-IM
+	0x13400098: 176, // en-IN
+	0x13400099: 177, // en-IO
+	0x1340009e: 178, // en-JE
+	0x1340009f: 179, // en-JM
+	0x134000a3: 180, // en-KE
+	0x134000a6: 181, // en-KI
+	0x134000a8: 182, // en-KN
+	0x134000ac: 183, // en-KY
+	0x134000b0: 184, // en-LC
+	0x134000b3: 185, // en-LR
+	0x134000b4: 186, // en-LS
+	0x134000be: 187, // en-MG
+	0x134000bf: 188, // en-MH
+	0x134000c5: 189, // en-MO
+	0x134000c6: 190, // en-MP
+	0x134000c9: 191, // en-MS
+	0x134000ca: 192, // en-MT
+	0x134000cb: 193, // en-MU
+	0x134000cd: 194, // en-MW
+	0x134000cf: 195, // en-MY
+	0x134000d1: 196, // en-NA
+	0x134000d4: 197, // en-NF
+	0x134000d5: 198, // en-NG
+	0x134000d8: 199, // en-NL
+	0x134000dc: 200, // en-NR
+	0x134000de: 201, // en-NU
+	0x134000df: 202, // en-NZ
+	0x134000e5: 203, // en-PG
+	0x134000e6: 204, // en-PH
+	0x134000e7: 205, // en-PK
+	0x134000ea: 206, // en-PN
+	0x134000eb: 207, // en-PR
+	0x134000ef: 208, // en-PW
+	0x13400106: 209, // en-RW
+	0x13400108: 210, // en-SB
+	0x13400109: 211, // en-SC
+	0x1340010a: 212, // en-SD
+	0x1340010b: 213, // en-SE
+	0x1340010c: 214, // en-SG
+	0x1340010d: 215, // en-SH
+	0x1340010e: 216, // en-SI
+	0x13400111: 217, // en-SL
+	0x13400116: 218, // en-SS
+	0x1340011a: 219, // en-SX
+	0x1340011c: 220, // en-SZ
+	0x1340011e: 221, // en-TC
+	0x13400124: 222, // en-TK
+	0x13400128: 223, // en-TO
+	0x1340012b: 224, // en-TT
+	0x1340012c: 225, // en-TV
+	0x1340012e: 226, // en-TZ
+	0x13400130: 227, // en-UG
+	0x13400132: 228, // en-UM
+	0x13400134: 229, // en-US
+	0x13400138: 230, // en-VC
+	0x1340013b: 231, // en-VG
+	0x1340013c: 232, // en-VI
+	0x1340013e: 233, // en-VU
+	0x13400141: 234, // en-WS
+	0x13400160: 235, // en-ZA
+	0x13400161: 236, // en-ZM
+	0x13400163: 237, // en-ZW
+	0x13700000: 238, // eo
+	0x13700001: 239, // eo-001
+	0x13900000: 240, // es
+	0x1390001e: 241, // es-419
+	0x1390002b: 242, // es-AR
+	0x1390003e: 243, // es-BO
+	0x13900040: 244, // es-BR
+	0x13900050: 245, // es-CL
+	0x13900053: 246, // es-CO
+	0x13900055: 247, // es-CR
+	0x13900058: 248, // es-CU
+	0x13900064: 249, // es-DO
+	0x13900067: 250, // es-EA
+	0x13900068: 251, // es-EC
+	0x1390006d: 252, // es-ES
+	0x13900085: 253, // es-GQ
+	0x13900088: 254, // es-GT
+	0x1390008e: 255, // es-HN
+	0x13900093: 256, // es-IC
+	0x139000ce: 257, // es-MX
+	0x139000d7: 258, // es-NI
+	0x139000e1: 259, // es-PA
+	0x139000e3: 260, // es-PE
+	0x139000e6: 261, // es-PH
+	0x139000eb: 262, // es-PR
+	0x139000f0: 263, // es-PY
+	0x13900119: 264, // es-SV
+	0x13900134: 265, // es-US
+	0x13900135: 266, // es-UY
+	0x1390013a: 267, // es-VE
+	0x13b00000: 268, // et
+	0x13b00069: 269, // et-EE
+	0x14000000: 270, // eu
+	0x1400006d: 271, // eu-ES
+	0x14100000: 272, // ewo
+	0x14100051: 273, // ewo-CM
+	0x14300000: 274, // fa
+	0x14300023: 275, // fa-AF
+	0x1430009b: 276, // fa-IR
+	0x14900000: 277, // ff
+	0x14900051: 278, // ff-CM
+	0x14900083: 279, // ff-GN
+	0x149000c8: 280, // ff-MR
+	0x14900113: 281, // ff-SN
+	0x14c00000: 282, // fi
+	0x14c00071: 283, // fi-FI
+	0x14e00000: 284, // fil
+	0x14e000e6: 285, // fil-PH
+	0x15300000: 286, // fo
+	0x15300062: 287, // fo-DK
+	0x15300075: 288, // fo-FO
+	0x15900000: 289, // fr
+	0x15900035: 290, // fr-BE
+	0x15900036: 291, // fr-BF
+	0x15900039: 292, // fr-BI
+	0x1590003a: 293, // fr-BJ
+	0x1590003b: 294, // fr-BL
+	0x15900048: 295, // fr-CA
+	0x1590004a: 296, // fr-CD
+	0x1590004b: 297, // fr-CF
+	0x1590004c: 298, // fr-CG
+	0x1590004d: 299, // fr-CH
+	0x1590004e: 300, // fr-CI
+	0x15900051: 301, // fr-CM
+	0x15900061: 302, // fr-DJ
+	0x15900066: 303, // fr-DZ
+	0x15900077: 304, // fr-FR
+	0x15900079: 305, // fr-GA
+	0x1590007d: 306, // fr-GF
+	0x15900083: 307, // fr-GN
+	0x15900084: 308, // fr-GP
+	0x15900085: 309, // fr-GQ
+	0x15900090: 310, // fr-HT
+	0x159000a7: 311, // fr-KM
+	0x159000b6: 312, // fr-LU
+	0x159000b9: 313, // fr-MA
+	0x159000ba: 314, // fr-MC
+	0x159000bd: 315, // fr-MF
+	0x159000be: 316, // fr-MG
+	0x159000c2: 317, // fr-ML
+	0x159000c7: 318, // fr-MQ
+	0x159000c8: 319, // fr-MR
+	0x159000cb: 320, // fr-MU
+	0x159000d2: 321, // fr-NC
+	0x159000d3: 322, // fr-NE
+	0x159000e4: 323, // fr-PF
+	0x159000e9: 324, // fr-PM
+	0x15900101: 325, // fr-RE
+	0x15900106: 326, // fr-RW
+	0x15900109: 327, // fr-SC
+	0x15900113: 328, // fr-SN
+	0x1590011b: 329, // fr-SY
+	0x1590011f: 330, // fr-TD
+	0x15900121: 331, // fr-TG
+	0x15900127: 332, // fr-TN
+	0x1590013e: 333, // fr-VU
+	0x1590013f: 334, // fr-WF
+	0x1590015e: 335, // fr-YT
+	0x16400000: 336, // fur
+	0x1640009d: 337, // fur-IT
+	0x16800000: 338, // fy
+	0x168000d8: 339, // fy-NL
+	0x16900000: 340, // ga
+	0x16900095: 341, // ga-IE
+	0x17800000: 342, // gd
+	0x1780007a: 343, // gd-GB
+	0x18a00000: 344, // gl
+	0x18a0006d: 345, // gl-ES
+	0x19c00000: 346, // gsw
+	0x19c0004d: 347, // gsw-CH
+	0x19c00077: 348, // gsw-FR
+	0x19c000b1: 349, // gsw-LI
+	0x19d00000: 350, // gu
+	0x19d00098: 351, // gu-IN
+	0x1a200000: 352, // guw
+	0x1a400000: 353, // guz
+	0x1a4000a3: 354, // guz-KE
+	0x1a500000: 355, // gv
+	0x1a500097: 356, // gv-IM
+	0x1ad00000: 357, // ha
+	0x1ad0007f: 358, // ha-GH
+	0x1ad000d3: 359, // ha-NE
+	0x1ad000d5: 360, // ha-NG
+	0x1b100000: 361, // haw
+	0x1b100134: 362, // haw-US
+	0x1b500000: 363, // he
+	0x1b500096: 364, // he-IL
+	0x1b700000: 365, // hi
+	0x1b700098: 366, // hi-IN
+	0x1ca00000: 367, // hr
+	0x1ca00032: 368, // hr-BA
+	0x1ca0008f: 369, // hr-HR
+	0x1cb00000: 370, // hsb
+	0x1cb0005f: 371, // hsb-DE
+	0x1ce00000: 372, // hu
+	0x1ce00091: 373, // hu-HU
+	0x1d000000: 374, // hy
+	0x1d000027: 375, // hy-AM
+	0x1da00000: 376, // id
+	0x1da00094: 377, // id-ID
+	0x1df00000: 378, // ig
+	0x1df000d5: 379, // ig-NG
+	0x1e200000: 380, // ii
+	0x1e200052: 381, // ii-CN
+	0x1f000000: 382, // is
+	0x1f00009c: 383, // is-IS
+	0x1f100000: 384, // it
+	0x1f10004d: 385, // it-CH
+	0x1f10009d: 386, // it-IT
+	0x1f100112: 387, // it-SM
+	0x1f200000: 388, // iu
+	0x1f800000: 389, // ja
+	0x1f8000a1: 390, // ja-JP
+	0x1fb00000: 391, // jbo
+	0x1ff00000: 392, // jgo
+	0x1ff00051: 393, // jgo-CM
+	0x20200000: 394, // jmc
+	0x2020012e: 395, // jmc-TZ
+	0x20600000: 396, // jv
+	0x20800000: 397, // ka
+	0x2080007c: 398, // ka-GE
+	0x20a00000: 399, // kab
+	0x20a00066: 400, // kab-DZ
+	0x20e00000: 401, // kaj
+	0x20f00000: 402, // kam
+	0x20f000a3: 403, // kam-KE
+	0x21700000: 404, // kcg
+	0x21b00000: 405, // kde
+	0x21b0012e: 406, // kde-TZ
+	0x21f00000: 407, // kea
+	0x21f00059: 408, // kea-CV
+	0x22c00000: 409, // khq
+	0x22c000c2: 410, // khq-ML
+	0x23100000: 411, // ki
+	0x231000a3: 412, // ki-KE
+	0x23a00000: 413, // kk
+	0x23a000ad: 414, // kk-KZ
+	0x23c00000: 415, // kkj
+	0x23c00051: 416, // kkj-CM
+	0x23d00000: 417, // kl
+	0x23d00081: 418, // kl-GL
+	0x23e00000: 419, // kln
+	0x23e000a3: 420, // kln-KE
+	0x24200000: 421, // km
+	0x242000a5: 422, // km-KH
+	0x24900000: 423, // kn
+	0x24900098: 424, // kn-IN
+	0x24b00000: 425, // ko
+	0x24b000a9: 426, // ko-KP
+	0x24b000aa: 427, // ko-KR
+	0x24d00000: 428, // kok
+	0x24d00098: 429, // kok-IN
+	0x26100000: 430, // ks
+	0x26100098: 431, // ks-IN
+	0x26200000: 432, // ksb
+	0x2620012e: 433, // ksb-TZ
+	0x26400000: 434, // ksf
+	0x26400051: 435, // ksf-CM
+	0x26500000: 436, // ksh
+	0x2650005f: 437, // ksh-DE
+	0x26b00000: 438, // ku
+	0x27800000: 439, // kw
+	0x2780007a: 440, // kw-GB
+	0x28100000: 441, // ky
+	0x281000a4: 442, // ky-KG
+	0x28800000: 443, // lag
+	0x2880012e: 444, // lag-TZ
+	0x28c00000: 445, // lb
+	0x28c000b6: 446, // lb-LU
+	0x29a00000: 447, // lg
+	0x29a00130: 448, // lg-UG
+	0x2a600000: 449, // lkt
+	0x2a600134: 450, // lkt-US
+	0x2ac00000: 451, // ln
+	0x2ac00029: 452, // ln-AO
+	0x2ac0004a: 453, // ln-CD
+	0x2ac0004b: 454, // ln-CF
+	0x2ac0004c: 455, // ln-CG
+	0x2af00000: 456, // lo
+	0x2af000ae: 457, // lo-LA
+	0x2b600000: 458, // lrc
+	0x2b60009a: 459, // lrc-IQ
+	0x2b60009b: 460, // lrc-IR
+	0x2b700000: 461, // lt
+	0x2b7000b5: 462, // lt-LT
+	0x2b900000: 463, // lu
+	0x2b90004a: 464, // lu-CD
+	0x2bb00000: 465, // luo
+	0x2bb000a3: 466, // luo-KE
+	0x2bc00000: 467, // luy
+	0x2bc000a3: 468, // luy-KE
+	0x2be00000: 469, // lv
+	0x2be000b7: 470, // lv-LV
+	0x2c800000: 471, // mas
+	0x2c8000a3: 472, // mas-KE
+	0x2c80012e: 473, // mas-TZ
+	0x2e000000: 474, // mer
+	0x2e0000a3: 475, // mer-KE
+	0x2e400000: 476, // mfe
+	0x2e4000cb: 477, // mfe-MU
+	0x2e800000: 478, // mg
+	0x2e8000be: 479, // mg-MG
+	0x2e900000: 480, // mgh
+	0x2e9000d0: 481, // mgh-MZ
+	0x2eb00000: 482, // mgo
+	0x2eb00051: 483, // mgo-CM
+	0x2f600000: 484, // mk
+	0x2f6000c1: 485, // mk-MK
+	0x2fb00000: 486, // ml
+	0x2fb00098: 487, // ml-IN
+	0x30200000: 488, // mn
+	0x302000c4: 489, // mn-MN
+	0x31200000: 490, // mr
+	0x31200098: 491, // mr-IN
+	0x31600000: 492, // ms
+	0x3160003d: 493, // ms-BN
+	0x316000cf: 494, // ms-MY
+	0x3160010c: 495, // ms-SG
+	0x31700000: 496, // mt
+	0x317000ca: 497, // mt-MT
+	0x31c00000: 498, // mua
+	0x31c00051: 499, // mua-CM
+	0x32800000: 500, // my
+	0x328000c3: 501, // my-MM
+	0x33100000: 502, // mzn
+	0x3310009b: 503, // mzn-IR
+	0x33800000: 504, // nah
+	0x33c00000: 505, // naq
+	0x33c000d1: 506, // naq-NA
+	0x33e00000: 507, // nb
+	0x33e000d9: 508, // nb-NO
+	0x33e0010f: 509, // nb-SJ
+	0x34500000: 510, // nd
+	0x34500163: 511, // nd-ZW
+	0x34700000: 512, // nds
+	0x3470005f: 513, // nds-DE
+	0x347000d8: 514, // nds-NL
+	0x34800000: 515, // ne
+	0x34800098: 516, // ne-IN
+	0x348000da: 517, // ne-NP
+	0x35e00000: 518, // nl
+	0x35e0002f: 519, // nl-AW
+	0x35e00035: 520, // nl-BE
+	0x35e0003f: 521, // nl-BQ
+	0x35e0005a: 522, // nl-CW
+	0x35e000d8: 523, // nl-NL
+	0x35e00115: 524, // nl-SR
+	0x35e0011a: 525, // nl-SX
+	0x35f00000: 526, // nmg
+	0x35f00051: 527, // nmg-CM
+	0x36100000: 528, // nn
+	0x361000d9: 529, // nn-NO
+	0x36300000: 530, // nnh
+	0x36300051: 531, // nnh-CM
+	0x36600000: 532, // no
+	0x36c00000: 533, // nqo
+	0x36d00000: 534, // nr
+	0x37100000: 535, // nso
+	0x37700000: 536, // nus
+	0x37700116: 537, // nus-SS
+	0x37e00000: 538, // ny
+	0x38000000: 539, // nyn
+	0x38000130: 540, // nyn-UG
+	0x38700000: 541, // om
+	0x3870006e: 542, // om-ET
+	0x387000a3: 543, // om-KE
+	0x38c00000: 544, // or
+	0x38c00098: 545, // or-IN
+	0x38f00000: 546, // os
+	0x38f0007c: 547, // os-GE
+	0x38f00105: 548, // os-RU
+	0x39400000: 549, // pa
+	0x39405000: 550, // pa-Arab
+	0x394050e7: 551, // pa-Arab-PK
+	0x3942f000: 552, // pa-Guru
+	0x3942f098: 553, // pa-Guru-IN
+	0x39800000: 554, // pap
+	0x3aa00000: 555, // pl
+	0x3aa000e8: 556, // pl-PL
+	0x3b400000: 557, // prg
+	0x3b400001: 558, // prg-001
+	0x3b500000: 559, // ps
+	0x3b500023: 560, // ps-AF
+	0x3b700000: 561, // pt
+	0x3b700029: 562, // pt-AO
+	0x3b700040: 563, // pt-BR
+	0x3b70004d: 564, // pt-CH
+	0x3b700059: 565, // pt-CV
+	0x3b700085: 566, // pt-GQ
+	0x3b70008a: 567, // pt-GW
+	0x3b7000b6: 568, // pt-LU
+	0x3b7000c5: 569, // pt-MO
+	0x3b7000d0: 570, // pt-MZ
+	0x3b7000ed: 571, // pt-PT
+	0x3b700117: 572, // pt-ST
+	0x3b700125: 573, // pt-TL
+	0x3bb00000: 574, // qu
+	0x3bb0003e: 575, // qu-BO
+	0x3bb00068: 576, // qu-EC
+	0x3bb000e3: 577, // qu-PE
+	0x3cb00000: 578, // rm
+	0x3cb0004d: 579, // rm-CH
+	0x3d000000: 580, // rn
+	0x3d000039: 581, // rn-BI
+	0x3d300000: 582, // ro
+	0x3d3000bb: 583, // ro-MD
+	0x3d300103: 584, // ro-RO
+	0x3d500000: 585, // rof
+	0x3d50012e: 586, // rof-TZ
+	0x3d900000: 587, // ru
+	0x3d900046: 588, // ru-BY
+	0x3d9000a4: 589, // ru-KG
+	0x3d9000ad: 590, // ru-KZ
+	0x3d9000bb: 591, // ru-MD
+	0x3d900105: 592, // ru-RU
+	0x3d90012f: 593, // ru-UA
+	0x3dc00000: 594, // rw
+	0x3dc00106: 595, // rw-RW
+	0x3dd00000: 596, // rwk
+	0x3dd0012e: 597, // rwk-TZ
+	0x3e200000: 598, // sah
+	0x3e200105: 599, // sah-RU
+	0x3e300000: 600, // saq
+	0x3e3000a3: 601, // saq-KE
+	0x3e900000: 602, // sbp
+	0x3e90012e: 603, // sbp-TZ
+	0x3f200000: 604, // sdh
+	0x3f300000: 605, // se
+	0x3f300071: 606, // se-FI
+	0x3f3000d9: 607, // se-NO
+	0x3f30010b: 608, // se-SE
+	0x3f500000: 609, // seh
+	0x3f5000d0: 610, // seh-MZ
+	0x3f700000: 611, // ses
+	0x3f7000c2: 612, // ses-ML
+	0x3f800000: 613, // sg
+	0x3f80004b: 614, // sg-CF
+	0x3fe00000: 615, // shi
+	0x3fe52000: 616, // shi-Latn
+	0x3fe520b9: 617, // shi-Latn-MA
+	0x3fed2000: 618, // shi-Tfng
+	0x3fed20b9: 619, // shi-Tfng-MA
+	0x40200000: 620, // si
+	0x402000b2: 621, // si-LK
+	0x40800000: 622, // sk
+	0x40800110: 623, // sk-SK
+	0x40c00000: 624, // sl
+	0x40c0010e: 625, // sl-SI
+	0x41200000: 626, // sma
+	0x41300000: 627, // smi
+	0x41400000: 628, // smj
+	0x41500000: 629, // smn
+	0x41500071: 630, // smn-FI
+	0x41800000: 631, // sms
+	0x41900000: 632, // sn
+	0x41900163: 633, // sn-ZW
+	0x41f00000: 634, // so
+	0x41f00061: 635, // so-DJ
+	0x41f0006e: 636, // so-ET
+	0x41f000a3: 637, // so-KE
+	0x41f00114: 638, // so-SO
+	0x42700000: 639, // sq
+	0x42700026: 640, // sq-AL
+	0x427000c1: 641, // sq-MK
+	0x4270014c: 642, // sq-XK
+	0x42800000: 643, // sr
+	0x4281e000: 644, // sr-Cyrl
+	0x4281e032: 645, // sr-Cyrl-BA
+	0x4281e0bc: 646, // sr-Cyrl-ME
+	0x4281e104: 647, // sr-Cyrl-RS
+	0x4281e14c: 648, // sr-Cyrl-XK
+	0x42852000: 649, // sr-Latn
+	0x42852032: 650, // sr-Latn-BA
+	0x428520bc: 651, // sr-Latn-ME
+	0x42852104: 652, // sr-Latn-RS
+	0x4285214c: 653, // sr-Latn-XK
+	0x42d00000: 654, // ss
+	0x43000000: 655, // ssy
+	0x43100000: 656, // st
+	0x43a00000: 657, // sv
+	0x43a00030: 658, // sv-AX
+	0x43a00071: 659, // sv-FI
+	0x43a0010b: 660, // sv-SE
+	0x43b00000: 661, // sw
+	0x43b0004a: 662, // sw-CD
+	0x43b000a3: 663, // sw-KE
+	0x43b0012e: 664, // sw-TZ
+	0x43b00130: 665, // sw-UG
+	0x44400000: 666, // syr
+	0x44600000: 667, // ta
+	0x44600098: 668, // ta-IN
+	0x446000b2: 669, // ta-LK
+	0x446000cf: 670, // ta-MY
+	0x4460010c: 671, // ta-SG
+	0x45700000: 672, // te
+	0x45700098: 673, // te-IN
+	0x45a00000: 674, // teo
+	0x45a000a3: 675, // teo-KE
+	0x45a00130: 676, // teo-UG
+	0x46100000: 677, // th
+	0x46100122: 678, // th-TH
+	0x46500000: 679, // ti
+	0x4650006c: 680, // ti-ER
+	0x4650006e: 681, // ti-ET
+	0x46700000: 682, // tig
+	0x46c00000: 683, // tk
+	0x46c00126: 684, // tk-TM
+	0x47600000: 685, // tn
+	0x47800000: 686, // to
+	0x47800128: 687, // to-TO
+	0x48000000: 688, // tr
+	0x4800005c: 689, // tr-CY
+	0x4800012a: 690, // tr-TR
+	0x48400000: 691, // ts
+	0x49a00000: 692, // twq
+	0x49a000d3: 693, // twq-NE
+	0x49f00000: 694, // tzm
+	0x49f000b9: 695, // tzm-MA
+	0x4a200000: 696, // ug
+	0x4a200052: 697, // ug-CN
+	0x4a400000: 698, // uk
+	0x4a40012f: 699, // uk-UA
+	0x4aa00000: 700, // ur
+	0x4aa00098: 701, // ur-IN
+	0x4aa000e7: 702, // ur-PK
+	0x4b200000: 703, // uz
+	0x4b205000: 704, // uz-Arab
+	0x4b205023: 705, // uz-Arab-AF
+	0x4b21e000: 706, // uz-Cyrl
+	0x4b21e136: 707, // uz-Cyrl-UZ
+	0x4b252000: 708, // uz-Latn
+	0x4b252136: 709, // uz-Latn-UZ
+	0x4b400000: 710, // vai
+	0x4b452000: 711, // vai-Latn
+	0x4b4520b3: 712, // vai-Latn-LR
+	0x4b4d9000: 713, // vai-Vaii
+	0x4b4d90b3: 714, // vai-Vaii-LR
+	0x4b600000: 715, // ve
+	0x4b900000: 716, // vi
+	0x4b90013d: 717, // vi-VN
+	0x4bf00000: 718, // vo
+	0x4bf00001: 719, // vo-001
+	0x4c200000: 720, // vun
+	0x4c20012e: 721, // vun-TZ
+	0x4c400000: 722, // wa
+	0x4c500000: 723, // wae
+	0x4c50004d: 724, // wae-CH
+	0x4db00000: 725, // wo
+	0x4e800000: 726, // xh
+	0x4f100000: 727, // xog
+	0x4f100130: 728, // xog-UG
+	0x4ff00000: 729, // yav
+	0x4ff00051: 730, // yav-CM
+	0x50800000: 731, // yi
+	0x50800001: 732, // yi-001
+	0x50e00000: 733, // yo
+	0x50e0003a: 734, // yo-BJ
+	0x50e000d5: 735, // yo-NG
+	0x51500000: 736, // yue
+	0x5150008c: 737, // yue-HK
+	0x51e00000: 738, // zgh
+	0x51e000b9: 739, // zgh-MA
+	0x51f00000: 740, // zh
+	0x51f34000: 741, // zh-Hans
+	0x51f34052: 742, // zh-Hans-CN
+	0x51f3408c: 743, // zh-Hans-HK
+	0x51f340c5: 744, // zh-Hans-MO
+	0x51f3410c: 745, // zh-Hans-SG
+	0x51f35000: 746, // zh-Hant
+	0x51f3508c: 747, // zh-Hant-HK
+	0x51f350c5: 748, // zh-Hant-MO
+	0x51f3512d: 749, // zh-Hant-TW
+	0x52400000: 750, // zu
+	0x52400160: 751, // zu-ZA
+}
+
+// Total table size 4580 bytes (4KiB); checksum: A7F72A2A

vendor/golang.org/x/text/language/language.go

@@ -0,0 +1,975 @@
+// Copyright 2013 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.
+
+//go:generate go run maketables.go gen_common.go -output tables.go
+//go:generate go run gen_index.go
+
+// Package language implements BCP 47 language tags and related functionality.
+//
+// The Tag type, which is used to represent languages, is agnostic to the
+// meaning of its subtags. Tags are not fully canonicalized to preserve
+// information that may be valuable in certain contexts. As a consequence, two
+// different tags may represent identical languages.
+//
+// Initializing language- or locale-specific components usually consists of
+// two steps. The first step is to select a display language based on the
+// preferred languages of the user and the languages supported by an application.
+// The second step is to create the language-specific services based on
+// this selection. Each is discussed in more details below.
+//
+// Matching preferred against supported languages
+//
+// An application may support various languages. This list is typically limited
+// by the languages for which there exists translations of the user interface.
+// Similarly, a user may provide a list of preferred languages which is limited
+// by the languages understood by this user.
+// An application should use a Matcher to find the best supported language based
+// on the user's preferred list.
+// Matchers are aware of the intricacies of equivalence between languages.
+// The default Matcher implementation takes into account things such as
+// deprecated subtags, legacy tags, and mutual intelligibility between scripts
+// and languages.
+//
+// A Matcher for English, Australian English, Danish, and standard Mandarin can
+// be defined as follows:
+//
+//		var matcher = language.NewMatcher([]language.Tag{
+//			language.English,   // The first language is used as fallback.
+// 			language.MustParse("en-AU"),
+//			language.Danish,
+//			language.Chinese,
+//		})
+//
+// The following code selects the best match for someone speaking Spanish and
+// Norwegian:
+//
+// 		preferred := []language.Tag{ language.Spanish, language.Norwegian }
+//		tag, _, _ := matcher.Match(preferred...)
+//
+// In this case, the best match is Danish, as Danish is sufficiently a match to
+// Norwegian to not have to fall back to the default.
+// See ParseAcceptLanguage on how to handle the Accept-Language HTTP header.
+//
+// Selecting language-specific services
+//
+// One should always use the Tag returned by the Matcher to create an instance
+// of any of the language-specific services provided by the text repository.
+// This prevents the mixing of languages, such as having a different language for
+// messages and display names, as well as improper casing or sorting order for
+// the selected language.
+// Using the returned Tag also allows user-defined settings, such as collation
+// order or numbering system to be transparently passed as options.
+//
+// If you have language-specific data in your application, however, it will in
+// most cases suffice to use the index returned by the matcher to identify
+// the user language.
+// The following loop provides an alternative in case this is not sufficient:
+//
+// 		supported := map[language.Tag]data{
+//			language.English:            enData,
+// 			language.MustParse("en-AU"): enAUData,
+//			language.Danish:             daData,
+//			language.Chinese:            zhData,
+// 		}
+//		tag, _, _ := matcher.Match(preferred...)
+//		for ; tag != language.Und; tag = tag.Parent() {
+//			if v, ok := supported[tag]; ok {
+//				return v
+//			}
+//		}
+// 		return enData // should not reach here
+//
+// Repeatedly taking the Parent of the tag returned by Match will eventually
+// match one of the tags used to initialize the Matcher.
+//
+// Canonicalization
+//
+// By default, only legacy and deprecated tags are converted into their
+// canonical equivalent. All other information is preserved. This approach makes
+// the confidence scores more accurate and allows matchers to distinguish
+// between variants that are otherwise lost.
+//
+// As a consequence, two tags that should be treated as identical according to
+// BCP 47 or CLDR, like "en-Latn" and "en", will be represented differently. The
+// Matchers will handle such distinctions, though, and are aware of the
+// equivalence relations. The CanonType type can be used to alter the
+// canonicalization form.
+//
+// References
+//
+// BCP 47 - Tags for Identifying Languages
+// http://tools.ietf.org/html/bcp47
+package language // import "golang.org/x/text/language"
+
+// TODO: Remove above NOTE after:
+// - verifying that tables are dropped correctly (most notably matcher tables).
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+)
+
+const (
+	// maxCoreSize is the maximum size of a BCP 47 tag without variants and
+	// extensions. Equals max lang (3) + script (4) + max reg (3) + 2 dashes.
+	maxCoreSize = 12
+
+	// max99thPercentileSize is a somewhat arbitrary buffer size that presumably
+	// is large enough to hold at least 99% of the BCP 47 tags.
+	max99thPercentileSize = 32
+
+	// maxSimpleUExtensionSize is the maximum size of a -u extension with one
+	// key-type pair. Equals len("-u-") + key (2) + dash + max value (8).
+	maxSimpleUExtensionSize = 14
+)
+
+// Tag represents a BCP 47 language tag. It is used to specify an instance of a
+// specific language or locale. All language tag values are guaranteed to be
+// well-formed.
+type Tag struct {
+	lang     langID
+	region   regionID
+	script   scriptID
+	pVariant byte   // offset in str, includes preceding '-'
+	pExt     uint16 // offset of first extension, includes preceding '-'
+
+	// str is the string representation of the Tag. It will only be used if the
+	// tag has variants or extensions.
+	str string
+}
+
+// Make is a convenience wrapper for Parse that omits the error.
+// In case of an error, a sensible default is returned.
+func Make(s string) Tag {
+	return Default.Make(s)
+}
+
+// Make is a convenience wrapper for c.Parse that omits the error.
+// In case of an error, a sensible default is returned.
+func (c CanonType) Make(s string) Tag {
+	t, _ := c.Parse(s)
+	return t
+}
+
+// Raw returns the raw base language, script and region, without making an
+// attempt to infer their values.
+func (t Tag) Raw() (b Base, s Script, r Region) {
+	return Base{t.lang}, Script{t.script}, Region{t.region}
+}
+
+// equalTags compares language, script and region subtags only.
+func (t Tag) equalTags(a Tag) bool {
+	return t.lang == a.lang && t.script == a.script && t.region == a.region
+}
+
+// IsRoot returns true if t is equal to language "und".
+func (t Tag) IsRoot() bool {
+	if int(t.pVariant) < len(t.str) {
+		return false
+	}
+	return t.equalTags(und)
+}
+
+// private reports whether the Tag consists solely of a private use tag.
+func (t Tag) private() bool {
+	return t.str != "" && t.pVariant == 0
+}
+
+// CanonType can be used to enable or disable various types of canonicalization.
+type CanonType int
+
+const (
+	// Replace deprecated base languages with their preferred replacements.
+	DeprecatedBase CanonType = 1 << iota
+	// Replace deprecated scripts with their preferred replacements.
+	DeprecatedScript
+	// Replace deprecated regions with their preferred replacements.
+	DeprecatedRegion
+	// Remove redundant scripts.
+	SuppressScript
+	// Normalize legacy encodings. This includes legacy languages defined in
+	// CLDR as well as bibliographic codes defined in ISO-639.
+	Legacy
+	// Map the dominant language of a macro language group to the macro language
+	// subtag. For example cmn -> zh.
+	Macro
+	// The CLDR flag should be used if full compatibility with CLDR is required.
+	// There are a few cases where language.Tag may differ from CLDR. To follow all
+	// of CLDR's suggestions, use All|CLDR.
+	CLDR
+
+	// Raw can be used to Compose or Parse without Canonicalization.
+	Raw CanonType = 0
+
+	// Replace all deprecated tags with their preferred replacements.
+	Deprecated = DeprecatedBase | DeprecatedScript | DeprecatedRegion
+
+	// All canonicalizations recommended by BCP 47.
+	BCP47 = Deprecated | SuppressScript
+
+	// All canonicalizations.
+	All = BCP47 | Legacy | Macro
+
+	// Default is the canonicalization used by Parse, Make and Compose. To
+	// preserve as much information as possible, canonicalizations that remove
+	// potentially valuable information are not included. The Matcher is
+	// designed to recognize similar tags that would be the same if
+	// they were canonicalized using All.
+	Default = Deprecated | Legacy
+
+	canonLang = DeprecatedBase | Legacy | Macro
+
+	// TODO: LikelyScript, LikelyRegion: suppress similar to ICU.
+)
+
+// canonicalize returns the canonicalized equivalent of the tag and
+// whether there was any change.
+func (t Tag) canonicalize(c CanonType) (Tag, bool) {
+	if c == Raw {
+		return t, false
+	}
+	changed := false
+	if c&SuppressScript != 0 {
+		if t.lang < langNoIndexOffset && uint8(t.script) == suppressScript[t.lang] {
+			t.script = 0
+			changed = true
+		}
+	}
+	if c&canonLang != 0 {
+		for {
+			if l, aliasType := normLang(t.lang); l != t.lang {
+				switch aliasType {
+				case langLegacy:
+					if c&Legacy != 0 {
+						if t.lang == _sh && t.script == 0 {
+							t.script = _Latn
+						}
+						t.lang = l
+						changed = true
+					}
+				case langMacro:
+					if c&Macro != 0 {
+						// We deviate here from CLDR. The mapping "nb" -> "no"
+						// qualifies as a typical Macro language mapping.  However,
+						// for legacy reasons, CLDR maps "no", the macro language
+						// code for Norwegian, to the dominant variant "nb". This
+						// change is currently under consideration for CLDR as well.
+						// See http://unicode.org/cldr/trac/ticket/2698 and also
+						// http://unicode.org/cldr/trac/ticket/1790 for some of the
+						// practical implications. TODO: this check could be removed
+						// if CLDR adopts this change.
+						if c&CLDR == 0 || t.lang != _nb {
+							changed = true
+							t.lang = l
+						}
+					}
+				case langDeprecated:
+					if c&DeprecatedBase != 0 {
+						if t.lang == _mo && t.region == 0 {
+							t.region = _MD
+						}
+						t.lang = l
+						changed = true
+						// Other canonicalization types may still apply.
+						continue
+					}
+				}
+			} else if c&Legacy != 0 && t.lang == _no && c&CLDR != 0 {
+				t.lang = _nb
+				changed = true
+			}
+			break
+		}
+	}
+	if c&DeprecatedScript != 0 {
+		if t.script == _Qaai {
+			changed = true
+			t.script = _Zinh
+		}
+	}
+	if c&DeprecatedRegion != 0 {
+		if r := normRegion(t.region); r != 0 {
+			changed = true
+			t.region = r
+		}
+	}
+	return t, changed
+}
+
+// Canonicalize returns the canonicalized equivalent of the tag.
+func (c CanonType) Canonicalize(t Tag) (Tag, error) {
+	t, changed := t.canonicalize(c)
+	if changed {
+		t.remakeString()
+	}
+	return t, nil
+}
+
+// Confidence indicates the level of certainty for a given return value.
+// For example, Serbian may be written in Cyrillic or Latin script.
+// The confidence level indicates whether a value was explicitly specified,
+// whether it is typically the only possible value, or whether there is
+// an ambiguity.
+type Confidence int
+
+const (
+	No    Confidence = iota // full confidence that there was no match
+	Low                     // most likely value picked out of a set of alternatives
+	High                    // value is generally assumed to be the correct match
+	Exact                   // exact match or explicitly specified value
+)
+
+var confName = []string{"No", "Low", "High", "Exact"}
+
+func (c Confidence) String() string {
+	return confName[c]
+}
+
+// remakeString is used to update t.str in case lang, script or region changed.
+// It is assumed that pExt and pVariant still point to the start of the
+// respective parts.
+func (t *Tag) remakeString() {
+	if t.str == "" {
+		return
+	}
+	extra := t.str[t.pVariant:]
+	if t.pVariant > 0 {
+		extra = extra[1:]
+	}
+	if t.equalTags(und) && strings.HasPrefix(extra, "x-") {
+		t.str = extra
+		t.pVariant = 0
+		t.pExt = 0
+		return
+	}
+	var buf [max99thPercentileSize]byte // avoid extra memory allocation in most cases.
+	b := buf[:t.genCoreBytes(buf[:])]
+	if extra != "" {
+		diff := len(b) - int(t.pVariant)
+		b = append(b, '-')
+		b = append(b, extra...)
+		t.pVariant = uint8(int(t.pVariant) + diff)
+		t.pExt = uint16(int(t.pExt) + diff)
+	} else {
+		t.pVariant = uint8(len(b))
+		t.pExt = uint16(len(b))
+	}
+	t.str = string(b)
+}
+
+// genCoreBytes writes a string for the base languages, script and region tags
+// to the given buffer and returns the number of bytes written. It will never
+// write more than maxCoreSize bytes.
+func (t *Tag) genCoreBytes(buf []byte) int {
+	n := t.lang.stringToBuf(buf[:])
+	if t.script != 0 {
+		n += copy(buf[n:], "-")
+		n += copy(buf[n:], t.script.String())
+	}
+	if t.region != 0 {
+		n += copy(buf[n:], "-")
+		n += copy(buf[n:], t.region.String())
+	}
+	return n
+}
+
+// String returns the canonical string representation of the language tag.
+func (t Tag) String() string {
+	if t.str != "" {
+		return t.str
+	}
+	if t.script == 0 && t.region == 0 {
+		return t.lang.String()
+	}
+	buf := [maxCoreSize]byte{}
+	return string(buf[:t.genCoreBytes(buf[:])])
+}
+
+// Base returns the base language of the language tag. If the base language is
+// unspecified, an attempt will be made to infer it from the context.
+// It uses a variant of CLDR's Add Likely Subtags algorithm. This is subject to change.
+func (t Tag) Base() (Base, Confidence) {
+	if t.lang != 0 {
+		return Base{t.lang}, Exact
+	}
+	c := High
+	if t.script == 0 && !(Region{t.region}).IsCountry() {
+		c = Low
+	}
+	if tag, err := addTags(t); err == nil && tag.lang != 0 {
+		return Base{tag.lang}, c
+	}
+	return Base{0}, No
+}
+
+// Script infers the script for the language tag. If it was not explicitly given, it will infer
+// a most likely candidate.
+// If more than one script is commonly used for a language, the most likely one
+// is returned with a low confidence indication. For example, it returns (Cyrl, Low)
+// for Serbian.
+// If a script cannot be inferred (Zzzz, No) is returned. We do not use Zyyy (undetermined)
+// as one would suspect from the IANA registry for BCP 47. In a Unicode context Zyyy marks
+// common characters (like 1, 2, 3, '.', etc.) and is therefore more like multiple scripts.
+// See http://www.unicode.org/reports/tr24/#Values for more details. Zzzz is also used for
+// unknown value in CLDR.  (Zzzz, Exact) is returned if Zzzz was explicitly specified.
+// Note that an inferred script is never guaranteed to be the correct one. Latin is
+// almost exclusively used for Afrikaans, but Arabic has been used for some texts
+// in the past.  Also, the script that is commonly used may change over time.
+// It uses a variant of CLDR's Add Likely Subtags algorithm. This is subject to change.
+func (t Tag) Script() (Script, Confidence) {
+	if t.script != 0 {
+		return Script{t.script}, Exact
+	}
+	sc, c := scriptID(_Zzzz), No
+	if t.lang < langNoIndexOffset {
+		if scr := scriptID(suppressScript[t.lang]); scr != 0 {
+			// Note: it is not always the case that a language with a suppress
+			// script value is only written in one script (e.g. kk, ms, pa).
+			if t.region == 0 {
+				return Script{scriptID(scr)}, High
+			}
+			sc, c = scr, High
+		}
+	}
+	if tag, err := addTags(t); err == nil {
+		if tag.script != sc {
+			sc, c = tag.script, Low
+		}
+	} else {
+		t, _ = (Deprecated | Macro).Canonicalize(t)
+		if tag, err := addTags(t); err == nil && tag.script != sc {
+			sc, c = tag.script, Low
+		}
+	}
+	return Script{sc}, c
+}
+
+// Region returns the region for the language tag. If it was not explicitly given, it will
+// infer a most likely candidate from the context.
+// It uses a variant of CLDR's Add Likely Subtags algorithm. This is subject to change.
+func (t Tag) Region() (Region, Confidence) {
+	if t.region != 0 {
+		return Region{t.region}, Exact
+	}
+	if t, err := addTags(t); err == nil {
+		return Region{t.region}, Low // TODO: differentiate between high and low.
+	}
+	t, _ = (Deprecated | Macro).Canonicalize(t)
+	if tag, err := addTags(t); err == nil {
+		return Region{tag.region}, Low
+	}
+	return Region{_ZZ}, No // TODO: return world instead of undetermined?
+}
+
+// Variant returns the variants specified explicitly for this language tag.
+// or nil if no variant was specified.
+func (t Tag) Variants() []Variant {
+	v := []Variant{}
+	if int(t.pVariant) < int(t.pExt) {
+		for x, str := "", t.str[t.pVariant:t.pExt]; str != ""; {
+			x, str = nextToken(str)
+			v = append(v, Variant{x})
+		}
+	}
+	return v
+}
+
+// Parent returns the CLDR parent of t. In CLDR, missing fields in data for a
+// specific language are substituted with fields from the parent language.
+// The parent for a language may change for newer versions of CLDR.
+func (t Tag) Parent() Tag {
+	if t.str != "" {
+		// Strip the variants and extensions.
+		t, _ = Raw.Compose(t.Raw())
+		if t.region == 0 && t.script != 0 && t.lang != 0 {
+			base, _ := addTags(Tag{lang: t.lang})
+			if base.script == t.script {
+				return Tag{lang: t.lang}
+			}
+		}
+		return t
+	}
+	if t.lang != 0 {
+		if t.region != 0 {
+			maxScript := t.script
+			if maxScript == 0 {
+				max, _ := addTags(t)
+				maxScript = max.script
+			}
+
+			for i := range parents {
+				if langID(parents[i].lang) == t.lang && scriptID(parents[i].maxScript) == maxScript {
+					for _, r := range parents[i].fromRegion {
+						if regionID(r) == t.region {
+							return Tag{
+								lang:   t.lang,
+								script: scriptID(parents[i].script),
+								region: regionID(parents[i].toRegion),
+							}
+						}
+					}
+				}
+			}
+
+			// Strip the script if it is the default one.
+			base, _ := addTags(Tag{lang: t.lang})
+			if base.script != maxScript {
+				return Tag{lang: t.lang, script: maxScript}
+			}
+			return Tag{lang: t.lang}
+		} else if t.script != 0 {
+			// The parent for an base-script pair with a non-default script is
+			// "und" instead of the base language.
+			base, _ := addTags(Tag{lang: t.lang})
+			if base.script != t.script {
+				return und
+			}
+			return Tag{lang: t.lang}
+		}
+	}
+	return und
+}
+
+// returns token t and the rest of the string.
+func nextToken(s string) (t, tail string) {
+	p := strings.Index(s[1:], "-")
+	if p == -1 {
+		return s[1:], ""
+	}
+	p++
+	return s[1:p], s[p:]
+}
+
+// Extension is a single BCP 47 extension.
+type Extension struct {
+	s string
+}
+
+// String returns the string representation of the extension, including the
+// type tag.
+func (e Extension) String() string {
+	return e.s
+}
+
+// ParseExtension parses s as an extension and returns it on success.
+func ParseExtension(s string) (e Extension, err error) {
+	scan := makeScannerString(s)
+	var end int
+	if n := len(scan.token); n != 1 {
+		return Extension{}, errSyntax
+	}
+	scan.toLower(0, len(scan.b))
+	end = parseExtension(&scan)
+	if end != len(s) {
+		return Extension{}, errSyntax
+	}
+	return Extension{string(scan.b)}, nil
+}
+
+// Type returns the one-byte extension type of e. It returns 0 for the zero
+// exception.
+func (e Extension) Type() byte {
+	if e.s == "" {
+		return 0
+	}
+	return e.s[0]
+}
+
+// Tokens returns the list of tokens of e.
+func (e Extension) Tokens() []string {
+	return strings.Split(e.s, "-")
+}
+
+// Extension returns the extension of type x for tag t. It will return
+// false for ok if t does not have the requested extension. The returned
+// extension will be invalid in this case.
+func (t Tag) Extension(x byte) (ext Extension, ok bool) {
+	for i := int(t.pExt); i < len(t.str)-1; {
+		var ext string
+		i, ext = getExtension(t.str, i)
+		if ext[0] == x {
+			return Extension{ext}, true
+		}
+	}
+	return Extension{}, false
+}
+
+// Extensions returns all extensions of t.
+func (t Tag) Extensions() []Extension {
+	e := []Extension{}
+	for i := int(t.pExt); i < len(t.str)-1; {
+		var ext string
+		i, ext = getExtension(t.str, i)
+		e = append(e, Extension{ext})
+	}
+	return e
+}
+
+// TypeForKey returns the type associated with the given key, where key and type
+// are of the allowed values defined for the Unicode locale extension ('u') in
+// http://www.unicode.org/reports/tr35/#Unicode_Language_and_Locale_Identifiers.
+// TypeForKey will traverse the inheritance chain to get the correct value.
+func (t Tag) TypeForKey(key string) string {
+	if start, end, _ := t.findTypeForKey(key); end != start {
+		return t.str[start:end]
+	}
+	return ""
+}
+
+var (
+	errPrivateUse       = errors.New("cannot set a key on a private use tag")
+	errInvalidArguments = errors.New("invalid key or type")
+)
+
+// SetTypeForKey returns a new Tag with the key set to type, where key and type
+// are of the allowed values defined for the Unicode locale extension ('u') in
+// http://www.unicode.org/reports/tr35/#Unicode_Language_and_Locale_Identifiers.
+// An empty value removes an existing pair with the same key.
+func (t Tag) SetTypeForKey(key, value string) (Tag, error) {
+	if t.private() {
+		return t, errPrivateUse
+	}
+	if len(key) != 2 {
+		return t, errInvalidArguments
+	}
+
+	// Remove the setting if value is "".
+	if value == "" {
+		start, end, _ := t.findTypeForKey(key)
+		if start != end {
+			// Remove key tag and leading '-'.
+			start -= 4
+
+			// Remove a possible empty extension.
+			if (end == len(t.str) || t.str[end+2] == '-') && t.str[start-2] == '-' {
+				start -= 2
+			}
+			if start == int(t.pVariant) && end == len(t.str) {
+				t.str = ""
+				t.pVariant, t.pExt = 0, 0
+			} else {
+				t.str = fmt.Sprintf("%s%s", t.str[:start], t.str[end:])
+			}
+		}
+		return t, nil
+	}
+
+	if len(value) < 3 || len(value) > 8 {
+		return t, errInvalidArguments
+	}
+
+	var (
+		buf    [maxCoreSize + maxSimpleUExtensionSize]byte
+		uStart int // start of the -u extension.
+	)
+
+	// Generate the tag string if needed.
+	if t.str == "" {
+		uStart = t.genCoreBytes(buf[:])
+		buf[uStart] = '-'
+		uStart++
+	}
+
+	// Create new key-type pair and parse it to verify.
+	b := buf[uStart:]
+	copy(b, "u-")
+	copy(b[2:], key)
+	b[4] = '-'
+	b = b[:5+copy(b[5:], value)]
+	scan := makeScanner(b)
+	if parseExtensions(&scan); scan.err != nil {
+		return t, scan.err
+	}
+
+	// Assemble the replacement string.
+	if t.str == "" {
+		t.pVariant, t.pExt = byte(uStart-1), uint16(uStart-1)
+		t.str = string(buf[:uStart+len(b)])
+	} else {
+		s := t.str
+		start, end, hasExt := t.findTypeForKey(key)
+		if start == end {
+			if hasExt {
+				b = b[2:]
+			}
+			t.str = fmt.Sprintf("%s-%s%s", s[:start], b, s[end:])
+		} else {
+			t.str = fmt.Sprintf("%s%s%s", s[:start], value, s[end:])
+		}
+	}
+	return t, nil
+}
+
+// findKeyAndType returns the start and end position for the type corresponding
+// to key or the point at which to insert the key-value pair if the type
+// wasn't found. The hasExt return value reports whether an -u extension was present.
+// Note: the extensions are typically very small and are likely to contain
+// only one key-type pair.
+func (t Tag) findTypeForKey(key string) (start, end int, hasExt bool) {
+	p := int(t.pExt)
+	if len(key) != 2 || p == len(t.str) || p == 0 {
+		return p, p, false
+	}
+	s := t.str
+
+	// Find the correct extension.
+	for p++; s[p] != 'u'; p++ {
+		if s[p] > 'u' {
+			p--
+			return p, p, false
+		}
+		if p = nextExtension(s, p); p == len(s) {
+			return len(s), len(s), false
+		}
+	}
+	// Proceed to the hyphen following the extension name.
+	p++
+
+	// curKey is the key currently being processed.
+	curKey := ""
+
+	// Iterate over keys until we get the end of a section.
+	for {
+		// p points to the hyphen preceding the current token.
+		if p3 := p + 3; s[p3] == '-' {
+			// Found a key.
+			// Check whether we just processed the key that was requested.
+			if curKey == key {
+				return start, p, true
+			}
+			// Set to the next key and continue scanning type tokens.
+			curKey = s[p+1 : p3]
+			if curKey > key {
+				return p, p, true
+			}
+			// Start of the type token sequence.
+			start = p + 4
+			// A type is at least 3 characters long.
+			p += 7 // 4 + 3
+		} else {
+			// Attribute or type, which is at least 3 characters long.
+			p += 4
+		}
+		// p points past the third character of a type or attribute.
+		max := p + 5 // maximum length of token plus hyphen.
+		if len(s) < max {
+			max = len(s)
+		}
+		for ; p < max && s[p] != '-'; p++ {
+		}
+		// Bail if we have exhausted all tokens or if the next token starts
+		// a new extension.
+		if p == len(s) || s[p+2] == '-' {
+			if curKey == key {
+				return start, p, true
+			}
+			return p, p, true
+		}
+	}
+}
+
+// CompactIndex returns an index, where 0 <= index < NumCompactTags, for tags
+// for which data exists in the text repository. The index will change over time
+// and should not be stored in persistent storage. Extensions, except for the
+// 'va' type of the 'u' extension, are ignored. It will return 0, false if no
+// compact tag exists, where 0 is the index for the root language (Und).
+func CompactIndex(t Tag) (index int, ok bool) {
+	// TODO: perhaps give more frequent tags a lower index.
+	// TODO: we could make the indexes stable. This will excluded some
+	//       possibilities for optimization, so don't do this quite yet.
+	b, s, r := t.Raw()
+	if len(t.str) > 0 {
+		if strings.HasPrefix(t.str, "x-") {
+			// We have no entries for user-defined tags.
+			return 0, false
+		}
+		if uint16(t.pVariant) != t.pExt {
+			// There are no tags with variants and an u-va type.
+			if t.TypeForKey("va") != "" {
+				return 0, false
+			}
+			t, _ = Raw.Compose(b, s, r, t.Variants())
+		} else if _, ok := t.Extension('u'); ok {
+			// Strip all but the 'va' entry.
+			variant := t.TypeForKey("va")
+			t, _ = Raw.Compose(b, s, r)
+			t, _ = t.SetTypeForKey("va", variant)
+		}
+		if len(t.str) > 0 {
+			// We have some variants.
+			for i, s := range specialTags {
+				if s == t {
+					return i + 1, true
+				}
+			}
+			return 0, false
+		}
+	}
+	// No variants specified: just compare core components.
+	// The key has the form lllssrrr, where l, s, and r are nibbles for
+	// respectively the langID, scriptID, and regionID.
+	key := uint32(b.langID) << (8 + 12)
+	key |= uint32(s.scriptID) << 12
+	key |= uint32(r.regionID)
+	x, ok := coreTags[key]
+	return int(x), ok
+}
+
+// Base is an ISO 639 language code, used for encoding the base language
+// of a language tag.
+type Base struct {
+	langID
+}
+
+// ParseBase parses a 2- or 3-letter ISO 639 code.
+// It returns a ValueError if s is a well-formed but unknown language identifier
+// or another error if another error occurred.
+func ParseBase(s string) (Base, error) {
+	if n := len(s); n < 2 || 3 < n {
+		return Base{}, errSyntax
+	}
+	var buf [3]byte
+	l, err := getLangID(buf[:copy(buf[:], s)])
+	return Base{l}, err
+}
+
+// Script is a 4-letter ISO 15924 code for representing scripts.
+// It is idiomatically represented in title case.
+type Script struct {
+	scriptID
+}
+
+// ParseScript parses a 4-letter ISO 15924 code.
+// It returns a ValueError if s is a well-formed but unknown script identifier
+// or another error if another error occurred.
+func ParseScript(s string) (Script, error) {
+	if len(s) != 4 {
+		return Script{}, errSyntax
+	}
+	var buf [4]byte
+	sc, err := getScriptID(script, buf[:copy(buf[:], s)])
+	return Script{sc}, err
+}
+
+// Region is an ISO 3166-1 or UN M.49 code for representing countries and regions.
+type Region struct {
+	regionID
+}
+
+// EncodeM49 returns the Region for the given UN M.49 code.
+// It returns an error if r is not a valid code.
+func EncodeM49(r int) (Region, error) {
+	rid, err := getRegionM49(r)
+	return Region{rid}, err
+}
+
+// ParseRegion parses a 2- or 3-letter ISO 3166-1 or a UN M.49 code.
+// It returns a ValueError if s is a well-formed but unknown region identifier
+// or another error if another error occurred.
+func ParseRegion(s string) (Region, error) {
+	if n := len(s); n < 2 || 3 < n {
+		return Region{}, errSyntax
+	}
+	var buf [3]byte
+	r, err := getRegionID(buf[:copy(buf[:], s)])
+	return Region{r}, err
+}
+
+// IsCountry returns whether this region is a country or autonomous area. This
+// includes non-standard definitions from CLDR.
+func (r Region) IsCountry() bool {
+	if r.regionID == 0 || r.IsGroup() || r.IsPrivateUse() && r.regionID != _XK {
+		return false
+	}
+	return true
+}
+
+// IsGroup returns whether this region defines a collection of regions. This
+// includes non-standard definitions from CLDR.
+func (r Region) IsGroup() bool {
+	if r.regionID == 0 {
+		return false
+	}
+	return int(regionInclusion[r.regionID]) < len(regionContainment)
+}
+
+// Contains returns whether Region c is contained by Region r. It returns true
+// if c == r.
+func (r Region) Contains(c Region) bool {
+	return r.regionID.contains(c.regionID)
+}
+
+func (r regionID) contains(c regionID) bool {
+	if r == c {
+		return true
+	}
+	g := regionInclusion[r]
+	if g >= nRegionGroups {
+		return false
+	}
+	m := regionContainment[g]
+
+	d := regionInclusion[c]
+	b := regionInclusionBits[d]
+
+	// A contained country may belong to multiple disjoint groups. Matching any
+	// of these indicates containment. If the contained region is a group, it
+	// must strictly be a subset.
+	if d >= nRegionGroups {
+		return b&m != 0
+	}
+	return b&^m == 0
+}
+
+var errNoTLD = errors.New("language: region is not a valid ccTLD")
+
+// TLD returns the country code top-level domain (ccTLD). UK is returned for GB.
+// In all other cases it returns either the region itself or an error.
+//
+// This method may return an error for a region for which there exists a
+// canonical form with a ccTLD. To get that ccTLD canonicalize r first. The
+// region will already be canonicalized it was obtained from a Tag that was
+// obtained using any of the default methods.
+func (r Region) TLD() (Region, error) {
+	// See http://en.wikipedia.org/wiki/Country_code_top-level_domain for the
+	// difference between ISO 3166-1 and IANA ccTLD.
+	if r.regionID == _GB {
+		r = Region{_UK}
+	}
+	if (r.typ() & ccTLD) == 0 {
+		return Region{}, errNoTLD
+	}
+	return r, nil
+}
+
+// Canonicalize returns the region or a possible replacement if the region is
+// deprecated. It will not return a replacement for deprecated regions that
+// are split into multiple regions.
+func (r Region) Canonicalize() Region {
+	if cr := normRegion(r.regionID); cr != 0 {
+		return Region{cr}
+	}
+	return r
+}
+
+// Variant represents a registered variant of a language as defined by BCP 47.
+type Variant struct {
+	variant string
+}
+
+// ParseVariant parses and returns a Variant. An error is returned if s is not
+// a valid variant.
+func ParseVariant(s string) (Variant, error) {
+	s = strings.ToLower(s)
+	if _, ok := variantIndex[s]; ok {
+		return Variant{s}, nil
+	}
+	return Variant{}, mkErrInvalid([]byte(s))
+}
+
+// String returns the string representation of the variant.
+func (v Variant) String() string {
+	return v.variant
+}

vendor/golang.org/x/text/language/language_test.go

@@ -0,0 +1,878 @@
+// Copyright 2013 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.
+
+package language
+
+import (
+	"reflect"
+	"testing"
+
+	"golang.org/x/text/internal/testtext"
+)
+
+func TestTagSize(t *testing.T) {
+	id := Tag{}
+	typ := reflect.TypeOf(id)
+	if typ.Size() > 24 {
+		t.Errorf("size of Tag was %d; want 24", typ.Size())
+	}
+}
+
+func TestIsRoot(t *testing.T) {
+	loc := Tag{}
+	if !loc.IsRoot() {
+		t.Errorf("unspecified should be root.")
+	}
+	for i, tt := range parseTests() {
+		loc, _ := Parse(tt.in)
+		undef := tt.lang == "und" && tt.script == "" && tt.region == "" && tt.ext == ""
+		if loc.IsRoot() != undef {
+			t.Errorf("%d: was %v; want %v", i, loc.IsRoot(), undef)
+		}
+	}
+}
+
+func TestEquality(t *testing.T) {
+	for i, tt := range parseTests()[48:49] {
+		s := tt.in
+		tag := Make(s)
+		t1 := Make(tag.String())
+		if tag != t1 {
+			t.Errorf("%d:%s: equality test 1 failed\n got: %#v\nwant: %#v)", i, s, t1, tag)
+		}
+		t2, _ := Compose(tag)
+		if tag != t2 {
+			t.Errorf("%d:%s: equality test 2 failed\n got: %#v\nwant: %#v", i, s, t2, tag)
+		}
+	}
+}
+
+func TestMakeString(t *testing.T) {
+	tests := []struct{ in, out string }{
+		{"und", "und"},
+		{"und", "und-CW"},
+		{"nl", "nl-NL"},
+		{"de-1901", "nl-1901"},
+		{"de-1901", "de-Arab-1901"},
+		{"x-a-b", "de-Arab-x-a-b"},
+		{"x-a-b", "x-a-b"},
+	}
+	for i, tt := range tests {
+		id, _ := Parse(tt.in)
+		mod, _ := Parse(tt.out)
+		id.setTagsFrom(mod)
+		for j := 0; j < 2; j++ {
+			id.remakeString()
+			if str := id.String(); str != tt.out {
+				t.Errorf("%d:%d: found %s; want %s", i, j, id.String(), tt.out)
+			}
+		}
+		// The bytes to string conversion as used in remakeString
+		// occasionally measures as more than one alloc, breaking this test.
+		// To alleviate this we set the number of runs to more than 1.
+		if n := testtext.AllocsPerRun(8, id.remakeString); n > 1 {
+			t.Errorf("%d: # allocs got %.1f; want <= 1", i, n)
+		}
+	}
+}
+
+func TestCompactIndex(t *testing.T) {
+	tests := []struct {
+		tag   string
+		index int
+		ok    bool
+	}{
+		// TODO: these values will change with each CLDR update. This issue
+		// will be solved if we decide to fix the indexes.
+		{"und", 0, true},
+		{"ca-ES-valencia", 1, true},
+		{"ca-ES-valencia-u-va-posix", 0, false},
+		{"ca-ES-valencia-u-co-phonebk", 1, true},
+		{"ca-ES-valencia-u-co-phonebk-va-posix", 0, false},
+		{"x-klingon", 0, false},
+		{"en-US", 229, true},
+		{"en-US-u-va-posix", 2, true},
+		{"en", 133, true},
+		{"en-u-co-phonebk", 133, true},
+		{"en-001", 134, true},
+		{"sh", 0, false}, // We don't normalize.
+	}
+	for _, tt := range tests {
+		x, ok := CompactIndex(Raw.MustParse(tt.tag))
+		if x != tt.index || ok != tt.ok {
+			t.Errorf("%s: got %d, %v; want %d %v", tt.tag, x, ok, tt.index, tt.ok)
+		}
+	}
+}
+
+func TestBase(t *testing.T) {
+	tests := []struct {
+		loc, lang string
+		conf      Confidence
+	}{
+		{"und", "en", Low},
+		{"x-abc", "und", No},
+		{"en", "en", Exact},
+		{"und-Cyrl", "ru", High},
+		// If a region is not included, the official language should be English.
+		{"und-US", "en", High},
+		// TODO: not-explicitly listed scripts should probably be und, No
+		// Modify addTags to return info on how the match was derived.
+		// {"und-Aghb", "und", No},
+	}
+	for i, tt := range tests {
+		loc, _ := Parse(tt.loc)
+		lang, conf := loc.Base()
+		if lang.String() != tt.lang {
+			t.Errorf("%d: language was %s; want %s", i, lang, tt.lang)
+		}
+		if conf != tt.conf {
+			t.Errorf("%d: confidence was %d; want %d", i, conf, tt.conf)
+		}
+	}
+}
+
+func TestParseBase(t *testing.T) {
+	tests := []struct {
+		in  string
+		out string
+		ok  bool
+	}{
+		{"en", "en", true},
+		{"EN", "en", true},
+		{"nld", "nl", true},
+		{"dut", "dut", true},  // bibliographic
+		{"aaj", "und", false}, // unknown
+		{"qaa", "qaa", true},
+		{"a", "und", false},
+		{"", "und", false},
+		{"aaaa", "und", false},
+	}
+	for i, tt := range tests {
+		x, err := ParseBase(tt.in)
+		if x.String() != tt.out || err == nil != tt.ok {
+			t.Errorf("%d:%s: was %s, %v; want %s, %v", i, tt.in, x, err == nil, tt.out, tt.ok)
+		}
+		if y, _, _ := Raw.Make(tt.out).Raw(); x != y {
+			t.Errorf("%d:%s: tag was %s; want %s", i, tt.in, x, y)
+		}
+	}
+}
+
+func TestScript(t *testing.T) {
+	tests := []struct {
+		loc, scr string
+		conf     Confidence
+	}{
+		{"und", "Latn", Low},
+		{"en-Latn", "Latn", Exact},
+		{"en", "Latn", High},
+		{"sr", "Cyrl", Low},
+		{"kk", "Cyrl", High},
+		{"kk-CN", "Arab", Low},
+		{"cmn", "Hans", Low},
+		{"ru", "Cyrl", High},
+		{"ru-RU", "Cyrl", High},
+		{"yue", "Hant", Low},
+		{"x-abc", "Zzzz", Low},
+		{"und-zyyy", "Zyyy", Exact},
+	}
+	for i, tt := range tests {
+		loc, _ := Parse(tt.loc)
+		sc, conf := loc.Script()
+		if sc.String() != tt.scr {
+			t.Errorf("%d:%s: script was %s; want %s", i, tt.loc, sc, tt.scr)
+		}
+		if conf != tt.conf {
+			t.Errorf("%d:%s: confidence was %d; want %d", i, tt.loc, conf, tt.conf)
+		}
+	}
+}
+
+func TestParseScript(t *testing.T) {
+	tests := []struct {
+		in  string
+		out string
+		ok  bool
+	}{
+		{"Latn", "Latn", true},
+		{"zzzz", "Zzzz", true},
+		{"zyyy", "Zyyy", true},
+		{"Latm", "Zzzz", false},
+		{"Zzz", "Zzzz", false},
+		{"", "Zzzz", false},
+		{"Zzzxx", "Zzzz", false},
+	}
+	for i, tt := range tests {
+		x, err := ParseScript(tt.in)
+		if x.String() != tt.out || err == nil != tt.ok {
+			t.Errorf("%d:%s: was %s, %v; want %s, %v", i, tt.in, x, err == nil, tt.out, tt.ok)
+		}
+		if err == nil {
+			if _, y, _ := Raw.Make("und-" + tt.out).Raw(); x != y {
+				t.Errorf("%d:%s: tag was %s; want %s", i, tt.in, x, y)
+			}
+		}
+	}
+}
+
+func TestRegion(t *testing.T) {
+	tests := []struct {
+		loc, reg string
+		conf     Confidence
+	}{
+		{"und", "US", Low},
+		{"en", "US", Low},
+		{"zh-Hant", "TW", Low},
+		{"en-US", "US", Exact},
+		{"cmn", "CN", Low},
+		{"ru", "RU", Low},
+		{"yue", "HK", Low},
+		{"x-abc", "ZZ", Low},
+	}
+	for i, tt := range tests {
+		loc, _ := Raw.Parse(tt.loc)
+		reg, conf := loc.Region()
+		if reg.String() != tt.reg {
+			t.Errorf("%d:%s: region was %s; want %s", i, tt.loc, reg, tt.reg)
+		}
+		if conf != tt.conf {
+			t.Errorf("%d:%s: confidence was %d; want %d", i, tt.loc, conf, tt.conf)
+		}
+	}
+}
+
+func TestEncodeM49(t *testing.T) {
+	tests := []struct {
+		m49  int
+		code string
+		ok   bool
+	}{
+		{1, "001", true},
+		{840, "US", true},
+		{899, "ZZ", false},
+	}
+	for i, tt := range tests {
+		if r, err := EncodeM49(tt.m49); r.String() != tt.code || err == nil != tt.ok {
+			t.Errorf("%d:%d: was %s, %v; want %s, %v", i, tt.m49, r, err == nil, tt.code, tt.ok)
+		}
+	}
+	for i := 1; i <= 1000; i++ {
+		if r, err := EncodeM49(i); err == nil && r.M49() == 0 {
+			t.Errorf("%d has no error, but maps to undefined region", i)
+		}
+	}
+}
+
+func TestParseRegion(t *testing.T) {
+	tests := []struct {
+		in  string
+		out string
+		ok  bool
+	}{
+		{"001", "001", true},
+		{"840", "US", true},
+		{"899", "ZZ", false},
+		{"USA", "US", true},
+		{"US", "US", true},
+		{"BC", "ZZ", false},
+		{"C", "ZZ", false},
+		{"CCCC", "ZZ", false},
+		{"01", "ZZ", false},
+	}
+	for i, tt := range tests {
+		r, err := ParseRegion(tt.in)
+		if r.String() != tt.out || err == nil != tt.ok {
+			t.Errorf("%d:%s: was %s, %v; want %s, %v", i, tt.in, r, err == nil, tt.out, tt.ok)
+		}
+		if err == nil {
+			if _, _, y := Raw.Make("und-" + tt.out).Raw(); r != y {
+				t.Errorf("%d:%s: tag was %s; want %s", i, tt.in, r, y)
+			}
+		}
+	}
+}
+
+func TestIsCountry(t *testing.T) {
+	tests := []struct {
+		reg     string
+		country bool
+	}{
+		{"US", true},
+		{"001", false},
+		{"958", false},
+		{"419", false},
+		{"203", true},
+		{"020", true},
+		{"900", false},
+		{"999", false},
+		{"QO", false},
+		{"EU", false},
+		{"AA", false},
+		{"XK", true},
+	}
+	for i, tt := range tests {
+		reg, _ := getRegionID([]byte(tt.reg))
+		r := Region{reg}
+		if r.IsCountry() != tt.country {
+			t.Errorf("%d: IsCountry(%s) was %v; want %v", i, tt.reg, r.IsCountry(), tt.country)
+		}
+	}
+}
+
+func TestIsGroup(t *testing.T) {
+	tests := []struct {
+		reg   string
+		group bool
+	}{
+		{"US", false},
+		{"001", true},
+		{"958", false},
+		{"419", true},
+		{"203", false},
+		{"020", false},
+		{"900", false},
+		{"999", false},
+		{"QO", true},
+		{"EU", true},
+		{"AA", false},
+		{"XK", false},
+	}
+	for i, tt := range tests {
+		reg, _ := getRegionID([]byte(tt.reg))
+		r := Region{reg}
+		if r.IsGroup() != tt.group {
+			t.Errorf("%d: IsGroup(%s) was %v; want %v", i, tt.reg, r.IsGroup(), tt.group)
+		}
+	}
+}
+
+func TestContains(t *testing.T) {
+	tests := []struct {
+		enclosing, contained string
+		contains             bool
+	}{
+		// A region contains itself.
+		{"US", "US", true},
+		{"001", "001", true},
+
+		// Direct containment.
+		{"001", "002", true},
+		{"039", "XK", true},
+		{"150", "XK", true},
+		{"EU", "AT", true},
+		{"QO", "AQ", true},
+
+		// Indirect containemnt.
+		{"001", "US", true},
+		{"001", "419", true},
+		{"001", "013", true},
+
+		// No containment.
+		{"US", "001", false},
+		{"155", "EU", false},
+	}
+	for i, tt := range tests {
+		enc, _ := getRegionID([]byte(tt.enclosing))
+		con, _ := getRegionID([]byte(tt.contained))
+		r := Region{enc}
+		if got := r.Contains(Region{con}); got != tt.contains {
+			t.Errorf("%d: %s.Contains(%s) was %v; want %v", i, tt.enclosing, tt.contained, got, tt.contains)
+		}
+	}
+}
+
+func TestRegionCanonicalize(t *testing.T) {
+	for i, tt := range []struct{ in, out string }{
+		{"UK", "GB"},
+		{"TP", "TL"},
+		{"QU", "EU"},
+		{"SU", "SU"},
+		{"VD", "VN"},
+		{"DD", "DE"},
+	} {
+		r := MustParseRegion(tt.in)
+		want := MustParseRegion(tt.out)
+		if got := r.Canonicalize(); got != want {
+			t.Errorf("%d: got %v; want %v", i, got, want)
+		}
+	}
+}
+
+func TestRegionTLD(t *testing.T) {
+	for _, tt := range []struct {
+		in, out string
+		ok      bool
+	}{
+		{"EH", "EH", true},
+		{"FR", "FR", true},
+		{"TL", "TL", true},
+
+		// In ccTLD before in ISO.
+		{"GG", "GG", true},
+
+		// Non-standard assignment of ccTLD to ISO code.
+		{"GB", "UK", true},
+
+		// Exceptionally reserved in ISO and valid ccTLD.
+		{"UK", "UK", true},
+		{"AC", "AC", true},
+		{"EU", "EU", true},
+		{"SU", "SU", true},
+
+		// Exceptionally reserved in ISO and invalid ccTLD.
+		{"CP", "ZZ", false},
+		{"DG", "ZZ", false},
+		{"EA", "ZZ", false},
+		{"FX", "ZZ", false},
+		{"IC", "ZZ", false},
+		{"TA", "ZZ", false},
+
+		// Transitionally reserved in ISO (e.g. deprecated) but valid ccTLD as
+		// it is still being phased out.
+		{"AN", "AN", true},
+		{"TP", "TP", true},
+
+		// Transitionally reserved in ISO (e.g. deprecated) and invalid ccTLD.
+		// Defined in package language as it has a mapping in CLDR.
+		{"BU", "ZZ", false},
+		{"CS", "ZZ", false},
+		{"NT", "ZZ", false},
+		{"YU", "ZZ", false},
+		{"ZR", "ZZ", false},
+		// Not defined in package: SF.
+
+		// Indeterminately reserved in ISO.
+		// Defined in package language as it has a legacy mapping in CLDR.
+		{"DY", "ZZ", false},
+		{"RH", "ZZ", false},
+		{"VD", "ZZ", false},
+		// Not defined in package: EW, FL, JA, LF, PI, RA, RB, RC, RI, RL, RM,
+		// RN, RP, WG, WL, WV, and YV.
+
+		// Not assigned in ISO, but legacy definitions in CLDR.
+		{"DD", "ZZ", false},
+		{"YD", "ZZ", false},
+
+		// Normal mappings but somewhat special status in ccTLD.
+		{"BL", "BL", true},
+		{"MF", "MF", true},
+		{"BV", "BV", true},
+		{"SJ", "SJ", true},
+
+		// Have values when normalized, but not as is.
+		{"QU", "ZZ", false},
+
+		// ISO Private Use.
+		{"AA", "ZZ", false},
+		{"QM", "ZZ", false},
+		{"QO", "ZZ", false},
+		{"XA", "ZZ", false},
+		{"XK", "ZZ", false}, // Sometimes used for Kosovo, but invalid ccTLD.
+	} {
+		if tt.in == "" {
+			continue
+		}
+
+		r := MustParseRegion(tt.in)
+		var want Region
+		if tt.out != "ZZ" {
+			want = MustParseRegion(tt.out)
+		}
+		tld, err := r.TLD()
+		if got := err == nil; got != tt.ok {
+			t.Errorf("error(%v): got %v; want %v", r, got, tt.ok)
+		}
+		if tld != want {
+			t.Errorf("TLD(%v): got %v; want %v", r, tld, want)
+		}
+	}
+}
+
+func TestCanonicalize(t *testing.T) {
+	// TODO: do a full test using CLDR data in a separate regression test.
+	tests := []struct {
+		in, out string
+		option  CanonType
+	}{
+		{"en-Latn", "en", SuppressScript},
+		{"sr-Cyrl", "sr-Cyrl", SuppressScript},
+		{"sh", "sr-Latn", Legacy},
+		{"sh-HR", "sr-Latn-HR", Legacy},
+		{"sh-Cyrl-HR", "sr-Cyrl-HR", Legacy},
+		{"tl", "fil", Legacy},
+		{"no", "no", Legacy},
+		{"no", "nb", Legacy | CLDR},
+		{"cmn", "cmn", Legacy},
+		{"cmn", "zh", Macro},
+		{"cmn-u-co-stroke", "zh-u-co-stroke", Macro},
+		{"yue", "yue", Macro},
+		{"nb", "no", Macro},
+		{"nb", "nb", Macro | CLDR},
+		{"no", "no", Macro},
+		{"no", "no", Macro | CLDR},
+		{"iw", "he", DeprecatedBase},
+		{"iw", "he", Deprecated | CLDR},
+		{"mo", "ro-MD", Deprecated}, // Adopted by CLDR as of version 25.
+		{"alb", "sq", Legacy},       // bibliographic
+		{"dut", "nl", Legacy},       // bibliographic
+		// As of CLDR 25, mo is no longer considered a legacy mapping.
+		{"mo", "mo", Legacy | CLDR},
+		{"und-AN", "und-AN", Deprecated},
+		{"und-YD", "und-YE", DeprecatedRegion},
+		{"und-YD", "und-YD", DeprecatedBase},
+		{"und-Qaai", "und-Zinh", DeprecatedScript},
+		{"und-Qaai", "und-Qaai", DeprecatedBase},
+		{"drh", "mn", All}, // drh -> khk -> mn
+	}
+	for i, tt := range tests {
+		in, _ := Raw.Parse(tt.in)
+		in, _ = tt.option.Canonicalize(in)
+		if in.String() != tt.out {
+			t.Errorf("%d:%s: was %s; want %s", i, tt.in, in.String(), tt.out)
+		}
+		if int(in.pVariant) > int(in.pExt) || int(in.pExt) > len(in.str) {
+			t.Errorf("%d:%s:offsets %d <= %d <= %d must be true", i, tt.in, in.pVariant, in.pExt, len(in.str))
+		}
+	}
+	// Test idempotence.
+	for _, base := range Supported.BaseLanguages() {
+		tag, _ := Raw.Compose(base)
+		got, _ := All.Canonicalize(tag)
+		want, _ := All.Canonicalize(got)
+		if got != want {
+			t.Errorf("idem(%s): got %s; want %s", tag, got, want)
+		}
+	}
+}
+
+func TestTypeForKey(t *testing.T) {
+	tests := []struct{ key, in, out string }{
+		{"co", "en", ""},
+		{"co", "en-u-abc", ""},
+		{"co", "en-u-co-phonebk", "phonebk"},
+		{"co", "en-u-co-phonebk-cu-aud", "phonebk"},
+		{"co", "x-foo-u-co-phonebk", ""},
+		{"nu", "en-u-co-phonebk-nu-arabic", "arabic"},
+		{"kc", "cmn-u-co-stroke", ""},
+	}
+	for _, tt := range tests {
+		if v := Make(tt.in).TypeForKey(tt.key); v != tt.out {
+			t.Errorf("%q[%q]: was %q; want %q", tt.in, tt.key, v, tt.out)
+		}
+	}
+}
+
+func TestSetTypeForKey(t *testing.T) {
+	tests := []struct {
+		key, value, in, out string
+		err                 bool
+	}{
+		// replace existing value
+		{"co", "pinyin", "en-u-co-phonebk", "en-u-co-pinyin", false},
+		{"co", "pinyin", "en-u-co-phonebk-cu-xau", "en-u-co-pinyin-cu-xau", false},
+		{"co", "pinyin", "en-u-co-phonebk-v-xx", "en-u-co-pinyin-v-xx", false},
+		{"co", "pinyin", "en-u-co-phonebk-x-x", "en-u-co-pinyin-x-x", false},
+		{"nu", "arabic", "en-u-co-phonebk-nu-vaai", "en-u-co-phonebk-nu-arabic", false},
+		// add to existing -u extension
+		{"co", "pinyin", "en-u-ca-gregory", "en-u-ca-gregory-co-pinyin", false},
+		{"co", "pinyin", "en-u-ca-gregory-nu-vaai", "en-u-ca-gregory-co-pinyin-nu-vaai", false},
+		{"co", "pinyin", "en-u-ca-gregory-v-va", "en-u-ca-gregory-co-pinyin-v-va", false},
+		{"co", "pinyin", "en-u-ca-gregory-x-a", "en-u-ca-gregory-co-pinyin-x-a", false},
+		{"ca", "gregory", "en-u-co-pinyin", "en-u-ca-gregory-co-pinyin", false},
+		// remove pair
+		{"co", "", "en-u-co-phonebk", "en", false},
+		{"co", "", "en-u-ca-gregory-co-phonebk", "en-u-ca-gregory", false},
+		{"co", "", "en-u-co-phonebk-nu-arabic", "en-u-nu-arabic", false},
+		{"co", "", "en", "en", false},
+		// add -u extension
+		{"co", "pinyin", "en", "en-u-co-pinyin", false},
+		{"co", "pinyin", "und", "und-u-co-pinyin", false},
+		{"co", "pinyin", "en-a-aaa", "en-a-aaa-u-co-pinyin", false},
+		{"co", "pinyin", "en-x-aaa", "en-u-co-pinyin-x-aaa", false},
+		{"co", "pinyin", "en-v-aa", "en-u-co-pinyin-v-aa", false},
+		{"co", "pinyin", "en-a-aaa-x-x", "en-a-aaa-u-co-pinyin-x-x", false},
+		{"co", "pinyin", "en-a-aaa-v-va", "en-a-aaa-u-co-pinyin-v-va", false},
+		// error on invalid values
+		{"co", "pinyinxxx", "en", "en", true},
+		{"co", "piny.n", "en", "en", true},
+		{"co", "pinyinxxx", "en-a-aaa", "en-a-aaa", true},
+		{"co", "pinyinxxx", "en-u-aaa", "en-u-aaa", true},
+		{"co", "pinyinxxx", "en-u-aaa-co-pinyin", "en-u-aaa-co-pinyin", true},
+		{"co", "pinyi.", "en-u-aaa-co-pinyin", "en-u-aaa-co-pinyin", true},
+		{"col", "pinyin", "en", "en", true},
+		{"co", "cu", "en", "en", true},
+		// error when setting on a private use tag
+		{"co", "phonebook", "x-foo", "x-foo", true},
+	}
+	for i, tt := range tests {
+		tag := Make(tt.in)
+		if v, err := tag.SetTypeForKey(tt.key, tt.value); v.String() != tt.out {
+			t.Errorf("%d:%q[%q]=%q: was %q; want %q", i, tt.in, tt.key, tt.value, v, tt.out)
+		} else if (err != nil) != tt.err {
+			t.Errorf("%d:%q[%q]=%q: error was %v; want %v", i, tt.in, tt.key, tt.value, err != nil, tt.err)
+		} else if val := v.TypeForKey(tt.key); err == nil && val != tt.value {
+			t.Errorf("%d:%q[%q]==%q: was %v; want %v", i, tt.out, tt.key, tt.value, val, tt.value)
+		}
+		if len(tag.String()) <= 3 {
+			// Simulate a tag for which the string has not been set.
+			tag.str, tag.pExt, tag.pVariant = "", 0, 0
+			if tag, err := tag.SetTypeForKey(tt.key, tt.value); err == nil {
+				if val := tag.TypeForKey(tt.key); err == nil && val != tt.value {
+					t.Errorf("%d:%q[%q]==%q: was %v; want %v", i, tt.out, tt.key, tt.value, val, tt.value)
+				}
+			}
+		}
+	}
+}
+
+func TestFindKeyAndType(t *testing.T) {
+	// out is either the matched type in case of a match or the original
+	// string up till the insertion point.
+	tests := []struct {
+		key     string
+		hasExt  bool
+		in, out string
+	}{
+		// Don't search past a private use extension.
+		{"co", false, "en-x-foo-u-co-pinyin", "en"},
+		{"co", false, "x-foo-u-co-pinyin", ""},
+		{"co", false, "en-s-fff-x-foo", "en-s-fff"},
+		// Insertion points in absence of -u extension.
+		{"cu", false, "en", ""}, // t.str is ""
+		{"cu", false, "en-v-va", "en"},
+		{"cu", false, "en-a-va", "en-a-va"},
+		{"cu", false, "en-a-va-v-va", "en-a-va"},
+		{"cu", false, "en-x-a", "en"},
+		// Tags with the -u extension.
+		{"co", true, "en-u-co-standard", "standard"},
+		{"co", true, "yue-u-co-pinyin", "pinyin"},
+		{"co", true, "en-u-co-abc", "abc"},
+		{"co", true, "en-u-co-abc-def", "abc-def"},
+		{"co", true, "en-u-co-abc-def-x-foo", "abc-def"},
+		{"co", true, "en-u-co-standard-nu-arab", "standard"},
+		{"co", true, "yue-u-co-pinyin-nu-arab", "pinyin"},
+		// Insertion points.
+		{"cu", true, "en-u-co-standard", "en-u-co-standard"},
+		{"cu", true, "yue-u-co-pinyin-x-foo", "yue-u-co-pinyin"},
+		{"cu", true, "en-u-co-abc", "en-u-co-abc"},
+		{"cu", true, "en-u-nu-arabic", "en-u"},
+		{"cu", true, "en-u-co-abc-def-nu-arabic", "en-u-co-abc-def"},
+	}
+	for i, tt := range tests {
+		start, end, hasExt := Make(tt.in).findTypeForKey(tt.key)
+		if start != end {
+			res := tt.in[start:end]
+			if res != tt.out {
+				t.Errorf("%d:%s: was %q; want %q", i, tt.in, res, tt.out)
+			}
+		} else {
+			if hasExt != tt.hasExt {
+				t.Errorf("%d:%s: hasExt was %v; want %v", i, tt.in, hasExt, tt.hasExt)
+				continue
+			}
+			if tt.in[:start] != tt.out {
+				t.Errorf("%d:%s: insertion point was %q; want %q", i, tt.in, tt.in[:start], tt.out)
+			}
+		}
+	}
+}
+
+func TestParent(t *testing.T) {
+	tests := []struct{ in, out string }{
+		// Strip variants and extensions first
+		{"de-u-co-phonebk", "de"},
+		{"de-1994", "de"},
+		{"de-Latn-1994", "de"}, // remove superfluous script.
+
+		// Ensure the canonical Tag for an entry is in the chain for base-script
+		// pairs.
+		{"zh-Hans", "zh"},
+
+		// Skip the script if it is the maximized version. CLDR files for the
+		// skipped tag are always empty.
+		{"zh-Hans-TW", "zh"},
+		{"zh-Hans-CN", "zh"},
+
+		// Insert the script if the maximized script is not the same as the
+		// maximized script of the base language.
+		{"zh-TW", "zh-Hant"},
+		{"zh-HK", "zh-Hant"},
+		{"zh-Hant-TW", "zh-Hant"},
+		{"zh-Hant-HK", "zh-Hant"},
+
+		// Non-default script skips to und.
+		// CLDR
+		{"az-Cyrl", "und"},
+		{"bs-Cyrl", "und"},
+		{"en-Dsrt", "und"},
+		{"ha-Arab", "und"},
+		{"mn-Mong", "und"},
+		{"pa-Arab", "und"},
+		{"shi-Latn", "und"},
+		{"sr-Latn", "und"},
+		{"uz-Arab", "und"},
+		{"uz-Cyrl", "und"},
+		{"vai-Latn", "und"},
+		{"zh-Hant", "und"},
+		// extra
+		{"nl-Cyrl", "und"},
+
+		// World english inherits from en-001.
+		{"en-150", "en-001"},
+		{"en-AU", "en-001"},
+		{"en-BE", "en-001"},
+		{"en-GG", "en-001"},
+		{"en-GI", "en-001"},
+		{"en-HK", "en-001"},
+		{"en-IE", "en-001"},
+		{"en-IM", "en-001"},
+		{"en-IN", "en-001"},
+		{"en-JE", "en-001"},
+		{"en-MT", "en-001"},
+		{"en-NZ", "en-001"},
+		{"en-PK", "en-001"},
+		{"en-SG", "en-001"},
+
+		// Spanish in Latin-American countries have es-419 as parent.
+		{"es-AR", "es-419"},
+		{"es-BO", "es-419"},
+		{"es-CL", "es-419"},
+		{"es-CO", "es-419"},
+		{"es-CR", "es-419"},
+		{"es-CU", "es-419"},
+		{"es-DO", "es-419"},
+		{"es-EC", "es-419"},
+		{"es-GT", "es-419"},
+		{"es-HN", "es-419"},
+		{"es-MX", "es-419"},
+		{"es-NI", "es-419"},
+		{"es-PA", "es-419"},
+		{"es-PE", "es-419"},
+		{"es-PR", "es-419"},
+		{"es-PY", "es-419"},
+		{"es-SV", "es-419"},
+		{"es-US", "es-419"},
+		{"es-UY", "es-419"},
+		{"es-VE", "es-419"},
+		// exceptions (according to CLDR)
+		{"es-CW", "es"},
+
+		// Inherit from pt-PT, instead of pt for these countries.
+		{"pt-AO", "pt-PT"},
+		{"pt-CV", "pt-PT"},
+		{"pt-GW", "pt-PT"},
+		{"pt-MO", "pt-PT"},
+		{"pt-MZ", "pt-PT"},
+		{"pt-ST", "pt-PT"},
+		{"pt-TL", "pt-PT"},
+	}
+	for _, tt := range tests {
+		tag := Raw.MustParse(tt.in)
+		if p := Raw.MustParse(tt.out); p != tag.Parent() {
+			t.Errorf("%s: was %v; want %v", tt.in, tag.Parent(), p)
+		}
+	}
+}
+
+var (
+	// Tags without error that don't need to be changed.
+	benchBasic = []string{
+		"en",
+		"en-Latn",
+		"en-GB",
+		"za",
+		"zh-Hant",
+		"zh",
+		"zh-HK",
+		"ar-MK",
+		"en-CA",
+		"fr-CA",
+		"fr-CH",
+		"fr",
+		"lv",
+		"he-IT",
+		"tlh",
+		"ja",
+		"ja-Jpan",
+		"ja-Jpan-JP",
+		"de-1996",
+		"de-CH",
+		"sr",
+		"sr-Latn",
+	}
+	// Tags with extensions, not changes required.
+	benchExt = []string{
+		"x-a-b-c-d",
+		"x-aa-bbbb-cccccccc-d",
+		"en-x_cc-b-bbb-a-aaa",
+		"en-c_cc-b-bbb-a-aaa-x-x",
+		"en-u-co-phonebk",
+		"en-Cyrl-u-co-phonebk",
+		"en-US-u-co-phonebk-cu-xau",
+		"en-nedix-u-co-phonebk",
+		"en-t-t0-abcd",
+		"en-t-nl-latn",
+		"en-t-t0-abcd-x-a",
+	}
+	// Change, but not memory allocation required.
+	benchSimpleChange = []string{
+		"EN",
+		"i-klingon",
+		"en-latn",
+		"zh-cmn-Hans-CN",
+		"iw-NL",
+	}
+	// Change and memory allocation required.
+	benchChangeAlloc = []string{
+		"en-c_cc-b-bbb-a-aaa",
+		"en-u-cu-xua-co-phonebk",
+		"en-u-cu-xua-co-phonebk-a-cd",
+		"en-u-def-abc-cu-xua-co-phonebk",
+		"en-t-en-Cyrl-NL-1994",
+		"en-t-en-Cyrl-NL-1994-t0-abc-def",
+	}
+	// Tags that result in errors.
+	benchErr = []string{
+		// IllFormed
+		"x_A.-B-C_D",
+		"en-u-cu-co-phonebk",
+		"en-u-cu-xau-co",
+		"en-t-nl-abcd",
+		// Invalid
+		"xx",
+		"nl-Uuuu",
+		"nl-QB",
+	}
+	benchChange = append(benchSimpleChange, benchChangeAlloc...)
+	benchAll    = append(append(append(benchBasic, benchExt...), benchChange...), benchErr...)
+)
+
+func doParse(b *testing.B, tag []string) {
+	for i := 0; i < b.N; i++ {
+		// Use the modulo instead of looping over all tags so that we get a somewhat
+		// meaningful ns/op.
+		Parse(tag[i%len(tag)])
+	}
+}
+
+func BenchmarkParse(b *testing.B) {
+	doParse(b, benchAll)
+}
+
+func BenchmarkParseBasic(b *testing.B) {
+	doParse(b, benchBasic)
+}
+
+func BenchmarkParseError(b *testing.B) {
+	doParse(b, benchErr)
+}
+
+func BenchmarkParseSimpleChange(b *testing.B) {
+	doParse(b, benchSimpleChange)
+}
+
+func BenchmarkParseChangeAlloc(b *testing.B) {
+	doParse(b, benchChangeAlloc)
+}

vendor/golang.org/x/text/language/lookup.go

@@ -0,0 +1,396 @@
+// Copyright 2013 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.
+
+package language
+
+import (
+	"bytes"
+	"fmt"
+	"sort"
+	"strconv"
+
+	"golang.org/x/text/internal/tag"
+)
+
+// findIndex tries to find the given tag in idx and returns a standardized error
+// if it could not be found.
+func findIndex(idx tag.Index, key []byte, form string) (index int, err error) {
+	if !tag.FixCase(form, key) {
+		return 0, errSyntax
+	}
+	i := idx.Index(key)
+	if i == -1 {
+		return 0, mkErrInvalid(key)
+	}
+	return i, nil
+}
+
+func searchUint(imap []uint16, key uint16) int {
+	return sort.Search(len(imap), func(i int) bool {
+		return imap[i] >= key
+	})
+}
+
+type langID uint16
+
+// getLangID returns the langID of s if s is a canonical subtag
+// or langUnknown if s is not a canonical subtag.
+func getLangID(s []byte) (langID, error) {
+	if len(s) == 2 {
+		return getLangISO2(s)
+	}
+	return getLangISO3(s)
+}
+
+// mapLang returns the mapped langID of id according to mapping m.
+func normLang(id langID) (langID, langAliasType) {
+	k := sort.Search(len(langAliasMap), func(i int) bool {
+		return langAliasMap[i].from >= uint16(id)
+	})
+	if k < len(langAliasMap) && langAliasMap[k].from == uint16(id) {
+		return langID(langAliasMap[k].to), langAliasTypes[k]
+	}
+	return id, langAliasTypeUnknown
+}
+
+// getLangISO2 returns the langID for the given 2-letter ISO language code
+// or unknownLang if this does not exist.
+func getLangISO2(s []byte) (langID, error) {
+	if !tag.FixCase("zz", s) {
+		return 0, errSyntax
+	}
+	if i := lang.Index(s); i != -1 && lang.Elem(i)[3] != 0 {
+		return langID(i), nil
+	}
+	return 0, mkErrInvalid(s)
+}
+
+const base = 'z' - 'a' + 1
+
+func strToInt(s []byte) uint {
+	v := uint(0)
+	for i := 0; i < len(s); i++ {
+		v *= base
+		v += uint(s[i] - 'a')
+	}
+	return v
+}
+
+// converts the given integer to the original ASCII string passed to strToInt.
+// len(s) must match the number of characters obtained.
+func intToStr(v uint, s []byte) {
+	for i := len(s) - 1; i >= 0; i-- {
+		s[i] = byte(v%base) + 'a'
+		v /= base
+	}
+}
+
+// getLangISO3 returns the langID for the given 3-letter ISO language code
+// or unknownLang if this does not exist.
+func getLangISO3(s []byte) (langID, error) {
+	if tag.FixCase("und", s) {
+		// first try to match canonical 3-letter entries
+		for i := lang.Index(s[:2]); i != -1; i = lang.Next(s[:2], i) {
+			if e := lang.Elem(i); e[3] == 0 && e[2] == s[2] {
+				// We treat "und" as special and always translate it to "unspecified".
+				// Note that ZZ and Zzzz are private use and are not treated as
+				// unspecified by default.
+				id := langID(i)
+				if id == nonCanonicalUnd {
+					return 0, nil
+				}
+				return id, nil
+			}
+		}
+		if i := altLangISO3.Index(s); i != -1 {
+			return langID(altLangIndex[altLangISO3.Elem(i)[3]]), nil
+		}
+		n := strToInt(s)
+		if langNoIndex[n/8]&(1<<(n%8)) != 0 {
+			return langID(n) + langNoIndexOffset, nil
+		}
+		// Check for non-canonical uses of ISO3.
+		for i := lang.Index(s[:1]); i != -1; i = lang.Next(s[:1], i) {
+			if e := lang.Elem(i); e[2] == s[1] && e[3] == s[2] {
+				return langID(i), nil
+			}
+		}
+		return 0, mkErrInvalid(s)
+	}
+	return 0, errSyntax
+}
+
+// stringToBuf writes the string to b and returns the number of bytes
+// written.  cap(b) must be >= 3.
+func (id langID) stringToBuf(b []byte) int {
+	if id >= langNoIndexOffset {
+		intToStr(uint(id)-langNoIndexOffset, b[:3])
+		return 3
+	} else if id == 0 {
+		return copy(b, "und")
+	}
+	l := lang[id<<2:]
+	if l[3] == 0 {
+		return copy(b, l[:3])
+	}
+	return copy(b, l[:2])
+}
+
+// String returns the BCP 47 representation of the langID.
+// Use b as variable name, instead of id, to ensure the variable
+// used is consistent with that of Base in which this type is embedded.
+func (b langID) String() string {
+	if b == 0 {
+		return "und"
+	} else if b >= langNoIndexOffset {
+		b -= langNoIndexOffset
+		buf := [3]byte{}
+		intToStr(uint(b), buf[:])
+		return string(buf[:])
+	}
+	l := lang.Elem(int(b))
+	if l[3] == 0 {
+		return l[:3]
+	}
+	return l[:2]
+}
+
+// ISO3 returns the ISO 639-3 language code.
+func (b langID) ISO3() string {
+	if b == 0 || b >= langNoIndexOffset {
+		return b.String()
+	}
+	l := lang.Elem(int(b))
+	if l[3] == 0 {
+		return l[:3]
+	} else if l[2] == 0 {
+		return altLangISO3.Elem(int(l[3]))[:3]
+	}
+	// This allocation will only happen for 3-letter ISO codes
+	// that are non-canonical BCP 47 language identifiers.
+	return l[0:1] + l[2:4]
+}
+
+// IsPrivateUse reports whether this language code is reserved for private use.
+func (b langID) IsPrivateUse() bool {
+	return langPrivateStart <= b && b <= langPrivateEnd
+}
+
+type regionID uint16
+
+// getRegionID returns the region id for s if s is a valid 2-letter region code
+// or unknownRegion.
+func getRegionID(s []byte) (regionID, error) {
+	if len(s) == 3 {
+		if isAlpha(s[0]) {
+			return getRegionISO3(s)
+		}
+		if i, err := strconv.ParseUint(string(s), 10, 10); err == nil {
+			return getRegionM49(int(i))
+		}
+	}
+	return getRegionISO2(s)
+}
+
+// getRegionISO2 returns the regionID for the given 2-letter ISO country code
+// or unknownRegion if this does not exist.
+func getRegionISO2(s []byte) (regionID, error) {
+	i, err := findIndex(regionISO, s, "ZZ")
+	if err != nil {
+		return 0, err
+	}
+	return regionID(i) + isoRegionOffset, nil
+}
+
+// getRegionISO3 returns the regionID for the given 3-letter ISO country code
+// or unknownRegion if this does not exist.
+func getRegionISO3(s []byte) (regionID, error) {
+	if tag.FixCase("ZZZ", s) {
+		for i := regionISO.Index(s[:1]); i != -1; i = regionISO.Next(s[:1], i) {
+			if e := regionISO.Elem(i); e[2] == s[1] && e[3] == s[2] {
+				return regionID(i) + isoRegionOffset, nil
+			}
+		}
+		for i := 0; i < len(altRegionISO3); i += 3 {
+			if tag.Compare(altRegionISO3[i:i+3], s) == 0 {
+				return regionID(altRegionIDs[i/3]), nil
+			}
+		}
+		return 0, mkErrInvalid(s)
+	}
+	return 0, errSyntax
+}
+
+func getRegionM49(n int) (regionID, error) {
+	if 0 < n && n <= 999 {
+		const (
+			searchBits = 7
+			regionBits = 9
+			regionMask = 1<<regionBits - 1
+		)
+		idx := n >> searchBits
+		buf := fromM49[m49Index[idx]:m49Index[idx+1]]
+		val := uint16(n) << regionBits // we rely on bits shifting out
+		i := sort.Search(len(buf), func(i int) bool {
+			return buf[i] >= val
+		})
+		if r := fromM49[int(m49Index[idx])+i]; r&^regionMask == val {
+			return regionID(r & regionMask), nil
+		}
+	}
+	var e ValueError
+	fmt.Fprint(bytes.NewBuffer([]byte(e.v[:])), n)
+	return 0, e
+}
+
+// normRegion returns a region if r is deprecated or 0 otherwise.
+// TODO: consider supporting BYS (-> BLR), CSK (-> 200 or CZ), PHI (-> PHL) and AFI (-> DJ).
+// TODO: consider mapping split up regions to new most populous one (like CLDR).
+func normRegion(r regionID) regionID {
+	m := regionOldMap
+	k := sort.Search(len(m), func(i int) bool {
+		return m[i].from >= uint16(r)
+	})
+	if k < len(m) && m[k].from == uint16(r) {
+		return regionID(m[k].to)
+	}
+	return 0
+}
+
+const (
+	iso3166UserAssigned = 1 << iota
+	ccTLD
+	bcp47Region
+)
+
+func (r regionID) typ() byte {
+	return regionTypes[r]
+}
+
+// String returns the BCP 47 representation for the region.
+// It returns "ZZ" for an unspecified region.
+func (r regionID) String() string {
+	if r < isoRegionOffset {
+		if r == 0 {
+			return "ZZ"
+		}
+		return fmt.Sprintf("%03d", r.M49())
+	}
+	r -= isoRegionOffset
+	return regionISO.Elem(int(r))[:2]
+}
+
+// ISO3 returns the 3-letter ISO code of r.
+// Note that not all regions have a 3-letter ISO code.
+// In such cases this method returns "ZZZ".
+func (r regionID) ISO3() string {
+	if r < isoRegionOffset {
+		return "ZZZ"
+	}
+	r -= isoRegionOffset
+	reg := regionISO.Elem(int(r))
+	switch reg[2] {
+	case 0:
+		return altRegionISO3[reg[3]:][:3]
+	case ' ':
+		return "ZZZ"
+	}
+	return reg[0:1] + reg[2:4]
+}
+
+// M49 returns the UN M.49 encoding of r, or 0 if this encoding
+// is not defined for r.
+func (r regionID) M49() int {
+	return int(m49[r])
+}
+
+// IsPrivateUse reports whether r has the ISO 3166 User-assigned status. This
+// may include private-use tags that are assigned by CLDR and used in this
+// implementation. So IsPrivateUse and IsCountry can be simultaneously true.
+func (r regionID) IsPrivateUse() bool {
+	return r.typ()&iso3166UserAssigned != 0
+}
+
+type scriptID uint8
+
+// getScriptID returns the script id for string s. It assumes that s
+// is of the format [A-Z][a-z]{3}.
+func getScriptID(idx tag.Index, s []byte) (scriptID, error) {
+	i, err := findIndex(idx, s, "Zzzz")
+	return scriptID(i), err
+}
+
+// String returns the script code in title case.
+// It returns "Zzzz" for an unspecified script.
+func (s scriptID) String() string {
+	if s == 0 {
+		return "Zzzz"
+	}
+	return script.Elem(int(s))
+}
+
+// IsPrivateUse reports whether this script code is reserved for private use.
+func (s scriptID) IsPrivateUse() bool {
+	return _Qaaa <= s && s <= _Qabx
+}
+
+const (
+	maxAltTaglen = len("en-US-POSIX")
+	maxLen       = maxAltTaglen
+)
+
+var (
+	// grandfatheredMap holds a mapping from legacy and grandfathered tags to
+	// their base language or index to more elaborate tag.
+	grandfatheredMap = map[[maxLen]byte]int16{
+		[maxLen]byte{'a', 'r', 't', '-', 'l', 'o', 'j', 'b', 'a', 'n'}: _jbo, // art-lojban
+		[maxLen]byte{'i', '-', 'a', 'm', 'i'}:                          _ami, // i-ami
+		[maxLen]byte{'i', '-', 'b', 'n', 'n'}:                          _bnn, // i-bnn
+		[maxLen]byte{'i', '-', 'h', 'a', 'k'}:                          _hak, // i-hak
+		[maxLen]byte{'i', '-', 'k', 'l', 'i', 'n', 'g', 'o', 'n'}:      _tlh, // i-klingon
+		[maxLen]byte{'i', '-', 'l', 'u', 'x'}:                          _lb,  // i-lux
+		[maxLen]byte{'i', '-', 'n', 'a', 'v', 'a', 'j', 'o'}:           _nv,  // i-navajo
+		[maxLen]byte{'i', '-', 'p', 'w', 'n'}:                          _pwn, // i-pwn
+		[maxLen]byte{'i', '-', 't', 'a', 'o'}:                          _tao, // i-tao
+		[maxLen]byte{'i', '-', 't', 'a', 'y'}:                          _tay, // i-tay
+		[maxLen]byte{'i', '-', 't', 's', 'u'}:                          _tsu, // i-tsu
+		[maxLen]byte{'n', 'o', '-', 'b', 'o', 'k'}:                     _nb,  // no-bok
+		[maxLen]byte{'n', 'o', '-', 'n', 'y', 'n'}:                     _nn,  // no-nyn
+		[maxLen]byte{'s', 'g', 'n', '-', 'b', 'e', '-', 'f', 'r'}:      _sfb, // sgn-BE-FR
+		[maxLen]byte{'s', 'g', 'n', '-', 'b', 'e', '-', 'n', 'l'}:      _vgt, // sgn-BE-NL
+		[maxLen]byte{'s', 'g', 'n', '-', 'c', 'h', '-', 'd', 'e'}:      _sgg, // sgn-CH-DE
+		[maxLen]byte{'z', 'h', '-', 'g', 'u', 'o', 'y', 'u'}:           _cmn, // zh-guoyu
+		[maxLen]byte{'z', 'h', '-', 'h', 'a', 'k', 'k', 'a'}:           _hak, // zh-hakka
+		[maxLen]byte{'z', 'h', '-', 'm', 'i', 'n', '-', 'n', 'a', 'n'}: _nan, // zh-min-nan
+		[maxLen]byte{'z', 'h', '-', 'x', 'i', 'a', 'n', 'g'}:           _hsn, // zh-xiang
+
+		// Grandfathered tags with no modern replacement will be converted as
+		// follows:
+		[maxLen]byte{'c', 'e', 'l', '-', 'g', 'a', 'u', 'l', 'i', 's', 'h'}: -1, // cel-gaulish
+		[maxLen]byte{'e', 'n', '-', 'g', 'b', '-', 'o', 'e', 'd'}:           -2, // en-GB-oed
+		[maxLen]byte{'i', '-', 'd', 'e', 'f', 'a', 'u', 'l', 't'}:           -3, // i-default
+		[maxLen]byte{'i', '-', 'e', 'n', 'o', 'c', 'h', 'i', 'a', 'n'}:      -4, // i-enochian
+		[maxLen]byte{'i', '-', 'm', 'i', 'n', 'g', 'o'}:                     -5, // i-mingo
+		[maxLen]byte{'z', 'h', '-', 'm', 'i', 'n'}:                          -6, // zh-min
+
+		// CLDR-specific tag.
+		[maxLen]byte{'r', 'o', 'o', 't'}:                                    0,  // root
+		[maxLen]byte{'e', 'n', '-', 'u', 's', '-', 'p', 'o', 's', 'i', 'x'}: -7, // en_US_POSIX"
+	}
+
+	altTagIndex = [...]uint8{0, 17, 31, 45, 61, 74, 86, 102}
+
+	altTags = "xtg-x-cel-gaulishen-GB-oxendicten-x-i-defaultund-x-i-enochiansee-x-i-mingonan-x-zh-minen-US-u-va-posix"
+)
+
+func grandfathered(s [maxAltTaglen]byte) (t Tag, ok bool) {
+	if v, ok := grandfatheredMap[s]; ok {
+		if v < 0 {
+			return Make(altTags[altTagIndex[-v-1]:altTagIndex[-v]]), true
+		}
+		t.lang = langID(v)
+		return t, true
+	}
+	return t, false
+}

vendor/golang.org/x/text/language/lookup_test.go

@@ -0,0 +1,457 @@
+// Copyright 2013 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.
+
+package language
+
+import (
+	"testing"
+
+	"golang.org/x/text/internal/tag"
+)
+
+func b(s string) []byte {
+	return []byte(s)
+}
+
+func TestLangID(t *testing.T) {
+	tests := []struct {
+		id, bcp47, iso3, norm string
+		err                   error
+	}{
+		{id: "", bcp47: "und", iso3: "und", err: errSyntax},
+		{id: "  ", bcp47: "und", iso3: "und", err: errSyntax},
+		{id: "   ", bcp47: "und", iso3: "und", err: errSyntax},
+		{id: "    ", bcp47: "und", iso3: "und", err: errSyntax},
+		{id: "xxx", bcp47: "und", iso3: "und", err: mkErrInvalid([]byte("xxx"))},
+		{id: "und", bcp47: "und", iso3: "und"},
+		{id: "aju", bcp47: "aju", iso3: "aju", norm: "jrb"},
+		{id: "jrb", bcp47: "jrb", iso3: "jrb"},
+		{id: "es", bcp47: "es", iso3: "spa"},
+		{id: "spa", bcp47: "es", iso3: "spa"},
+		{id: "ji", bcp47: "ji", iso3: "yid-", norm: "yi"},
+		{id: "jw", bcp47: "jw", iso3: "jav-", norm: "jv"},
+		{id: "ar", bcp47: "ar", iso3: "ara"},
+		{id: "kw", bcp47: "kw", iso3: "cor"},
+		{id: "arb", bcp47: "arb", iso3: "arb", norm: "ar"},
+		{id: "ar", bcp47: "ar", iso3: "ara"},
+		{id: "kur", bcp47: "ku", iso3: "kur"},
+		{id: "nl", bcp47: "nl", iso3: "nld"},
+		{id: "NL", bcp47: "nl", iso3: "nld"},
+		{id: "gsw", bcp47: "gsw", iso3: "gsw"},
+		{id: "gSW", bcp47: "gsw", iso3: "gsw"},
+		{id: "und", bcp47: "und", iso3: "und"},
+		{id: "sh", bcp47: "sh", iso3: "hbs", norm: "sr"},
+		{id: "hbs", bcp47: "sh", iso3: "hbs", norm: "sr"},
+		{id: "no", bcp47: "no", iso3: "nor", norm: "no"},
+		{id: "nor", bcp47: "no", iso3: "nor", norm: "no"},
+		{id: "cmn", bcp47: "cmn", iso3: "cmn", norm: "zh"},
+	}
+	for i, tt := range tests {
+		want, err := getLangID(b(tt.id))
+		if err != tt.err {
+			t.Errorf("%d:err(%s): found %q; want %q", i, tt.id, err, tt.err)
+		}
+		if err != nil {
+			continue
+		}
+		if id, _ := getLangISO2(b(tt.bcp47)); len(tt.bcp47) == 2 && want != id {
+			t.Errorf("%d:getISO2(%s): found %v; want %v", i, tt.bcp47, id, want)
+		}
+		if len(tt.iso3) == 3 {
+			if id, _ := getLangISO3(b(tt.iso3)); want != id {
+				t.Errorf("%d:getISO3(%s): found %q; want %q", i, tt.iso3, id, want)
+			}
+			if id, _ := getLangID(b(tt.iso3)); want != id {
+				t.Errorf("%d:getID3(%s): found %v; want %v", i, tt.iso3, id, want)
+			}
+		}
+		norm := want
+		if tt.norm != "" {
+			norm, _ = getLangID(b(tt.norm))
+		}
+		id, _ := normLang(want)
+		if id != norm {
+			t.Errorf("%d:norm(%s): found %v; want %v", i, tt.id, id, norm)
+		}
+		if id := want.String(); tt.bcp47 != id {
+			t.Errorf("%d:String(): found %s; want %s", i, id, tt.bcp47)
+		}
+		if id := want.ISO3(); tt.iso3[:3] != id {
+			t.Errorf("%d:iso3(): found %s; want %s", i, id, tt.iso3[:3])
+		}
+	}
+}
+
+func TestGrandfathered(t *testing.T) {
+	for _, tt := range []struct{ in, out string }{
+		{"art-lojban", "jbo"},
+		{"i-ami", "ami"},
+		{"i-bnn", "bnn"},
+		{"i-hak", "hak"},
+		{"i-klingon", "tlh"},
+		{"i-lux", "lb"},
+		{"i-navajo", "nv"},
+		{"i-pwn", "pwn"},
+		{"i-tao", "tao"},
+		{"i-tay", "tay"},
+		{"i-tsu", "tsu"},
+		{"no-bok", "nb"},
+		{"no-nyn", "nn"},
+		{"sgn-BE-FR", "sfb"},
+		{"sgn-BE-NL", "vgt"},
+		{"sgn-CH-DE", "sgg"},
+		{"sgn-ch-de", "sgg"},
+		{"zh-guoyu", "cmn"},
+		{"zh-hakka", "hak"},
+		{"zh-min-nan", "nan"},
+		{"zh-xiang", "hsn"},
+
+		// Grandfathered tags with no modern replacement will be converted as follows:
+		{"cel-gaulish", "xtg-x-cel-gaulish"},
+		{"en-GB-oed", "en-GB-oxendict"},
+		{"en-gb-oed", "en-GB-oxendict"},
+		{"i-default", "en-x-i-default"},
+		{"i-enochian", "und-x-i-enochian"},
+		{"i-mingo", "see-x-i-mingo"},
+		{"zh-min", "nan-x-zh-min"},
+
+		{"root", "und"},
+		{"en_US_POSIX", "en-US-u-va-posix"},
+		{"en_us_posix", "en-US-u-va-posix"},
+		{"en-us-posix", "en-US-u-va-posix"},
+	} {
+		got := Raw.Make(tt.in)
+		want := Raw.MustParse(tt.out)
+		if got != want {
+			t.Errorf("%s: got %q; want %q", tt.in, got, want)
+		}
+	}
+}
+
+func TestRegionID(t *testing.T) {
+	tests := []struct {
+		in, out string
+	}{
+		{"_  ", ""},
+		{"_000", ""},
+		{"419", "419"},
+		{"AA", "AA"},
+		{"ATF", "TF"},
+		{"HV", "HV"},
+		{"CT", "CT"},
+		{"DY", "DY"},
+		{"IC", "IC"},
+		{"FQ", "FQ"},
+		{"JT", "JT"},
+		{"ZZ", "ZZ"},
+		{"EU", "EU"},
+		{"QO", "QO"},
+		{"FX", "FX"},
+	}
+	for i, tt := range tests {
+		if tt.in[0] == '_' {
+			id := tt.in[1:]
+			if _, err := getRegionID(b(id)); err == nil {
+				t.Errorf("%d:err(%s): found nil; want error", i, id)
+			}
+			continue
+		}
+		want, _ := getRegionID(b(tt.in))
+		if s := want.String(); s != tt.out {
+			t.Errorf("%d:%s: found %q; want %q", i, tt.in, s, tt.out)
+		}
+		if len(tt.in) == 2 {
+			want, _ := getRegionISO2(b(tt.in))
+			if s := want.String(); s != tt.out {
+				t.Errorf("%d:getISO2(%s): found %q; want %q", i, tt.in, s, tt.out)
+			}
+		}
+	}
+}
+
+func TestRegionType(t *testing.T) {
+	for _, tt := range []struct {
+		r string
+		t byte
+	}{
+		{"NL", bcp47Region | ccTLD},
+		{"EU", bcp47Region | ccTLD}, // exceptionally reserved
+		{"AN", bcp47Region | ccTLD}, // transitionally reserved
+
+		{"DD", bcp47Region}, // deleted in ISO, deprecated in BCP 47
+		{"NT", bcp47Region}, // transitionally reserved, deprecated in BCP 47
+
+		{"XA", iso3166UserAssigned | bcp47Region},
+		{"ZZ", iso3166UserAssigned | bcp47Region},
+		{"AA", iso3166UserAssigned | bcp47Region},
+		{"QO", iso3166UserAssigned | bcp47Region},
+		{"QM", iso3166UserAssigned | bcp47Region},
+		{"XK", iso3166UserAssigned | bcp47Region},
+
+		{"CT", 0}, // deleted in ISO, not in BCP 47, canonicalized in CLDR
+	} {
+		r := MustParseRegion(tt.r)
+		if tp := r.typ(); tp != tt.t {
+			t.Errorf("Type(%s): got %x; want %x", tt.r, tp, tt.t)
+		}
+	}
+}
+
+func TestRegionISO3(t *testing.T) {
+	tests := []struct {
+		from, iso3, to string
+	}{
+		{"  ", "ZZZ", "ZZ"},
+		{"000", "ZZZ", "ZZ"},
+		{"AA", "AAA", ""},
+		{"CT", "CTE", ""},
+		{"DY", "DHY", ""},
+		{"EU", "QUU", ""},
+		{"HV", "HVO", ""},
+		{"IC", "ZZZ", "ZZ"},
+		{"JT", "JTN", ""},
+		{"PZ", "PCZ", ""},
+		{"QU", "QUU", "EU"},
+		{"QO", "QOO", ""},
+		{"YD", "YMD", ""},
+		{"FQ", "ATF", "TF"},
+		{"TF", "ATF", ""},
+		{"FX", "FXX", ""},
+		{"ZZ", "ZZZ", ""},
+		{"419", "ZZZ", "ZZ"},
+	}
+	for _, tt := range tests {
+		r, _ := getRegionID(b(tt.from))
+		if s := r.ISO3(); s != tt.iso3 {
+			t.Errorf("iso3(%q): found %q; want %q", tt.from, s, tt.iso3)
+		}
+		if tt.iso3 == "" {
+			continue
+		}
+		want := tt.to
+		if tt.to == "" {
+			want = tt.from
+		}
+		r, _ = getRegionID(b(want))
+		if id, _ := getRegionISO3(b(tt.iso3)); id != r {
+			t.Errorf("%s: found %q; want %q", tt.iso3, id, want)
+		}
+	}
+}
+
+func TestRegionM49(t *testing.T) {
+	fromTests := []struct {
+		m49 int
+		id  string
+	}{
+		{0, ""},
+		{-1, ""},
+		{1000, ""},
+		{10000, ""},
+
+		{001, "001"},
+		{104, "MM"},
+		{180, "CD"},
+		{230, "ET"},
+		{231, "ET"},
+		{249, "FX"},
+		{250, "FR"},
+		{276, "DE"},
+		{278, "DD"},
+		{280, "DE"},
+		{419, "419"},
+		{626, "TL"},
+		{736, "SD"},
+		{840, "US"},
+		{854, "BF"},
+		{891, "CS"},
+		{899, ""},
+		{958, "AA"},
+		{966, "QT"},
+		{967, "EU"},
+		{999, "ZZ"},
+	}
+	for _, tt := range fromTests {
+		id, err := getRegionM49(tt.m49)
+		if want, have := err != nil, tt.id == ""; want != have {
+			t.Errorf("error(%d): have %v; want %v", tt.m49, have, want)
+			continue
+		}
+		r, _ := getRegionID(b(tt.id))
+		if r != id {
+			t.Errorf("region(%d): have %s; want %s", tt.m49, id, r)
+		}
+	}
+
+	toTests := []struct {
+		m49 int
+		id  string
+	}{
+		{0, "000"},
+		{0, "IC"}, // Some codes don't have an ID
+
+		{001, "001"},
+		{104, "MM"},
+		{104, "BU"},
+		{180, "CD"},
+		{180, "ZR"},
+		{231, "ET"},
+		{250, "FR"},
+		{249, "FX"},
+		{276, "DE"},
+		{278, "DD"},
+		{419, "419"},
+		{626, "TL"},
+		{626, "TP"},
+		{729, "SD"},
+		{826, "GB"},
+		{840, "US"},
+		{854, "BF"},
+		{891, "YU"},
+		{891, "CS"},
+		{958, "AA"},
+		{966, "QT"},
+		{967, "EU"},
+		{967, "QU"},
+		{999, "ZZ"},
+		// For codes that don't have an M49 code use the replacement value,
+		// if available.
+		{854, "HV"}, // maps to Burkino Faso
+	}
+	for _, tt := range toTests {
+		r, _ := getRegionID(b(tt.id))
+		if r.M49() != tt.m49 {
+			t.Errorf("m49(%q): have %d; want %d", tt.id, r.M49(), tt.m49)
+		}
+	}
+}
+
+func TestRegionDeprecation(t *testing.T) {
+	tests := []struct{ in, out string }{
+		{"BU", "MM"},
+		{"BUR", "MM"},
+		{"CT", "KI"},
+		{"DD", "DE"},
+		{"DDR", "DE"},
+		{"DY", "BJ"},
+		{"FX", "FR"},
+		{"HV", "BF"},
+		{"JT", "UM"},
+		{"MI", "UM"},
+		{"NH", "VU"},
+		{"NQ", "AQ"},
+		{"PU", "UM"},
+		{"PZ", "PA"},
+		{"QU", "EU"},
+		{"RH", "ZW"},
+		{"TP", "TL"},
+		{"UK", "GB"},
+		{"VD", "VN"},
+		{"WK", "UM"},
+		{"YD", "YE"},
+		{"NL", "NL"},
+	}
+	for _, tt := range tests {
+		rIn, _ := getRegionID([]byte(tt.in))
+		rOut, _ := getRegionISO2([]byte(tt.out))
+		r := normRegion(rIn)
+		if rOut == rIn && r != 0 {
+			t.Errorf("%s: was %q; want %q", tt.in, r, tt.in)
+		}
+		if rOut != rIn && r != rOut {
+			t.Errorf("%s: was %q; want %q", tt.in, r, tt.out)
+		}
+
+	}
+}
+
+func TestGetScriptID(t *testing.T) {
+	idx := tag.Index("0000BbbbDdddEeeeZzzz\xff\xff\xff\xff")
+	tests := []struct {
+		in  string
+		out scriptID
+	}{
+		{"    ", 0},
+		{"      ", 0},
+		{"  ", 0},
+		{"", 0},
+		{"Aaaa", 0},
+		{"Bbbb", 1},
+		{"Dddd", 2},
+		{"dddd", 2},
+		{"dDDD", 2},
+		{"Eeee", 3},
+		{"Zzzz", 4},
+	}
+	for i, tt := range tests {
+		if id, err := getScriptID(idx, b(tt.in)); id != tt.out {
+			t.Errorf("%d:%s: found %d; want %d", i, tt.in, id, tt.out)
+		} else if id == 0 && err == nil {
+			t.Errorf("%d:%s: no error; expected one", i, tt.in)
+		}
+	}
+}
+
+func TestIsPrivateUse(t *testing.T) {
+	type test struct {
+		s       string
+		private bool
+	}
+	tests := []test{
+		{"en", false},
+		{"und", false},
+		{"pzn", false},
+		{"qaa", true},
+		{"qtz", true},
+		{"qua", false},
+	}
+	for i, tt := range tests {
+		x, _ := getLangID([]byte(tt.s))
+		if b := x.IsPrivateUse(); b != tt.private {
+			t.Errorf("%d: langID.IsPrivateUse(%s) was %v; want %v", i, tt.s, b, tt.private)
+		}
+	}
+	tests = []test{
+		{"001", false},
+		{"419", false},
+		{"899", false},
+		{"900", false},
+		{"957", false},
+		{"958", true},
+		{"AA", true},
+		{"AC", false},
+		{"EU", false}, // CLDR grouping, exceptionally reserved in ISO.
+		{"QU", true},  // Canonicalizes to EU, User-assigned in ISO.
+		{"QO", true},  // CLDR grouping, User-assigned in ISO.
+		{"QA", false},
+		{"QM", true},
+		{"QZ", true},
+		{"XA", true},
+		{"XK", true}, // Assigned to Kosovo in CLDR, User-assigned in ISO.
+		{"XZ", true},
+		{"ZW", false},
+		{"ZZ", true},
+	}
+	for i, tt := range tests {
+		x, _ := getRegionID([]byte(tt.s))
+		if b := x.IsPrivateUse(); b != tt.private {
+			t.Errorf("%d: regionID.IsPrivateUse(%s) was %v; want %v", i, tt.s, b, tt.private)
+		}
+	}
+	tests = []test{
+		{"Latn", false},
+		{"Laaa", false}, // invalid
+		{"Qaaa", true},
+		{"Qabx", true},
+		{"Qaby", false},
+		{"Zyyy", false},
+		{"Zzzz", false},
+	}
+	for i, tt := range tests {
+		x, _ := getScriptID(script, []byte(tt.s))
+		if b := x.IsPrivateUse(); b != tt.private {
+			t.Errorf("%d: scriptID.IsPrivateUse(%s) was %v; want %v", i, tt.s, b, tt.private)
+		}
+	}
+}

vendor/golang.org/x/text/language/match.go

@@ -0,0 +1,841 @@
+// Copyright 2013 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.
+
+package language
+
+import "errors"
+
+// Matcher is the interface that wraps the Match method.
+//
+// Match returns the best match for any of the given tags, along with
+// a unique index associated with the returned tag and a confidence
+// score.
+type Matcher interface {
+	Match(t ...Tag) (tag Tag, index int, c Confidence)
+}
+
+// Comprehends reports the confidence score for a speaker of a given language
+// to being able to comprehend the written form of an alternative language.
+func Comprehends(speaker, alternative Tag) Confidence {
+	_, _, c := NewMatcher([]Tag{alternative}).Match(speaker)
+	return c
+}
+
+// NewMatcher returns a Matcher that matches an ordered list of preferred tags
+// against a list of supported tags based on written intelligibility, closeness
+// of dialect, equivalence of subtags and various other rules. It is initialized
+// with the list of supported tags. The first element is used as the default
+// value in case no match is found.
+//
+// Its Match method matches the first of the given Tags to reach a certain
+// confidence threshold. The tags passed to Match should therefore be specified
+// in order of preference. Extensions are ignored for matching.
+//
+// The index returned by the Match method corresponds to the index of the
+// matched tag in t, but is augmented with the Unicode extension ('u')of the
+// corresponding preferred tag. This allows user locale options to be passed
+// transparently.
+func NewMatcher(t []Tag) Matcher {
+	return newMatcher(t)
+}
+
+func (m *matcher) Match(want ...Tag) (t Tag, index int, c Confidence) {
+	match, w, c := m.getBest(want...)
+	if match == nil {
+		t = m.default_.tag
+	} else {
+		t, index = match.tag, match.index
+	}
+	// Copy options from the user-provided tag into the result tag. This is hard
+	// to do after the fact, so we do it here.
+	// TODO: consider also adding in variants that are compatible with the
+	// matched language.
+	// TODO: Add back region if it is non-ambiguous? Or create another tag to
+	// preserve the region?
+	if u, ok := w.Extension('u'); ok {
+		t, _ = Raw.Compose(t, u)
+	}
+	return t, index, c
+}
+
+type scriptRegionFlags uint8
+
+const (
+	isList = 1 << iota
+	scriptInFrom
+	regionInFrom
+)
+
+func (t *Tag) setUndefinedLang(id langID) {
+	if t.lang == 0 {
+		t.lang = id
+	}
+}
+
+func (t *Tag) setUndefinedScript(id scriptID) {
+	if t.script == 0 {
+		t.script = id
+	}
+}
+
+func (t *Tag) setUndefinedRegion(id regionID) {
+	if t.region == 0 || t.region.contains(id) {
+		t.region = id
+	}
+}
+
+// ErrMissingLikelyTagsData indicates no information was available
+// to compute likely values of missing tags.
+var ErrMissingLikelyTagsData = errors.New("missing likely tags data")
+
+// addLikelySubtags sets subtags to their most likely value, given the locale.
+// In most cases this means setting fields for unknown values, but in some
+// cases it may alter a value.  It returns a ErrMissingLikelyTagsData error
+// if the given locale cannot be expanded.
+func (t Tag) addLikelySubtags() (Tag, error) {
+	id, err := addTags(t)
+	if err != nil {
+		return t, err
+	} else if id.equalTags(t) {
+		return t, nil
+	}
+	id.remakeString()
+	return id, nil
+}
+
+// specializeRegion attempts to specialize a group region.
+func specializeRegion(t *Tag) bool {
+	if i := regionInclusion[t.region]; i < nRegionGroups {
+		x := likelyRegionGroup[i]
+		if langID(x.lang) == t.lang && scriptID(x.script) == t.script {
+			t.region = regionID(x.region)
+		}
+		return true
+	}
+	return false
+}
+
+func addTags(t Tag) (Tag, error) {
+	// We leave private use identifiers alone.
+	if t.private() {
+		return t, nil
+	}
+	if t.script != 0 && t.region != 0 {
+		if t.lang != 0 {
+			// already fully specified
+			specializeRegion(&t)
+			return t, nil
+		}
+		// Search matches for und-script-region. Note that for these cases
+		// region will never be a group so there is no need to check for this.
+		list := likelyRegion[t.region : t.region+1]
+		if x := list[0]; x.flags&isList != 0 {
+			list = likelyRegionList[x.lang : x.lang+uint16(x.script)]
+		}
+		for _, x := range list {
+			// Deviating from the spec. See match_test.go for details.
+			if scriptID(x.script) == t.script {
+				t.setUndefinedLang(langID(x.lang))
+				return t, nil
+			}
+		}
+	}
+	if t.lang != 0 {
+		// Search matches for lang-script and lang-region, where lang != und.
+		if t.lang < langNoIndexOffset {
+			x := likelyLang[t.lang]
+			if x.flags&isList != 0 {
+				list := likelyLangList[x.region : x.region+uint16(x.script)]
+				if t.script != 0 {
+					for _, x := range list {
+						if scriptID(x.script) == t.script && x.flags&scriptInFrom != 0 {
+							t.setUndefinedRegion(regionID(x.region))
+							return t, nil
+						}
+					}
+				} else if t.region != 0 {
+					count := 0
+					goodScript := true
+					tt := t
+					for _, x := range list {
+						// We visit all entries for which the script was not
+						// defined, including the ones where the region was not
+						// defined. This allows for proper disambiguation within
+						// regions.
+						if x.flags&scriptInFrom == 0 && t.region.contains(regionID(x.region)) {
+							tt.region = regionID(x.region)
+							tt.setUndefinedScript(scriptID(x.script))
+							goodScript = goodScript && tt.script == scriptID(x.script)
+							count++
+						}
+					}
+					if count == 1 {
+						return tt, nil
+					}
+					// Even if we fail to find a unique Region, we might have
+					// an unambiguous script.
+					if goodScript {
+						t.script = tt.script
+					}
+				}
+			}
+		}
+	} else {
+		// Search matches for und-script.
+		if t.script != 0 {
+			x := likelyScript[t.script]
+			if x.region != 0 {
+				t.setUndefinedRegion(regionID(x.region))
+				t.setUndefinedLang(langID(x.lang))
+				return t, nil
+			}
+		}
+		// Search matches for und-region. If und-script-region exists, it would
+		// have been found earlier.
+		if t.region != 0 {
+			if i := regionInclusion[t.region]; i < nRegionGroups {
+				x := likelyRegionGroup[i]
+				if x.region != 0 {
+					t.setUndefinedLang(langID(x.lang))
+					t.setUndefinedScript(scriptID(x.script))
+					t.region = regionID(x.region)
+				}
+			} else {
+				x := likelyRegion[t.region]
+				if x.flags&isList != 0 {
+					x = likelyRegionList[x.lang]
+				}
+				if x.script != 0 && x.flags != scriptInFrom {
+					t.setUndefinedLang(langID(x.lang))
+					t.setUndefinedScript(scriptID(x.script))
+					return t, nil
+				}
+			}
+		}
+	}
+
+	// Search matches for lang.
+	if t.lang < langNoIndexOffset {
+		x := likelyLang[t.lang]
+		if x.flags&isList != 0 {
+			x = likelyLangList[x.region]
+		}
+		if x.region != 0 {
+			t.setUndefinedScript(scriptID(x.script))
+			t.setUndefinedRegion(regionID(x.region))
+		}
+		specializeRegion(&t)
+		if t.lang == 0 {
+			t.lang = _en // default language
+		}
+		return t, nil
+	}
+	return t, ErrMissingLikelyTagsData
+}
+
+func (t *Tag) setTagsFrom(id Tag) {
+	t.lang = id.lang
+	t.script = id.script
+	t.region = id.region
+}
+
+// minimize removes the region or script subtags from t such that
+// t.addLikelySubtags() == t.minimize().addLikelySubtags().
+func (t Tag) minimize() (Tag, error) {
+	t, err := minimizeTags(t)
+	if err != nil {
+		return t, err
+	}
+	t.remakeString()
+	return t, nil
+}
+
+// minimizeTags mimics the behavior of the ICU 51 C implementation.
+func minimizeTags(t Tag) (Tag, error) {
+	if t.equalTags(und) {
+		return t, nil
+	}
+	max, err := addTags(t)
+	if err != nil {
+		return t, err
+	}
+	for _, id := range [...]Tag{
+		{lang: t.lang},
+		{lang: t.lang, region: t.region},
+		{lang: t.lang, script: t.script},
+	} {
+		if x, err := addTags(id); err == nil && max.equalTags(x) {
+			t.setTagsFrom(id)
+			break
+		}
+	}
+	return t, nil
+}
+
+// Tag Matching
+// CLDR defines an algorithm for finding the best match between two sets of language
+// tags. The basic algorithm defines how to score a possible match and then find
+// the match with the best score
+// (see http://www.unicode.org/reports/tr35/#LanguageMatching).
+// Using scoring has several disadvantages. The scoring obfuscates the importance of
+// the various factors considered, making the algorithm harder to understand. Using
+// scoring also requires the full score to be computed for each pair of tags.
+//
+// We will use a different algorithm which aims to have the following properties:
+// - clarity on the precedence of the various selection factors, and
+// - improved performance by allowing early termination of a comparison.
+//
+// Matching algorithm (overview)
+// Input:
+//   - supported: a set of supported tags
+//   - default:   the default tag to return in case there is no match
+//   - desired:   list of desired tags, ordered by preference, starting with
+//                the most-preferred.
+//
+// Algorithm:
+//   1) Set the best match to the lowest confidence level
+//   2) For each tag in "desired":
+//     a) For each tag in "supported":
+//        1) compute the match between the two tags.
+//        2) if the match is better than the previous best match, replace it
+//           with the new match. (see next section)
+//     b) if the current best match is above a certain threshold, return this
+//        match without proceeding to the next tag in "desired". [See Note 1]
+//   3) If the best match so far is below a certain threshold, return "default".
+//
+// Ranking:
+// We use two phases to determine whether one pair of tags are a better match
+// than another pair of tags. First, we determine a rough confidence level. If the
+// levels are different, the one with the highest confidence wins.
+// Second, if the rough confidence levels are identical, we use a set of tie-breaker
+// rules.
+//
+// The confidence level of matching a pair of tags is determined by finding the
+// lowest confidence level of any matches of the corresponding subtags (the
+// result is deemed as good as its weakest link).
+// We define the following levels:
+//   Exact    - An exact match of a subtag, before adding likely subtags.
+//   MaxExact - An exact match of a subtag, after adding likely subtags.
+//              [See Note 2].
+//   High     - High level of mutual intelligibility between different subtag
+//              variants.
+//   Low      - Low level of mutual intelligibility between different subtag
+//              variants.
+//   No       - No mutual intelligibility.
+//
+// The following levels can occur for each type of subtag:
+//   Base:    Exact, MaxExact, High, Low, No
+//   Script:  Exact, MaxExact [see Note 3], Low, No
+//   Region:  Exact, MaxExact, High
+//   Variant: Exact, High
+//   Private: Exact, No
+//
+// Any result with a confidence level of Low or higher is deemed a possible match.
+// Once a desired tag matches any of the supported tags with a level of MaxExact
+// or higher, the next desired tag is not considered (see Step 2.b).
+// Note that CLDR provides languageMatching data that defines close equivalence
+// classes for base languages, scripts and regions.
+//
+// Tie-breaking
+// If we get the same confidence level for two matches, we apply a sequence of
+// tie-breaking rules. The first that succeeds defines the result. The rules are
+// applied in the following order.
+//   1) Original language was defined and was identical.
+//   2) Original region was defined and was identical.
+//   3) Distance between two maximized regions was the smallest.
+//   4) Original script was defined and was identical.
+//   5) Distance from want tag to have tag using the parent relation [see Note 5.]
+// If there is still no winner after these rules are applied, the first match
+// found wins.
+//
+// Notes:
+// [1] Note that even if we may not have a perfect match, if a match is above a
+//     certain threshold, it is considered a better match than any other match
+//     to a tag later in the list of preferred language tags.
+// [2] In practice, as matching of Exact is done in a separate phase from
+//     matching the other levels, we reuse the Exact level to mean MaxExact in
+//     the second phase. As a consequence, we only need the levels defined by
+//     the Confidence type. The MaxExact confidence level is mapped to High in
+//     the public API.
+// [3] We do not differentiate between maximized script values that were derived
+//     from suppressScript versus most likely tag data. We determined that in
+//     ranking the two, one ranks just after the other. Moreover, the two cannot
+//     occur concurrently. As a consequence, they are identical for practical
+//     purposes.
+// [4] In case of deprecated, macro-equivalents and legacy mappings, we assign
+//     the MaxExact level to allow iw vs he to still be a closer match than
+//     en-AU vs en-US, for example.
+// [5] In CLDR a locale inherits fields that are unspecified for this locale
+//     from its parent. Therefore, if a locale is a parent of another locale,
+//     it is a strong measure for closeness, especially when no other tie
+//     breaker rule applies. One could also argue it is inconsistent, for
+//     example, when pt-AO matches pt (which CLDR equates with pt-BR), even
+//     though its parent is pt-PT according to the inheritance rules.
+//
+// Implementation Details:
+// There are several performance considerations worth pointing out. Most notably,
+// we preprocess as much as possible (within reason) at the time of creation of a
+// matcher. This includes:
+//   - creating a per-language map, which includes data for the raw base language
+//     and its canonicalized variant (if applicable),
+//   - expanding entries for the equivalence classes defined in CLDR's
+//     languageMatch data.
+// The per-language map ensures that typically only a very small number of tags
+// need to be considered. The pre-expansion of canonicalized subtags and
+// equivalence classes reduces the amount of map lookups that need to be done at
+// runtime.
+
+// matcher keeps a set of supported language tags, indexed by language.
+type matcher struct {
+	default_     *haveTag
+	index        map[langID]*matchHeader
+	passSettings bool
+}
+
+// matchHeader has the lists of tags for exact matches and matches based on
+// maximized and canonicalized tags for a given language.
+type matchHeader struct {
+	exact []*haveTag
+	max   []*haveTag
+}
+
+// haveTag holds a supported Tag and its maximized script and region. The maximized
+// or canonicalized language is not stored as it is not needed during matching.
+type haveTag struct {
+	tag Tag
+
+	// index of this tag in the original list of supported tags.
+	index int
+
+	// conf is the maximum confidence that can result from matching this haveTag.
+	// When conf < Exact this means it was inserted after applying a CLDR equivalence rule.
+	conf Confidence
+
+	// Maximized region and script.
+	maxRegion regionID
+	maxScript scriptID
+
+	// altScript may be checked as an alternative match to maxScript. If altScript
+	// matches, the confidence level for this match is Low. Theoretically there
+	// could be multiple alternative scripts. This does not occur in practice.
+	altScript scriptID
+
+	// nextMax is the index of the next haveTag with the same maximized tags.
+	nextMax uint16
+}
+
+func makeHaveTag(tag Tag, index int) (haveTag, langID) {
+	max := tag
+	if tag.lang != 0 {
+		max, _ = max.canonicalize(All)
+		max, _ = addTags(max)
+		max.remakeString()
+	}
+	return haveTag{tag, index, Exact, max.region, max.script, altScript(max.lang, max.script), 0}, max.lang
+}
+
+// altScript returns an alternative script that may match the given script with
+// a low confidence.  At the moment, the langMatch data allows for at most one
+// script to map to another and we rely on this to keep the code simple.
+func altScript(l langID, s scriptID) scriptID {
+	for _, alt := range matchScript {
+		if (alt.lang == 0 || langID(alt.lang) == l) && scriptID(alt.have) == s {
+			return scriptID(alt.want)
+		}
+	}
+	return 0
+}
+
+// addIfNew adds a haveTag to the list of tags only if it is a unique tag.
+// Tags that have the same maximized values are linked by index.
+func (h *matchHeader) addIfNew(n haveTag, exact bool) {
+	// Don't add new exact matches.
+	for _, v := range h.exact {
+		if v.tag.equalsRest(n.tag) {
+			return
+		}
+	}
+	if exact {
+		h.exact = append(h.exact, &n)
+	}
+	// Allow duplicate maximized tags, but create a linked list to allow quickly
+	// comparing the equivalents and bail out.
+	for i, v := range h.max {
+		if v.maxScript == n.maxScript &&
+			v.maxRegion == n.maxRegion &&
+			v.tag.variantOrPrivateTagStr() == n.tag.variantOrPrivateTagStr() {
+			for h.max[i].nextMax != 0 {
+				i = int(h.max[i].nextMax)
+			}
+			h.max[i].nextMax = uint16(len(h.max))
+			break
+		}
+	}
+	h.max = append(h.max, &n)
+}
+
+// header returns the matchHeader for the given language. It creates one if
+// it doesn't already exist.
+func (m *matcher) header(l langID) *matchHeader {
+	if h := m.index[l]; h != nil {
+		return h
+	}
+	h := &matchHeader{}
+	m.index[l] = h
+	return h
+}
+
+// newMatcher builds an index for the given supported tags and returns it as
+// a matcher. It also expands the index by considering various equivalence classes
+// for a given tag.
+func newMatcher(supported []Tag) *matcher {
+	m := &matcher{
+		index: make(map[langID]*matchHeader),
+	}
+	if len(supported) == 0 {
+		m.default_ = &haveTag{}
+		return m
+	}
+	// Add supported languages to the index. Add exact matches first to give
+	// them precedence.
+	for i, tag := range supported {
+		pair, _ := makeHaveTag(tag, i)
+		m.header(tag.lang).addIfNew(pair, true)
+	}
+	m.default_ = m.header(supported[0].lang).exact[0]
+	for i, tag := range supported {
+		pair, max := makeHaveTag(tag, i)
+		if max != tag.lang {
+			m.header(max).addIfNew(pair, false)
+		}
+	}
+
+	// update is used to add indexes in the map for equivalent languages.
+	// If force is true, the update will also apply to derived entries. To
+	// avoid applying a "transitive closure", use false.
+	update := func(want, have uint16, conf Confidence, force bool) {
+		if hh := m.index[langID(have)]; hh != nil {
+			if !force && len(hh.exact) == 0 {
+				return
+			}
+			hw := m.header(langID(want))
+			for _, ht := range hh.max {
+				v := *ht
+				if conf < v.conf {
+					v.conf = conf
+				}
+				v.nextMax = 0 // this value needs to be recomputed
+				if v.altScript != 0 {
+					v.altScript = altScript(langID(want), v.maxScript)
+				}
+				hw.addIfNew(v, conf == Exact && len(hh.exact) > 0)
+			}
+		}
+	}
+
+	// Add entries for languages with mutual intelligibility as defined by CLDR's
+	// languageMatch data.
+	for _, ml := range matchLang {
+		update(ml.want, ml.have, Confidence(ml.conf), false)
+		if !ml.oneway {
+			update(ml.have, ml.want, Confidence(ml.conf), false)
+		}
+	}
+
+	// Add entries for possible canonicalizations. This is an optimization to
+	// ensure that only one map lookup needs to be done at runtime per desired tag.
+	// First we match deprecated equivalents. If they are perfect equivalents
+	// (their canonicalization simply substitutes a different language code, but
+	// nothing else), the match confidence is Exact, otherwise it is High.
+	for i, lm := range langAliasMap {
+		if lm.from == _sh {
+			continue
+		}
+
+		// If deprecated codes match and there is no fiddling with the script or
+		// or region, we consider it an exact match.
+		conf := Exact
+		if langAliasTypes[i] != langMacro {
+			if !isExactEquivalent(langID(lm.from)) {
+				conf = High
+			}
+			update(lm.to, lm.from, conf, true)
+		}
+		update(lm.from, lm.to, conf, true)
+	}
+	return m
+}
+
+// getBest gets the best matching tag in m for any of the given tags, taking into
+// account the order of preference of the given tags.
+func (m *matcher) getBest(want ...Tag) (got *haveTag, orig Tag, c Confidence) {
+	best := bestMatch{}
+	for _, w := range want {
+		var max Tag
+		// Check for exact match first.
+		h := m.index[w.lang]
+		if w.lang != 0 {
+			// Base language is defined.
+			if h == nil {
+				continue
+			}
+			for i := range h.exact {
+				have := h.exact[i]
+				if have.tag.equalsRest(w) {
+					return have, w, Exact
+				}
+			}
+			max, _ = w.canonicalize(Legacy | Deprecated)
+			max, _ = addTags(max)
+		} else {
+			// Base language is not defined.
+			if h != nil {
+				for i := range h.exact {
+					have := h.exact[i]
+					if have.tag.equalsRest(w) {
+						return have, w, Exact
+					}
+				}
+			}
+			if w.script == 0 && w.region == 0 {
+				// We skip all tags matching und for approximate matching, including
+				// private tags.
+				continue
+			}
+			max, _ = addTags(w)
+			if h = m.index[max.lang]; h == nil {
+				continue
+			}
+		}
+		// Check for match based on maximized tag.
+		for i := range h.max {
+			have := h.max[i]
+			best.update(have, w, max.script, max.region)
+			if best.conf == Exact {
+				for have.nextMax != 0 {
+					have = h.max[have.nextMax]
+					best.update(have, w, max.script, max.region)
+				}
+				return best.have, best.want, High
+			}
+		}
+	}
+	if best.conf <= No {
+		if len(want) != 0 {
+			return nil, want[0], No
+		}
+		return nil, Tag{}, No
+	}
+	return best.have, best.want, best.conf
+}
+
+// bestMatch accumulates the best match so far.
+type bestMatch struct {
+	have *haveTag
+	want Tag
+	conf Confidence
+	// Cached results from applying tie-breaking rules.
+	origLang   bool
+	origReg    bool
+	regDist    uint8
+	origScript bool
+	parentDist uint8 // 255 if have is not an ancestor of want tag.
+}
+
+// update updates the existing best match if the new pair is considered to be a
+// better match.
+// To determine if the given pair is a better match, it first computes the rough
+// confidence level. If this surpasses the current match, it will replace it and
+// update the tie-breaker rule cache. If there is a tie, it proceeds with applying
+// a series of tie-breaker rules. If there is no conclusive winner after applying
+// the tie-breaker rules, it leaves the current match as the preferred match.
+func (m *bestMatch) update(have *haveTag, tag Tag, maxScript scriptID, maxRegion regionID) {
+	// Bail if the maximum attainable confidence is below that of the current best match.
+	c := have.conf
+	if c < m.conf {
+		return
+	}
+	if have.maxScript != maxScript {
+		// There is usually very little comprehension between different scripts.
+		// In a few cases there may still be Low comprehension. This possibility is
+		// pre-computed and stored in have.altScript.
+		if Low < m.conf || have.altScript != maxScript {
+			return
+		}
+		c = Low
+	} else if have.maxRegion != maxRegion {
+		// There is usually a small difference between languages across regions.
+		// We use the region distance (below) to disambiguate between equal matches.
+		if High < c {
+			c = High
+		}
+	}
+
+	// We store the results of the computations of the tie-breaker rules along
+	// with the best match. There is no need to do the checks once we determine
+	// we have a winner, but we do still need to do the tie-breaker computations.
+	// We use "beaten" to keep track if we still need to do the checks.
+	beaten := false // true if the new pair defeats the current one.
+	if c != m.conf {
+		if c < m.conf {
+			return
+		}
+		beaten = true
+	}
+
+	// Tie-breaker rules:
+	// We prefer if the pre-maximized language was specified and identical.
+	origLang := have.tag.lang == tag.lang && tag.lang != 0
+	if !beaten && m.origLang != origLang {
+		if m.origLang {
+			return
+		}
+		beaten = true
+	}
+
+	// We prefer if the pre-maximized region was specified and identical.
+	origReg := have.tag.region == tag.region && tag.region != 0
+	if !beaten && m.origReg != origReg {
+		if m.origReg {
+			return
+		}
+		beaten = true
+	}
+
+	// Next we prefer smaller distances between regions, as defined by regionDist.
+	regDist := regionDist(have.maxRegion, maxRegion, tag.lang)
+	if !beaten && m.regDist != regDist {
+		if regDist > m.regDist {
+			return
+		}
+		beaten = true
+	}
+
+	// Next we prefer if the pre-maximized script was specified and identical.
+	origScript := have.tag.script == tag.script && tag.script != 0
+	if !beaten && m.origScript != origScript {
+		if m.origScript {
+			return
+		}
+		beaten = true
+	}
+
+	// Finally we prefer tags which have a closer parent relationship.
+	parentDist := parentDistance(have.tag.region, tag)
+	if !beaten && m.parentDist != parentDist {
+		if parentDist > m.parentDist {
+			return
+		}
+		beaten = true
+	}
+
+	// Update m to the newly found best match.
+	if beaten {
+		m.have = have
+		m.want = tag
+		m.conf = c
+		m.origLang = origLang
+		m.origReg = origReg
+		m.origScript = origScript
+		m.regDist = regDist
+		m.parentDist = parentDist
+	}
+}
+
+// parentDistance returns the number of times Parent must be called before the
+// regions match. It is assumed that it has already been checked that lang and
+// script are identical. If haveRegion does not occur in the ancestor chain of
+// tag, it returns 255.
+func parentDistance(haveRegion regionID, tag Tag) uint8 {
+	p := tag.Parent()
+	d := uint8(1)
+	for haveRegion != p.region {
+		if p.region == 0 {
+			return 255
+		}
+		p = p.Parent()
+		d++
+	}
+	return d
+}
+
+// regionDist wraps regionDistance with some exceptions to the algorithmic distance.
+func regionDist(a, b regionID, lang langID) uint8 {
+	if lang == _en {
+		// Two variants of non-US English are close to each other, regardless of distance.
+		if a != _US && b != _US {
+			return 2
+		}
+	}
+	return uint8(regionDistance(a, b))
+}
+
+// regionDistance computes the distance between two regions based on the
+// distance in the graph of region containments as defined in CLDR. It iterates
+// over increasingly inclusive sets of groups, represented as bit vectors, until
+// the source bit vector has bits in common with the destination vector.
+func regionDistance(a, b regionID) int {
+	if a == b {
+		return 0
+	}
+	p, q := regionInclusion[a], regionInclusion[b]
+	if p < nRegionGroups {
+		p, q = q, p
+	}
+	set := regionInclusionBits
+	if q < nRegionGroups && set[p]&(1<<q) != 0 {
+		return 1
+	}
+	d := 2
+	for goal := set[q]; set[p]&goal == 0; p = regionInclusionNext[p] {
+		d++
+	}
+	return d
+}
+
+func (t Tag) variants() string {
+	if t.pVariant == 0 {
+		return ""
+	}
+	return t.str[t.pVariant:t.pExt]
+}
+
+// variantOrPrivateTagStr returns variants or private use tags.
+func (t Tag) variantOrPrivateTagStr() string {
+	if t.pExt > 0 {
+		return t.str[t.pVariant:t.pExt]
+	}
+	return t.str[t.pVariant:]
+}
+
+// equalsRest compares everything except the language.
+func (a Tag) equalsRest(b Tag) bool {
+	// TODO: don't include extensions in this comparison. To do this efficiently,
+	// though, we should handle private tags separately.
+	return a.script == b.script && a.region == b.region && a.variantOrPrivateTagStr() == b.variantOrPrivateTagStr()
+}
+
+// isExactEquivalent returns true if canonicalizing the language will not alter
+// the script or region of a tag.
+func isExactEquivalent(l langID) bool {
+	for _, o := range notEquivalent {
+		if o == l {
+			return false
+		}
+	}
+	return true
+}
+
+var notEquivalent []langID
+
+func init() {
+	// Create a list of all languages for which canonicalization may alter the
+	// script or region.
+	for _, lm := range langAliasMap {
+		tag := Tag{lang: langID(lm.from)}
+		if tag, _ = tag.canonicalize(All); tag.script != 0 || tag.region != 0 {
+			notEquivalent = append(notEquivalent, langID(lm.from))
+		}
+	}
+}

vendor/golang.org/x/text/language/match_test.go

@@ -0,0 +1,409 @@
+// Copyright 2013 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.
+
+package language
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"strings"
+	"testing"
+
+	"golang.org/x/text/internal/testtext"
+)
+
+var verbose = flag.Bool("verbose", false, "set to true to print the internal tables of matchers")
+
+func TestAddLikelySubtags(t *testing.T) {
+	tests := []struct{ in, out string }{
+		{"aa", "aa-Latn-ET"},
+		{"aa-Latn", "aa-Latn-ET"},
+		{"aa-Arab", "aa-Arab-ET"},
+		{"aa-Arab-ER", "aa-Arab-ER"},
+		{"kk", "kk-Cyrl-KZ"},
+		{"kk-CN", "kk-Arab-CN"},
+		{"cmn", "cmn"},
+		{"zh-AU", "zh-Hant-AU"},
+		{"zh-VN", "zh-Hant-VN"},
+		{"zh-SG", "zh-Hans-SG"},
+		{"zh-Hant", "zh-Hant-TW"},
+		{"zh-Hani", "zh-Hani-CN"},
+		{"und-Hani", "zh-Hani-CN"},
+		{"und", "en-Latn-US"},
+		{"und-GB", "en-Latn-GB"},
+		{"und-CW", "pap-Latn-CW"},
+		{"und-YT", "fr-Latn-YT"},
+		{"und-Arab", "ar-Arab-EG"},
+		{"und-AM", "hy-Armn-AM"},
+		{"und-002", "en-Latn-NG"},
+		{"und-Latn-002", "en-Latn-NG"},
+		{"en-Latn-002", "en-Latn-NG"},
+		{"en-002", "en-Latn-NG"},
+		{"en-001", "en-Latn-US"},
+		{"und-003", "en-Latn-US"},
+		{"und-GB", "en-Latn-GB"},
+		{"Latn-001", "en-Latn-US"},
+		{"en-001", "en-Latn-US"},
+		{"es-419", "es-Latn-419"},
+		{"he-145", "he-Hebr-IL"},
+		{"ky-145", "ky-Latn-TR"},
+		{"kk", "kk-Cyrl-KZ"},
+		// Don't specialize duplicate and ambiguous matches.
+		{"kk-034", "kk-Arab-034"}, // Matches IR and AF. Both are Arab.
+		{"ku-145", "ku-Latn-TR"},  // Matches IQ, TR, and LB, but kk -> TR.
+		{"und-Arab-CC", "ms-Arab-CC"},
+		{"und-Arab-GB", "ks-Arab-GB"},
+		{"und-Hans-CC", "zh-Hans-CC"},
+		{"und-CC", "en-Latn-CC"},
+		{"sr", "sr-Cyrl-RS"},
+		{"sr-151", "sr-Latn-151"}, // Matches RO and RU.
+		// We would like addLikelySubtags to generate the same results if the input
+		// only changes by adding tags that would otherwise have been added
+		// by the expansion.
+		// In other words:
+		//     und-AA -> xx-Scrp-AA   implies und-Scrp-AA -> xx-Scrp-AA
+		//     und-AA -> xx-Scrp-AA   implies xx-AA -> xx-Scrp-AA
+		//     und-Scrp -> xx-Scrp-AA implies und-Scrp-AA -> xx-Scrp-AA
+		//     und-Scrp -> xx-Scrp-AA implies xx-Scrp -> xx-Scrp-AA
+		//     xx -> xx-Scrp-AA       implies xx-Scrp -> xx-Scrp-AA
+		//     xx -> xx-Scrp-AA       implies xx-AA -> xx-Scrp-AA
+		//
+		// The algorithm specified in
+		//   http://unicode.org/reports/tr35/tr35-9.html#Supplemental_Data,
+		// Section C.10, does not handle the first case. For example,
+		// the CLDR data contains an entry und-BJ -> fr-Latn-BJ, but not
+		// there is no rule for und-Latn-BJ.  According to spec, und-Latn-BJ
+		// would expand to en-Latn-BJ, violating the aforementioned principle.
+		// We deviate from the spec by letting und-Scrp-AA expand to xx-Scrp-AA
+		// if a rule of the form und-AA -> xx-Scrp-AA is defined.
+		// Note that as of version 23, CLDR has some explicitly specified
+		// entries that do not conform to these rules. The implementation
+		// will not correct these explicit inconsistencies. A later versions of CLDR
+		// is supposed to fix this.
+		{"und-Latn-BJ", "fr-Latn-BJ"},
+		{"und-Bugi-ID", "bug-Bugi-ID"},
+		// regions, scripts and languages without definitions
+		{"und-Arab-AA", "ar-Arab-AA"},
+		{"und-Afak-RE", "fr-Afak-RE"},
+		{"und-Arab-GB", "ks-Arab-GB"},
+		{"abp-Arab-GB", "abp-Arab-GB"},
+		// script has preference over region
+		{"und-Arab-NL", "ar-Arab-NL"},
+		{"zza", "zza-Latn-TR"},
+		// preserve variants and extensions
+		{"de-1901", "de-Latn-DE-1901"},
+		{"de-x-abc", "de-Latn-DE-x-abc"},
+		{"de-1901-x-abc", "de-Latn-DE-1901-x-abc"},
+		{"x-abc", "x-abc"}, // TODO: is this the desired behavior?
+	}
+	for i, tt := range tests {
+		in, _ := Parse(tt.in)
+		out, _ := Parse(tt.out)
+		in, _ = in.addLikelySubtags()
+		if in.String() != out.String() {
+			t.Errorf("%d: add(%s) was %s; want %s", i, tt.in, in, tt.out)
+		}
+	}
+}
+func TestMinimize(t *testing.T) {
+	tests := []struct{ in, out string }{
+		{"aa", "aa"},
+		{"aa-Latn", "aa"},
+		{"aa-Latn-ET", "aa"},
+		{"aa-ET", "aa"},
+		{"aa-Arab", "aa-Arab"},
+		{"aa-Arab-ER", "aa-Arab-ER"},
+		{"aa-Arab-ET", "aa-Arab"},
+		{"und", "und"},
+		{"und-Latn", "und"},
+		{"und-Latn-US", "und"},
+		{"en-Latn-US", "en"},
+		{"cmn", "cmn"},
+		{"cmn-Hans", "cmn-Hans"},
+		{"cmn-Hant", "cmn-Hant"},
+		{"zh-AU", "zh-AU"},
+		{"zh-VN", "zh-VN"},
+		{"zh-SG", "zh-SG"},
+		{"zh-Hant", "zh-Hant"},
+		{"zh-Hant-TW", "zh-TW"},
+		{"zh-Hans", "zh"},
+		{"zh-Hani", "zh-Hani"},
+		{"und-Hans", "und-Hans"},
+		{"und-Hani", "und-Hani"},
+
+		{"und-CW", "und-CW"},
+		{"und-YT", "und-YT"},
+		{"und-Arab", "und-Arab"},
+		{"und-AM", "und-AM"},
+		{"und-Arab-CC", "und-Arab-CC"},
+		{"und-CC", "und-CC"},
+		{"und-Latn-BJ", "und-BJ"},
+		{"und-Bugi-ID", "und-Bugi"},
+		{"bug-Bugi-ID", "bug-Bugi"},
+		// regions, scripts and languages without definitions
+		{"und-Arab-AA", "und-Arab-AA"},
+		// preserve variants and extensions
+		{"de-Latn-1901", "de-1901"},
+		{"de-Latn-x-abc", "de-x-abc"},
+		{"de-DE-1901-x-abc", "de-1901-x-abc"},
+		{"x-abc", "x-abc"}, // TODO: is this the desired behavior?
+	}
+	for i, tt := range tests {
+		in, _ := Parse(tt.in)
+		out, _ := Parse(tt.out)
+		min, _ := in.minimize()
+		if min.String() != out.String() {
+			t.Errorf("%d: min(%s) was %s; want %s", i, tt.in, min, tt.out)
+		}
+		max, _ := min.addLikelySubtags()
+		if x, _ := in.addLikelySubtags(); x.String() != max.String() {
+			t.Errorf("%d: max(min(%s)) = %s; want %s", i, tt.in, max, x)
+		}
+	}
+}
+
+func TestRegionDistance(t *testing.T) {
+	tests := []struct {
+		a, b string
+		d    int
+	}{
+		{"NL", "NL", 0},
+		{"NL", "EU", 1},
+		{"EU", "NL", 1},
+		{"005", "005", 0},
+		{"NL", "BE", 2},
+		{"CO", "005", 1},
+		{"005", "CO", 1},
+		{"CO", "419", 2},
+		{"419", "CO", 2},
+		{"005", "419", 1},
+		{"419", "005", 1},
+		{"001", "013", 2},
+		{"013", "001", 2},
+		{"CO", "CW", 4},
+		{"CO", "PW", 6},
+		{"CO", "BV", 6},
+		{"ZZ", "QQ", 2},
+	}
+	for i, tt := range tests {
+		testtext.Run(t, tt.a+"/"+tt.b, func(t *testing.T) {
+			ra, _ := getRegionID([]byte(tt.a))
+			rb, _ := getRegionID([]byte(tt.b))
+			if d := regionDistance(ra, rb); d != tt.d {
+				t.Errorf("%d: d(%s, %s) = %v; want %v", i, tt.a, tt.b, d, tt.d)
+			}
+		})
+	}
+}
+
+func TestParentDistance(t *testing.T) {
+	tests := []struct {
+		parent string
+		tag    string
+		d      uint8
+	}{
+		{"en-001", "en-AU", 1},
+		{"pt-PT", "pt-AO", 1},
+		{"pt", "pt-AO", 2},
+		{"en-AU", "en-GB", 255},
+		{"en-NL", "en-AU", 255},
+		// Note that pt-BR and en-US are not automatically minimized.
+		{"pt-BR", "pt-AO", 255},
+		{"en-US", "en-AU", 255},
+	}
+	for _, tt := range tests {
+		r := Raw.MustParse(tt.parent).region
+		tag := Raw.MustParse(tt.tag)
+		if d := parentDistance(r, tag); d != tt.d {
+			t.Errorf("d(%s, %s) was %d; want %d", r, tag, d, tt.d)
+		}
+	}
+}
+
+// Implementation of String methods for various types for debugging purposes.
+
+func (m *matcher) String() string {
+	w := &bytes.Buffer{}
+	fmt.Fprintln(w, "Default:", m.default_)
+	for tag, h := range m.index {
+		fmt.Fprintf(w, "  %s: %v\n", tag, h)
+	}
+	return w.String()
+}
+
+func (h *matchHeader) String() string {
+	w := &bytes.Buffer{}
+	fmt.Fprintf(w, "exact: ")
+	for _, h := range h.exact {
+		fmt.Fprintf(w, "%v, ", h)
+	}
+	fmt.Fprint(w, "; max: ")
+	for _, h := range h.max {
+		fmt.Fprintf(w, "%v, ", h)
+	}
+	return w.String()
+}
+
+func (t haveTag) String() string {
+	return fmt.Sprintf("%v:%d:%v:%v-%v|%v", t.tag, t.index, t.conf, t.maxRegion, t.maxScript, t.altScript)
+}
+
+func parseSupported(list string) (out []Tag) {
+	for _, s := range strings.Split(list, ",") {
+		out = append(out, mk(strings.TrimSpace(s)))
+	}
+	return out
+}
+
+// The test set for TestBestMatch is defined in data_test.go.
+func TestBestMatch(t *testing.T) {
+	for i, tt := range matchTests {
+		supported := parseSupported(tt.supported)
+		m := newMatcher(supported)
+		if *verbose {
+			fmt.Printf("%s:\n%v\n", tt.comment, m)
+		}
+		for _, tm := range tt.test {
+			tag, _, conf := m.Match(parseSupported(tm.desired)...)
+			if tag.String() != tm.match {
+				t.Errorf("%d:%s: find %s in %q: have %s; want %s (%v)\n", i, tt.comment, tm.desired, tt.supported, tag, tm.match, conf)
+			}
+		}
+	}
+}
+
+func TestBestMatchAlloc(t *testing.T) {
+	m := NewMatcher(parseSupported("en sr nl"))
+	// Go allocates when creating a list of tags from a single tag!
+	list := []Tag{English}
+	avg := testtext.AllocsPerRun(1, func() {
+		m.Match(list...)
+	})
+	if avg > 0 {
+		t.Errorf("got %f; want 0", avg)
+	}
+}
+
+var benchHave = []Tag{
+	mk("en"),
+	mk("en-GB"),
+	mk("za"),
+	mk("zh-Hant"),
+	mk("zh-Hans-CN"),
+	mk("zh"),
+	mk("zh-HK"),
+	mk("ar-MK"),
+	mk("en-CA"),
+	mk("fr-CA"),
+	mk("fr-US"),
+	mk("fr-CH"),
+	mk("fr"),
+	mk("lt"),
+	mk("lv"),
+	mk("iw"),
+	mk("iw-NL"),
+	mk("he"),
+	mk("he-IT"),
+	mk("tlh"),
+	mk("ja"),
+	mk("ja-Jpan"),
+	mk("ja-Jpan-JP"),
+	mk("de"),
+	mk("de-CH"),
+	mk("de-AT"),
+	mk("de-DE"),
+	mk("sr"),
+	mk("sr-Latn"),
+	mk("sr-Cyrl"),
+	mk("sr-ME"),
+}
+
+var benchWant = [][]Tag{
+	[]Tag{
+		mk("en"),
+	},
+	[]Tag{
+		mk("en-AU"),
+		mk("de-HK"),
+		mk("nl"),
+		mk("fy"),
+		mk("lv"),
+	},
+	[]Tag{
+		mk("en-AU"),
+		mk("de-HK"),
+		mk("nl"),
+		mk("fy"),
+	},
+	[]Tag{
+		mk("ja-Hant"),
+		mk("da-HK"),
+		mk("nl"),
+		mk("zh-TW"),
+	},
+	[]Tag{
+		mk("ja-Hant"),
+		mk("da-HK"),
+		mk("nl"),
+		mk("hr"),
+	},
+}
+
+func BenchmarkMatch(b *testing.B) {
+	m := newMatcher(benchHave)
+	for i := 0; i < b.N; i++ {
+		for _, want := range benchWant {
+			m.getBest(want...)
+		}
+	}
+}
+
+func BenchmarkMatchExact(b *testing.B) {
+	want := mk("en")
+	m := newMatcher(benchHave)
+	for i := 0; i < b.N; i++ {
+		m.getBest(want)
+	}
+}
+
+func BenchmarkMatchAltLanguagePresent(b *testing.B) {
+	want := mk("hr")
+	m := newMatcher(benchHave)
+	for i := 0; i < b.N; i++ {
+		m.getBest(want)
+	}
+}
+
+func BenchmarkMatchAltLanguageNotPresent(b *testing.B) {
+	want := mk("nn")
+	m := newMatcher(benchHave)
+	for i := 0; i < b.N; i++ {
+		m.getBest(want)
+	}
+}
+
+func BenchmarkMatchAltScriptPresent(b *testing.B) {
+	want := mk("zh-Hant-CN")
+	m := newMatcher(benchHave)
+	for i := 0; i < b.N; i++ {
+		m.getBest(want)
+	}
+}
+
+func BenchmarkMatchAltScriptNotPresent(b *testing.B) {
+	want := mk("fr-Cyrl")
+	m := newMatcher(benchHave)
+	for i := 0; i < b.N; i++ {
+		m.getBest(want)
+	}
+}
+
+func BenchmarkMatchLimitedExact(b *testing.B) {
+	want := []Tag{mk("he-NL"), mk("iw-NL")}
+	m := newMatcher(benchHave)
+	for i := 0; i < b.N; i++ {
+		m.getBest(want...)
+	}
+}

vendor/golang.org/x/text/language/parse.go

@@ -0,0 +1,859 @@
+// Copyright 2013 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.
+
+package language
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"sort"
+	"strconv"
+	"strings"
+
+	"golang.org/x/text/internal/tag"
+)
+
+// isAlpha returns true if the byte is not a digit.
+// b must be an ASCII letter or digit.
+func isAlpha(b byte) bool {
+	return b > '9'
+}
+
+// isAlphaNum returns true if the string contains only ASCII letters or digits.
+func isAlphaNum(s []byte) bool {
+	for _, c := range s {
+		if !('a' <= c && c <= 'z' || 'A' <= c && c <= 'Z' || '0' <= c && c <= '9') {
+			return false
+		}
+	}
+	return true
+}
+
+// errSyntax is returned by any of the parsing functions when the
+// input is not well-formed, according to BCP 47.
+// TODO: return the position at which the syntax error occurred?
+var errSyntax = errors.New("language: tag is not well-formed")
+
+// ValueError is returned by any of the parsing functions when the
+// input is well-formed but the respective subtag is not recognized
+// as a valid value.
+type ValueError struct {
+	v [8]byte
+}
+
+func mkErrInvalid(s []byte) error {
+	var e ValueError
+	copy(e.v[:], s)
+	return e
+}
+
+func (e ValueError) tag() []byte {
+	n := bytes.IndexByte(e.v[:], 0)
+	if n == -1 {
+		n = 8
+	}
+	return e.v[:n]
+}
+
+// Error implements the error interface.
+func (e ValueError) Error() string {
+	return fmt.Sprintf("language: subtag %q is well-formed but unknown", e.tag())
+}
+
+// Subtag returns the subtag for which the error occurred.
+func (e ValueError) Subtag() string {
+	return string(e.tag())
+}
+
+// scanner is used to scan BCP 47 tokens, which are separated by _ or -.
+type scanner struct {
+	b     []byte
+	bytes [max99thPercentileSize]byte
+	token []byte
+	start int // start position of the current token
+	end   int // end position of the current token
+	next  int // next point for scan
+	err   error
+	done  bool
+}
+
+func makeScannerString(s string) scanner {
+	scan := scanner{}
+	if len(s) <= len(scan.bytes) {
+		scan.b = scan.bytes[:copy(scan.bytes[:], s)]
+	} else {
+		scan.b = []byte(s)
+	}
+	scan.init()
+	return scan
+}
+
+// makeScanner returns a scanner using b as the input buffer.
+// b is not copied and may be modified by the scanner routines.
+func makeScanner(b []byte) scanner {
+	scan := scanner{b: b}
+	scan.init()
+	return scan
+}
+
+func (s *scanner) init() {
+	for i, c := range s.b {
+		if c == '_' {
+			s.b[i] = '-'
+		}
+	}
+	s.scan()
+}
+
+// restToLower converts the string between start and end to lower case.
+func (s *scanner) toLower(start, end int) {
+	for i := start; i < end; i++ {
+		c := s.b[i]
+		if 'A' <= c && c <= 'Z' {
+			s.b[i] += 'a' - 'A'
+		}
+	}
+}
+
+func (s *scanner) setError(e error) {
+	if s.err == nil || (e == errSyntax && s.err != errSyntax) {
+		s.err = e
+	}
+}
+
+// resizeRange shrinks or grows the array at position oldStart such that
+// a new string of size newSize can fit between oldStart and oldEnd.
+// Sets the scan point to after the resized range.
+func (s *scanner) resizeRange(oldStart, oldEnd, newSize int) {
+	s.start = oldStart
+	if end := oldStart + newSize; end != oldEnd {
+		diff := end - oldEnd
+		if end < cap(s.b) {
+			b := make([]byte, len(s.b)+diff)
+			copy(b, s.b[:oldStart])
+			copy(b[end:], s.b[oldEnd:])
+			s.b = b
+		} else {
+			s.b = append(s.b[end:], s.b[oldEnd:]...)
+		}
+		s.next = end + (s.next - s.end)
+		s.end = end
+	}
+}
+
+// replace replaces the current token with repl.
+func (s *scanner) replace(repl string) {
+	s.resizeRange(s.start, s.end, len(repl))
+	copy(s.b[s.start:], repl)
+}
+
+// gobble removes the current token from the input.
+// Caller must call scan after calling gobble.
+func (s *scanner) gobble(e error) {
+	s.setError(e)
+	if s.start == 0 {
+		s.b = s.b[:+copy(s.b, s.b[s.next:])]
+		s.end = 0
+	} else {
+		s.b = s.b[:s.start-1+copy(s.b[s.start-1:], s.b[s.end:])]
+		s.end = s.start - 1
+	}
+	s.next = s.start
+}
+
+// deleteRange removes the given range from s.b before the current token.
+func (s *scanner) deleteRange(start, end int) {
+	s.setError(errSyntax)
+	s.b = s.b[:start+copy(s.b[start:], s.b[end:])]
+	diff := end - start
+	s.next -= diff
+	s.start -= diff
+	s.end -= diff
+}
+
+// scan parses the next token of a BCP 47 string.  Tokens that are larger
+// than 8 characters or include non-alphanumeric characters result in an error
+// and are gobbled and removed from the output.
+// It returns the end position of the last token consumed.
+func (s *scanner) scan() (end int) {
+	end = s.end
+	s.token = nil
+	for s.start = s.next; s.next < len(s.b); {
+		i := bytes.IndexByte(s.b[s.next:], '-')
+		if i == -1 {
+			s.end = len(s.b)
+			s.next = len(s.b)
+			i = s.end - s.start
+		} else {
+			s.end = s.next + i
+			s.next = s.end + 1
+		}
+		token := s.b[s.start:s.end]
+		if i < 1 || i > 8 || !isAlphaNum(token) {
+			s.gobble(errSyntax)
+			continue
+		}
+		s.token = token
+		return end
+	}
+	if n := len(s.b); n > 0 && s.b[n-1] == '-' {
+		s.setError(errSyntax)
+		s.b = s.b[:len(s.b)-1]
+	}
+	s.done = true
+	return end
+}
+
+// acceptMinSize parses multiple tokens of the given size or greater.
+// It returns the end position of the last token consumed.
+func (s *scanner) acceptMinSize(min int) (end int) {
+	end = s.end
+	s.scan()
+	for ; len(s.token) >= min; s.scan() {
+		end = s.end
+	}
+	return end
+}
+
+// Parse parses the given BCP 47 string and returns a valid Tag. If parsing
+// failed it returns an error and any part of the tag that could be parsed.
+// If parsing succeeded but an unknown value was found, it returns
+// ValueError. The Tag returned in this case is just stripped of the unknown
+// value. All other values are preserved. It accepts tags in the BCP 47 format
+// and extensions to this standard defined in
+// http://www.unicode.org/reports/tr35/#Unicode_Language_and_Locale_Identifiers.
+// The resulting tag is canonicalized using the default canonicalization type.
+func Parse(s string) (t Tag, err error) {
+	return Default.Parse(s)
+}
+
+// Parse parses the given BCP 47 string and returns a valid Tag. If parsing
+// failed it returns an error and any part of the tag that could be parsed.
+// If parsing succeeded but an unknown value was found, it returns
+// ValueError. The Tag returned in this case is just stripped of the unknown
+// value. All other values are preserved. It accepts tags in the BCP 47 format
+// and extensions to this standard defined in
+// http://www.unicode.org/reports/tr35/#Unicode_Language_and_Locale_Identifiers.
+// The resulting tag is canonicalized using the the canonicalization type c.
+func (c CanonType) Parse(s string) (t Tag, err error) {
+	// TODO: consider supporting old-style locale key-value pairs.
+	if s == "" {
+		return und, errSyntax
+	}
+	if len(s) <= maxAltTaglen {
+		b := [maxAltTaglen]byte{}
+		for i, c := range s {
+			// Generating invalid UTF-8 is okay as it won't match.
+			if 'A' <= c && c <= 'Z' {
+				c += 'a' - 'A'
+			} else if c == '_' {
+				c = '-'
+			}
+			b[i] = byte(c)
+		}
+		if t, ok := grandfathered(b); ok {
+			return t, nil
+		}
+	}
+	scan := makeScannerString(s)
+	t, err = parse(&scan, s)
+	t, changed := t.canonicalize(c)
+	if changed {
+		t.remakeString()
+	}
+	return t, err
+}
+
+func parse(scan *scanner, s string) (t Tag, err error) {
+	t = und
+	var end int
+	if n := len(scan.token); n <= 1 {
+		scan.toLower(0, len(scan.b))
+		if n == 0 || scan.token[0] != 'x' {
+			return t, errSyntax
+		}
+		end = parseExtensions(scan)
+	} else if n >= 4 {
+		return und, errSyntax
+	} else { // the usual case
+		t, end = parseTag(scan)
+		if n := len(scan.token); n == 1 {
+			t.pExt = uint16(end)
+			end = parseExtensions(scan)
+		} else if end < len(scan.b) {
+			scan.setError(errSyntax)
+			scan.b = scan.b[:end]
+		}
+	}
+	if int(t.pVariant) < len(scan.b) {
+		if end < len(s) {
+			s = s[:end]
+		}
+		if len(s) > 0 && tag.Compare(s, scan.b) == 0 {
+			t.str = s
+		} else {
+			t.str = string(scan.b)
+		}
+	} else {
+		t.pVariant, t.pExt = 0, 0
+	}
+	return t, scan.err
+}
+
+// parseTag parses language, script, region and variants.
+// It returns a Tag and the end position in the input that was parsed.
+func parseTag(scan *scanner) (t Tag, end int) {
+	var e error
+	// TODO: set an error if an unknown lang, script or region is encountered.
+	t.lang, e = getLangID(scan.token)
+	scan.setError(e)
+	scan.replace(t.lang.String())
+	langStart := scan.start
+	end = scan.scan()
+	for len(scan.token) == 3 && isAlpha(scan.token[0]) {
+		// From http://tools.ietf.org/html/bcp47, <lang>-<extlang> tags are equivalent
+		// to a tag of the form <extlang>.
+		lang, e := getLangID(scan.token)
+		if lang != 0 {
+			t.lang = lang
+			copy(scan.b[langStart:], lang.String())
+			scan.b[langStart+3] = '-'
+			scan.start = langStart + 4
+		}
+		scan.gobble(e)
+		end = scan.scan()
+	}
+	if len(scan.token) == 4 && isAlpha(scan.token[0]) {
+		t.script, e = getScriptID(script, scan.token)
+		if t.script == 0 {
+			scan.gobble(e)
+		}
+		end = scan.scan()
+	}
+	if n := len(scan.token); n >= 2 && n <= 3 {
+		t.region, e = getRegionID(scan.token)
+		if t.region == 0 {
+			scan.gobble(e)
+		} else {
+			scan.replace(t.region.String())
+		}
+		end = scan.scan()
+	}
+	scan.toLower(scan.start, len(scan.b))
+	t.pVariant = byte(end)
+	end = parseVariants(scan, end, t)
+	t.pExt = uint16(end)
+	return t, end
+}
+
+var separator = []byte{'-'}
+
+// parseVariants scans tokens as long as each token is a valid variant string.
+// Duplicate variants are removed.
+func parseVariants(scan *scanner, end int, t Tag) int {
+	start := scan.start
+	varIDBuf := [4]uint8{}
+	variantBuf := [4][]byte{}
+	varID := varIDBuf[:0]
+	variant := variantBuf[:0]
+	last := -1
+	needSort := false
+	for ; len(scan.token) >= 4; scan.scan() {
+		// TODO: measure the impact of needing this conversion and redesign
+		// the data structure if there is an issue.
+		v, ok := variantIndex[string(scan.token)]
+		if !ok {
+			// unknown variant
+			// TODO: allow user-defined variants?
+			scan.gobble(mkErrInvalid(scan.token))
+			continue
+		}
+		varID = append(varID, v)
+		variant = append(variant, scan.token)
+		if !needSort {
+			if last < int(v) {
+				last = int(v)
+			} else {
+				needSort = true
+				// There is no legal combinations of more than 7 variants
+				// (and this is by no means a useful sequence).
+				const maxVariants = 8
+				if len(varID) > maxVariants {
+					break
+				}
+			}
+		}
+		end = scan.end
+	}
+	if needSort {
+		sort.Sort(variantsSort{varID, variant})
+		k, l := 0, -1
+		for i, v := range varID {
+			w := int(v)
+			if l == w {
+				// Remove duplicates.
+				continue
+			}
+			varID[k] = varID[i]
+			variant[k] = variant[i]
+			k++
+			l = w
+		}
+		if str := bytes.Join(variant[:k], separator); len(str) == 0 {
+			end = start - 1
+		} else {
+			scan.resizeRange(start, end, len(str))
+			copy(scan.b[scan.start:], str)
+			end = scan.end
+		}
+	}
+	return end
+}
+
+type variantsSort struct {
+	i []uint8
+	v [][]byte
+}
+
+func (s variantsSort) Len() int {
+	return len(s.i)
+}
+
+func (s variantsSort) Swap(i, j int) {
+	s.i[i], s.i[j] = s.i[j], s.i[i]
+	s.v[i], s.v[j] = s.v[j], s.v[i]
+}
+
+func (s variantsSort) Less(i, j int) bool {
+	return s.i[i] < s.i[j]
+}
+
+type bytesSort [][]byte
+
+func (b bytesSort) Len() int {
+	return len(b)
+}
+
+func (b bytesSort) Swap(i, j int) {
+	b[i], b[j] = b[j], b[i]
+}
+
+func (b bytesSort) Less(i, j int) bool {
+	return bytes.Compare(b[i], b[j]) == -1
+}
+
+// parseExtensions parses and normalizes the extensions in the buffer.
+// It returns the last position of scan.b that is part of any extension.
+// It also trims scan.b to remove excess parts accordingly.
+func parseExtensions(scan *scanner) int {
+	start := scan.start
+	exts := [][]byte{}
+	private := []byte{}
+	end := scan.end
+	for len(scan.token) == 1 {
+		extStart := scan.start
+		ext := scan.token[0]
+		end = parseExtension(scan)
+		extension := scan.b[extStart:end]
+		if len(extension) < 3 || (ext != 'x' && len(extension) < 4) {
+			scan.setError(errSyntax)
+			end = extStart
+			continue
+		} else if start == extStart && (ext == 'x' || scan.start == len(scan.b)) {
+			scan.b = scan.b[:end]
+			return end
+		} else if ext == 'x' {
+			private = extension
+			break
+		}
+		exts = append(exts, extension)
+	}
+	sort.Sort(bytesSort(exts))
+	if len(private) > 0 {
+		exts = append(exts, private)
+	}
+	scan.b = scan.b[:start]
+	if len(exts) > 0 {
+		scan.b = append(scan.b, bytes.Join(exts, separator)...)
+	} else if start > 0 {
+		// Strip trailing '-'.
+		scan.b = scan.b[:start-1]
+	}
+	return end
+}
+
+// parseExtension parses a single extension and returns the position of
+// the extension end.
+func parseExtension(scan *scanner) int {
+	start, end := scan.start, scan.end
+	switch scan.token[0] {
+	case 'u':
+		attrStart := end
+		scan.scan()
+		for last := []byte{}; len(scan.token) > 2; scan.scan() {
+			if bytes.Compare(scan.token, last) != -1 {
+				// Attributes are unsorted. Start over from scratch.
+				p := attrStart + 1
+				scan.next = p
+				attrs := [][]byte{}
+				for scan.scan(); len(scan.token) > 2; scan.scan() {
+					attrs = append(attrs, scan.token)
+					end = scan.end
+				}
+				sort.Sort(bytesSort(attrs))
+				copy(scan.b[p:], bytes.Join(attrs, separator))
+				break
+			}
+			last = scan.token
+			end = scan.end
+		}
+		var last, key []byte
+		for attrEnd := end; len(scan.token) == 2; last = key {
+			key = scan.token
+			keyEnd := scan.end
+			end = scan.acceptMinSize(3)
+			// TODO: check key value validity
+			if keyEnd == end || bytes.Compare(key, last) != 1 {
+				// We have an invalid key or the keys are not sorted.
+				// Start scanning keys from scratch and reorder.
+				p := attrEnd + 1
+				scan.next = p
+				keys := [][]byte{}
+				for scan.scan(); len(scan.token) == 2; {
+					keyStart, keyEnd := scan.start, scan.end
+					end = scan.acceptMinSize(3)
+					if keyEnd != end {
+						keys = append(keys, scan.b[keyStart:end])
+					} else {
+						scan.setError(errSyntax)
+						end = keyStart
+					}
+				}
+				sort.Sort(bytesSort(keys))
+				reordered := bytes.Join(keys, separator)
+				if e := p + len(reordered); e < end {
+					scan.deleteRange(e, end)
+					end = e
+				}
+				copy(scan.b[p:], bytes.Join(keys, separator))
+				break
+			}
+		}
+	case 't':
+		scan.scan()
+		if n := len(scan.token); n >= 2 && n <= 3 && isAlpha(scan.token[1]) {
+			_, end = parseTag(scan)
+			scan.toLower(start, end)
+		}
+		for len(scan.token) == 2 && !isAlpha(scan.token[1]) {
+			end = scan.acceptMinSize(3)
+		}
+	case 'x':
+		end = scan.acceptMinSize(1)
+	default:
+		end = scan.acceptMinSize(2)
+	}
+	return end
+}
+
+// Compose creates a Tag from individual parts, which may be of type Tag, Base,
+// Script, Region, Variant, []Variant, Extension, []Extension or error. If a
+// Base, Script or Region or slice of type Variant or Extension is passed more
+// than once, the latter will overwrite the former. Variants and Extensions are
+// accumulated, but if two extensions of the same type are passed, the latter
+// will replace the former. A Tag overwrites all former values and typically
+// only makes sense as the first argument. The resulting tag is returned after
+// canonicalizing using the Default CanonType. If one or more errors are
+// encountered, one of the errors is returned.
+func Compose(part ...interface{}) (t Tag, err error) {
+	return Default.Compose(part...)
+}
+
+// Compose creates a Tag from individual parts, which may be of type Tag, Base,
+// Script, Region, Variant, []Variant, Extension, []Extension or error. If a
+// Base, Script or Region or slice of type Variant or Extension is passed more
+// than once, the latter will overwrite the former. Variants and Extensions are
+// accumulated, but if two extensions of the same type are passed, the latter
+// will replace the former. A Tag overwrites all former values and typically
+// only makes sense as the first argument. The resulting tag is returned after
+// canonicalizing using CanonType c. If one or more errors are encountered,
+// one of the errors is returned.
+func (c CanonType) Compose(part ...interface{}) (t Tag, err error) {
+	var b builder
+	if err = b.update(part...); err != nil {
+		return und, err
+	}
+	t, _ = b.tag.canonicalize(c)
+
+	if len(b.ext) > 0 || len(b.variant) > 0 {
+		sort.Sort(sortVariant(b.variant))
+		sort.Strings(b.ext)
+		if b.private != "" {
+			b.ext = append(b.ext, b.private)
+		}
+		n := maxCoreSize + tokenLen(b.variant...) + tokenLen(b.ext...)
+		buf := make([]byte, n)
+		p := t.genCoreBytes(buf)
+		t.pVariant = byte(p)
+		p += appendTokens(buf[p:], b.variant...)
+		t.pExt = uint16(p)
+		p += appendTokens(buf[p:], b.ext...)
+		t.str = string(buf[:p])
+	} else if b.private != "" {
+		t.str = b.private
+		t.remakeString()
+	}
+	return
+}
+
+type builder struct {
+	tag Tag
+
+	private string // the x extension
+	ext     []string
+	variant []string
+
+	err error
+}
+
+func (b *builder) addExt(e string) {
+	if e == "" {
+	} else if e[0] == 'x' {
+		b.private = e
+	} else {
+		b.ext = append(b.ext, e)
+	}
+}
+
+var errInvalidArgument = errors.New("invalid Extension or Variant")
+
+func (b *builder) update(part ...interface{}) (err error) {
+	replace := func(l *[]string, s string, eq func(a, b string) bool) bool {
+		if s == "" {
+			b.err = errInvalidArgument
+			return true
+		}
+		for i, v := range *l {
+			if eq(v, s) {
+				(*l)[i] = s
+				return true
+			}
+		}
+		return false
+	}
+	for _, x := range part {
+		switch v := x.(type) {
+		case Tag:
+			b.tag.lang = v.lang
+			b.tag.region = v.region
+			b.tag.script = v.script
+			if v.str != "" {
+				b.variant = nil
+				for x, s := "", v.str[v.pVariant:v.pExt]; s != ""; {
+					x, s = nextToken(s)
+					b.variant = append(b.variant, x)
+				}
+				b.ext, b.private = nil, ""
+				for i, e := int(v.pExt), ""; i < len(v.str); {
+					i, e = getExtension(v.str, i)
+					b.addExt(e)
+				}
+			}
+		case Base:
+			b.tag.lang = v.langID
+		case Script:
+			b.tag.script = v.scriptID
+		case Region:
+			b.tag.region = v.regionID
+		case Variant:
+			if !replace(&b.variant, v.variant, func(a, b string) bool { return a == b }) {
+				b.variant = append(b.variant, v.variant)
+			}
+		case Extension:
+			if !replace(&b.ext, v.s, func(a, b string) bool { return a[0] == b[0] }) {
+				b.addExt(v.s)
+			}
+		case []Variant:
+			b.variant = nil
+			for _, x := range v {
+				b.update(x)
+			}
+		case []Extension:
+			b.ext, b.private = nil, ""
+			for _, e := range v {
+				b.update(e)
+			}
+		// TODO: support parsing of raw strings based on morphology or just extensions?
+		case error:
+			err = v
+		}
+	}
+	return
+}
+
+func tokenLen(token ...string) (n int) {
+	for _, t := range token {
+		n += len(t) + 1
+	}
+	return
+}
+
+func appendTokens(b []byte, token ...string) int {
+	p := 0
+	for _, t := range token {
+		b[p] = '-'
+		copy(b[p+1:], t)
+		p += 1 + len(t)
+	}
+	return p
+}
+
+type sortVariant []string
+
+func (s sortVariant) Len() int {
+	return len(s)
+}
+
+func (s sortVariant) Swap(i, j int) {
+	s[j], s[i] = s[i], s[j]
+}
+
+func (s sortVariant) Less(i, j int) bool {
+	return variantIndex[s[i]] < variantIndex[s[j]]
+}
+
+func findExt(list []string, x byte) int {
+	for i, e := range list {
+		if e[0] == x {
+			return i
+		}
+	}
+	return -1
+}
+
+// getExtension returns the name, body and end position of the extension.
+func getExtension(s string, p int) (end int, ext string) {
+	if s[p] == '-' {
+		p++
+	}
+	if s[p] == 'x' {
+		return len(s), s[p:]
+	}
+	end = nextExtension(s, p)
+	return end, s[p:end]
+}
+
+// nextExtension finds the next extension within the string, searching
+// for the -<char>- pattern from position p.
+// In the fast majority of cases, language tags will have at most
+// one extension and extensions tend to be small.
+func nextExtension(s string, p int) int {
+	for n := len(s) - 3; p < n; {
+		if s[p] == '-' {
+			if s[p+2] == '-' {
+				return p
+			}
+			p += 3
+		} else {
+			p++
+		}
+	}
+	return len(s)
+}
+
+var errInvalidWeight = errors.New("ParseAcceptLanguage: invalid weight")
+
+// ParseAcceptLanguage parses the contents of a Accept-Language header as
+// defined in http://www.ietf.org/rfc/rfc2616.txt and returns a list of Tags and
+// a list of corresponding quality weights. It is more permissive than RFC 2616
+// and may return non-nil slices even if the input is not valid.
+// The Tags will be sorted by highest weight first and then by first occurrence.
+// Tags with a weight of zero will be dropped. An error will be returned if the
+// input could not be parsed.
+func ParseAcceptLanguage(s string) (tag []Tag, q []float32, err error) {
+	var entry string
+	for s != "" {
+		if entry, s = split(s, ','); entry == "" {
+			continue
+		}
+
+		entry, weight := split(entry, ';')
+
+		// Scan the language.
+		t, err := Parse(entry)
+		if err != nil {
+			id, ok := acceptFallback[entry]
+			if !ok {
+				return nil, nil, err
+			}
+			t = Tag{lang: id}
+		}
+
+		// Scan the optional weight.
+		w := 1.0
+		if weight != "" {
+			weight = consume(weight, 'q')
+			weight = consume(weight, '=')
+			// consume returns the empty string when a token could not be
+			// consumed, resulting in an error for ParseFloat.
+			if w, err = strconv.ParseFloat(weight, 32); err != nil {
+				return nil, nil, errInvalidWeight
+			}
+			// Drop tags with a quality weight of 0.
+			if w <= 0 {
+				continue
+			}
+		}
+
+		tag = append(tag, t)
+		q = append(q, float32(w))
+	}
+	sortStable(&tagSort{tag, q})
+	return tag, q, nil
+}
+
+// consume removes a leading token c from s and returns the result or the empty
+// string if there is no such token.
+func consume(s string, c byte) string {
+	if s == "" || s[0] != c {
+		return ""
+	}
+	return strings.TrimSpace(s[1:])
+}
+
+func split(s string, c byte) (head, tail string) {
+	if i := strings.IndexByte(s, c); i >= 0 {
+		return strings.TrimSpace(s[:i]), strings.TrimSpace(s[i+1:])
+	}
+	return strings.TrimSpace(s), ""
+}
+
+// Add hack mapping to deal with a small number of cases that that occur
+// in Accept-Language (with reasonable frequency).
+var acceptFallback = map[string]langID{
+	"english": _en,
+	"deutsch": _de,
+	"italian": _it,
+	"french":  _fr,
+	"*":       _mul, // defined in the spec to match all languages.
+}
+
+type tagSort struct {
+	tag []Tag
+	q   []float32
+}
+
+func (s *tagSort) Len() int {
+	return len(s.q)
+}
+
+func (s *tagSort) Less(i, j int) bool {
+	return s.q[i] > s.q[j]
+}
+
+func (s *tagSort) Swap(i, j int) {
+	s.tag[i], s.tag[j] = s.tag[j], s.tag[i]
+	s.q[i], s.q[j] = s.q[j], s.q[i]
+}

vendor/golang.org/x/text/language/parse_test.go

@@ -0,0 +1,517 @@
+// Copyright 2013 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.
+
+package language
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+
+	"golang.org/x/text/internal/tag"
+)
+
+type scanTest struct {
+	ok  bool // true if scanning does not result in an error
+	in  string
+	tok []string // the expected tokens
+}
+
+var tests = []scanTest{
+	{true, "", []string{}},
+	{true, "1", []string{"1"}},
+	{true, "en", []string{"en"}},
+	{true, "root", []string{"root"}},
+	{true, "maxchars", []string{"maxchars"}},
+	{false, "bad/", []string{}},
+	{false, "morethan8", []string{}},
+	{false, "-", []string{}},
+	{false, "----", []string{}},
+	{false, "_", []string{}},
+	{true, "en-US", []string{"en", "US"}},
+	{true, "en_US", []string{"en", "US"}},
+	{false, "en-US-", []string{"en", "US"}},
+	{false, "en-US--", []string{"en", "US"}},
+	{false, "en-US---", []string{"en", "US"}},
+	{false, "en--US", []string{"en", "US"}},
+	{false, "-en-US", []string{"en", "US"}},
+	{false, "-en--US-", []string{"en", "US"}},
+	{false, "-en--US-", []string{"en", "US"}},
+	{false, "en-.-US", []string{"en", "US"}},
+	{false, ".-en--US-.", []string{"en", "US"}},
+	{false, "en-u.-US", []string{"en", "US"}},
+	{true, "en-u1-US", []string{"en", "u1", "US"}},
+	{true, "maxchar1_maxchar2-maxchar3", []string{"maxchar1", "maxchar2", "maxchar3"}},
+	{false, "moreThan8-moreThan8-e", []string{"e"}},
+}
+
+func TestScan(t *testing.T) {
+	for i, tt := range tests {
+		scan := makeScannerString(tt.in)
+		for j := 0; !scan.done; j++ {
+			if j >= len(tt.tok) {
+				t.Errorf("%d: extra token %q", i, scan.token)
+			} else if tag.Compare(tt.tok[j], scan.token) != 0 {
+				t.Errorf("%d: token %d: found %q; want %q", i, j, scan.token, tt.tok[j])
+				break
+			}
+			scan.scan()
+		}
+		if s := strings.Join(tt.tok, "-"); tag.Compare(s, bytes.Replace(scan.b, b("_"), b("-"), -1)) != 0 {
+			t.Errorf("%d: input: found %q; want %q", i, scan.b, s)
+		}
+		if (scan.err == nil) != tt.ok {
+			t.Errorf("%d: ok: found %v; want %v", i, scan.err == nil, tt.ok)
+		}
+	}
+}
+
+func TestAcceptMinSize(t *testing.T) {
+	for i, tt := range tests {
+		// count number of successive tokens with a minimum size.
+		for sz := 1; sz <= 8; sz++ {
+			scan := makeScannerString(tt.in)
+			scan.end, scan.next = 0, 0
+			end := scan.acceptMinSize(sz)
+			n := 0
+			for i := 0; i < len(tt.tok) && len(tt.tok[i]) >= sz; i++ {
+				n += len(tt.tok[i])
+				if i > 0 {
+					n++
+				}
+			}
+			if end != n {
+				t.Errorf("%d:%d: found len %d; want %d", i, sz, end, n)
+			}
+		}
+	}
+}
+
+type parseTest struct {
+	i                    int // the index of this test
+	in                   string
+	lang, script, region string
+	variants, ext        string
+	extList              []string // only used when more than one extension is present
+	invalid              bool
+	rewrite              bool // special rewrite not handled by parseTag
+	changed              bool // string needed to be reformatted
+}
+
+func parseTests() []parseTest {
+	tests := []parseTest{
+		{in: "root", lang: "und"},
+		{in: "und", lang: "und"},
+		{in: "en", lang: "en"},
+		{in: "xy", lang: "und", invalid: true},
+		{in: "en-ZY", lang: "en", invalid: true},
+		{in: "gsw", lang: "gsw"},
+		{in: "sr_Latn", lang: "sr", script: "Latn"},
+		{in: "af-Arab", lang: "af", script: "Arab"},
+		{in: "nl-BE", lang: "nl", region: "BE"},
+		{in: "es-419", lang: "es", region: "419"},
+		{in: "und-001", lang: "und", region: "001"},
+		{in: "de-latn-be", lang: "de", script: "Latn", region: "BE"},
+		// Variants
+		{in: "de-1901", lang: "de", variants: "1901"},
+		// Accept with unsuppressed script.
+		{in: "de-Latn-1901", lang: "de", script: "Latn", variants: "1901"},
+		// Specialized.
+		{in: "sl-rozaj", lang: "sl", variants: "rozaj"},
+		{in: "sl-rozaj-lipaw", lang: "sl", variants: "rozaj-lipaw"},
+		{in: "sl-rozaj-biske", lang: "sl", variants: "rozaj-biske"},
+		{in: "sl-rozaj-biske-1994", lang: "sl", variants: "rozaj-biske-1994"},
+		{in: "sl-rozaj-1994", lang: "sl", variants: "rozaj-1994"},
+		// Maximum number of variants while adhering to prefix rules.
+		{in: "sl-rozaj-biske-1994-alalc97-fonipa-fonupa-fonxsamp", lang: "sl", variants: "rozaj-biske-1994-alalc97-fonipa-fonupa-fonxsamp"},
+
+		// Sorting.
+		{in: "sl-1994-biske-rozaj", lang: "sl", variants: "rozaj-biske-1994", changed: true},
+		{in: "sl-rozaj-biske-1994-alalc97-fonupa-fonipa-fonxsamp", lang: "sl", variants: "rozaj-biske-1994-alalc97-fonipa-fonupa-fonxsamp", changed: true},
+		{in: "nl-fonxsamp-alalc97-fonipa-fonupa", lang: "nl", variants: "alalc97-fonipa-fonupa-fonxsamp", changed: true},
+
+		// Duplicates variants are removed, but not an error.
+		{in: "nl-fonupa-fonupa", lang: "nl", variants: "fonupa"},
+
+		// Variants that do not have correct prefixes. We still accept these.
+		{in: "de-Cyrl-1901", lang: "de", script: "Cyrl", variants: "1901"},
+		{in: "sl-rozaj-lipaw-1994", lang: "sl", variants: "rozaj-lipaw-1994"},
+		{in: "sl-1994-biske-rozaj-1994-biske-rozaj", lang: "sl", variants: "rozaj-biske-1994", changed: true},
+		{in: "de-Cyrl-1901", lang: "de", script: "Cyrl", variants: "1901"},
+
+		// Invalid variant.
+		{in: "de-1902", lang: "de", variants: "", invalid: true},
+
+		{in: "EN_CYRL", lang: "en", script: "Cyrl"},
+		// private use and extensions
+		{in: "x-a-b-c-d", ext: "x-a-b-c-d"},
+		{in: "x_A.-B-C_D", ext: "x-b-c-d", invalid: true, changed: true},
+		{in: "x-aa-bbbb-cccccccc-d", ext: "x-aa-bbbb-cccccccc-d"},
+		{in: "en-c_cc-b-bbb-a-aaa", lang: "en", changed: true, extList: []string{"a-aaa", "b-bbb", "c-cc"}},
+		{in: "en-x_cc-b-bbb-a-aaa", lang: "en", ext: "x-cc-b-bbb-a-aaa", changed: true},
+		{in: "en-c_cc-b-bbb-a-aaa-x-x", lang: "en", changed: true, extList: []string{"a-aaa", "b-bbb", "c-cc", "x-x"}},
+		{in: "en-v-c", lang: "en", ext: "", invalid: true},
+		{in: "en-v-abcdefghi", lang: "en", ext: "", invalid: true},
+		{in: "en-v-abc-x", lang: "en", ext: "v-abc", invalid: true},
+		{in: "en-v-abc-x-", lang: "en", ext: "v-abc", invalid: true},
+		{in: "en-v-abc-w-x-xx", lang: "en", extList: []string{"v-abc", "x-xx"}, invalid: true, changed: true},
+		{in: "en-v-abc-w-y-yx", lang: "en", extList: []string{"v-abc", "y-yx"}, invalid: true, changed: true},
+		{in: "en-v-c-abc", lang: "en", ext: "c-abc", invalid: true, changed: true},
+		{in: "en-v-w-abc", lang: "en", ext: "w-abc", invalid: true, changed: true},
+		{in: "en-v-x-abc", lang: "en", ext: "x-abc", invalid: true, changed: true},
+		{in: "en-v-x-a", lang: "en", ext: "x-a", invalid: true, changed: true},
+		{in: "en-9-aa-0-aa-z-bb-x-a", lang: "en", extList: []string{"0-aa", "9-aa", "z-bb", "x-a"}, changed: true},
+		{in: "en-u-c", lang: "en", ext: "", invalid: true},
+		{in: "en-u-co-phonebk", lang: "en", ext: "u-co-phonebk"},
+		{in: "en-u-co-phonebk-ca", lang: "en", ext: "u-co-phonebk", invalid: true},
+		{in: "en-u-nu-arabic-co-phonebk-ca", lang: "en", ext: "u-co-phonebk-nu-arabic", invalid: true, changed: true},
+		{in: "en-u-nu-arabic-co-phonebk-ca-x", lang: "en", ext: "u-co-phonebk-nu-arabic", invalid: true, changed: true},
+		{in: "en-u-nu-arabic-co-phonebk-ca-s", lang: "en", ext: "u-co-phonebk-nu-arabic", invalid: true, changed: true},
+		{in: "en-u-nu-arabic-co-phonebk-ca-a12345678", lang: "en", ext: "u-co-phonebk-nu-arabic", invalid: true, changed: true},
+		{in: "en-u-co-phonebook", lang: "en", ext: "", invalid: true},
+		{in: "en-u-co-phonebook-cu-xau", lang: "en", ext: "u-cu-xau", invalid: true, changed: true},
+		{in: "en-Cyrl-u-co-phonebk", lang: "en", script: "Cyrl", ext: "u-co-phonebk"},
+		{in: "en-US-u-co-phonebk", lang: "en", region: "US", ext: "u-co-phonebk"},
+		{in: "en-US-u-co-phonebk-cu-xau", lang: "en", region: "US", ext: "u-co-phonebk-cu-xau"},
+		{in: "en-scotland-u-co-phonebk", lang: "en", variants: "scotland", ext: "u-co-phonebk"},
+		{in: "en-u-cu-xua-co-phonebk", lang: "en", ext: "u-co-phonebk-cu-xua", changed: true},
+		{in: "en-u-def-abc-cu-xua-co-phonebk", lang: "en", ext: "u-abc-def-co-phonebk-cu-xua", changed: true},
+		{in: "en-u-def-abc", lang: "en", ext: "u-abc-def", changed: true},
+		{in: "en-u-cu-xua-co-phonebk-a-cd", lang: "en", extList: []string{"a-cd", "u-co-phonebk-cu-xua"}, changed: true},
+		// Invalid "u" extension. Drop invalid parts.
+		{in: "en-u-cu-co-phonebk", lang: "en", extList: []string{"u-co-phonebk"}, invalid: true, changed: true},
+		{in: "en-u-cu-xau-co", lang: "en", extList: []string{"u-cu-xau"}, invalid: true},
+		// We allow duplicate keys as the LDML spec does not explicitly prohibit it.
+		// TODO: Consider eliminating duplicates and returning an error.
+		{in: "en-u-cu-xau-co-phonebk-cu-xau", lang: "en", ext: "u-co-phonebk-cu-xau-cu-xau", changed: true},
+		{in: "en-t-en-Cyrl-NL-fonipa", lang: "en", ext: "t-en-cyrl-nl-fonipa", changed: true},
+		{in: "en-t-en-Cyrl-NL-fonipa-t0-abc-def", lang: "en", ext: "t-en-cyrl-nl-fonipa-t0-abc-def", changed: true},
+		{in: "en-t-t0-abcd", lang: "en", ext: "t-t0-abcd"},
+		// Not necessary to have changed here.
+		{in: "en-t-nl-abcd", lang: "en", ext: "t-nl", invalid: true},
+		{in: "en-t-nl-latn", lang: "en", ext: "t-nl-latn"},
+		{in: "en-t-t0-abcd-x-a", lang: "en", extList: []string{"t-t0-abcd", "x-a"}},
+		// invalid
+		{in: "", lang: "und", invalid: true},
+		{in: "-", lang: "und", invalid: true},
+		{in: "x", lang: "und", invalid: true},
+		{in: "x-", lang: "und", invalid: true},
+		{in: "x--", lang: "und", invalid: true},
+		{in: "a-a-b-c-d", lang: "und", invalid: true},
+		{in: "en-", lang: "en", invalid: true},
+		{in: "enne-", lang: "und", invalid: true},
+		{in: "en.", lang: "und", invalid: true},
+		{in: "en.-latn", lang: "und", invalid: true},
+		{in: "en.-en", lang: "en", invalid: true},
+		{in: "x-a-tooManyChars-c-d", ext: "x-a-c-d", invalid: true, changed: true},
+		{in: "a-tooManyChars-c-d", lang: "und", invalid: true},
+		// TODO: check key-value validity
+		// { in: "en-u-cu-xd", lang: "en", ext: "u-cu-xd", invalid: true },
+		{in: "en-t-abcd", lang: "en", invalid: true},
+		{in: "en-Latn-US-en", lang: "en", script: "Latn", region: "US", invalid: true},
+		// rewrites (more tests in TestGrandfathered)
+		{in: "zh-min-nan", lang: "nan"},
+		{in: "zh-yue", lang: "yue"},
+		{in: "zh-xiang", lang: "hsn", rewrite: true},
+		{in: "zh-guoyu", lang: "cmn", rewrite: true},
+		{in: "iw", lang: "iw"},
+		{in: "sgn-BE-FR", lang: "sfb", rewrite: true},
+		{in: "i-klingon", lang: "tlh", rewrite: true},
+	}
+	for i, tt := range tests {
+		tests[i].i = i
+		if tt.extList != nil {
+			tests[i].ext = strings.Join(tt.extList, "-")
+		}
+		if tt.ext != "" && tt.extList == nil {
+			tests[i].extList = []string{tt.ext}
+		}
+	}
+	return tests
+}
+
+func TestParseExtensions(t *testing.T) {
+	for i, tt := range parseTests() {
+		if tt.ext == "" || tt.rewrite {
+			continue
+		}
+		scan := makeScannerString(tt.in)
+		if len(scan.b) > 1 && scan.b[1] != '-' {
+			scan.end = nextExtension(string(scan.b), 0)
+			scan.next = scan.end + 1
+			scan.scan()
+		}
+		start := scan.start
+		scan.toLower(start, len(scan.b))
+		parseExtensions(&scan)
+		ext := string(scan.b[start:])
+		if ext != tt.ext {
+			t.Errorf("%d(%s): ext was %v; want %v", i, tt.in, ext, tt.ext)
+		}
+		if changed := !strings.HasPrefix(tt.in[start:], ext); changed != tt.changed {
+			t.Errorf("%d(%s): changed was %v; want %v", i, tt.in, changed, tt.changed)
+		}
+	}
+}
+
+// partChecks runs checks for each part by calling the function returned by f.
+func partChecks(t *testing.T, f func(*parseTest) (Tag, bool)) {
+	for i, tt := range parseTests() {
+		tag, skip := f(&tt)
+		if skip {
+			continue
+		}
+		if l, _ := getLangID(b(tt.lang)); l != tag.lang {
+			t.Errorf("%d: lang was %q; want %q", i, tag.lang, l)
+		}
+		if sc, _ := getScriptID(script, b(tt.script)); sc != tag.script {
+			t.Errorf("%d: script was %q; want %q", i, tag.script, sc)
+		}
+		if r, _ := getRegionID(b(tt.region)); r != tag.region {
+			t.Errorf("%d: region was %q; want %q", i, tag.region, r)
+		}
+		if tag.str == "" {
+			continue
+		}
+		p := int(tag.pVariant)
+		if p < int(tag.pExt) {
+			p++
+		}
+		if s, g := tag.str[p:tag.pExt], tt.variants; s != g {
+			t.Errorf("%d: variants was %q; want %q", i, s, g)
+		}
+		p = int(tag.pExt)
+		if p > 0 && p < len(tag.str) {
+			p++
+		}
+		if s, g := (tag.str)[p:], tt.ext; s != g {
+			t.Errorf("%d: extensions were %q; want %q", i, s, g)
+		}
+	}
+}
+
+func TestParseTag(t *testing.T) {
+	partChecks(t, func(tt *parseTest) (id Tag, skip bool) {
+		if strings.HasPrefix(tt.in, "x-") || tt.rewrite {
+			return Tag{}, true
+		}
+		scan := makeScannerString(tt.in)
+		id, end := parseTag(&scan)
+		id.str = string(scan.b[:end])
+		tt.ext = ""
+		tt.extList = []string{}
+		return id, false
+	})
+}
+
+func TestParse(t *testing.T) {
+	partChecks(t, func(tt *parseTest) (id Tag, skip bool) {
+		id, err := Raw.Parse(tt.in)
+		ext := ""
+		if id.str != "" {
+			if strings.HasPrefix(id.str, "x-") {
+				ext = id.str
+			} else if int(id.pExt) < len(id.str) && id.pExt > 0 {
+				ext = id.str[id.pExt+1:]
+			}
+		}
+		if tag, _ := Raw.Parse(id.String()); tag.String() != id.String() {
+			t.Errorf("%d:%s: reparse was %q; want %q", tt.i, tt.in, id.String(), tag.String())
+		}
+		if ext != tt.ext {
+			t.Errorf("%d:%s: ext was %q; want %q", tt.i, tt.in, ext, tt.ext)
+		}
+		changed := id.str != "" && !strings.HasPrefix(tt.in, id.str)
+		if changed != tt.changed {
+			t.Errorf("%d:%s: changed was %v; want %v", tt.i, tt.in, changed, tt.changed)
+		}
+		if (err != nil) != tt.invalid {
+			t.Errorf("%d:%s: invalid was %v; want %v. Error: %v", tt.i, tt.in, err != nil, tt.invalid, err)
+		}
+		return id, false
+	})
+}
+
+func TestErrors(t *testing.T) {
+	mkInvalid := func(s string) error {
+		return mkErrInvalid([]byte(s))
+	}
+	tests := []struct {
+		in  string
+		out error
+	}{
+		// invalid subtags.
+		{"ac", mkInvalid("ac")},
+		{"AC", mkInvalid("ac")},
+		{"aa-Uuuu", mkInvalid("Uuuu")},
+		{"aa-AB", mkInvalid("AB")},
+		// ill-formed wins over invalid.
+		{"ac-u", errSyntax},
+		{"ac-u-ca", errSyntax},
+		{"ac-u-ca-co-pinyin", errSyntax},
+		{"noob", errSyntax},
+	}
+	for _, tt := range tests {
+		_, err := Parse(tt.in)
+		if err != tt.out {
+			t.Errorf("%s: was %q; want %q", tt.in, err, tt.out)
+		}
+	}
+}
+
+func TestCompose1(t *testing.T) {
+	partChecks(t, func(tt *parseTest) (id Tag, skip bool) {
+		l, _ := ParseBase(tt.lang)
+		s, _ := ParseScript(tt.script)
+		r, _ := ParseRegion(tt.region)
+		v := []Variant{}
+		for _, x := range strings.Split(tt.variants, "-") {
+			p, _ := ParseVariant(x)
+			v = append(v, p)
+		}
+		e := []Extension{}
+		for _, x := range tt.extList {
+			p, _ := ParseExtension(x)
+			e = append(e, p)
+		}
+		id, _ = Raw.Compose(l, s, r, v, e)
+		return id, false
+	})
+}
+
+func TestCompose2(t *testing.T) {
+	partChecks(t, func(tt *parseTest) (id Tag, skip bool) {
+		l, _ := ParseBase(tt.lang)
+		s, _ := ParseScript(tt.script)
+		r, _ := ParseRegion(tt.region)
+		p := []interface{}{l, s, r, s, r, l}
+		for _, x := range strings.Split(tt.variants, "-") {
+			v, _ := ParseVariant(x)
+			p = append(p, v)
+		}
+		for _, x := range tt.extList {
+			e, _ := ParseExtension(x)
+			p = append(p, e)
+		}
+		id, _ = Raw.Compose(p...)
+		return id, false
+	})
+}
+
+func TestCompose3(t *testing.T) {
+	partChecks(t, func(tt *parseTest) (id Tag, skip bool) {
+		id, _ = Raw.Parse(tt.in)
+		id, _ = Raw.Compose(id)
+		return id, false
+	})
+}
+
+func mk(s string) Tag {
+	return Raw.Make(s)
+}
+
+func TestParseAcceptLanguage(t *testing.T) {
+	type res struct {
+		t Tag
+		q float32
+	}
+	en := []res{{mk("en"), 1.0}}
+	tests := []struct {
+		out []res
+		in  string
+		ok  bool
+	}{
+		{en, "en", true},
+		{en, "   en", true},
+		{en, "en   ", true},
+		{en, "  en  ", true},
+		{en, "en,", true},
+		{en, ",en", true},
+		{en, ",,,en,,,", true},
+		{en, ",en;q=1", true},
+
+		// We allow an empty input, contrary to spec.
+		{nil, "", true},
+		{[]res{{mk("aa"), 1}}, "aa;", true}, // allow unspecified weight
+
+		// errors
+		{nil, ";", false},
+		{nil, "$", false},
+		{nil, "e;", false},
+		{nil, "x;", false},
+		{nil, "x", false},
+		{nil, "ac", false}, // non-existing language
+		{nil, "aa;q", false},
+		{nil, "aa;q=", false},
+		{nil, "aa;q=.", false},
+
+		// odd fallbacks
+		{
+			[]res{{mk("en"), 0.1}},
+			" english ;q=.1",
+			true,
+		},
+		{
+			[]res{{mk("it"), 1.0}, {mk("de"), 1.0}, {mk("fr"), 1.0}},
+			" italian, deutsch, french",
+			true,
+		},
+
+		// lists
+		{
+			[]res{{mk("en"), 0.1}},
+			"en;q=.1",
+			true,
+		},
+		{
+			[]res{{mk("mul"), 1.0}},
+			"*",
+			true,
+		},
+		{
+			[]res{{mk("en"), 1.0}, {mk("de"), 1.0}},
+			"en,de",
+			true,
+		},
+		{
+			[]res{{mk("en"), 1.0}, {mk("de"), .5}},
+			"en,de;q=0.5",
+			true,
+		},
+		{
+			[]res{{mk("de"), 0.8}, {mk("en"), 0.5}},
+			"  en ;   q    =   0.5    ,  , de;q=0.8",
+			true,
+		},
+		{
+			[]res{{mk("en"), 1.0}, {mk("de"), 1.0}, {mk("fr"), 1.0}, {mk("tlh"), 1.0}},
+			"en,de,fr,i-klingon",
+			true,
+		},
+		// sorting
+		{
+			[]res{{mk("tlh"), 0.4}, {mk("de"), 0.2}, {mk("fr"), 0.2}, {mk("en"), 0.1}},
+			"en;q=0.1,de;q=0.2,fr;q=0.2,i-klingon;q=0.4",
+			true,
+		},
+		// dropping
+		{
+			[]res{{mk("fr"), 0.2}, {mk("en"), 0.1}},
+			"en;q=0.1,de;q=0,fr;q=0.2,i-klingon;q=0.0",
+			true,
+		},
+	}
+	for i, tt := range tests {
+		tags, qs, e := ParseAcceptLanguage(tt.in)
+		if e == nil != tt.ok {
+			t.Errorf("%d:%s:err: was %v; want %v", i, tt.in, e == nil, tt.ok)
+		}
+		for j, tag := range tags {
+			if out := tt.out[j]; !tag.equalTags(out.t) || qs[j] != out.q {
+				t.Errorf("%d:%s: was %s, %1f; want %s, %1f", i, tt.in, tag, qs[j], out.t, out.q)
+				break
+			}
+		}
+	}
+}

vendor/golang.org/x/text/language/tags.go

@@ -0,0 +1,143 @@
+// Copyright 2013 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.
+
+package language
+
+// TODO: Various sets of commonly use tags and regions.
+
+// MustParse is like Parse, but panics if the given BCP 47 tag cannot be parsed.
+// It simplifies safe initialization of Tag values.
+func MustParse(s string) Tag {
+	t, err := Parse(s)
+	if err != nil {
+		panic(err)
+	}
+	return t
+}
+
+// MustParse is like Parse, but panics if the given BCP 47 tag cannot be parsed.
+// It simplifies safe initialization of Tag values.
+func (c CanonType) MustParse(s string) Tag {
+	t, err := c.Parse(s)
+	if err != nil {
+		panic(err)
+	}
+	return t
+}
+
+// MustParseBase is like ParseBase, but panics if the given base cannot be parsed.
+// It simplifies safe initialization of Base values.
+func MustParseBase(s string) Base {
+	b, err := ParseBase(s)
+	if err != nil {
+		panic(err)
+	}
+	return b
+}
+
+// MustParseScript is like ParseScript, but panics if the given script cannot be
+// parsed. It simplifies safe initialization of Script values.
+func MustParseScript(s string) Script {
+	scr, err := ParseScript(s)
+	if err != nil {
+		panic(err)
+	}
+	return scr
+}
+
+// MustParseRegion is like ParseRegion, but panics if the given region cannot be
+// parsed. It simplifies safe initialization of Region values.
+func MustParseRegion(s string) Region {
+	r, err := ParseRegion(s)
+	if err != nil {
+		panic(err)
+	}
+	return r
+}
+
+var (
+	und = Tag{}
+
+	Und Tag = Tag{}
+
+	Afrikaans            Tag = Tag{lang: _af}                //  af
+	Amharic              Tag = Tag{lang: _am}                //  am
+	Arabic               Tag = Tag{lang: _ar}                //  ar
+	ModernStandardArabic Tag = Tag{lang: _ar, region: _001}  //  ar-001
+	Azerbaijani          Tag = Tag{lang: _az}                //  az
+	Bulgarian            Tag = Tag{lang: _bg}                //  bg
+	Bengali              Tag = Tag{lang: _bn}                //  bn
+	Catalan              Tag = Tag{lang: _ca}                //  ca
+	Czech                Tag = Tag{lang: _cs}                //  cs
+	Danish               Tag = Tag{lang: _da}                //  da
+	German               Tag = Tag{lang: _de}                //  de
+	Greek                Tag = Tag{lang: _el}                //  el
+	English              Tag = Tag{lang: _en}                //  en
+	AmericanEnglish      Tag = Tag{lang: _en, region: _US}   //  en-US
+	BritishEnglish       Tag = Tag{lang: _en, region: _GB}   //  en-GB
+	Spanish              Tag = Tag{lang: _es}                //  es
+	EuropeanSpanish      Tag = Tag{lang: _es, region: _ES}   //  es-ES
+	LatinAmericanSpanish Tag = Tag{lang: _es, region: _419}  //  es-419
+	Estonian             Tag = Tag{lang: _et}                //  et
+	Persian              Tag = Tag{lang: _fa}                //  fa
+	Finnish              Tag = Tag{lang: _fi}                //  fi
+	Filipino             Tag = Tag{lang: _fil}               //  fil
+	French               Tag = Tag{lang: _fr}                //  fr
+	CanadianFrench       Tag = Tag{lang: _fr, region: _CA}   //  fr-CA
+	Gujarati             Tag = Tag{lang: _gu}                //  gu
+	Hebrew               Tag = Tag{lang: _he}                //  he
+	Hindi                Tag = Tag{lang: _hi}                //  hi
+	Croatian             Tag = Tag{lang: _hr}                //  hr
+	Hungarian            Tag = Tag{lang: _hu}                //  hu
+	Armenian             Tag = Tag{lang: _hy}                //  hy
+	Indonesian           Tag = Tag{lang: _id}                //  id
+	Icelandic            Tag = Tag{lang: _is}                //  is
+	Italian              Tag = Tag{lang: _it}                //  it
+	Japanese             Tag = Tag{lang: _ja}                //  ja
+	Georgian             Tag = Tag{lang: _ka}                //  ka
+	Kazakh               Tag = Tag{lang: _kk}                //  kk
+	Khmer                Tag = Tag{lang: _km}                //  km
+	Kannada              Tag = Tag{lang: _kn}                //  kn
+	Korean               Tag = Tag{lang: _ko}                //  ko
+	Kirghiz              Tag = Tag{lang: _ky}                //  ky
+	Lao                  Tag = Tag{lang: _lo}                //  lo
+	Lithuanian           Tag = Tag{lang: _lt}                //  lt
+	Latvian              Tag = Tag{lang: _lv}                //  lv
+	Macedonian           Tag = Tag{lang: _mk}                //  mk
+	Malayalam            Tag = Tag{lang: _ml}                //  ml
+	Mongolian            Tag = Tag{lang: _mn}                //  mn
+	Marathi              Tag = Tag{lang: _mr}                //  mr
+	Malay                Tag = Tag{lang: _ms}                //  ms
+	Burmese              Tag = Tag{lang: _my}                //  my
+	Nepali               Tag = Tag{lang: _ne}                //  ne
+	Dutch                Tag = Tag{lang: _nl}                //  nl
+	Norwegian            Tag = Tag{lang: _no}                //  no
+	Punjabi              Tag = Tag{lang: _pa}                //  pa
+	Polish               Tag = Tag{lang: _pl}                //  pl
+	Portuguese           Tag = Tag{lang: _pt}                //  pt
+	BrazilianPortuguese  Tag = Tag{lang: _pt, region: _BR}   //  pt-BR
+	EuropeanPortuguese   Tag = Tag{lang: _pt, region: _PT}   //  pt-PT
+	Romanian             Tag = Tag{lang: _ro}                //  ro
+	Russian              Tag = Tag{lang: _ru}                //  ru
+	Sinhala              Tag = Tag{lang: _si}                //  si
+	Slovak               Tag = Tag{lang: _sk}                //  sk
+	Slovenian            Tag = Tag{lang: _sl}                //  sl
+	Albanian             Tag = Tag{lang: _sq}                //  sq
+	Serbian              Tag = Tag{lang: _sr}                //  sr
+	SerbianLatin         Tag = Tag{lang: _sr, script: _Latn} //  sr-Latn
+	Swedish              Tag = Tag{lang: _sv}                //  sv
+	Swahili              Tag = Tag{lang: _sw}                //  sw
+	Tamil                Tag = Tag{lang: _ta}                //  ta
+	Telugu               Tag = Tag{lang: _te}                //  te
+	Thai                 Tag = Tag{lang: _th}                //  th
+	Turkish              Tag = Tag{lang: _tr}                //  tr
+	Ukrainian            Tag = Tag{lang: _uk}                //  uk
+	Urdu                 Tag = Tag{lang: _ur}                //  ur
+	Uzbek                Tag = Tag{lang: _uz}                //  uz
+	Vietnamese           Tag = Tag{lang: _vi}                //  vi
+	Chinese              Tag = Tag{lang: _zh}                //  zh
+	SimplifiedChinese    Tag = Tag{lang: _zh, script: _Hans} //  zh-Hans
+	TraditionalChinese   Tag = Tag{lang: _zh, script: _Hant} //  zh-Hant
+	Zulu                 Tag = Tag{lang: _zu}                //  zu
+)