summaryrefslogtreecommitdiffstats
path: root/vendor/golang.org/x/text/internal
diff options
context:
space:
mode:
authorChristopher Speller <crspeller@gmail.com>2017-07-20 15:22:49 -0700
committerGitHub <noreply@github.com>2017-07-20 15:22:49 -0700
commit58839cefb50e56ae5b157b37e9814ae83ceee70b (patch)
tree5de966481678096fc9567f74f96673b34a65127c /vendor/golang.org/x/text/internal
parente2f4492eadb5d3c58606b1fdd5774b63a07c236a (diff)
downloadchat-58839cefb50e56ae5b157b37e9814ae83ceee70b.tar.gz
chat-58839cefb50e56ae5b157b37e9814ae83ceee70b.tar.bz2
chat-58839cefb50e56ae5b157b37e9814ae83ceee70b.zip
Upgrading server dependancies (#6984)
Diffstat (limited to 'vendor/golang.org/x/text/internal')
-rw-r--r--vendor/golang.org/x/text/internal/export/idna/idna.go51
-rw-r--r--vendor/golang.org/x/text/internal/export/idna/idna_test.go23
-rw-r--r--vendor/golang.org/x/text/internal/number/decimal.go51
-rw-r--r--vendor/golang.org/x/text/internal/number/decimal_test.go13
-rwxr-xr-xvendor/golang.org/x/text/internal/number/format.go252
-rwxr-xr-xvendor/golang.org/x/text/internal/number/format_test.go247
-rw-r--r--vendor/golang.org/x/text/internal/number/number_test.go6
-rw-r--r--vendor/golang.org/x/text/internal/number/pattern.go33
-rw-r--r--vendor/golang.org/x/text/internal/number/pattern_test.go24
-rw-r--r--vendor/golang.org/x/text/internal/number/tables.go533
-rw-r--r--vendor/golang.org/x/text/internal/tables.go125
11 files changed, 856 insertions, 502 deletions
diff --git a/vendor/golang.org/x/text/internal/export/idna/idna.go b/vendor/golang.org/x/text/internal/export/idna/idna.go
index 3184fbbd9..471119682 100644
--- a/vendor/golang.org/x/text/internal/export/idna/idna.go
+++ b/vendor/golang.org/x/text/internal/export/idna/idna.go
@@ -67,6 +67,15 @@ func VerifyDNSLength(verify bool) Option {
return func(o *options) { o.verifyDNSLength = verify }
}
+// RemoveLeadingDots removes leading label separators. Leading runes that map to
+// dots, such as U+3002 IDEOGRAPHIC FULL STOP, are removed as well.
+//
+// This is the behavior suggested by the UTS #46 and is adopted by some
+// browsers.
+func RemoveLeadingDots(remove bool) Option {
+ return func(o *options) { o.removeLeadingDots = remove }
+}
+
// ValidateLabels sets whether to check the mandatory label validation criteria
// as defined in Section 5.4 of RFC 5891. This includes testing for correct use
// of hyphens ('-'), normalization, validity of runes, and the context rules.
@@ -133,14 +142,16 @@ func MapForLookup() Option {
o.mapping = validateAndMap
StrictDomainName(true)(o)
ValidateLabels(true)(o)
+ RemoveLeadingDots(true)(o)
}
}
type options struct {
- transitional bool
- useSTD3Rules bool
- validateLabels bool
- verifyDNSLength bool
+ transitional bool
+ useSTD3Rules bool
+ validateLabels bool
+ verifyDNSLength bool
+ removeLeadingDots bool
trie *idnaTrie
@@ -240,21 +251,23 @@ var (
punycode = &Profile{}
lookup = &Profile{options{
- transitional: true,
- useSTD3Rules: true,
- validateLabels: true,
- trie: trie,
- fromPuny: validateFromPunycode,
- mapping: validateAndMap,
- bidirule: bidirule.ValidString,
+ transitional: true,
+ useSTD3Rules: true,
+ validateLabels: true,
+ removeLeadingDots: true,
+ trie: trie,
+ fromPuny: validateFromPunycode,
+ mapping: validateAndMap,
+ bidirule: bidirule.ValidString,
}}
display = &Profile{options{
- useSTD3Rules: true,
- validateLabels: true,
- trie: trie,
- fromPuny: validateFromPunycode,
- mapping: validateAndMap,
- bidirule: bidirule.ValidString,
+ useSTD3Rules: true,
+ validateLabels: true,
+ removeLeadingDots: true,
+ trie: trie,
+ fromPuny: validateFromPunycode,
+ mapping: validateAndMap,
+ bidirule: bidirule.ValidString,
}}
registration = &Profile{options{
useSTD3Rules: true,
@@ -293,7 +306,9 @@ func (p *Profile) process(s string, toASCII bool) (string, error) {
s, err = p.mapping(p, s)
}
// Remove leading empty labels.
- for ; len(s) > 0 && s[0] == '.'; s = s[1:] {
+ if p.removeLeadingDots {
+ for ; len(s) > 0 && s[0] == '.'; s = s[1:] {
+ }
}
// It seems like we should only create this error on ToASCII, but the
// UTS 46 conformance tests suggests we should always check this.
diff --git a/vendor/golang.org/x/text/internal/export/idna/idna_test.go b/vendor/golang.org/x/text/internal/export/idna/idna_test.go
index 01fd50b7f..82ead035a 100644
--- a/vendor/golang.org/x/text/internal/export/idna/idna_test.go
+++ b/vendor/golang.org/x/text/internal/export/idna/idna_test.go
@@ -117,7 +117,7 @@ func TestLabelErrors(t *testing.T) {
f func(string) (string, error)
}
punyA := kind{"PunycodeA", punycode.ToASCII}
- resolve := kind{"ToASCII", Lookup.ToASCII}
+ resolve := kind{"ResolveA", Lookup.ToASCII}
display := kind{"ToUnicode", Display.ToUnicode}
p := New(VerifyDNSLength(true), MapForLookup(), BidiRule())
lengthU := kind{"CheckLengthU", p.ToUnicode}
@@ -145,16 +145,25 @@ func TestLabelErrors(t *testing.T) {
{display, "foo.xn--.bar", "foo..bar", ""},
{lengthA, "a..b", "a..b", "A4"},
- // Stripping leading empty labels here but not for "empty" punycode
- // above seems inconsistent, but seems to be applied by both the
- // conformance test and Chrome. Different interpretations would be
- // possible, though.
+ {punyA, ".b", ".b", ""},
+ // For backwards compatibility, the Punycode profile does not map runes.
+ {punyA, "\u3002b", "xn--b-83t", ""},
+ {punyA, "..b", "..b", ""},
+ // Only strip leading empty labels for certain profiles. Stripping
+ // leading empty labels here but not for "empty" punycode above seems
+ // inconsistent, but seems to be applied by both the conformance test
+ // and Chrome. So we turn it off by default, support it as an option,
+ // and enable it in profiles where it seems commonplace.
+ {lengthA, ".b", "b", ""},
+ {lengthA, "\u3002b", "b", ""},
{lengthA, "..b", "b", ""},
- {lengthA, "b..", "b..", ""}, // TODO: remove trailing dots?
+ {lengthA, "b..", "b..", ""},
{resolve, "a..b", "a..b", ""},
+ {resolve, ".b", "b", ""},
+ {resolve, "\u3002b", "b", ""},
{resolve, "..b", "b", ""},
- {resolve, "b..", "b..", ""}, // TODO: remove trailing dots?
+ {resolve, "b..", "b..", ""},
// Raw punycode
{punyA, "", "", ""},
diff --git a/vendor/golang.org/x/text/internal/number/decimal.go b/vendor/golang.org/x/text/internal/number/decimal.go
index 4e42ec785..f6828efd0 100644
--- a/vendor/golang.org/x/text/internal/number/decimal.go
+++ b/vendor/golang.org/x/text/internal/number/decimal.go
@@ -34,6 +34,8 @@ type RoundingContext struct {
Scale int32 // maximum number of decimals after the dot.
}
+const maxIntDigits = 20
+
// A Decimal represents floating point number represented in digits of the base
// in which a number is to be displayed. Digits represents a number [0, 1.0),
// and the absolute value represented by Decimal is Digits * 10^Exp.
@@ -53,7 +55,7 @@ type Decimal struct {
Inf bool // Takes precedence over Digits and Exp.
NaN bool // Takes precedence over Inf.
- buf [10]byte
+ buf [maxIntDigits]byte
}
// normalize retuns a new Decimal with leading and trailing zeros removed.
@@ -97,10 +99,9 @@ func (x *Decimal) String() string {
buf = append(buf, "Inf"...)
return string(buf)
}
- if len(x.Digits) == 0 {
- return "0"
- }
switch {
+ case len(x.Digits) == 0:
+ buf = append(buf, '0')
case x.Exp <= 0:
// 0.00ddd
buf = append(buf, "0."...)
@@ -273,29 +274,29 @@ func (d *Decimal) Convert(r *RoundingContext, number interface{}) {
d.clear()
f.Convert(d, r)
case float32:
- d.convertFloat64(r, float64(f), 32)
+ d.ConvertFloat(r, float64(f), 32)
case float64:
- d.convertFloat64(r, f, 64)
+ d.ConvertFloat(r, f, 64)
case int:
- d.convertInt(r, signed, uint64(f))
+ d.ConvertInt(r, signed, uint64(f))
case int8:
- d.convertInt(r, signed, uint64(f))
+ d.ConvertInt(r, signed, uint64(f))
case int16:
- d.convertInt(r, signed, uint64(f))
+ d.ConvertInt(r, signed, uint64(f))
case int32:
- d.convertInt(r, signed, uint64(f))
+ d.ConvertInt(r, signed, uint64(f))
case int64:
- d.convertInt(r, signed, uint64(f))
+ d.ConvertInt(r, signed, uint64(f))
case uint:
- d.convertInt(r, unsigned, uint64(f))
+ d.ConvertInt(r, unsigned, uint64(f))
case uint8:
- d.convertInt(r, unsigned, uint64(f))
+ d.ConvertInt(r, unsigned, uint64(f))
case uint16:
- d.convertInt(r, unsigned, uint64(f))
+ d.ConvertInt(r, unsigned, uint64(f))
case uint32:
- d.convertInt(r, unsigned, uint64(f))
+ d.ConvertInt(r, unsigned, uint64(f))
case uint64:
- d.convertInt(r, unsigned, f)
+ d.ConvertInt(r, unsigned, f)
// TODO:
// case string: if produced by strconv, allows for easy arbitrary pos.
@@ -308,13 +309,14 @@ func (d *Decimal) Convert(r *RoundingContext, number interface{}) {
}
}
-func (d *Decimal) convertInt(r *RoundingContext, signed bool, x uint64) {
+// ConvertInt converts an integer to decimals.
+func (d *Decimal) ConvertInt(r *RoundingContext, signed bool, x uint64) {
if r.Increment > 0 {
// TODO: if uint64 is too large, fall back to float64
if signed {
- d.convertFloat64(r, float64(int64(x)), 64)
+ d.ConvertFloat(r, float64(int64(x)), 64)
} else {
- d.convertFloat64(r, float64(x), 64)
+ d.ConvertFloat(r, float64(x), 64)
}
return
}
@@ -327,7 +329,8 @@ func (d *Decimal) convertInt(r *RoundingContext, signed bool, x uint64) {
d.Exp = int32(len(d.Digits))
}
-func (d *Decimal) convertFloat64(r *RoundingContext, x float64, size int) {
+// ConvertFloat converts a floating point number to decimals.
+func (d *Decimal) ConvertFloat(r *RoundingContext, x float64, size int) {
d.clear()
if math.IsNaN(x) {
d.NaN = true
@@ -343,7 +346,7 @@ func (d *Decimal) convertFloat64(r *RoundingContext, x float64, size int) {
return
}
// Simple case: decimal notation
- if r.Scale > 0 || r.Increment > 0 && r.Scale == 0 {
+ if r.Scale > 0 || r.Increment > 0 || r.Precision == 0 {
if int(r.Scale) > len(scales) {
x *= math.Pow(10, float64(r.Scale))
} else {
@@ -368,6 +371,7 @@ func (d *Decimal) convertFloat64(r *RoundingContext, x float64, size int) {
// TODO: expose functionality in strconv so we can avoid this hack.
// Something like this would work:
// AppendDigits(dst []byte, x float64, base, size, prec int) (digits []byte, exp, accuracy int)
+ // TODO: This only supports the nearest even rounding mode.
prec := int(r.Precision)
if prec > 0 {
@@ -401,11 +405,10 @@ func (d *Decimal) convertFloat64(r *RoundingContext, x float64, size int) {
}
func (d *Decimal) fillIntDigits(x uint64) {
- const maxUintDigits = 10
- if cap(d.Digits) < maxUintDigits {
+ if cap(d.Digits) < maxIntDigits {
d.Digits = d.buf[:]
} else {
- d.Digits = d.buf[:maxUintDigits]
+ d.Digits = d.buf[:maxIntDigits]
}
i := 0
for ; x > 0; x /= 10 {
diff --git a/vendor/golang.org/x/text/internal/number/decimal_test.go b/vendor/golang.org/x/text/internal/number/decimal_test.go
index b99fedc40..5c8170049 100644
--- a/vendor/golang.org/x/text/internal/number/decimal_test.go
+++ b/vendor/golang.org/x/text/internal/number/decimal_test.go
@@ -195,13 +195,10 @@ func TestRounding(t *testing.T) {
negModes := tc.modes
negModes[1], negModes[6] = negModes[6], negModes[1]
for i, res := range negModes {
- if res != "0" {
- negModes[i] = "-" + res
- }
+ negModes[i] = "-" + res
}
-
for i, m := range modes {
- t.Run(fmt.Sprintf("v:%s/n:%d/%s", tc.x, tc.n, m), func(t *testing.T) {
+ t.Run(fmt.Sprintf("x:%s/n:%d/%s", tc.x, tc.n, m), func(t *testing.T) {
d := mkdec(tc.x)
d.round(m, tc.n)
if got := d.String(); got != tc.modes[i] {
@@ -224,9 +221,7 @@ func TestRounding(t *testing.T) {
t.Errorf("neg decimal: got %q; want %q", d.String(), want)
}
- if f = mkfloat(tc.x); f != 0 {
- f = -f // avoid creating -0.0
- }
+ f = -mkfloat(tc.x)
f = m.roundFloat(f/mult) * mult
if got := fmt.Sprintf("%.0f", f); got != negModes[i] {
t.Errorf("neg float: got %q; want %q", got, negModes[i])
@@ -257,6 +252,8 @@ func TestConvert(t *testing.T) {
{uint32(234), scale2, "234"},
{uint64(234), scale2, "234"},
{uint(234), scale2, "234"},
+ {-0.001, scale2, "-0"},
+ {-1e9, scale2, "-1000000000.00"},
{0.234, scale2, "0.23"},
{0.234, scale2away, "0.24"},
{0.1234, prec3, "0.123"},
diff --git a/vendor/golang.org/x/text/internal/number/format.go b/vendor/golang.org/x/text/internal/number/format.go
index 84903fad8..70ddf7df1 100755
--- a/vendor/golang.org/x/text/internal/number/format.go
+++ b/vendor/golang.org/x/text/internal/number/format.go
@@ -6,41 +6,136 @@ package number
import (
"strconv"
+ "unicode/utf8"
"golang.org/x/text/language"
)
// TODO:
-// - public (but internal) API for creating formatters
-// - split out the logic that computes the visible digits from the rest of the
-// formatting code (needed for plural).
// - grouping of fractions
-// - reuse percent pattern for permille
-// - padding
+// - allow user-defined superscript notation (such as <sup>4</sup>)
+// - same for non-breaking spaces, like &nbsp;
+
+// Formatting proceeds along the following lines:
+// 0) Compose rounding information from format and context.
+// 1) Convert a number into a Decimal.
+// 2) Sanitize Decimal by adding trailing zeros, removing leading digits, and
+// (non-increment) rounding. The Decimal that results from this is suitable
+// for determining the plural form.
+// 3) Render the Decimal in the localized form.
// Formatter contains all the information needed to render a number.
type Formatter struct {
- *Pattern
+ Pattern
Info
RoundingContext
- f func(dst []byte, f *Formatter, d *Decimal) []byte
}
-func lookupFormat(t language.Tag, tagToIndex []uint8) *Pattern {
+func (f *Formatter) init(t language.Tag, index []uint8) {
+ f.Info = InfoFromTag(t)
for ; ; t = t.Parent() {
if ci, ok := language.CompactIndex(t); ok {
- return &formats[tagToIndex[ci]]
+ f.Pattern = formats[index[ci]]
+ break
}
}
}
+// InitPattern initializes a Formatter for the given Pattern.
+func (f *Formatter) InitPattern(t language.Tag, pat *Pattern) {
+ f.Info = InfoFromTag(t)
+ f.Pattern = *pat
+}
+
+// InitDecimal initializes a Formatter using the default Pattern for the given
+// language.
+func (f *Formatter) InitDecimal(t language.Tag) {
+ f.init(t, tagToDecimal)
+}
+
+// InitScientific initializes a Formatter using the default Pattern for the
+// given language.
+func (f *Formatter) InitScientific(t language.Tag) {
+ f.init(t, tagToScientific)
+}
+
+// InitEngineering initializes a Formatter using the default Pattern for the
+// given language.
+func (f *Formatter) InitEngineering(t language.Tag) {
+ f.init(t, tagToScientific)
+ f.Pattern.MaxIntegerDigits = 3
+ f.Pattern.MinIntegerDigits = 1
+}
+
+// InitPercent initializes a Formatter using the default Pattern for the given
+// language.
+func (f *Formatter) InitPercent(t language.Tag) {
+ f.init(t, tagToPercent)
+}
+
+// InitPerMille initializes a Formatter using the default Pattern for the given
+// language.
+func (f *Formatter) InitPerMille(t language.Tag) {
+ f.init(t, tagToPercent)
+ f.Pattern.DigitShift = 3
+}
+
+func (f *Formatter) Append(dst []byte, x interface{}) []byte {
+ var d Decimal
+ d.Convert(&f.RoundingContext, x)
+ return f.Format(dst, &d)
+}
+
func (f *Formatter) Format(dst []byte, d *Decimal) []byte {
- return f.f(dst, f, d)
+ var result []byte
+ var postPrefix, preSuffix int
+ if f.MinExponentDigits > 0 {
+ result, postPrefix, preSuffix = appendScientific(dst, f, d)
+ } else {
+ result, postPrefix, preSuffix = appendDecimal(dst, f, d)
+ }
+ if f.PadRune == 0 {
+ return result
+ }
+ width := int(f.FormatWidth)
+ if count := utf8.RuneCount(result); count < width {
+ insertPos := 0
+ switch f.Flags & PadMask {
+ case PadAfterPrefix:
+ insertPos = postPrefix
+ case PadBeforeSuffix:
+ insertPos = preSuffix
+ case PadAfterSuffix:
+ insertPos = len(result)
+ }
+ num := width - count
+ pad := [utf8.UTFMax]byte{' '}
+ sz := 1
+ if r := f.PadRune; r != 0 {
+ sz = utf8.EncodeRune(pad[:], r)
+ }
+ extra := sz * num
+ if n := len(result) + extra; n < cap(result) {
+ result = result[:n]
+ copy(result[insertPos+extra:], result[insertPos:])
+ } else {
+ buf := make([]byte, n)
+ copy(buf, result[:insertPos])
+ copy(buf[insertPos+extra:], result[insertPos:])
+ result = buf
+ }
+ for ; num > 0; num-- {
+ insertPos += copy(result[insertPos:], pad[:sz])
+ }
+ }
+ return result
}
-func appendDecimal(dst []byte, f *Formatter, d *Decimal) []byte {
+// appendDecimal appends a formatted number to dst. It returns two possible
+// insertion points for padding.
+func appendDecimal(dst []byte, f *Formatter, d *Decimal) (b []byte, postPre, preSuf int) {
if dst, ok := f.renderSpecial(dst, d); ok {
- return dst
+ return dst, 0, len(dst)
}
n := d.normalize()
if maxSig := int(f.MaxSignificantDigits); maxSig > 0 {
@@ -48,6 +143,7 @@ func appendDecimal(dst []byte, f *Formatter, d *Decimal) []byte {
}
digits := n.Digits
exp := n.Exp
+ exp += int32(f.Pattern.DigitShift)
// Split in integer and fraction part.
var intDigits, fracDigits []byte
@@ -94,7 +190,7 @@ func appendDecimal(dst []byte, f *Formatter, d *Decimal) []byte {
}
}
- neg := d.Neg && numInt+numFrac > 0
+ neg := d.Neg
affix, suffix := f.getAffixes(neg)
dst = appendAffix(dst, f, affix, neg)
savedLen := len(dst)
@@ -104,9 +200,9 @@ func appendDecimal(dst []byte, f *Formatter, d *Decimal) []byte {
minInt = 1
}
// add leading zeros
- for i := numInt; i < minInt; i++ {
+ for i := minInt; i > numInt; i-- {
dst = f.AppendDigit(dst, 0)
- if f.needsSep(minInt - i) {
+ if f.needsSep(i) {
dst = append(dst, f.Symbol(SymGroup)...)
}
}
@@ -142,18 +238,14 @@ func appendDecimal(dst []byte, f *Formatter, d *Decimal) []byte {
for ; trailZero > 0; trailZero-- {
dst = f.AppendDigit(dst, 0)
}
- // Ensure that at least one digit is written no matter what. This makes
- // things more robust, even though a pattern should always require at least
- // one fraction or integer digit.
- if len(dst) == savedLen {
- dst = f.AppendDigit(dst, 0)
- }
- return appendAffix(dst, f, suffix, neg)
+ return appendAffix(dst, f, suffix, neg), savedLen, len(dst)
}
-func appendScientific(dst []byte, f *Formatter, d *Decimal) []byte {
+// appendScientific appends a formatted number to dst. It returns two possible
+// insertion points for padding.
+func appendScientific(dst []byte, f *Formatter, d *Decimal) (b []byte, postPre, preSuf int) {
if dst, ok := f.renderSpecial(dst, d); ok {
- return dst
+ return dst, 0, 0
}
// Significant digits are transformed by parser for scientific notation and
// do not need to be handled here.
@@ -197,7 +289,7 @@ func appendScientific(dst []byte, f *Formatter, d *Decimal) []byte {
} else {
intDigits = digits
}
- neg := d.Neg && len(digits) > 0
+ neg := d.Neg
affix, suffix := f.getAffixes(neg)
dst = appendAffix(dst, f, affix, neg)
savedLen := len(dst)
@@ -227,33 +319,73 @@ func appendScientific(dst []byte, f *Formatter, d *Decimal) []byte {
for ; trailZero > 0; trailZero-- {
dst = f.AppendDigit(dst, 0)
}
- // Ensure that at least one digit is written no matter what. This makes
- // things more robust, even though a pattern should always require at least
- // one fraction or integer digit.
- if len(dst) == savedLen {
- dst = f.AppendDigit(dst, 0)
- }
// exp
- dst = append(dst, f.Symbol(SymExponential)...)
- switch {
- case exp < 0:
- dst = append(dst, f.Symbol(SymMinusSign)...)
- exp = -exp
- case f.Flags&AlwaysExpSign != 0:
- dst = append(dst, f.Symbol(SymPlusSign)...)
- }
buf := [12]byte{}
- b := strconv.AppendUint(buf[:0], uint64(exp), 10)
- for i := len(b); i < int(f.MinExponentDigits); i++ {
+ // TODO: use exponential if superscripting is not available (no Latin
+ // numbers or no tags) and use exponential in all other cases.
+ exponential := f.Symbol(SymExponential)
+ if exponential == "E" {
+ dst = append(dst, "\u202f"...) // NARROW NO-BREAK SPACE
+ dst = append(dst, f.Symbol(SymSuperscriptingExponent)...)
+ dst = append(dst, "\u202f"...) // NARROW NO-BREAK SPACE
+ dst = f.AppendDigit(dst, 1)
dst = f.AppendDigit(dst, 0)
+ switch {
+ case exp < 0:
+ dst = append(dst, superMinus...)
+ exp = -exp
+ case f.Flags&AlwaysExpSign != 0:
+ dst = append(dst, superPlus...)
+ }
+ b = strconv.AppendUint(buf[:0], uint64(exp), 10)
+ for i := len(b); i < int(f.MinExponentDigits); i++ {
+ dst = append(dst, superDigits[0]...)
+ }
+ for _, c := range b {
+ dst = append(dst, superDigits[c-'0']...)
+ }
+ } else {
+ dst = append(dst, exponential...)
+ switch {
+ case exp < 0:
+ dst = append(dst, f.Symbol(SymMinusSign)...)
+ exp = -exp
+ case f.Flags&AlwaysExpSign != 0:
+ dst = append(dst, f.Symbol(SymPlusSign)...)
+ }
+ b = strconv.AppendUint(buf[:0], uint64(exp), 10)
+ for i := len(b); i < int(f.MinExponentDigits); i++ {
+ dst = f.AppendDigit(dst, 0)
+ }
+ for _, c := range b {
+ dst = f.AppendDigit(dst, c-'0')
+ }
}
- for _, c := range b {
- dst = f.AppendDigit(dst, c-'0')
- }
- return appendAffix(dst, f, suffix, neg)
+ return appendAffix(dst, f, suffix, neg), savedLen, len(dst)
}
+const (
+ superMinus = "\u207B" // SUPERSCRIPT HYPHEN-MINUS
+ superPlus = "\u207A" // SUPERSCRIPT PLUS SIGN
+)
+
+var (
+ // Note: the digits are not sequential!!!
+ superDigits = []string{
+ "\u2070", // SUPERSCRIPT DIGIT ZERO
+ "\u00B9", // SUPERSCRIPT DIGIT ONE
+ "\u00B2", // SUPERSCRIPT DIGIT TWO
+ "\u00B3", // SUPERSCRIPT DIGIT THREE
+ "\u2074", // SUPERSCRIPT DIGIT FOUR
+ "\u2075", // SUPERSCRIPT DIGIT FIVE
+ "\u2076", // SUPERSCRIPT DIGIT SIX
+ "\u2077", // SUPERSCRIPT DIGIT SEVEN
+ "\u2078", // SUPERSCRIPT DIGIT EIGHT
+ "\u2079", // SUPERSCRIPT DIGIT NINE
+ }
+)
+
func (f *Formatter) getAffixes(neg bool) (affix, suffix string) {
str := f.Affix
if str != "" {
@@ -267,8 +399,11 @@ func (f *Formatter) getAffixes(neg bool) (affix, suffix string) {
sufStart := 1 + str[0]
affix = str[1:sufStart]
suffix = str[sufStart+1:]
- } else if neg {
- affix = "-"
+ }
+ // TODO: introduce a NeedNeg sign to indicate if the left pattern already
+ // has a sign marked?
+ if f.NegOffset == 0 && (neg || f.Flags&AlwaysSign != 0) {
+ affix = "-" + affix
}
return affix, suffix
}
@@ -288,10 +423,11 @@ func fmtNaN(dst []byte, f *Formatter) []byte {
}
func fmtInfinite(dst []byte, f *Formatter, d *Decimal) []byte {
- if d.Neg {
- dst = append(dst, f.Symbol(SymMinusSign)...)
- }
- return append(dst, f.Symbol(SymInfinity)...)
+ affix, suffix := f.getAffixes(d.Neg)
+ dst = appendAffix(dst, f, affix, d.Neg)
+ dst = append(dst, f.Symbol(SymInfinity)...)
+ dst = appendAffix(dst, f, suffix, d.Neg)
+ return dst
}
func appendAffix(dst []byte, f *Formatter, affix string, neg bool) []byte {
@@ -307,11 +443,21 @@ func appendAffix(dst []byte, f *Formatter, affix string, neg bool) []byte {
escaping = true
case r == '\'':
quoting = !quoting
- case !quoting && (r == '-' || r == '+'):
+ case quoting:
+ dst = append(dst, string(r)...)
+ case r == '%':
+ if f.DigitShift == 3 {
+ dst = append(dst, f.Symbol(SymPerMille)...)
+ } else {
+ dst = append(dst, f.Symbol(SymPercentSign)...)
+ }
+ case r == '-' || r == '+':
if neg {
dst = append(dst, f.Symbol(SymMinusSign)...)
- } else {
+ } else if f.Flags&ElideSign == 0 {
dst = append(dst, f.Symbol(SymPlusSign)...)
+ } else {
+ dst = append(dst, ' ')
}
default:
dst = append(dst, string(r)...)
diff --git a/vendor/golang.org/x/text/internal/number/format_test.go b/vendor/golang.org/x/text/internal/number/format_test.go
index 355a33a70..4c47bc568 100755
--- a/vendor/golang.org/x/text/internal/number/format_test.go
+++ b/vendor/golang.org/x/text/internal/number/format_test.go
@@ -7,7 +7,6 @@ package number
import (
"fmt"
"log"
- "strings"
"testing"
"golang.org/x/text/language"
@@ -37,7 +36,7 @@ func TestAppendDecimal(t *testing.T) {
"-Inf": "-∞",
},
}, {
- pattern: "+0",
+ pattern: "+0;+0",
test: pairs{
"0": "+0",
"1": "+1",
@@ -48,9 +47,10 @@ func TestAppendDecimal(t *testing.T) {
"1.2": "+1",
"NaN": "NaN",
"-Inf": "-∞",
+ "Inf": "+∞",
},
}, {
- pattern: "0 +",
+ pattern: "0 +;0 +",
test: pairs{
"0": "0 +",
"1": "1 +",
@@ -60,7 +60,10 @@ func TestAppendDecimal(t *testing.T) {
}, {
pattern: "0;0-",
test: pairs{
- "-1": "1-",
+ "-1": "1-",
+ "NaN": "NaN",
+ "-Inf": "∞-",
+ "Inf": "∞",
},
}, {
pattern: "0000",
@@ -149,20 +152,28 @@ func TestAppendDecimal(t *testing.T) {
"123456789012": "1,23,45,67,89,012",
"0.123456789": "0.123",
},
+ }, {
+ pattern: "0,00,000.###",
+ test: pairs{
+ "0": "0,00,000",
+ "123456789012": "1,23,45,67,89,012",
+ "12.3456789": "0,00,012.345",
+ "0.123456789": "0,00,000.123",
+ },
// Support for ill-formed patterns.
}, {
pattern: "#",
test: pairs{
- ".00": "0",
- "0": "0",
+ ".00": "", // This is the behavior of fmt.
+ "0": "", // This is the behavior of fmt.
"1": "1",
"10.": "10",
},
}, {
pattern: ".#",
test: pairs{
- "0": "0",
+ "0": "", // This is the behavior of fmt.
"1": "1",
"1.2": "1.2",
"1.2345": "1.2",
@@ -252,57 +263,174 @@ func TestAppendDecimal(t *testing.T) {
}, {
pattern: "#E0",
test: pairs{
- "0": "0E0",
- "1": "1E0",
- "123.456": "1E2",
+ "0": "0\u202f×\u202f10⁰",
+ "1": "1\u202f×\u202f10⁰",
+ "123.456": "1\u202f×\u202f10²",
},
}, {
pattern: "#E+0",
test: pairs{
- "0": "0E+0",
- "1000": "1E+3",
- "1E100": "1E+100",
- "1E-100": "1E-100",
+ "0": "0\u202f×\u202f10⁺⁰",
+ "1000": "1\u202f×\u202f10⁺³",
+ "1E100": "1\u202f×\u202f10⁺¹⁰⁰",
+ "1E-100": "1\u202f×\u202f10⁻¹⁰⁰",
"NaN": "NaN",
"-Inf": "-∞",
},
}, {
pattern: "##0E00",
test: pairs{
- "100": "100E00",
- "12345": "10E03",
- "123.456": "100E00",
+ "100": "100\u202f×\u202f10⁰⁰",
+ "12345": "10\u202f×\u202f10⁰³",
+ "123.456": "100\u202f×\u202f10⁰⁰",
},
}, {
pattern: "##0.###E00",
test: pairs{
- "100": "100E00",
- "12345": "12.34E03",
- "123.456": "123.4E00",
+ "100": "100\u202f×\u202f10⁰⁰",
+ "12345": "12.34\u202f×\u202f10⁰³",
+ "123.456": "123.4\u202f×\u202f10⁰⁰",
},
}, {
pattern: "##0.000E00",
test: pairs{
- "100": "100.0E00",
- "12345": "12.34E03",
- "123.456": "123.4E00",
+ "100": "100.0\u202f×\u202f10⁰⁰",
+ "12345": "12.34\u202f×\u202f10⁰³",
+ "123.456": "123.4\u202f×\u202f10⁰⁰",
+ },
+ }, {
+ pattern: "@@E0",
+ test: pairs{
+ "0": "0.0\u202f×\u202f10⁰",
+ "99": "9.9\u202f×\u202f10¹",
+ "0.99": "9.9\u202f×\u202f10⁻¹",
+ },
+ }, {
+ pattern: "@###E00",
+ test: pairs{
+ "0": "0\u202f×\u202f10⁰⁰",
+ "1": "1\u202f×\u202f10⁰⁰",
+ "11": "1.1\u202f×\u202f10⁰¹",
+ "111": "1.11\u202f×\u202f10⁰²",
+ "1111": "1.111\u202f×\u202f10⁰³",
+ "11111": "1.111\u202f×\u202f10⁰⁴",
+ "0.1": "1\u202f×\u202f10⁻⁰¹",
+ "0.11": "1.1\u202f×\u202f10⁻⁰¹",
+ "0.001": "1\u202f×\u202f10⁻⁰³",
+ },
+ }, {
+ pattern: "*x##0",
+ test: pairs{
+ "0": "xx0",
+ "10": "x10",
+ "100": "100",
+ "1000": "1000",
+ },
+ }, {
+ pattern: "##0*x",
+ test: pairs{
+ "0": "0xx",
+ "10": "10x",
+ "100": "100",
+ "1000": "1000",
+ },
+ }, {
+ pattern: "* ###0.000",
+ test: pairs{
+ "0": " 0.000",
+ "123": " 123.000",
+ "123.456": " 123.456",
+ "1234.567": "1234.567",
+ },
+ }, {
+ pattern: "**0.0#######E00",
+ test: pairs{
+ "0": "***0.0\u202f×\u202f10⁰⁰",
+ "10": "***1.0\u202f×\u202f10⁰¹",
+ "11": "***1.1\u202f×\u202f10⁰¹",
+ "111": "**1.11\u202f×\u202f10⁰²",
+ "1111": "*1.111\u202f×\u202f10⁰³",
+ "11111": "1.1111\u202f×\u202f10⁰⁴",
+ "11110": "*1.111\u202f×\u202f10⁰⁴",
+ "11100": "**1.11\u202f×\u202f10⁰⁴",
+ "11000": "***1.1\u202f×\u202f10⁰⁴",
+ "10000": "***1.0\u202f×\u202f10⁰⁴",
+ },
+ }, {
+ pattern: "*xpre0suf",
+ test: pairs{
+ "0": "pre0suf",
+ "10": "pre10suf",
+ },
+ }, {
+ pattern: "*∞ pre ###0 suf",
+ test: pairs{
+ "0": "∞∞∞ pre 0 suf",
+ "10": "∞∞ pre 10 suf",
+ "100": "∞ pre 100 suf",
+ "1000": " pre 1000 suf",
+ },
+ }, {
+ pattern: "pre *∞###0 suf",
+ test: pairs{
+ "0": "pre ∞∞∞0 suf",
+ "10": "pre ∞∞10 suf",
+ "100": "pre ∞100 suf",
+ "1000": "pre 1000 suf",
+ },
+ }, {
+ pattern: "pre ###0*∞ suf",
+ test: pairs{
+ "0": "pre 0∞∞∞ suf",
+ "10": "pre 10∞∞ suf",
+ "100": "pre 100∞ suf",
+ "1000": "pre 1000 suf",
+ },
+ }, {
+ pattern: "pre ###0 suf *∞",
+ test: pairs{
+ "0": "pre 0 suf ∞∞∞",
+ "10": "pre 10 suf ∞∞",
+ "100": "pre 100 suf ∞",
+ "1000": "pre 1000 suf ",
+ },
+ }, {
+ // Take width of positive pattern.
+ pattern: "**###0;**-#####0x",
+ test: pairs{
+ "0": "***0",
+ "-1": "*-1x",
+ },
+ }, {
+ pattern: "0.00%",
+ test: pairs{
+ "0.1": "10.00%",
+ },
+ }, {
+ pattern: "0.##%",
+ test: pairs{
+ "0.1": "10%",
+ "0.11": "11%",
+ "0.111": "11.1%",
+ "0.1111": "11.11%",
+ "0.11111": "11.11%",
+ },
+ }, {
+ pattern: "‰ 0.0#",
+ test: pairs{
+ "0.1": "‰ 100.0",
+ "0.11": "‰ 110.0",
+ "0.111": "‰ 111.0",
+ "0.1111": "‰ 111.1",
+ "0.11111": "‰ 111.11",
+ "0.111111": "‰ 111.11",
},
}}
// TODO:
- // "@@E0",
- // "@###E00",
- // "0.0%",
- // "0.0‰",
// "#,##0.00¤",
// "#,##0.00 ¤;(#,##0.00 ¤)",
- // // padding
- // "*x#",
- // "#*x",
- // "*xpre#suf",
- // "pre*x#suf",
- // "pre#*xsuf",
- // "pre#suf*x",
+
for _, tc := range testCases {
pat := tc.pat
if pat == nil {
@@ -311,22 +439,15 @@ func TestAppendDecimal(t *testing.T) {
log.Fatal(err)
}
}
- f := &Formatter{
- pat,
- InfoFromTag(language.English),
- RoundingContext{},
- appendDecimal,
- }
- if strings.IndexByte(tc.pattern, 'E') != -1 {
- f.f = appendScientific
- }
+ var f Formatter
+ f.InitPattern(language.English, pat)
for dec, want := range tc.test {
buf := make([]byte, 100)
t.Run(tc.pattern+"/"+dec, func(t *testing.T) {
dec := mkdec(dec)
buf = f.Format(buf[:0], &dec)
if got := string(buf); got != want {
- t.Errorf("\n got %q\nwant %q", got, want)
+ t.Errorf("\n got %[1]q (%[1]s)\nwant %[2]q (%[2]s)", got, want)
}
})
}
@@ -341,22 +462,46 @@ func TestLocales(t *testing.T) {
}{
{language.Make("en"), "123456.78", "123,456.78"},
{language.Make("de"), "123456.78", "123.456,78"},
- {language.Make("de-CH"), "123456.78", "123'456.78"},
+ {language.Make("de-CH"), "123456.78", "123’456.78"},
{language.Make("fr"), "123456.78", "123 456,78"},
{language.Make("bn"), "123456.78", "১,২৩,৪৫৬.৭৮"},
}
for _, tc := range testCases {
t.Run(fmt.Sprint(tc.tag, "/", tc.num), func(t *testing.T) {
- f := &Formatter{
- lookupFormat(tc.tag, tagToDecimal),
- InfoFromTag(tc.tag),
- RoundingContext{},
- appendDecimal,
+ var f Formatter
+ f.InitDecimal(tc.tag)
+ d := mkdec(tc.num)
+ b := f.Format(nil, &d)
+ if got := string(b); got != tc.want {
+ t.Errorf("got %[1]q (%[1]s); want %[2]q (%[2]s)", got, tc.want)
}
+ })
+ }
+}
+
+func TestFormatters(t *testing.T) {
+ var f Formatter
+ testCases := []struct {
+ init func(t language.Tag)
+ num string
+ want string
+ }{
+ {f.InitDecimal, "123456.78", "123,456.78"},
+ {f.InitScientific, "123456.78", "1.23\u202f×\u202f10⁵"},
+ {f.InitEngineering, "123456.78", "123\u202f×\u202f10³"},
+
+ {f.InitPercent, "0.1234", "12.34%"},
+ {f.InitPerMille, "0.1234", "123.40‰"},
+ }
+ for i, tc := range testCases {
+ t.Run(fmt.Sprint(i, "/", tc.num), func(t *testing.T) {
+ tc.init(language.English)
+ f.Pattern.MinFractionDigits = 2
+ f.Pattern.MaxFractionDigits = 2
d := mkdec(tc.num)
b := f.Format(nil, &d)
if got := string(b); got != tc.want {
- t.Errorf("got %q; want %q", got, tc.want)
+ t.Errorf("got %[1]q (%[1]s); want %[2]q (%[2]s)", got, tc.want)
}
})
}
diff --git a/vendor/golang.org/x/text/internal/number/number_test.go b/vendor/golang.org/x/text/internal/number/number_test.go
index 3eb533914..8717ead72 100644
--- a/vendor/golang.org/x/text/internal/number/number_test.go
+++ b/vendor/golang.org/x/text/internal/number/number_test.go
@@ -27,9 +27,9 @@ func TestInfo(t *testing.T) {
// U+096F DEVANAGARI DIGIT NINE ('९')
{"de-BE-u-nu-deva", SymGroup, ".", '\u096f'}, // miss -> latn -> de
{"de-Cyrl-BE", SymGroup, ",", '9'}, // inherits from root
- {"de-CH", SymGroup, "'", '9'}, // overrides values in de
- {"de-CH-oxendict", SymGroup, "'", '9'}, // inherits from de-CH (no compact index)
- {"de-CH-u-nu-deva", SymGroup, "'", '\u096f'}, // miss -> latn -> de-CH
+ {"de-CH", SymGroup, "’", '9'}, // overrides values in de
+ {"de-CH-oxendict", SymGroup, "’", '9'}, // inherits from de-CH (no compact index)
+ {"de-CH-u-nu-deva", SymGroup, "’", '\u096f'}, // miss -> latn -> de-CH
{"pa", SymExponential, "E", '9'},
diff --git a/vendor/golang.org/x/text/internal/number/pattern.go b/vendor/golang.org/x/text/internal/number/pattern.go
index 5610c6026..ef7f087fe 100644
--- a/vendor/golang.org/x/text/internal/number/pattern.go
+++ b/vendor/golang.org/x/text/internal/number/pattern.go
@@ -46,16 +46,17 @@ type Pattern struct {
Offset uint16 // Offset into Affix for prefix and suffix
NegOffset uint16 // Offset into Affix for negative prefix and suffix or 0.
- Multiplier uint32
+ FormatWidth uint16
+
RoundIncrement uint32 // Use Min*Digits to determine scale
PadRune rune
-
- FormatWidth uint16
+ DigitShift uint8 // Number of decimals to shift. Used for % and ‰.
GroupingSize [2]uint8
Flags PatternFlag
// Number of digits.
+ // TODO: consider using uint32
MinIntegerDigits uint8
MaxIntegerDigits uint8
MinFractionDigits uint8
@@ -90,6 +91,7 @@ type PatternFlag uint8
const (
AlwaysSign PatternFlag = 1 << iota
+ ElideSign // Use space instead of plus sign. AlwaysSign must be true.
AlwaysExpSign
AlwaysDecimalSeparator
ParenthesisForNegative // Common pattern. Saves space.
@@ -247,26 +249,41 @@ func (p *parser) affix(r rune) state {
'#', '@', '.', '*', ',', ';':
return nil
case '\'':
- return p.escape
+ p.FormatWidth--
+ return p.escapeFirst
case '%':
- if p.Multiplier != 0 {
+ if p.DigitShift != 0 {
p.setError(errDuplicatePercentSign)
}
- p.Multiplier = 100
+ p.DigitShift = 2
case '\u2030': // ‰ Per mille
- if p.Multiplier != 0 {
+ if p.DigitShift != 0 {
p.setError(errDuplicatePermilleSign)
}
- p.Multiplier = 1000
+ p.DigitShift = 3
// TODO: handle currency somehow: ¤, ¤¤, ¤¤¤, ¤¤¤¤
}
p.buf = append(p.buf, string(r)...)
return p.affix
}
+func (p *parser) escapeFirst(r rune) state {
+ switch r {
+ case '\'':
+ p.buf = append(p.buf, "\\'"...)
+ return p.affix
+ default:
+ p.buf = append(p.buf, '\'')
+ p.buf = append(p.buf, string(r)...)
+ }
+ return p.escape
+}
+
func (p *parser) escape(r rune) state {
switch r {
case '\'':
+ p.FormatWidth--
+ p.buf = append(p.buf, '\'')
return p.affix
default:
p.buf = append(p.buf, string(r)...)
diff --git a/vendor/golang.org/x/text/internal/number/pattern_test.go b/vendor/golang.org/x/text/internal/number/pattern_test.go
index 6adeaf7cc..97ff64d55 100644
--- a/vendor/golang.org/x/text/internal/number/pattern_test.go
+++ b/vendor/golang.org/x/text/internal/number/pattern_test.go
@@ -114,6 +114,11 @@ var testCases = []struct {
MinExponentDigits: 1,
},
}, {
+ // At least one exponent digit is required. As long as this is true, one can
+ // determine that scientific rendering is needed if MinExponentDigits > 0.
+ "#E#",
+ nil,
+}, {
"0E0",
&Pattern{
FormatWidth: 3,
@@ -230,7 +235,7 @@ var testCases = []struct {
"0.0%",
&Pattern{
Affix: "\x00\x01%",
- Multiplier: 100,
+ DigitShift: 2,
FormatWidth: 4,
MinIntegerDigits: 1,
MinFractionDigits: 1,
@@ -240,7 +245,7 @@ var testCases = []struct {
"0.0‰",
&Pattern{
Affix: "\x00\x03‰",
- Multiplier: 1000,
+ DigitShift: 3,
FormatWidth: 4,
MinIntegerDigits: 1,
MinFractionDigits: 1,
@@ -260,7 +265,7 @@ var testCases = []struct {
"#,##0.00 ¤;(#,##0.00 ¤)",
&Pattern{Affix: "\x00\x04\u00a0¤\x01(\x05\u00a0¤)",
NegOffset: 6,
- Multiplier: 0,
+ DigitShift: 0,
FormatWidth: 10,
GroupingSize: [2]uint8{3, 0},
MinIntegerDigits: 1,
@@ -314,6 +319,19 @@ var testCases = []struct {
Flags: PadAfterSuffix,
},
}, {
+ `* #0 o''clock`,
+ &Pattern{Affix: "\x00\x09 o\\'clock",
+ FormatWidth: 10,
+ PadRune: 32,
+ MinIntegerDigits: 0x1},
+}, {
+ `'123'* #0'456'`,
+ &Pattern{Affix: "\x05'123'\x05'456'",
+ FormatWidth: 8,
+ PadRune: 32,
+ MinIntegerDigits: 0x1,
+ Flags: PadAfterPrefix},
+}, {
// no duplicate padding
"*xpre#suf*x", nil,
}, {
diff --git a/vendor/golang.org/x/text/internal/number/tables.go b/vendor/golang.org/x/text/internal/number/tables.go
index 10baa0a1d..b08acc48c 100644
--- a/vendor/golang.org/x/text/internal/number/tables.go
+++ b/vendor/golang.org/x/text/internal/number/tables.go
@@ -5,7 +5,7 @@ package number
import "golang.org/x/text/internal/stringset"
// CLDRVersion is the CLDR version from which the tables in this package are derived.
-const CLDRVersion = "30"
+const CLDRVersion = "31"
var numSysData = []systemData{ // 58 elements
0: {id: 0x0, digitSize: 0x1, zero: [4]uint8{0x30, 0x0, 0x0, 0x0}},
@@ -255,82 +255,81 @@ var symIndex = [][12]uint8{ // 71 elements
22: [12]uint8{0x0, 0x1, 0x2, 0x3, 0xe, 0x1c, 0x6, 0x7, 0x8, 0x9, 0x1d, 0xb},
23: [12]uint8{0x1, 0xc, 0x2, 0x3, 0x4, 0x1b, 0x6, 0x7, 0x8, 0x9, 0x1e, 0x0},
24: [12]uint8{0x1, 0x0, 0x2, 0x3, 0x4, 0x1b, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb},
- 25: [12]uint8{0x0, 0x1f, 0x2, 0x3, 0x4, 0x1b, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb},
+ 25: [12]uint8{0x0, 0x15, 0x2, 0x3, 0x4, 0x1b, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb},
26: [12]uint8{0x0, 0x1, 0x2, 0x3, 0xe, 0xf, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb},
- 27: [12]uint8{0x1, 0xc, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x20, 0xb},
+ 27: [12]uint8{0x1, 0xc, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x1f, 0xb},
28: [12]uint8{0x0, 0x15, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb},
- 29: [12]uint8{0x1, 0xc, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x21, 0xb},
- 30: [12]uint8{0x1, 0xc, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x22, 0xb},
- 31: [12]uint8{0x1, 0x0, 0x2, 0x3, 0x4, 0x1b, 0x18, 0x13, 0x8, 0x9, 0x23, 0xb},
- 32: [12]uint8{0x1, 0xc, 0x2, 0x3, 0x4, 0x1b, 0x18, 0x7, 0x8, 0x9, 0x23, 0xb},
- 33: [12]uint8{0x1, 0xc, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x24, 0xb},
- 34: [12]uint8{0x1, 0x0, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x25, 0xb},
- 35: [12]uint8{0x1, 0xc, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x26, 0xb},
- 36: [12]uint8{0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x27, 0xb},
- 37: [12]uint8{0x1, 0xc, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x28, 0xb},
+ 29: [12]uint8{0x1, 0xc, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x20, 0xb},
+ 30: [12]uint8{0x1, 0xc, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x21, 0xb},
+ 31: [12]uint8{0x1, 0x0, 0x2, 0x3, 0x4, 0x1b, 0x18, 0x13, 0x8, 0x9, 0x22, 0xb},
+ 32: [12]uint8{0x1, 0xc, 0x2, 0x3, 0x4, 0x1b, 0x18, 0x7, 0x8, 0x9, 0x22, 0xb},
+ 33: [12]uint8{0x1, 0xc, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x23, 0xb},
+ 34: [12]uint8{0x1, 0x0, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x24, 0xb},
+ 35: [12]uint8{0x1, 0xc, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x25, 0xb},
+ 36: [12]uint8{0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x26, 0xb},
+ 37: [12]uint8{0x1, 0xc, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x27, 0xb},
38: [12]uint8{0x1, 0x0, 0x2, 0x3, 0xe, 0x1c, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb},
- 39: [12]uint8{0x1, 0xc, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x29, 0xb},
- 40: [12]uint8{0x1, 0xc, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x2a, 0xb},
- 41: [12]uint8{0x1, 0xc, 0x2, 0x3, 0x4, 0x1b, 0x2b, 0x13, 0x8, 0x9, 0x23, 0xb},
+ 39: [12]uint8{0x1, 0xc, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x28, 0xb},
+ 40: [12]uint8{0x1, 0xc, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x29, 0xb},
+ 41: [12]uint8{0x1, 0xc, 0x2, 0x3, 0x4, 0x1b, 0x2a, 0x13, 0x8, 0x9, 0x22, 0xb},
42: [12]uint8{0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0x0},
43: [12]uint8{0x1, 0xc, 0x2, 0x3, 0x4, 0x5, 0x17, 0x7, 0x8, 0x9, 0xa, 0xb},
- 44: [12]uint8{0x1, 0x0, 0x2, 0x3, 0x4, 0x2c, 0x17, 0x7, 0x8, 0x9, 0xa, 0xb},
- 45: [12]uint8{0x1, 0xc, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x2d, 0x0},
- 46: [12]uint8{0x1, 0xc, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x2e, 0xb},
- 47: [12]uint8{0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x2f, 0xb},
- 48: [12]uint8{0x1, 0xc, 0x2, 0x3, 0x4, 0x5, 0x30, 0x7, 0x8, 0x9, 0xa, 0xb},
- 49: [12]uint8{0x1, 0xc, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x31, 0xb},
- 50: [12]uint8{0x1, 0xc, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x32, 0xb},
- 51: [12]uint8{0x1, 0x1f, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb},
- 52: [12]uint8{0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x33, 0xb},
- 53: [12]uint8{0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x7, 0x3b, 0x9, 0xa, 0xb},
- 54: [12]uint8{0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x7, 0x3b, 0x9, 0x3c, 0xb},
- 55: [12]uint8{0x34, 0x35, 0x36, 0x11, 0x38, 0x39, 0x3a, 0x7, 0x3b, 0x9, 0xa, 0xb},
- 56: [12]uint8{0x34, 0x35, 0x36, 0x11, 0x38, 0x3d, 0x3a, 0x7, 0x3b, 0x9, 0xa, 0xb},
- 57: [12]uint8{0x34, 0xc, 0x36, 0x37, 0x38, 0x3e, 0x3a, 0x7, 0x3b, 0x9, 0xa, 0x0},
- 58: [12]uint8{0x34, 0x35, 0x36, 0x37, 0x38, 0x3e, 0x3a, 0x7, 0x3f, 0x9, 0x23, 0xb},
- 59: [12]uint8{0x34, 0x35, 0x36, 0x11, 0x40, 0x41, 0x42, 0x7, 0x3b, 0x9, 0xa, 0x34},
- 60: [12]uint8{0x34, 0x35, 0x36, 0x43, 0xe, 0x1c, 0x42, 0x7, 0x3b, 0x9, 0x1d, 0xb},
- 61: [12]uint8{0x34, 0x35, 0x36, 0x11, 0xe, 0x1c, 0x42, 0x7, 0x3b, 0x9, 0xa, 0x34},
- 62: [12]uint8{0x1, 0xc, 0x36, 0x11, 0x40, 0x44, 0x42, 0x7, 0x3b, 0x9, 0xa, 0x0},
- 63: [12]uint8{0x34, 0x1, 0x36, 0x11, 0x4, 0x5, 0x42, 0x7, 0x3b, 0x9, 0xa, 0x34},
- 64: [12]uint8{0x34, 0x35, 0x36, 0x11, 0x40, 0x44, 0x42, 0x7, 0x3b, 0x9, 0x23, 0xb},
- 65: [12]uint8{0x0, 0x1, 0x2, 0x3, 0x40, 0x41, 0x42, 0x7, 0x8, 0x9, 0xa, 0x34},
- 66: [12]uint8{0x34, 0x35, 0x36, 0x11, 0x4, 0x5, 0x42, 0x7, 0x3b, 0x9, 0x31, 0x34},
- 67: [12]uint8{0x34, 0x35, 0x36, 0x11, 0x4, 0x5, 0x42, 0x7, 0x3b, 0x9, 0x32, 0x34},
- 68: [12]uint8{0x0, 0x1, 0x45, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x27, 0xb},
- 69: [12]uint8{0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x46, 0xb},
- 70: [12]uint8{0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x47, 0x48, 0xb},
+ 44: [12]uint8{0x1, 0x0, 0x2, 0x3, 0x4, 0x1b, 0x17, 0x7, 0x8, 0x9, 0xa, 0xb},
+ 45: [12]uint8{0x1, 0xc, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x2b, 0x0},
+ 46: [12]uint8{0x1, 0xc, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x2c, 0xb},
+ 47: [12]uint8{0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x2d, 0xb},
+ 48: [12]uint8{0x1, 0xc, 0x2, 0x3, 0x4, 0x5, 0x2e, 0x7, 0x8, 0x9, 0xa, 0xb},
+ 49: [12]uint8{0x1, 0xc, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x2f, 0xb},
+ 50: [12]uint8{0x1, 0xc, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x30, 0xb},
+ 51: [12]uint8{0x1, 0x15, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb},
+ 52: [12]uint8{0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x31, 0xb},
+ 53: [12]uint8{0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x7, 0x39, 0x9, 0xa, 0xb},
+ 54: [12]uint8{0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x7, 0x39, 0x9, 0x3a, 0xb},
+ 55: [12]uint8{0x32, 0x33, 0x34, 0x11, 0x36, 0x37, 0x38, 0x7, 0x39, 0x9, 0xa, 0xb},
+ 56: [12]uint8{0x32, 0x33, 0x34, 0x11, 0x36, 0x3b, 0x38, 0x7, 0x39, 0x9, 0xa, 0xb},
+ 57: [12]uint8{0x32, 0xc, 0x34, 0x35, 0x36, 0x3c, 0x38, 0x7, 0x39, 0x9, 0xa, 0x0},
+ 58: [12]uint8{0x32, 0x33, 0x34, 0x35, 0x36, 0x3c, 0x38, 0x7, 0x3d, 0x9, 0x22, 0xb},
+ 59: [12]uint8{0x32, 0x33, 0x34, 0x11, 0x3e, 0x3f, 0x40, 0x7, 0x39, 0x9, 0xa, 0x32},
+ 60: [12]uint8{0x32, 0x33, 0x34, 0x41, 0xe, 0x1c, 0x40, 0x7, 0x39, 0x9, 0x1d, 0xb},
+ 61: [12]uint8{0x32, 0x33, 0x34, 0x11, 0xe, 0x1c, 0x40, 0x7, 0x39, 0x9, 0xa, 0x32},
+ 62: [12]uint8{0x1, 0xc, 0x34, 0x11, 0x3e, 0x42, 0x40, 0x7, 0x39, 0x9, 0xa, 0x0},
+ 63: [12]uint8{0x32, 0x1, 0x34, 0x11, 0x4, 0x5, 0x40, 0x7, 0x39, 0x9, 0xa, 0x32},
+ 64: [12]uint8{0x32, 0x33, 0x34, 0x11, 0x3e, 0x42, 0x40, 0x7, 0x39, 0x9, 0x22, 0xb},
+ 65: [12]uint8{0x0, 0x1, 0x2, 0x3, 0x3e, 0x3f, 0x40, 0x7, 0x8, 0x9, 0xa, 0x32},
+ 66: [12]uint8{0x32, 0x33, 0x34, 0x11, 0x4, 0x5, 0x40, 0x7, 0x39, 0x9, 0x2f, 0x32},
+ 67: [12]uint8{0x32, 0x33, 0x34, 0x11, 0x4, 0x5, 0x40, 0x7, 0x39, 0x9, 0x30, 0x32},
+ 68: [12]uint8{0x0, 0x1, 0x43, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x26, 0xb},
+ 69: [12]uint8{0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x44, 0xb},
+ 70: [12]uint8{0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x45, 0x46, 0xb},
} // Size: 876 bytes
var symData = stringset.Set{
- Data: "" + // Size: 584 bytes
+ Data: "" + // Size: 580 bytes
".,;%+-E׉∞NaN:\u00a0\u200e%\u200e\u200e+\u200e-ليس\u00a0رقمًا٪ND·Терхьаш" +
- "\u00a0дац'mnne×10^0/00INF−\u200e−ناعددepäluku’ՈչԹარ\u00a0არის\u00a0რიცხვ" +
- "იсан\u00a0емес¤¤¤сан\u00a0эмесບໍ່\u200bແມ່ນ\u200bໂຕ\u200bເລກNSဂဏန်းမဟု" +
- "တ်သောННне\u00a0числочыыһыла\u00a0буотах·10^–epilohosan\u00a0dälTFЕhaqi" +
- "qiy\u00a0son\u00a0emasҳақиқий\u00a0сон\u00a0эмас非數值٫٬؛٪\u061c\u061c+" +
- "\u061c-اس؉ليس\u00a0رقم\u200f−\u061c−؉\u200f\u200e+\u200e\u200e-\u200e×۱۰" +
- "^\u200e٪\u200e−\u200e၊ཨང་མེན་གྲངས་མེདཨང་མད",
- Index: []uint16{ // 74 elements
+ "\u00a0дац’mnne×10^0/00INF−\u200e−ناعددepälukuՈչԹარ\u00a0არის\u00a0რიცხვი" +
+ "сан\u00a0емес¤¤¤сан\u00a0эмесບໍ່\u200bແມ່ນ\u200bໂຕ\u200bເລກNSဂဏန်းမဟုတ်" +
+ "သောННне\u00a0числочыыһыла\u00a0буотах·10^epilohosan\u00a0dälTFЕhaqiqiy" +
+ "\u00a0son\u00a0emasҳақиқий\u00a0сон\u00a0эмас非數值٫٬؛٪\u061c\u061c+\u061c-" +
+ "اس؉ليس\u00a0رقم\u200f−\u061c−؉\u200f\u200e+\u200e\u200e-\u200e×۱۰^" +
+ "\u200e٪\u200e−\u200e၊ཨང་མེན་གྲངས་མེདཨང་མད",
+ Index: []uint16{ // 72 elements
// Entry 0 - 3F
0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
0x0009, 0x000c, 0x000f, 0x0012, 0x0013, 0x0015, 0x001c, 0x0020,
- 0x0024, 0x0036, 0x0038, 0x003a, 0x003c, 0x0052, 0x0053, 0x0056,
- 0x0057, 0x005c, 0x0060, 0x0063, 0x0066, 0x006c, 0x0076, 0x007e,
- 0x0081, 0x0087, 0x00af, 0x00bf, 0x00c5, 0x00d5, 0x0102, 0x0104,
- 0x012b, 0x012f, 0x013f, 0x015b, 0x0160, 0x0163, 0x016a, 0x0173,
- 0x0175, 0x0177, 0x0189, 0x01a9, 0x01b2, 0x01b4, 0x01b6, 0x01b8,
- 0x01bc, 0x01bf, 0x01c2, 0x01c6, 0x01c8, 0x01d6, 0x01dc, 0x01e1,
+ 0x0024, 0x0036, 0x0038, 0x003a, 0x003c, 0x0052, 0x0055, 0x0058,
+ 0x0059, 0x005e, 0x0062, 0x0065, 0x0068, 0x006e, 0x0078, 0x0080,
+ 0x0086, 0x00ae, 0x00be, 0x00c4, 0x00d4, 0x0101, 0x0103, 0x012a,
+ 0x012e, 0x013e, 0x015a, 0x015f, 0x0166, 0x016f, 0x0171, 0x0173,
+ 0x0185, 0x01a5, 0x01ae, 0x01b0, 0x01b2, 0x01b4, 0x01b8, 0x01bb,
+ 0x01be, 0x01c2, 0x01c4, 0x01d2, 0x01d8, 0x01dd, 0x01e2, 0x01e9,
// Entry 40 - 7F
- 0x01e6, 0x01ed, 0x01f4, 0x01fb, 0x0200, 0x0209, 0x020c, 0x0221,
- 0x0239, 0x0248,
+ 0x01f0, 0x01f7, 0x01fc, 0x0205, 0x0208, 0x021d, 0x0235, 0x0244,
},
-} // Size: 772 bytes
+} // Size: 764 bytes
// langToDefaults maps a compact language index to the default numbering system
// and default symbol set
-var langToDefaults = [752]uint8{
+var langToDefaults = [754]uint8{
// Entry 0 - 3F
0x80, 0x06, 0x13, 0x01, 0x01, 0x01, 0x01, 0x01,
0x00, 0x00, 0x00, 0x00, 0x83, 0x02, 0x02, 0x02,
@@ -365,79 +364,80 @@ var langToDefaults = [752]uint8{
0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x14, 0x14,
- 0x06, 0x00, 0x06, 0x06, 0x00, 0x06, 0x06, 0x01,
- 0x00, 0x00, 0x06, 0x06, 0x06, 0x06, 0x00, 0x00,
+ 0x06, 0x00, 0x06, 0x06, 0x00, 0x00, 0x06, 0x06,
+ 0x01, 0x00, 0x00, 0x06, 0x06, 0x06, 0x06, 0x00,
// Entry 100 - 13F
- 0x06, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x06,
- 0x00, 0x00, 0x06, 0x06, 0x15, 0x15, 0x06, 0x06,
- 0x01, 0x01, 0x97, 0x16, 0x16, 0x01, 0x01, 0x01,
- 0x01, 0x01, 0x17, 0x17, 0x00, 0x00, 0x18, 0x18,
- 0x18, 0x9a, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
- 0x01, 0x01, 0x01, 0x0d, 0x01, 0x01, 0x01, 0x01,
- 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
- 0x06, 0x06, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00,
+ 0x06, 0x00, 0x00, 0x06, 0x06, 0x15, 0x15, 0x06,
+ 0x06, 0x01, 0x01, 0x97, 0x16, 0x16, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x17, 0x17, 0x00, 0x00, 0x18,
+ 0x18, 0x18, 0x9a, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x06, 0x06, 0x01, 0x01, 0x01, 0x01, 0x01,
// Entry 140 - 17F
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
- 0x06, 0x06, 0x06, 0x06, 0x00, 0x00, 0x9d, 0x00,
- 0x06, 0x06, 0x19, 0x19, 0x19, 0x19, 0xa0, 0x00,
+ 0x01, 0x06, 0x06, 0x06, 0x06, 0x00, 0x00, 0x9d,
+ 0x00, 0x06, 0x06, 0x19, 0x19, 0x19, 0x19, 0xa0,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x1a, 0x1a, 0x00, 0x00, 0x06,
- 0x06, 0x06, 0x0b, 0x0b, 0x01, 0x01, 0x1b, 0x1b,
- 0x0a, 0x0a, 0xa2, 0x00, 0x00, 0x00, 0x06, 0x06,
+ 0x00, 0x00, 0x00, 0x00, 0x1a, 0x1a, 0x00, 0x00,
+ 0x06, 0x06, 0x06, 0x0b, 0x0b, 0x01, 0x01, 0x1b,
+ 0x1b, 0x0a, 0x0a, 0xa2, 0x00, 0x00, 0x00, 0x06,
// Entry 180 - 1BF
- 0x06, 0x1c, 0x06, 0x06, 0x00, 0x00, 0x00, 0x00,
- 0x06, 0x06, 0x00, 0x00, 0x00, 0x1d, 0x1d, 0x01,
- 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
- 0x01, 0x0d, 0x0d, 0x00, 0x00, 0x1e, 0x1e, 0x06,
- 0x06, 0x1f, 0x1f, 0x00, 0x00, 0x06, 0x06, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa5, 0x1a,
- 0x00, 0x00, 0x01, 0x01, 0x20, 0x20, 0x00, 0x00,
- 0x00, 0x21, 0x21, 0x00, 0x00, 0x06, 0x06, 0x00,
+ 0x06, 0x06, 0x1c, 0x06, 0x06, 0x06, 0x00, 0x00,
+ 0x00, 0x00, 0x06, 0x06, 0x00, 0x00, 0x00, 0x1d,
+ 0x1d, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x01, 0x01, 0x0d, 0x0d, 0x00, 0x00, 0x1e,
+ 0x1e, 0x06, 0x06, 0x1f, 0x1f, 0x00, 0x00, 0x06,
+ 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xa5, 0x1a, 0x00, 0x00, 0x01, 0x01, 0x20, 0x20,
+ 0x00, 0x00, 0x00, 0x21, 0x21, 0x00, 0x00, 0x06,
// Entry 1C0 - 1FF
- 0x00, 0x00, 0x00, 0x06, 0x06, 0x06, 0x06, 0x06,
- 0x22, 0x22, 0xa7, 0x00, 0x00, 0x15, 0x15, 0x06,
- 0x06, 0x00, 0x00, 0x00, 0x00, 0x23, 0x23, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x0d, 0x0d, 0x00, 0x00,
- 0x06, 0x06, 0x00, 0x00, 0x06, 0x06, 0x00, 0x00,
- 0x00, 0x00, 0xa9, 0x00, 0x00, 0x06, 0x00, 0x00,
- 0x00, 0x00, 0x06, 0x06, 0xaa, 0x24, 0xac, 0x00,
- 0x00, 0x00, 0x00, 0xad, 0x14, 0x14, 0x00, 0x00,
+ 0x06, 0x00, 0x00, 0x00, 0x00, 0x06, 0x06, 0x06,
+ 0x06, 0x06, 0x22, 0x22, 0xa7, 0x00, 0x00, 0x15,
+ 0x15, 0x06, 0x06, 0x00, 0x00, 0x00, 0x00, 0x23,
+ 0x23, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x0d,
+ 0x00, 0x00, 0x06, 0x06, 0x00, 0x00, 0x06, 0x06,
+ 0x00, 0x00, 0x00, 0x00, 0xa9, 0x00, 0x00, 0x06,
+ 0x00, 0x00, 0x00, 0x00, 0x06, 0x06, 0xaa, 0x24,
+ 0xac, 0x00, 0x00, 0x00, 0x00, 0xad, 0x14, 0x14,
// Entry 200 - 23F
- 0x06, 0x06, 0x06, 0xb0, 0x00, 0x00, 0xb1, 0x06,
- 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x01, 0x01,
- 0x14, 0x14, 0x06, 0x06, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x06, 0x06, 0x06, 0xb0, 0x00, 0x00,
+ 0xb1, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+ 0x01, 0x01, 0x14, 0x14, 0x06, 0x06, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x25, 0x25, 0x25, 0xb4, 0xb6, 0x1a,
- 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0xb8,
- 0x26, 0x06, 0x01, 0x06, 0x01, 0x01, 0x01, 0x01,
- 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x06,
+ 0x00, 0x00, 0x00, 0x00, 0x25, 0x25, 0x25, 0xb4,
+ 0xb6, 0x1a, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01,
+ 0x01, 0xb8, 0x26, 0x06, 0x01, 0x06, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
// Entry 240 - 27F
- 0x00, 0x00, 0x19, 0x19, 0x06, 0x06, 0x06, 0x06,
- 0x06, 0x00, 0x00, 0x27, 0x27, 0x27, 0x27, 0x27,
- 0x27, 0x27, 0x06, 0x06, 0x00, 0x00, 0x28, 0x28,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x29, 0x29,
- 0x29, 0x06, 0x06, 0x0d, 0x0d, 0x06, 0x06, 0x01,
- 0x01, 0x01, 0x01, 0x01, 0x2a, 0x2a, 0x2b, 0x2b,
- 0x2c, 0x2c, 0x00, 0x00, 0x00, 0x2d, 0x2d, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+ 0x00, 0x06, 0x00, 0x00, 0x19, 0x19, 0x06, 0x06,
+ 0x06, 0x06, 0x06, 0x00, 0x00, 0x27, 0x27, 0x27,
+ 0x27, 0x27, 0x27, 0x27, 0x06, 0x06, 0x00, 0x00,
+ 0x28, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29,
+ 0x29, 0x29, 0x29, 0x06, 0x06, 0x0d, 0x0d, 0x06,
+ 0x06, 0x01, 0x01, 0x01, 0x01, 0x01, 0x2a, 0x2a,
+ 0x2b, 0x2b, 0x2c, 0x2c, 0x00, 0x00, 0x00, 0x2d,
+ 0x2d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
// Entry 280 - 2BF
- 0x01, 0x01, 0x01, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
- 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x00, 0x00,
- 0x00, 0xba, 0x20, 0x20, 0x20, 0x00, 0x06, 0x00,
+ 0x00, 0x01, 0x01, 0x01, 0x01, 0x06, 0x06, 0x06,
+ 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+ 0x00, 0x00, 0x00, 0xba, 0x20, 0x20, 0x20, 0x00,
+ 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x2e, 0x2e, 0x00, 0x2f, 0x2f,
- 0x06, 0x06, 0x06, 0x00, 0x0d, 0x0d, 0x01, 0x01,
- 0x00, 0x00, 0x30, 0x30, 0xbd, 0xbf, 0x1a, 0xc0,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x2e, 0x2e, 0x00,
+ 0x2f, 0x2f, 0x06, 0x06, 0x06, 0x00, 0x0d, 0x0d,
+ 0x01, 0x01, 0x00, 0x00, 0x30, 0x30, 0xbd, 0xbf,
// Entry 2C0 - 2FF
- 0xc2, 0x26, 0xc4, 0x32, 0x31, 0x31, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x06, 0x06, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x33, 0x33, 0x00, 0x00, 0x00,
- 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x34, 0x34, 0x01, 0x01, 0xc6, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x34, 0x34, 0x34, 0x34, 0x00, 0x00,
-} // Size: 752 bytes
+ 0x1a, 0xc0, 0xc2, 0x26, 0xc4, 0x32, 0x31, 0x31,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x06,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x33, 0x33, 0x00,
+ 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x34, 0x34, 0x01, 0x01, 0xc6, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x34, 0x34, 0x34, 0x34,
+ 0x00, 0x00,
+} // Size: 754 bytes
// langToAlt is a list of numbering system and symbol set pairs, sorted and
// marked by compact language index.
@@ -464,59 +464,59 @@ var langToAlt = []altSymData{ // 73 elements
20: {compactTag: 0x63, system: 0x3, symIndex: 0x35},
21: {compactTag: 0x7b, system: 0x36, symIndex: 0x46},
22: {compactTag: 0x7b, system: 0x0, symIndex: 0x0},
- 23: {compactTag: 0x112, system: 0x4, symIndex: 0x3c},
- 24: {compactTag: 0x112, system: 0x0, symIndex: 0x16},
- 25: {compactTag: 0x112, system: 0x3, symIndex: 0x37},
- 26: {compactTag: 0x121, system: 0x0, symIndex: 0x1},
- 27: {compactTag: 0x121, system: 0x3, symIndex: 0x38},
- 28: {compactTag: 0x121, system: 0x4, symIndex: 0x3d},
- 29: {compactTag: 0x156, system: 0x0, symIndex: 0x0},
- 30: {compactTag: 0x156, system: 0x3, symIndex: 0x37},
- 31: {compactTag: 0x156, system: 0x4, symIndex: 0x3b},
- 32: {compactTag: 0x15e, system: 0x0, symIndex: 0x0},
- 33: {compactTag: 0x15e, system: 0x3, symIndex: 0x35},
- 34: {compactTag: 0x17a, system: 0x0, symIndex: 0x0},
- 35: {compactTag: 0x17a, system: 0x3, symIndex: 0x35},
- 36: {compactTag: 0x17a, system: 0x4, symIndex: 0x3b},
- 37: {compactTag: 0x1ae, system: 0x4, symIndex: 0x3b},
- 38: {compactTag: 0x1ae, system: 0x0, symIndex: 0x1a},
- 39: {compactTag: 0x1ca, system: 0x4, symIndex: 0x3b},
- 40: {compactTag: 0x1ca, system: 0x0, symIndex: 0x0},
- 41: {compactTag: 0x1ea, system: 0xb, symIndex: 0x0},
- 42: {compactTag: 0x1f4, system: 0x23, symIndex: 0x44},
- 43: {compactTag: 0x1f4, system: 0x0, symIndex: 0x24},
- 44: {compactTag: 0x1f6, system: 0x4, symIndex: 0x3b},
- 45: {compactTag: 0x1fb, system: 0x0, symIndex: 0x14},
- 46: {compactTag: 0x1fb, system: 0x3, symIndex: 0x39},
- 47: {compactTag: 0x1fb, system: 0x4, symIndex: 0x3e},
- 48: {compactTag: 0x203, system: 0xb, symIndex: 0x0},
- 49: {compactTag: 0x206, system: 0x0, symIndex: 0x6},
- 50: {compactTag: 0x206, system: 0x3, symIndex: 0x35},
- 51: {compactTag: 0x206, system: 0x4, symIndex: 0x3b},
- 52: {compactTag: 0x225, system: 0x0, symIndex: 0x0},
- 53: {compactTag: 0x225, system: 0x4, symIndex: 0x3f},
- 54: {compactTag: 0x226, system: 0x4, symIndex: 0x3b},
- 55: {compactTag: 0x226, system: 0x0, symIndex: 0x1a},
- 56: {compactTag: 0x22f, system: 0x4, symIndex: 0x3b},
- 57: {compactTag: 0x22f, system: 0x0, symIndex: 0x26},
- 58: {compactTag: 0x291, system: 0x0, symIndex: 0x20},
- 59: {compactTag: 0x291, system: 0x3, symIndex: 0x3a},
- 60: {compactTag: 0x291, system: 0x4, symIndex: 0x40},
- 61: {compactTag: 0x2bc, system: 0x0, symIndex: 0x1a},
- 62: {compactTag: 0x2bc, system: 0x4, symIndex: 0x41},
- 63: {compactTag: 0x2bd, system: 0x4, symIndex: 0x41},
- 64: {compactTag: 0x2bf, system: 0x0, symIndex: 0x31},
- 65: {compactTag: 0x2bf, system: 0x4, symIndex: 0x42},
- 66: {compactTag: 0x2c0, system: 0x4, symIndex: 0x3b},
- 67: {compactTag: 0x2c0, system: 0x0, symIndex: 0x26},
- 68: {compactTag: 0x2c2, system: 0x0, symIndex: 0x32},
- 69: {compactTag: 0x2c2, system: 0x4, symIndex: 0x43},
- 70: {compactTag: 0x2e4, system: 0x0, symIndex: 0x0},
- 71: {compactTag: 0x2e4, system: 0x3, symIndex: 0x35},
- 72: {compactTag: 0x2e4, system: 0x4, symIndex: 0x3b},
+ 23: {compactTag: 0x113, system: 0x4, symIndex: 0x3c},
+ 24: {compactTag: 0x113, system: 0x0, symIndex: 0x16},
+ 25: {compactTag: 0x113, system: 0x3, symIndex: 0x37},
+ 26: {compactTag: 0x122, system: 0x0, symIndex: 0x1},
+ 27: {compactTag: 0x122, system: 0x3, symIndex: 0x38},
+ 28: {compactTag: 0x122, system: 0x4, symIndex: 0x3d},
+ 29: {compactTag: 0x157, system: 0x0, symIndex: 0x0},
+ 30: {compactTag: 0x157, system: 0x3, symIndex: 0x37},
+ 31: {compactTag: 0x157, system: 0x4, symIndex: 0x3b},
+ 32: {compactTag: 0x15f, system: 0x0, symIndex: 0x0},
+ 33: {compactTag: 0x15f, system: 0x3, symIndex: 0x35},
+ 34: {compactTag: 0x17b, system: 0x0, symIndex: 0x0},
+ 35: {compactTag: 0x17b, system: 0x3, symIndex: 0x35},
+ 36: {compactTag: 0x17b, system: 0x4, symIndex: 0x3b},
+ 37: {compactTag: 0x1b0, system: 0x4, symIndex: 0x3b},
+ 38: {compactTag: 0x1b0, system: 0x0, symIndex: 0x1a},
+ 39: {compactTag: 0x1cc, system: 0x4, symIndex: 0x3b},
+ 40: {compactTag: 0x1cc, system: 0x0, symIndex: 0x0},
+ 41: {compactTag: 0x1ec, system: 0xb, symIndex: 0x0},
+ 42: {compactTag: 0x1f6, system: 0x23, symIndex: 0x44},
+ 43: {compactTag: 0x1f6, system: 0x0, symIndex: 0x24},
+ 44: {compactTag: 0x1f8, system: 0x4, symIndex: 0x3b},
+ 45: {compactTag: 0x1fd, system: 0x0, symIndex: 0x14},
+ 46: {compactTag: 0x1fd, system: 0x3, symIndex: 0x39},
+ 47: {compactTag: 0x1fd, system: 0x4, symIndex: 0x3e},
+ 48: {compactTag: 0x205, system: 0xb, symIndex: 0x0},
+ 49: {compactTag: 0x208, system: 0x0, symIndex: 0x6},
+ 50: {compactTag: 0x208, system: 0x3, symIndex: 0x35},
+ 51: {compactTag: 0x208, system: 0x4, symIndex: 0x3b},
+ 52: {compactTag: 0x227, system: 0x0, symIndex: 0x0},
+ 53: {compactTag: 0x227, system: 0x4, symIndex: 0x3f},
+ 54: {compactTag: 0x228, system: 0x4, symIndex: 0x3b},
+ 55: {compactTag: 0x228, system: 0x0, symIndex: 0x1a},
+ 56: {compactTag: 0x231, system: 0x4, symIndex: 0x3b},
+ 57: {compactTag: 0x231, system: 0x0, symIndex: 0x26},
+ 58: {compactTag: 0x293, system: 0x0, symIndex: 0x20},
+ 59: {compactTag: 0x293, system: 0x3, symIndex: 0x3a},
+ 60: {compactTag: 0x293, system: 0x4, symIndex: 0x40},
+ 61: {compactTag: 0x2be, system: 0x0, symIndex: 0x1a},
+ 62: {compactTag: 0x2be, system: 0x4, symIndex: 0x41},
+ 63: {compactTag: 0x2bf, system: 0x4, symIndex: 0x41},
+ 64: {compactTag: 0x2c1, system: 0x0, symIndex: 0x31},
+ 65: {compactTag: 0x2c1, system: 0x4, symIndex: 0x42},
+ 66: {compactTag: 0x2c2, system: 0x4, symIndex: 0x3b},
+ 67: {compactTag: 0x2c2, system: 0x0, symIndex: 0x26},
+ 68: {compactTag: 0x2c4, system: 0x0, symIndex: 0x32},
+ 69: {compactTag: 0x2c4, system: 0x4, symIndex: 0x43},
+ 70: {compactTag: 0x2e6, system: 0x0, symIndex: 0x0},
+ 71: {compactTag: 0x2e6, system: 0x3, symIndex: 0x35},
+ 72: {compactTag: 0x2e6, system: 0x4, symIndex: 0x3b},
} // Size: 316 bytes
-var tagToDecimal = []uint8{ // 752 elements
+var tagToDecimal = []uint8{ // 754 elements
// Entry 0 - 3F
0x01, 0x01, 0x08, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
@@ -566,10 +566,10 @@ var tagToDecimal = []uint8{ // 752 elements
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x05,
+ 0x05, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x05, 0x05,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
- 0x01, 0x01, 0x01, 0x01, 0x01, 0x05, 0x05, 0x01,
- 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
// Entry 180 - 1BF
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
@@ -577,16 +577,16 @@ var tagToDecimal = []uint8{ // 752 elements
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
- 0x01, 0x01, 0x01, 0x01, 0x05, 0x05, 0x05, 0x05,
- 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x05, 0x05,
+ 0x05, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
// Entry 1C0 - 1FF
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
- 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x05, 0x05,
- 0x01, 0x01, 0x05, 0x05, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x05, 0x05, 0x01, 0x01, 0x05, 0x05, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
// Entry 200 - 23F
@@ -594,8 +594,8 @@ var tagToDecimal = []uint8{ // 752 elements
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
- 0x05, 0x05, 0x01, 0x01, 0x01, 0x05, 0x01, 0x01,
- 0x05, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+ 0x01, 0x01, 0x05, 0x05, 0x01, 0x01, 0x01, 0x05,
+ 0x01, 0x01, 0x05, 0x05, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
// Entry 240 - 27F
@@ -611,7 +611,7 @@ var tagToDecimal = []uint8{ // 752 elements
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
- 0x01, 0x01, 0x01, 0x05, 0x05, 0x05, 0x01, 0x01,
+ 0x01, 0x01, 0x01, 0x01, 0x01, 0x05, 0x05, 0x05,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
@@ -623,9 +623,10 @@ var tagToDecimal = []uint8{ // 752 elements
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-} // Size: 776 bytes
+ 0x01, 0x01,
+} // Size: 778 bytes
-var tagToScientific = []uint8{ // 752 elements
+var tagToScientific = []uint8{ // 754 elements
// Entry 0 - 3F
0x02, 0x02, 0x09, 0x02, 0x02, 0x02, 0x02, 0x02,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
@@ -675,10 +676,10 @@ var tagToScientific = []uint8{ // 752 elements
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x0d,
+ 0x0d, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x0d, 0x0d,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
- 0x02, 0x02, 0x02, 0x02, 0x02, 0x0d, 0x0d, 0x02,
- 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
// Entry 180 - 1BF
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
@@ -691,11 +692,11 @@ var tagToScientific = []uint8{ // 752 elements
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
// Entry 1C0 - 1FF
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
- 0x0e, 0x0e, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+ 0x02, 0x02, 0x0e, 0x0e, 0x02, 0x02, 0x02, 0x02,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
- 0x02, 0x02, 0x0d, 0x0d, 0x02, 0x02, 0x02, 0x02,
+ 0x02, 0x02, 0x02, 0x02, 0x0d, 0x0d, 0x02, 0x02,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
// Entry 200 - 23F
@@ -703,8 +704,8 @@ var tagToScientific = []uint8{ // 752 elements
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
- 0x02, 0x02, 0x02, 0x02, 0x02, 0x0d, 0x02, 0x02,
- 0x0d, 0x0d, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
+ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x0d,
+ 0x02, 0x02, 0x0d, 0x0d, 0x02, 0x02, 0x02, 0x02,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
// Entry 240 - 27F
@@ -713,7 +714,7 @@ var tagToScientific = []uint8{ // 752 elements
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
- 0x02, 0x02, 0x02, 0x02, 0x0e, 0x0e, 0x02, 0x02,
+ 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x0e, 0x0e,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
// Entry 280 - 2BF
@@ -732,9 +733,10 @@ var tagToScientific = []uint8{ // 752 elements
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
-} // Size: 776 bytes
+ 0x02, 0x02,
+} // Size: 778 bytes
-var tagToPercent = []uint8{ // 752 elements
+var tagToPercent = []uint8{ // 754 elements
// Entry 0 - 3F
0x04, 0x04, 0x0a, 0x04, 0x04, 0x04, 0x04, 0x04,
0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
@@ -769,87 +771,88 @@ var tagToPercent = []uint8{ // 752 elements
0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
- 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x03,
- 0x03, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04,
+ 0x03, 0x03, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03,
// Entry 100 - 13F
- 0x03, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
- 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x0b, 0x0b,
- 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
- 0x04, 0x04, 0x03, 0x03, 0x04, 0x04, 0x03, 0x03,
+ 0x03, 0x03, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03,
+ 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x0b,
+ 0x0b, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x03, 0x03, 0x04, 0x04, 0x03,
0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
- 0x03, 0x03, 0x03, 0x04, 0x03, 0x03, 0x03, 0x03,
+ 0x03, 0x03, 0x03, 0x03, 0x04, 0x03, 0x03, 0x03,
0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
// Entry 140 - 17F
0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
- 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
- 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x06, 0x06,
- 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
- 0x04, 0x04, 0x04, 0x04, 0x04, 0x06, 0x06, 0x04,
- 0x04, 0x04, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04,
+ 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x06,
+ 0x06, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x06, 0x06,
+ 0x04, 0x04, 0x04, 0x03, 0x03, 0x04, 0x04, 0x04,
0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
// Entry 180 - 1BF
0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
- 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x04,
- 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03,
+ 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
- 0x04, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x04,
- 0x04, 0x04, 0x04, 0x04, 0x06, 0x06, 0x06, 0x06,
- 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x04, 0x04,
- 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x04,
+ 0x04, 0x04, 0x04, 0x03, 0x03, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x06, 0x06,
+ 0x06, 0x06, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03,
// Entry 1C0 - 1FF
- 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
- 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x04,
- 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03,
+ 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
- 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03,
// Entry 200 - 23F
0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
- 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x06, 0x06, 0x04, 0x04, 0x04, 0x06,
+ 0x04, 0x04, 0x06, 0x06, 0x04, 0x04, 0x04, 0x04,
0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
- 0x06, 0x06, 0x04, 0x04, 0x04, 0x06, 0x04, 0x04,
- 0x06, 0x06, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
- 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03,
// Entry 240 - 27F
0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
- 0x03, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03,
- 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
- 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03,
- 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
- 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03,
- 0x03, 0x03, 0x04, 0x04, 0x04, 0x03, 0x03, 0x04,
+ 0x03, 0x03, 0x03, 0x04, 0x04, 0x03, 0x03, 0x03,
+ 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03,
+ 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x04,
0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x03,
+ 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
// Entry 280 - 2BF
0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
- 0x04, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04,
- 0x04, 0x04, 0x04, 0x06, 0x06, 0x06, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x06, 0x06, 0x06,
0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
- 0x04, 0x04, 0x04, 0x03, 0x03, 0x04, 0x04, 0x04,
- 0x0f, 0x0f, 0x0f, 0x04, 0x04, 0x04, 0x04, 0x04,
- 0x04, 0x04, 0x04, 0x04, 0x06, 0x06, 0x06, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x04,
+ 0x04, 0x04, 0x0f, 0x0f, 0x0f, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x06, 0x06,
// Entry 2C0 - 2FF
+ 0x06, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
+ 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x04, 0x04,
0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
- 0x04, 0x04, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04,
- 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
-} // Size: 776 bytes
+ 0x04, 0x04,
+} // Size: 778 bytes
var formats = []Pattern{Pattern{Affix: "",
Offset: 0x0,
NegOffset: 0x0,
- Multiplier: 0x0,
+ FormatWidth: 0x0,
RoundIncrement: 0x0,
PadRune: 0,
- FormatWidth: 0x0,
+ DigitShift: 0x0,
GroupingSize: [2]uint8{0x0,
0x0},
Flags: 0x0,
@@ -863,10 +866,10 @@ var formats = []Pattern{Pattern{Affix: "",
Pattern{Affix: "",
Offset: 0x0,
NegOffset: 0x0,
- Multiplier: 0x0,
+ FormatWidth: 0x9,
RoundIncrement: 0x0,
PadRune: 0,
- FormatWidth: 0x9,
+ DigitShift: 0x0,
GroupingSize: [2]uint8{0x3,
0x0},
Flags: 0x0,
@@ -880,10 +883,10 @@ var formats = []Pattern{Pattern{Affix: "",
Pattern{Affix: "",
Offset: 0x0,
NegOffset: 0x0,
- Multiplier: 0x0,
+ FormatWidth: 0x3,
RoundIncrement: 0x0,
PadRune: 0,
- FormatWidth: 0x3,
+ DigitShift: 0x0,
GroupingSize: [2]uint8{0x0,
0x0},
Flags: 0x0,
@@ -897,10 +900,10 @@ var formats = []Pattern{Pattern{Affix: "",
Pattern{Affix: "\x00\x03\u00a0%",
Offset: 0x0,
NegOffset: 0x0,
- Multiplier: 0x64,
+ FormatWidth: 0x7,
RoundIncrement: 0x0,
PadRune: 0,
- FormatWidth: 0x7,
+ DigitShift: 0x2,
GroupingSize: [2]uint8{0x3,
0x0},
Flags: 0x0,
@@ -914,10 +917,10 @@ var formats = []Pattern{Pattern{Affix: "",
Pattern{Affix: "\x00\x01%",
Offset: 0x0,
NegOffset: 0x0,
- Multiplier: 0x64,
+ FormatWidth: 0x6,
RoundIncrement: 0x0,
PadRune: 0,
- FormatWidth: 0x6,
+ DigitShift: 0x2,
GroupingSize: [2]uint8{0x3,
0x0},
Flags: 0x0,
@@ -931,10 +934,10 @@ var formats = []Pattern{Pattern{Affix: "",
Pattern{Affix: "",
Offset: 0x0,
NegOffset: 0x0,
- Multiplier: 0x0,
+ FormatWidth: 0xc,
RoundIncrement: 0x0,
PadRune: 0,
- FormatWidth: 0xc,
+ DigitShift: 0x0,
GroupingSize: [2]uint8{0x3,
0x2},
Flags: 0x0,
@@ -948,10 +951,10 @@ var formats = []Pattern{Pattern{Affix: "",
Pattern{Affix: "\x00\x01%",
Offset: 0x0,
NegOffset: 0x0,
- Multiplier: 0x64,
+ FormatWidth: 0x9,
RoundIncrement: 0x0,
PadRune: 0,
- FormatWidth: 0x9,
+ DigitShift: 0x2,
GroupingSize: [2]uint8{0x3,
0x2},
Flags: 0x0,
@@ -965,10 +968,10 @@ var formats = []Pattern{Pattern{Affix: "",
Pattern{Affix: "\x00\x03\u00a0%",
Offset: 0x0,
NegOffset: 0x0,
- Multiplier: 0x64,
+ FormatWidth: 0xa,
RoundIncrement: 0x0,
PadRune: 0,
- FormatWidth: 0xa,
+ DigitShift: 0x2,
GroupingSize: [2]uint8{0x3,
0x2},
Flags: 0x0,
@@ -982,10 +985,10 @@ var formats = []Pattern{Pattern{Affix: "",
Pattern{Affix: "",
Offset: 0x0,
NegOffset: 0x0,
- Multiplier: 0x0,
+ FormatWidth: 0x9,
RoundIncrement: 0x0,
PadRune: 0,
- FormatWidth: 0x9,
+ DigitShift: 0x0,
GroupingSize: [2]uint8{0x0,
0x0},
Flags: 0x0,
@@ -999,13 +1002,13 @@ var formats = []Pattern{Pattern{Affix: "",
Pattern{Affix: "",
Offset: 0x0,
NegOffset: 0x0,
- Multiplier: 0x0,
+ FormatWidth: 0xd,
RoundIncrement: 0x0,
PadRune: 0,
- FormatWidth: 0xd,
+ DigitShift: 0x0,
GroupingSize: [2]uint8{0x0,
0x0},
- Flags: 0x2,
+ Flags: 0x4,
MinIntegerDigits: 0x1,
MaxIntegerDigits: 0x0,
MinFractionDigits: 0x6,
@@ -1016,10 +1019,10 @@ var formats = []Pattern{Pattern{Affix: "",
Pattern{Affix: "\x00\x01%",
Offset: 0x0,
NegOffset: 0x0,
- Multiplier: 0x64,
+ FormatWidth: 0x3,
RoundIncrement: 0x0,
PadRune: 0,
- FormatWidth: 0x3,
+ DigitShift: 0x2,
GroupingSize: [2]uint8{0x0,
0x0},
Flags: 0x0,
@@ -1033,10 +1036,10 @@ var formats = []Pattern{Pattern{Affix: "",
Pattern{Affix: "\x03%\u00a0\x00",
Offset: 0x0,
NegOffset: 0x0,
- Multiplier: 0x64,
+ FormatWidth: 0x7,
RoundIncrement: 0x0,
PadRune: 0,
- FormatWidth: 0x7,
+ DigitShift: 0x2,
GroupingSize: [2]uint8{0x3,
0x0},
Flags: 0x0,
@@ -1050,10 +1053,10 @@ var formats = []Pattern{Pattern{Affix: "",
Pattern{Affix: "\x03%\u00a0\x00\x04%\u00a0-\x00",
Offset: 0x0,
NegOffset: 0x5,
- Multiplier: 0x64,
+ FormatWidth: 0x7,
RoundIncrement: 0x0,
PadRune: 0,
- FormatWidth: 0x7,
+ DigitShift: 0x2,
GroupingSize: [2]uint8{0x3,
0x0},
Flags: 0x0,
@@ -1067,10 +1070,10 @@ var formats = []Pattern{Pattern{Affix: "",
Pattern{Affix: "\x01[\x01]",
Offset: 0x0,
NegOffset: 0x0,
- Multiplier: 0x0,
+ FormatWidth: 0x5,
RoundIncrement: 0x0,
PadRune: 0,
- FormatWidth: 0x5,
+ DigitShift: 0x0,
GroupingSize: [2]uint8{0x0,
0x0},
Flags: 0x0,
@@ -1084,10 +1087,10 @@ var formats = []Pattern{Pattern{Affix: "",
Pattern{Affix: "",
Offset: 0x0,
NegOffset: 0x0,
- Multiplier: 0x0,
+ FormatWidth: 0x1,
RoundIncrement: 0x0,
PadRune: 0,
- FormatWidth: 0x1,
+ DigitShift: 0x0,
GroupingSize: [2]uint8{0x0,
0x0},
Flags: 0x0,
@@ -1101,10 +1104,10 @@ var formats = []Pattern{Pattern{Affix: "",
Pattern{Affix: "\x01%\x00",
Offset: 0x0,
NegOffset: 0x0,
- Multiplier: 0x64,
+ FormatWidth: 0x6,
RoundIncrement: 0x0,
PadRune: 0,
- FormatWidth: 0x6,
+ DigitShift: 0x2,
GroupingSize: [2]uint8{0x3,
0x0},
Flags: 0x0,
@@ -1116,4 +1119,4 @@ var formats = []Pattern{Pattern{Affix: "",
MaxSignificantDigits: 0x0,
MinExponentDigits: 0x0}}
-// Total table size 7101 bytes (6KiB); checksum: A4A81DF0
+// Total table size 7101 bytes (6KiB); checksum: 5190D0B3
diff --git a/vendor/golang.org/x/text/internal/tables.go b/vendor/golang.org/x/text/internal/tables.go
index 7fb15f6b8..a53042aab 100644
--- a/vendor/golang.org/x/text/internal/tables.go
+++ b/vendor/golang.org/x/text/internal/tables.go
@@ -4,7 +4,7 @@ package internal
// Parent maps a compact index of a tag to the compact index of the parent of
// this tag.
-var Parent = []uint16{ // 752 elements
+var Parent = []uint16{ // 754 elements
// Entry 0 - 3F
0x0000, 0x0053, 0x00e5, 0x0000, 0x0003, 0x0003, 0x0000, 0x0006,
0x0000, 0x0008, 0x0000, 0x000a, 0x0000, 0x000c, 0x000c, 0x000c,
@@ -40,77 +40,78 @@ var Parent = []uint16{ // 752 elements
0x0086, 0x0086, 0x0086, 0x0086, 0x0085, 0x0085, 0x0086, 0x0086,
0x0085, 0x0086, 0x0086, 0x0086, 0x0086, 0x0086, 0x0000, 0x00ee,
0x0000, 0x00f0, 0x00f1, 0x00f1, 0x00f1, 0x00f1, 0x00f1, 0x00f1,
- 0x00f1, 0x00f1, 0x00f0, 0x00f1, 0x00f0, 0x00f0, 0x00f1, 0x00f1,
+ 0x00f1, 0x00f1, 0x00f1, 0x00f0, 0x00f1, 0x00f0, 0x00f0, 0x00f1,
// Entry 100 - 13F
- 0x00f0, 0x00f1, 0x00f1, 0x00f1, 0x00f1, 0x00f0, 0x00f1, 0x00f1,
- 0x00f1, 0x00f1, 0x00f1, 0x00f1, 0x0000, 0x010c, 0x0000, 0x010e,
- 0x0000, 0x0110, 0x0000, 0x0112, 0x0112, 0x0000, 0x0115, 0x0115,
- 0x0115, 0x0115, 0x0000, 0x011a, 0x0000, 0x011c, 0x0000, 0x011e,
- 0x011e, 0x0000, 0x0121, 0x0121, 0x0121, 0x0121, 0x0121, 0x0121,
- 0x0121, 0x0121, 0x0121, 0x0121, 0x0121, 0x0121, 0x0121, 0x0121,
- 0x0121, 0x0121, 0x0121, 0x0121, 0x0121, 0x0121, 0x0121, 0x0121,
- 0x0121, 0x0121, 0x0121, 0x0121, 0x0121, 0x0121, 0x0121, 0x0121,
+ 0x00f1, 0x00f0, 0x00f1, 0x00f1, 0x00f1, 0x00f1, 0x00f0, 0x00f1,
+ 0x00f1, 0x00f1, 0x00f1, 0x00f1, 0x00f1, 0x0000, 0x010d, 0x0000,
+ 0x010f, 0x0000, 0x0111, 0x0000, 0x0113, 0x0113, 0x0000, 0x0116,
+ 0x0116, 0x0116, 0x0116, 0x0000, 0x011b, 0x0000, 0x011d, 0x0000,
+ 0x011f, 0x011f, 0x0000, 0x0122, 0x0122, 0x0122, 0x0122, 0x0122,
+ 0x0122, 0x0122, 0x0122, 0x0122, 0x0122, 0x0122, 0x0122, 0x0122,
+ 0x0122, 0x0122, 0x0122, 0x0122, 0x0122, 0x0122, 0x0122, 0x0122,
+ 0x0122, 0x0122, 0x0122, 0x0122, 0x0122, 0x0122, 0x0122, 0x0122,
// Entry 140 - 17F
- 0x0121, 0x0121, 0x0121, 0x0121, 0x0121, 0x0121, 0x0121, 0x0121,
- 0x0121, 0x0121, 0x0121, 0x0121, 0x0121, 0x0121, 0x0121, 0x0121,
- 0x0000, 0x0150, 0x0000, 0x0152, 0x0000, 0x0154, 0x0000, 0x0156,
- 0x0000, 0x0158, 0x0000, 0x015a, 0x015a, 0x015a, 0x0000, 0x015e,
- 0x0000, 0x0000, 0x0161, 0x0000, 0x0163, 0x0000, 0x0165, 0x0165,
- 0x0165, 0x0000, 0x0169, 0x0000, 0x016b, 0x0000, 0x016d, 0x0000,
- 0x016f, 0x016f, 0x0000, 0x0172, 0x0000, 0x0174, 0x0000, 0x0176,
- 0x0000, 0x0178, 0x0000, 0x017a, 0x0000, 0x017c, 0x0000, 0x017e,
+ 0x0122, 0x0122, 0x0122, 0x0122, 0x0122, 0x0122, 0x0122, 0x0122,
+ 0x0122, 0x0122, 0x0122, 0x0122, 0x0122, 0x0122, 0x0122, 0x0122,
+ 0x0122, 0x0000, 0x0151, 0x0000, 0x0153, 0x0000, 0x0155, 0x0000,
+ 0x0157, 0x0000, 0x0159, 0x0000, 0x015b, 0x015b, 0x015b, 0x0000,
+ 0x015f, 0x0000, 0x0000, 0x0162, 0x0000, 0x0164, 0x0000, 0x0166,
+ 0x0166, 0x0166, 0x0000, 0x016a, 0x0000, 0x016c, 0x0000, 0x016e,
+ 0x0000, 0x0170, 0x0170, 0x0000, 0x0173, 0x0000, 0x0175, 0x0000,
+ 0x0177, 0x0000, 0x0179, 0x0000, 0x017b, 0x0000, 0x017d, 0x0000,
// Entry 180 - 1BF
- 0x0000, 0x0180, 0x0180, 0x0180, 0x0000, 0x0000, 0x0185, 0x0000,
- 0x0000, 0x0188, 0x0000, 0x018a, 0x0000, 0x0000, 0x018d, 0x0000,
- 0x018f, 0x0000, 0x0000, 0x0192, 0x0000, 0x0000, 0x0195, 0x0000,
+ 0x017f, 0x0000, 0x0181, 0x0181, 0x0181, 0x0181, 0x0000, 0x0000,
+ 0x0187, 0x0000, 0x0000, 0x018a, 0x0000, 0x018c, 0x0000, 0x0000,
+ 0x018f, 0x0000, 0x0191, 0x0000, 0x0000, 0x0194, 0x0000, 0x0000,
0x0197, 0x0000, 0x0199, 0x0000, 0x019b, 0x0000, 0x019d, 0x0000,
0x019f, 0x0000, 0x01a1, 0x0000, 0x01a3, 0x0000, 0x01a5, 0x0000,
- 0x01a7, 0x0000, 0x01a9, 0x01a9, 0x0000, 0x01ac, 0x0000, 0x01ae,
- 0x0000, 0x01b0, 0x0000, 0x01b2, 0x0000, 0x01b4, 0x0000, 0x0000,
- 0x01b7, 0x0000, 0x01b9, 0x0000, 0x01bb, 0x0000, 0x01bd, 0x0000,
+ 0x01a7, 0x0000, 0x01a9, 0x0000, 0x01ab, 0x01ab, 0x0000, 0x01ae,
+ 0x0000, 0x01b0, 0x0000, 0x01b2, 0x0000, 0x01b4, 0x0000, 0x01b6,
+ 0x0000, 0x0000, 0x01b9, 0x0000, 0x01bb, 0x0000, 0x01bd, 0x0000,
// Entry 1C0 - 1FF
- 0x01bf, 0x0000, 0x01c1, 0x0000, 0x01c3, 0x01c3, 0x01c3, 0x01c3,
- 0x0000, 0x01c8, 0x0000, 0x01ca, 0x01ca, 0x0000, 0x01cd, 0x0000,
+ 0x01bf, 0x0000, 0x01c1, 0x0000, 0x01c3, 0x0000, 0x01c5, 0x01c5,
+ 0x01c5, 0x01c5, 0x0000, 0x01ca, 0x0000, 0x01cc, 0x01cc, 0x0000,
0x01cf, 0x0000, 0x01d1, 0x0000, 0x01d3, 0x0000, 0x01d5, 0x0000,
- 0x01d7, 0x01d7, 0x0000, 0x01da, 0x0000, 0x01dc, 0x0000, 0x01de,
+ 0x01d7, 0x0000, 0x01d9, 0x01d9, 0x0000, 0x01dc, 0x0000, 0x01de,
0x0000, 0x01e0, 0x0000, 0x01e2, 0x0000, 0x01e4, 0x0000, 0x01e6,
- 0x0000, 0x01e8, 0x0000, 0x01ea, 0x0000, 0x01ec, 0x01ec, 0x01ec,
- 0x0000, 0x01f0, 0x0000, 0x01f2, 0x0000, 0x01f4, 0x0000, 0x01f6,
- 0x0000, 0x0000, 0x01f9, 0x0000, 0x01fb, 0x01fb, 0x0000, 0x01fe,
+ 0x0000, 0x01e8, 0x0000, 0x01ea, 0x0000, 0x01ec, 0x0000, 0x01ee,
+ 0x01ee, 0x01ee, 0x0000, 0x01f2, 0x0000, 0x01f4, 0x0000, 0x01f6,
+ 0x0000, 0x01f8, 0x0000, 0x0000, 0x01fb, 0x0000, 0x01fd, 0x01fd,
// Entry 200 - 23F
- 0x0000, 0x0200, 0x0200, 0x0000, 0x0203, 0x0203, 0x0000, 0x0206,
- 0x0206, 0x0206, 0x0206, 0x0206, 0x0206, 0x0206, 0x0000, 0x020e,
- 0x0000, 0x0210, 0x0000, 0x0212, 0x0000, 0x0000, 0x0000, 0x0000,
- 0x0000, 0x0218, 0x0000, 0x0000, 0x021b, 0x0000, 0x021d, 0x021d,
- 0x0000, 0x0220, 0x0000, 0x0222, 0x0222, 0x0000, 0x0000, 0x0226,
- 0x0225, 0x0225, 0x0000, 0x0000, 0x022b, 0x0000, 0x022d, 0x0000,
- 0x022f, 0x0000, 0x023b, 0x0231, 0x023b, 0x023b, 0x023b, 0x023b,
- 0x023b, 0x023b, 0x023b, 0x0231, 0x023b, 0x023b, 0x0000, 0x023e,
+ 0x0000, 0x0200, 0x0000, 0x0202, 0x0202, 0x0000, 0x0205, 0x0205,
+ 0x0000, 0x0208, 0x0208, 0x0208, 0x0208, 0x0208, 0x0208, 0x0208,
+ 0x0000, 0x0210, 0x0000, 0x0212, 0x0000, 0x0214, 0x0000, 0x0000,
+ 0x0000, 0x0000, 0x0000, 0x021a, 0x0000, 0x0000, 0x021d, 0x0000,
+ 0x021f, 0x021f, 0x0000, 0x0222, 0x0000, 0x0224, 0x0224, 0x0000,
+ 0x0000, 0x0228, 0x0227, 0x0227, 0x0000, 0x0000, 0x022d, 0x0000,
+ 0x022f, 0x0000, 0x0231, 0x0000, 0x023d, 0x0233, 0x023d, 0x023d,
+ 0x023d, 0x023d, 0x023d, 0x023d, 0x023d, 0x0233, 0x023d, 0x023d,
// Entry 240 - 27F
- 0x023e, 0x023e, 0x0000, 0x0242, 0x0000, 0x0244, 0x0000, 0x0246,
- 0x0246, 0x0000, 0x0249, 0x0000, 0x024b, 0x024b, 0x024b, 0x024b,
- 0x024b, 0x024b, 0x0000, 0x0252, 0x0000, 0x0254, 0x0000, 0x0256,
- 0x0000, 0x0258, 0x0000, 0x025a, 0x0000, 0x0000, 0x025d, 0x025d,
- 0x025d, 0x0000, 0x0261, 0x0000, 0x0263, 0x0000, 0x0265, 0x0000,
- 0x0000, 0x0268, 0x0267, 0x0267, 0x0000, 0x026c, 0x0000, 0x026e,
- 0x0000, 0x0270, 0x0000, 0x0000, 0x0000, 0x0000, 0x0275, 0x0000,
- 0x0000, 0x0278, 0x0000, 0x027a, 0x027a, 0x027a, 0x027a, 0x0000,
+ 0x0000, 0x0240, 0x0240, 0x0240, 0x0000, 0x0244, 0x0000, 0x0246,
+ 0x0000, 0x0248, 0x0248, 0x0000, 0x024b, 0x0000, 0x024d, 0x024d,
+ 0x024d, 0x024d, 0x024d, 0x024d, 0x0000, 0x0254, 0x0000, 0x0256,
+ 0x0000, 0x0258, 0x0000, 0x025a, 0x0000, 0x025c, 0x0000, 0x0000,
+ 0x025f, 0x025f, 0x025f, 0x0000, 0x0263, 0x0000, 0x0265, 0x0000,
+ 0x0267, 0x0000, 0x0000, 0x026a, 0x0269, 0x0269, 0x0000, 0x026e,
+ 0x0000, 0x0270, 0x0000, 0x0272, 0x0000, 0x0000, 0x0000, 0x0000,
+ 0x0277, 0x0000, 0x0000, 0x027a, 0x0000, 0x027c, 0x027c, 0x027c,
// Entry 280 - 2BF
- 0x027f, 0x027f, 0x027f, 0x0000, 0x0283, 0x0283, 0x0283, 0x0283,
- 0x0283, 0x0000, 0x0289, 0x0289, 0x0289, 0x0289, 0x0000, 0x0000,
- 0x0000, 0x0000, 0x0291, 0x0291, 0x0291, 0x0000, 0x0295, 0x0295,
- 0x0295, 0x0295, 0x0000, 0x0000, 0x029b, 0x029b, 0x029b, 0x029b,
- 0x0000, 0x02a0, 0x0000, 0x02a2, 0x02a2, 0x0000, 0x02a5, 0x0000,
- 0x02a7, 0x02a7, 0x0000, 0x0000, 0x02ab, 0x0000, 0x0000, 0x02ae,
- 0x0000, 0x02b0, 0x02b0, 0x0000, 0x0000, 0x02b4, 0x0000, 0x02b6,
- 0x0000, 0x02b8, 0x0000, 0x02ba, 0x0000, 0x02bc, 0x02bc, 0x0000,
+ 0x027c, 0x0000, 0x0281, 0x0281, 0x0281, 0x0000, 0x0285, 0x0285,
+ 0x0285, 0x0285, 0x0285, 0x0000, 0x028b, 0x028b, 0x028b, 0x028b,
+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0293, 0x0293, 0x0293, 0x0000,
+ 0x0297, 0x0297, 0x0297, 0x0297, 0x0000, 0x0000, 0x029d, 0x029d,
+ 0x029d, 0x029d, 0x0000, 0x02a2, 0x0000, 0x02a4, 0x02a4, 0x0000,
+ 0x02a7, 0x0000, 0x02a9, 0x02a9, 0x0000, 0x0000, 0x02ad, 0x0000,
+ 0x0000, 0x02b0, 0x0000, 0x02b2, 0x02b2, 0x0000, 0x0000, 0x02b6,
+ 0x0000, 0x02b8, 0x0000, 0x02ba, 0x0000, 0x02bc, 0x0000, 0x02be,
// Entry 2C0 - 2FF
- 0x0000, 0x02c0, 0x0000, 0x02c2, 0x02bf, 0x02bf, 0x0000, 0x0000,
- 0x02c7, 0x02c6, 0x02c6, 0x0000, 0x0000, 0x02cc, 0x0000, 0x02ce,
- 0x0000, 0x02d0, 0x0000, 0x0000, 0x02d3, 0x0000, 0x0000, 0x0000,
- 0x02d7, 0x0000, 0x02d9, 0x0000, 0x02db, 0x0000, 0x02dd, 0x02dd,
- 0x0000, 0x02e0, 0x0000, 0x02e2, 0x0000, 0x02e4, 0x02e4, 0x02e4,
- 0x02e4, 0x02e4, 0x0000, 0x02ea, 0x02eb, 0x02ea, 0x0000, 0x02ee,
-} // Size: 1528 bytes
+ 0x02be, 0x0000, 0x0000, 0x02c2, 0x0000, 0x02c4, 0x02c1, 0x02c1,
+ 0x0000, 0x0000, 0x02c9, 0x02c8, 0x02c8, 0x0000, 0x0000, 0x02ce,
+ 0x0000, 0x02d0, 0x0000, 0x02d2, 0x0000, 0x0000, 0x02d5, 0x0000,
+ 0x0000, 0x0000, 0x02d9, 0x0000, 0x02db, 0x0000, 0x02dd, 0x0000,
+ 0x02df, 0x02df, 0x0000, 0x02e2, 0x0000, 0x02e4, 0x0000, 0x02e6,
+ 0x02e6, 0x02e6, 0x02e6, 0x02e6, 0x0000, 0x02ec, 0x02ed, 0x02ec,
+ 0x0000, 0x02f0,
+} // Size: 1532 bytes
-// Total table size 1528 bytes (1KiB); checksum: B99CF952
+// Total table size 1532 bytes (1KiB); checksum: 90718A2
generated by cgit v1.2.3-1-g7c22 (git 2.25.1) at 2024-06-28 06:09:28 +0000