tweak cardinal rule generation for final design.

cmd/resources/generate_resources.go

@@ -5,6 +5,7 @@ import (
 	"log"
 	"os"
 	"os/exec"
+	"sort"
 	"strings"
 
 	"github.com/go-playground/universal-translator/resources/locales"
@@ -50,37 +51,12 @@ const (
 
 var (
 	prVarFuncs = map[string]string{
-		"n": `n, err := locales.N(num)
-		if err != nil {
-			return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue:num, InnerError: err}
-		}
-
-		`,
-		"i": `i, err := locales.I(num)
-		if err != nil {
-			return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue:num, InnerError: err}
-		}
-
-		`,
-		"v": "v := locales.V(num)\n\n",
-		"w": `w, err := locales.W(num)
-		if err != nil {
-			return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue:num, InnerError: err}
-		}
-
-		`,
-		"f": `f, err := locales.F(num)
-		if err != nil {
-			return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue:num, InnerError: err}
-		}
-
-		`,
-		"t": `t, err := locales.T(num)
-		if err != nil {
-			return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue:num, InnerError: err}
-		}
-
-		`,
+		"n": "n := math.Abs(num)\n",
+		"i": "i := int64(n)\n",
+		// "v": "v := ...", // inherently available as argument
+		"w": "w := locales.W(n, v)\n",
+		"f": "f := locales.F(n, v)\n",
+		"t": "t := locales.T(n, v)\n",
 	}
 )
 
@@ -109,27 +85,8 @@ func main() {
 		panic(err)
 	}
 
-	// cardinalPlurals := map[string]
-
-	// for _, p := range ldr.Supplemental().Plurals {
-
-	// 	for _, pr := range p.PluralRules {
-
-	// 		fmt.Println(pr.Locales)
-
-	// 		for _, rule := range pr.PluralRule {
-	// 			fmt.Println(rule.Count, rule.Common.Data())
-	// 		}
-	// 	}
-	// }
-
 	for _, l := range cldr.Locales() {
 
-		// // work on uk for the moment
-		// if l != "uk" && l != "fil" && l != "gd" {
-		// if l != "gd" {
-		// 	continue
-		// }
 		fmt.Println(l)
 
 		baseLocale := strings.SplitN(l, "_", 2)[0]
@@ -138,36 +95,60 @@ func main() {
 			Locale: l,
 		}
 
+		// plural rules
 		trans.CardinalFunc, trans.Plurals = parseCardinalPluralRuleFunc(cldr, baseLocale)
 
-		// fmt.Println(trans.CardinalFunc, trans.Plurals)
-		// cardinalRules := getLocaleCardinalPluralRules(cldr, baseLocale)
-		// fmt.Println("CardinalRules:", l, cardinalRules)
-		// Start Plural Rules
+		// // number values
+		// ldml := cldr.RawLDML(l)
+
+		// var decimal, group, minus, percent, permille string
+
+		// // some just have no data...
+		// if ldml.Numbers != nil {
 
-		// for _, p := range cldr.Supplemental().Plurals {
+		// 	symbol := ldml.Numbers.Symbols[0]
 
-		// 	for _, pr := range p.PluralRules {
+		// 	if len(symbol.Decimal) > 0 {
+		// 		decimal = symbol.Decimal[0].Data()
+		// 	}
+		// 	if len(symbol.Group) > 0 {
+		// 		group = symbol.Group[0].Data()
+		// 	}
+		// 	if len(symbol.MinusSign) > 0 {
+		// 		minus = symbol.MinusSign[0].Data()
+		// 	}
+		// 	if len(symbol.PercentSign) > 0 {
+		// 		percent = symbol.PercentSign[0].Data()
+		// 	}
+		// 	if len(symbol.PerMille) > 0 {
+		// 		permille = symbol.PerMille[0].Data()
+		// 	}
+		// }
 
-		// 		locales := strings.Split(pr.Locales, " ")
+		// var decimalFormat, currencyFormat, currencyAccountingFormat, percentageFormat string
 
-		// 		for _, loc := range locales {
+		// if len(ldml.Numbers.DecimalFormats) > 0 && len(ldml.Numbers.DecimalFormats[0].DecimalFormatLength) > 0 {
+		// 	decimalFormat = ldml.Numbers.DecimalFormats[0].DecimalFormatLength[0].DecimalFormat[0].Pattern[0].Data()
+		// }
 
-		// 			if loc == baseLocale {
+		// if len(ldml.Numbers.CurrencyFormats) > 0 && len(ldml.Numbers.CurrencyFormats[0].CurrencyFormatLength) > 0 {
 
-		// 				// plural rule found
-		// 				fmt.Println("Locale Plural Rules Found:", loc, baseLocale, l)
-		// 			}
-		// 		}
-		// 		// fmt.Println(pr.Locales)
+		// 	currencyFormat = ldml.Numbers.CurrencyFormats[0].CurrencyFormatLength[0].CurrencyFormat[0].Pattern[0].Data()
+		// 	currencyAccountingFormat = currencyFormat
 
-		// 		// for _, rule := range pr.PluralRule {
-		// 		// 	fmt.Println(rule.Count, rule.Common.Data())
-		// 		// }
+		// 	if len(ldml.Numbers.CurrencyFormats[0].CurrencyFormatLength[0].CurrencyFormat) > 1 {
+		// 		currencyAccountingFormat = ldml.Numbers.CurrencyFormats[0].CurrencyFormatLength[0].CurrencyFormat[1].Pattern[0].Data()
 		// 	}
 		// }
 
-		// End Plural Rules
+		// if len(ldml.Numbers.PercentFormats) > 0 && len(ldml.Numbers.PercentFormats[0].PercentFormatLength) > 0 {
+		// 	percentageFormat = ldml.Numbers.PercentFormats[0].PercentFormatLength[0].PercentFormat[0].Pattern[0].Data()
+		// }
+
+		// // parse Number values
+		// parseNumbers(decimal, group, minus, percent, permille, decimalFormat, currencyFormat, currencyAccountingFormat, percentageFormat)
+
+		// end number values
 
 		if err = os.MkdirAll(fmt.Sprintf(locDir, l), 0777); err != nil {
 			log.Fatal(err)
@@ -195,6 +176,134 @@ func main() {
 	}
 }
 
+// func parseNumbers(decimal, group, minus, percent, permille, decimalFormat, currencyFormat, currencyAccountingFormat, percentageFormat string) {
+
+// 	if includeDecimalDigits {
+
+// 		nfMutex.RLock()
+
+// 		if format, exists := numberFormats[pattern]; exists {
+// 			nfMutex.RUnlock()
+// 			return format
+// 		}
+
+// 		nfMutex.RUnlock()
+
+// 	} else {
+
+// 		nfndMutex.RLock()
+
+// 		if format, exists := numberFormatsNoDecimals[pattern]; exists {
+// 			nfndMutex.RUnlock()
+// 			return format
+// 		}
+
+// 		nfndMutex.RUnlock()
+// 	}
+
+// 	format := new(numberFormat)
+// 	patterns := strings.Split(pattern, ";")
+
+// 	matches := prefixSuffixRegex.FindAllStringSubmatch(patterns[0], -1)
+// 	if len(matches) > 0 {
+// 		if len(matches[0]) > 1 {
+// 			format.positivePrefix = matches[0][1]
+// 		}
+// 		if len(matches[0]) > 2 {
+// 			format.positiveSuffix = matches[0][2]
+// 		}
+// 	}
+
+// 	// default values for negative prefix & suffix
+// 	format.negativePrefix = string(n.Symbols.Negative) + string(format.positivePrefix)
+// 	format.negativeSuffix = format.positiveSuffix
+
+// 	// see if they are in the pattern
+// 	if len(patterns) > 1 {
+// 		matches = prefixSuffixRegex.FindAllStringSubmatch(patterns[1], -1)
+
+// 		if len(matches) > 0 {
+// 			if len(matches[0]) > 1 {
+// 				format.negativePrefix = matches[0][1]
+// 			}
+// 			if len(matches[0]) > 2 {
+// 				format.negativeSuffix = matches[0][2]
+// 			}
+// 		}
+// 	}
+
+// 	pat := patterns[0]
+
+// 	if strings.Index(pat, "%") != -1 {
+// 		format.multiplier = 100
+// 	} else if strings.Index(pat, "‰") != -1 {
+// 		format.multiplier = 1000
+// 	} else {
+// 		format.multiplier = 1
+// 	}
+
+// 	pos := strings.Index(pat, ".")
+
+// 	if pos != -1 {
+// 		pos2 := strings.LastIndex(pat, "0")
+// 		if pos2 > pos {
+// 			format.minDecimalDigits = pos2 - pos
+// 		}
+
+// 		pos3 := strings.LastIndex(pat, "#")
+// 		if pos3 >= pos2 {
+// 			format.maxDecimalDigits = pos3 - pos
+// 		} else {
+// 			format.maxDecimalDigits = format.minDecimalDigits
+// 		}
+
+// 		pat = pat[0:pos]
+// 	}
+
+// 	p := strings.Replace(pat, ",", "", -1)
+// 	pos = strings.Index(p, "0")
+// 	if pos != -1 {
+// 		format.minIntegerDigits = strings.LastIndex(p, "0") - pos + 1
+// 	}
+
+// 	p = strings.Replace(pat, "#", "0", -1)
+// 	pos = strings.LastIndex(pat, ",")
+// 	if pos != -1 {
+// 		format.groupSizeFinal = strings.LastIndex(p, "0") - pos
+// 		pos2 := strings.LastIndex(p[0:pos], ",")
+// 		if pos2 != -1 {
+// 			format.groupSizeMain = pos - pos2 - 1
+// 		} else {
+// 			format.groupSizeMain = format.groupSizeFinal
+// 		}
+// 	}
+
+// 	if includeDecimalDigits {
+// 		nfMutex.Lock()
+// 		numberFormats[pattern] = format
+// 		nfMutex.Unlock()
+// 		return format
+// 	}
+
+// 	format.maxDecimalDigits = 0
+// 	format.minDecimalDigits = 0
+// 	nfndMutex.Lock()
+// 	numberFormatsNoDecimals[pattern] = format
+// 	nfndMutex.Unlock()
+// 	return format
+// }
+
+type sortRank struct {
+	Rank  uint8
+	Value string
+}
+
+type ByRank []sortRank
+
+func (a ByRank) Len() int           { return len(a) }
+func (a ByRank) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
+func (a ByRank) Less(i, j int) bool { return a[i].Rank < a[j].Rank }
+
 // TODO: cleanup function logic perhaps write a lexer... but it's working right now, and
 // I'm already farther down the rabbit hole than I'd like and so pulling the chute here.
 func parseCardinalPluralRuleFunc(current *cldr.CLDR, baseLocale string) (results string, plurals string) {
@@ -242,35 +351,35 @@ func parseCardinalPluralRuleFunc(current *cldr.CLDR, baseLocale string) (results
 		psI := pluralStringToInt(rule.Count)
 		pluralArr = append(pluralArr, psI)
 
-		// fmt.Println(rule.Count, ps1)
-
 		data := strings.Replace(strings.Replace(strings.Replace(strings.TrimSpace(strings.SplitN(rule.Common.Data(), "@", 2)[0]), " = ", " == ", -1), " or ", " || ", -1), " and ", " && ", -1)
 
 		if len(data) == 0 {
 			if len(prCardinal.PluralRule) == 1 {
 
-				results = "return locales." + ps1 + ", nil"
+				results = "return locales." + ps1
 
 			} else {
 
-				results += "\n\nreturn locales." + ps1 + ", nil"
+				results += "\n\nreturn locales." + ps1
 				// results += "else {\nreturn locales." + locales.PluralStringToString(rule.Count) + ", nil\n}"
 			}
 
 			continue
 		}
 
-		if strings.Contains(data, "n") {
-			vals[prVarFuncs["n"]] = struct{}{}
-		}
+		// // All need n, so always add
+		// if strings.Contains(data, "n") {
+		// 	vals[prVarFuncs["n"]] = struct{}{}
+		// }
 
 		if strings.Contains(data, "i") {
 			vals[prVarFuncs["i"]] = struct{}{}
 		}
 
-		if strings.Contains(data, "v") {
-			vals[prVarFuncs["v"]] = struct{}{}
-		}
+		// v is inherently avaialable as an argument
+		// if strings.Contains(data, "v") {
+		// 	vals[prVarFuncs["v"]] = struct{}{}
+		// }
 
 		if strings.Contains(data, "w") {
 			vals[prVarFuncs["w"]] = struct{}{}
@@ -406,21 +515,58 @@ func parseCardinalPluralRuleFunc(current *cldr.CLDR, baseLocale string) (results
 		results += " {\n"
 
 		// return plural rule here
-		results += "return locales." + ps1 + ", nil\n"
+		results += "return locales." + ps1 + "\n"
 
 		results += "}"
 	}
 
 	pre := "\n"
 
+	// always needed
+	vals[prVarFuncs["n"]] = struct{}{}
+
+	sorted := make([]sortRank, 0, len(vals))
+
 	for k := range vals {
-		pre += k
+		switch k[:1] {
+		case "n":
+			sorted = append(sorted, sortRank{
+				Value: prVarFuncs["n"],
+				Rank:  1,
+			})
+		case "i":
+			sorted = append(sorted, sortRank{
+				Value: prVarFuncs["i"],
+				Rank:  2,
+			})
+		case "w":
+			sorted = append(sorted, sortRank{
+				Value: prVarFuncs["w"],
+				Rank:  3,
+			})
+		case "f":
+			sorted = append(sorted, sortRank{
+				Value: prVarFuncs["f"],
+				Rank:  4,
+			})
+		case "t":
+			sorted = append(sorted, sortRank{
+				Value: prVarFuncs["t"],
+				Rank:  5,
+			})
+		}
+	}
+
+	sort.Sort(ByRank(sorted))
+
+	for _, k := range sorted {
+		pre += k.Value
 	}
 
 	pre += "\n"
 
 	if len(results) == 0 {
-		results = "return locales.PluralRuleUnknown,nil"
+		results = "return locales.PluralRuleUnknown"
 	}
 
 	results = pre + results

cmd/resources/translator.tmpl

@@ -2,6 +2,8 @@
 package {{ .Locale }}
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -28,8 +30,8 @@ func(t *{{ .Locale }}) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for '{{ .Locale }}'
-func(t *{{ .Locale }}) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for '{{ .Locale }}'
+func(t *{{ .Locale }}) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 	{{ .CardinalFunc }}
 }
 

resources/locales/af/af.go

@@ -1,6 +1,8 @@
 package af
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,17 +29,14 @@ func (t *af) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'af'
-func (t *af) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'af'
+func (t *af) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/af_NA/af_NA.go

@@ -1,6 +1,8 @@
 package af_NA
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,17 +29,14 @@ func (t *af_NA) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'af_NA'
-func (t *af_NA) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'af_NA'
+func (t *af_NA) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/af_ZA/af_ZA.go

@@ -1,6 +1,8 @@
 package af_ZA
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,17 +29,14 @@ func (t *af_ZA) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'af_ZA'
-func (t *af_ZA) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'af_ZA'
+func (t *af_ZA) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/agq/agq.go

@@ -1,6 +1,8 @@
 package agq
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,7 +29,7 @@ func (t *agq) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'agq'
-func (t *agq) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'agq'
+func (t *agq) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 	return locales.PluralRuleUnknown, nil
 }

resources/locales/agq_CM/agq_CM.go

@@ -1,6 +1,8 @@
 package agq_CM
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,7 +29,7 @@ func (t *agq_CM) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'agq_CM'
-func (t *agq_CM) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'agq_CM'
+func (t *agq_CM) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 	return locales.PluralRuleUnknown, nil
 }

resources/locales/ak/ak.go

@@ -1,6 +1,8 @@
 package ak
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,17 +29,14 @@ func (t *ak) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ak'
-func (t *ak) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ak'
+func (t *ak) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n >= 0 && n <= 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ak_GH/ak_GH.go

@@ -1,6 +1,8 @@
 package ak_GH
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,17 +29,14 @@ func (t *ak_GH) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ak_GH'
-func (t *ak_GH) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ak_GH'
+func (t *ak_GH) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n >= 0 && n <= 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/am/am.go

@@ -1,6 +1,8 @@
 package am
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,22 +29,15 @@ func (t *am) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'am'
-func (t *am) CardinalPluralRule(num string) (locales.PluralRule, error) {
-
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'am'
+func (t *am) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	i, err := locales.I(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
+	i := int64(n)
 
 	if (i == 0) || (n == 1) {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/am_ET/am_ET.go

@@ -1,6 +1,8 @@
 package am_ET
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,22 +29,15 @@ func (t *am_ET) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'am_ET'
-func (t *am_ET) CardinalPluralRule(num string) (locales.PluralRule, error) {
-
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'am_ET'
+func (t *am_ET) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	i, err := locales.I(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
+	i := int64(n)
 
 	if (i == 0) || (n == 1) {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ar/ar.go

@@ -1,6 +1,8 @@
 package ar
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,25 +29,22 @@ func (t *ar) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ar'
-func (t *ar) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ar'
+func (t *ar) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 0 {
-		return locales.PluralRuleZero, nil
+		return locales.PluralRuleZero
 	} else if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if n == 2 {
-		return locales.PluralRuleTwo, nil
+		return locales.PluralRuleTwo
 	} else if n%100 >= 3 && n%100 <= 10 {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	} else if n%100 >= 11 && n%100 <= 99 {
-		return locales.PluralRuleMany, nil
+		return locales.PluralRuleMany
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ar_001/ar_001.go

@@ -1,6 +1,8 @@
 package ar_001
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,25 +29,22 @@ func (t *ar_001) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ar_001'
-func (t *ar_001) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ar_001'
+func (t *ar_001) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 0 {
-		return locales.PluralRuleZero, nil
+		return locales.PluralRuleZero
 	} else if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if n == 2 {
-		return locales.PluralRuleTwo, nil
+		return locales.PluralRuleTwo
 	} else if n%100 >= 3 && n%100 <= 10 {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	} else if n%100 >= 11 && n%100 <= 99 {
-		return locales.PluralRuleMany, nil
+		return locales.PluralRuleMany
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ar_AE/ar_AE.go

@@ -1,6 +1,8 @@
 package ar_AE
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,25 +29,22 @@ func (t *ar_AE) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ar_AE'
-func (t *ar_AE) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ar_AE'
+func (t *ar_AE) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 0 {
-		return locales.PluralRuleZero, nil
+		return locales.PluralRuleZero
 	} else if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if n == 2 {
-		return locales.PluralRuleTwo, nil
+		return locales.PluralRuleTwo
 	} else if n%100 >= 3 && n%100 <= 10 {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	} else if n%100 >= 11 && n%100 <= 99 {
-		return locales.PluralRuleMany, nil
+		return locales.PluralRuleMany
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ar_BH/ar_BH.go

@@ -1,6 +1,8 @@
 package ar_BH
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,25 +29,22 @@ func (t *ar_BH) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ar_BH'
-func (t *ar_BH) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ar_BH'
+func (t *ar_BH) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 0 {
-		return locales.PluralRuleZero, nil
+		return locales.PluralRuleZero
 	} else if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if n == 2 {
-		return locales.PluralRuleTwo, nil
+		return locales.PluralRuleTwo
 	} else if n%100 >= 3 && n%100 <= 10 {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	} else if n%100 >= 11 && n%100 <= 99 {
-		return locales.PluralRuleMany, nil
+		return locales.PluralRuleMany
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ar_DJ/ar_DJ.go

@@ -1,6 +1,8 @@
 package ar_DJ
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,25 +29,22 @@ func (t *ar_DJ) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ar_DJ'
-func (t *ar_DJ) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ar_DJ'
+func (t *ar_DJ) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 0 {
-		return locales.PluralRuleZero, nil
+		return locales.PluralRuleZero
 	} else if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if n == 2 {
-		return locales.PluralRuleTwo, nil
+		return locales.PluralRuleTwo
 	} else if n%100 >= 3 && n%100 <= 10 {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	} else if n%100 >= 11 && n%100 <= 99 {
-		return locales.PluralRuleMany, nil
+		return locales.PluralRuleMany
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ar_DZ/ar_DZ.go

@@ -1,6 +1,8 @@
 package ar_DZ
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,25 +29,22 @@ func (t *ar_DZ) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ar_DZ'
-func (t *ar_DZ) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ar_DZ'
+func (t *ar_DZ) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 0 {
-		return locales.PluralRuleZero, nil
+		return locales.PluralRuleZero
 	} else if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if n == 2 {
-		return locales.PluralRuleTwo, nil
+		return locales.PluralRuleTwo
 	} else if n%100 >= 3 && n%100 <= 10 {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	} else if n%100 >= 11 && n%100 <= 99 {
-		return locales.PluralRuleMany, nil
+		return locales.PluralRuleMany
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ar_EG/ar_EG.go

@@ -1,6 +1,8 @@
 package ar_EG
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,25 +29,22 @@ func (t *ar_EG) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ar_EG'
-func (t *ar_EG) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ar_EG'
+func (t *ar_EG) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 0 {
-		return locales.PluralRuleZero, nil
+		return locales.PluralRuleZero
 	} else if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if n == 2 {
-		return locales.PluralRuleTwo, nil
+		return locales.PluralRuleTwo
 	} else if n%100 >= 3 && n%100 <= 10 {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	} else if n%100 >= 11 && n%100 <= 99 {
-		return locales.PluralRuleMany, nil
+		return locales.PluralRuleMany
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ar_EH/ar_EH.go

@@ -1,6 +1,8 @@
 package ar_EH
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,25 +29,22 @@ func (t *ar_EH) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ar_EH'
-func (t *ar_EH) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ar_EH'
+func (t *ar_EH) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 0 {
-		return locales.PluralRuleZero, nil
+		return locales.PluralRuleZero
 	} else if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if n == 2 {
-		return locales.PluralRuleTwo, nil
+		return locales.PluralRuleTwo
 	} else if n%100 >= 3 && n%100 <= 10 {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	} else if n%100 >= 11 && n%100 <= 99 {
-		return locales.PluralRuleMany, nil
+		return locales.PluralRuleMany
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ar_ER/ar_ER.go

@@ -1,6 +1,8 @@
 package ar_ER
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,25 +29,22 @@ func (t *ar_ER) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ar_ER'
-func (t *ar_ER) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ar_ER'
+func (t *ar_ER) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 0 {
-		return locales.PluralRuleZero, nil
+		return locales.PluralRuleZero
 	} else if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if n == 2 {
-		return locales.PluralRuleTwo, nil
+		return locales.PluralRuleTwo
 	} else if n%100 >= 3 && n%100 <= 10 {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	} else if n%100 >= 11 && n%100 <= 99 {
-		return locales.PluralRuleMany, nil
+		return locales.PluralRuleMany
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ar_IL/ar_IL.go

@@ -1,6 +1,8 @@
 package ar_IL
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,25 +29,22 @@ func (t *ar_IL) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ar_IL'
-func (t *ar_IL) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ar_IL'
+func (t *ar_IL) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 0 {
-		return locales.PluralRuleZero, nil
+		return locales.PluralRuleZero
 	} else if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if n == 2 {
-		return locales.PluralRuleTwo, nil
+		return locales.PluralRuleTwo
 	} else if n%100 >= 3 && n%100 <= 10 {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	} else if n%100 >= 11 && n%100 <= 99 {
-		return locales.PluralRuleMany, nil
+		return locales.PluralRuleMany
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ar_IQ/ar_IQ.go

@@ -1,6 +1,8 @@
 package ar_IQ
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,25 +29,22 @@ func (t *ar_IQ) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ar_IQ'
-func (t *ar_IQ) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ar_IQ'
+func (t *ar_IQ) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 0 {
-		return locales.PluralRuleZero, nil
+		return locales.PluralRuleZero
 	} else if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if n == 2 {
-		return locales.PluralRuleTwo, nil
+		return locales.PluralRuleTwo
 	} else if n%100 >= 3 && n%100 <= 10 {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	} else if n%100 >= 11 && n%100 <= 99 {
-		return locales.PluralRuleMany, nil
+		return locales.PluralRuleMany
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ar_JO/ar_JO.go

@@ -1,6 +1,8 @@
 package ar_JO
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,25 +29,22 @@ func (t *ar_JO) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ar_JO'
-func (t *ar_JO) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ar_JO'
+func (t *ar_JO) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 0 {
-		return locales.PluralRuleZero, nil
+		return locales.PluralRuleZero
 	} else if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if n == 2 {
-		return locales.PluralRuleTwo, nil
+		return locales.PluralRuleTwo
 	} else if n%100 >= 3 && n%100 <= 10 {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	} else if n%100 >= 11 && n%100 <= 99 {
-		return locales.PluralRuleMany, nil
+		return locales.PluralRuleMany
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ar_KM/ar_KM.go

@@ -1,6 +1,8 @@
 package ar_KM
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,25 +29,22 @@ func (t *ar_KM) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ar_KM'
-func (t *ar_KM) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ar_KM'
+func (t *ar_KM) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 0 {
-		return locales.PluralRuleZero, nil
+		return locales.PluralRuleZero
 	} else if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if n == 2 {
-		return locales.PluralRuleTwo, nil
+		return locales.PluralRuleTwo
 	} else if n%100 >= 3 && n%100 <= 10 {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	} else if n%100 >= 11 && n%100 <= 99 {
-		return locales.PluralRuleMany, nil
+		return locales.PluralRuleMany
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ar_KW/ar_KW.go

@@ -1,6 +1,8 @@
 package ar_KW
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,25 +29,22 @@ func (t *ar_KW) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ar_KW'
-func (t *ar_KW) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ar_KW'
+func (t *ar_KW) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 0 {
-		return locales.PluralRuleZero, nil
+		return locales.PluralRuleZero
 	} else if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if n == 2 {
-		return locales.PluralRuleTwo, nil
+		return locales.PluralRuleTwo
 	} else if n%100 >= 3 && n%100 <= 10 {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	} else if n%100 >= 11 && n%100 <= 99 {
-		return locales.PluralRuleMany, nil
+		return locales.PluralRuleMany
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ar_LB/ar_LB.go

@@ -1,6 +1,8 @@
 package ar_LB
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,25 +29,22 @@ func (t *ar_LB) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ar_LB'
-func (t *ar_LB) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ar_LB'
+func (t *ar_LB) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 0 {
-		return locales.PluralRuleZero, nil
+		return locales.PluralRuleZero
 	} else if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if n == 2 {
-		return locales.PluralRuleTwo, nil
+		return locales.PluralRuleTwo
 	} else if n%100 >= 3 && n%100 <= 10 {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	} else if n%100 >= 11 && n%100 <= 99 {
-		return locales.PluralRuleMany, nil
+		return locales.PluralRuleMany
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ar_LY/ar_LY.go

@@ -1,6 +1,8 @@
 package ar_LY
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,25 +29,22 @@ func (t *ar_LY) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ar_LY'
-func (t *ar_LY) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ar_LY'
+func (t *ar_LY) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 0 {
-		return locales.PluralRuleZero, nil
+		return locales.PluralRuleZero
 	} else if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if n == 2 {
-		return locales.PluralRuleTwo, nil
+		return locales.PluralRuleTwo
 	} else if n%100 >= 3 && n%100 <= 10 {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	} else if n%100 >= 11 && n%100 <= 99 {
-		return locales.PluralRuleMany, nil
+		return locales.PluralRuleMany
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ar_MA/ar_MA.go

@@ -1,6 +1,8 @@
 package ar_MA
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,25 +29,22 @@ func (t *ar_MA) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ar_MA'
-func (t *ar_MA) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ar_MA'
+func (t *ar_MA) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 0 {
-		return locales.PluralRuleZero, nil
+		return locales.PluralRuleZero
 	} else if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if n == 2 {
-		return locales.PluralRuleTwo, nil
+		return locales.PluralRuleTwo
 	} else if n%100 >= 3 && n%100 <= 10 {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	} else if n%100 >= 11 && n%100 <= 99 {
-		return locales.PluralRuleMany, nil
+		return locales.PluralRuleMany
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ar_MR/ar_MR.go

@@ -1,6 +1,8 @@
 package ar_MR
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,25 +29,22 @@ func (t *ar_MR) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ar_MR'
-func (t *ar_MR) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ar_MR'
+func (t *ar_MR) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 0 {
-		return locales.PluralRuleZero, nil
+		return locales.PluralRuleZero
 	} else if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if n == 2 {
-		return locales.PluralRuleTwo, nil
+		return locales.PluralRuleTwo
 	} else if n%100 >= 3 && n%100 <= 10 {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	} else if n%100 >= 11 && n%100 <= 99 {
-		return locales.PluralRuleMany, nil
+		return locales.PluralRuleMany
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ar_OM/ar_OM.go

@@ -1,6 +1,8 @@
 package ar_OM
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,25 +29,22 @@ func (t *ar_OM) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ar_OM'
-func (t *ar_OM) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ar_OM'
+func (t *ar_OM) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 0 {
-		return locales.PluralRuleZero, nil
+		return locales.PluralRuleZero
 	} else if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if n == 2 {
-		return locales.PluralRuleTwo, nil
+		return locales.PluralRuleTwo
 	} else if n%100 >= 3 && n%100 <= 10 {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	} else if n%100 >= 11 && n%100 <= 99 {
-		return locales.PluralRuleMany, nil
+		return locales.PluralRuleMany
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ar_PS/ar_PS.go

@@ -1,6 +1,8 @@
 package ar_PS
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,25 +29,22 @@ func (t *ar_PS) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ar_PS'
-func (t *ar_PS) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ar_PS'
+func (t *ar_PS) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 0 {
-		return locales.PluralRuleZero, nil
+		return locales.PluralRuleZero
 	} else if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if n == 2 {
-		return locales.PluralRuleTwo, nil
+		return locales.PluralRuleTwo
 	} else if n%100 >= 3 && n%100 <= 10 {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	} else if n%100 >= 11 && n%100 <= 99 {
-		return locales.PluralRuleMany, nil
+		return locales.PluralRuleMany
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ar_QA/ar_QA.go

@@ -1,6 +1,8 @@
 package ar_QA
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,25 +29,22 @@ func (t *ar_QA) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ar_QA'
-func (t *ar_QA) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ar_QA'
+func (t *ar_QA) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 0 {
-		return locales.PluralRuleZero, nil
+		return locales.PluralRuleZero
 	} else if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if n == 2 {
-		return locales.PluralRuleTwo, nil
+		return locales.PluralRuleTwo
 	} else if n%100 >= 3 && n%100 <= 10 {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	} else if n%100 >= 11 && n%100 <= 99 {
-		return locales.PluralRuleMany, nil
+		return locales.PluralRuleMany
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ar_SA/ar_SA.go

@@ -1,6 +1,8 @@
 package ar_SA
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,25 +29,22 @@ func (t *ar_SA) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ar_SA'
-func (t *ar_SA) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ar_SA'
+func (t *ar_SA) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 0 {
-		return locales.PluralRuleZero, nil
+		return locales.PluralRuleZero
 	} else if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if n == 2 {
-		return locales.PluralRuleTwo, nil
+		return locales.PluralRuleTwo
 	} else if n%100 >= 3 && n%100 <= 10 {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	} else if n%100 >= 11 && n%100 <= 99 {
-		return locales.PluralRuleMany, nil
+		return locales.PluralRuleMany
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ar_SD/ar_SD.go

@@ -1,6 +1,8 @@
 package ar_SD
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,25 +29,22 @@ func (t *ar_SD) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ar_SD'
-func (t *ar_SD) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ar_SD'
+func (t *ar_SD) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 0 {
-		return locales.PluralRuleZero, nil
+		return locales.PluralRuleZero
 	} else if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if n == 2 {
-		return locales.PluralRuleTwo, nil
+		return locales.PluralRuleTwo
 	} else if n%100 >= 3 && n%100 <= 10 {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	} else if n%100 >= 11 && n%100 <= 99 {
-		return locales.PluralRuleMany, nil
+		return locales.PluralRuleMany
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ar_SO/ar_SO.go

@@ -1,6 +1,8 @@
 package ar_SO
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,25 +29,22 @@ func (t *ar_SO) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ar_SO'
-func (t *ar_SO) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ar_SO'
+func (t *ar_SO) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 0 {
-		return locales.PluralRuleZero, nil
+		return locales.PluralRuleZero
 	} else if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if n == 2 {
-		return locales.PluralRuleTwo, nil
+		return locales.PluralRuleTwo
 	} else if n%100 >= 3 && n%100 <= 10 {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	} else if n%100 >= 11 && n%100 <= 99 {
-		return locales.PluralRuleMany, nil
+		return locales.PluralRuleMany
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ar_SS/ar_SS.go

@@ -1,6 +1,8 @@
 package ar_SS
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,25 +29,22 @@ func (t *ar_SS) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ar_SS'
-func (t *ar_SS) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ar_SS'
+func (t *ar_SS) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 0 {
-		return locales.PluralRuleZero, nil
+		return locales.PluralRuleZero
 	} else if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if n == 2 {
-		return locales.PluralRuleTwo, nil
+		return locales.PluralRuleTwo
 	} else if n%100 >= 3 && n%100 <= 10 {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	} else if n%100 >= 11 && n%100 <= 99 {
-		return locales.PluralRuleMany, nil
+		return locales.PluralRuleMany
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ar_SY/ar_SY.go

@@ -1,6 +1,8 @@
 package ar_SY
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,25 +29,22 @@ func (t *ar_SY) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ar_SY'
-func (t *ar_SY) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ar_SY'
+func (t *ar_SY) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 0 {
-		return locales.PluralRuleZero, nil
+		return locales.PluralRuleZero
 	} else if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if n == 2 {
-		return locales.PluralRuleTwo, nil
+		return locales.PluralRuleTwo
 	} else if n%100 >= 3 && n%100 <= 10 {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	} else if n%100 >= 11 && n%100 <= 99 {
-		return locales.PluralRuleMany, nil
+		return locales.PluralRuleMany
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ar_TD/ar_TD.go

@@ -1,6 +1,8 @@
 package ar_TD
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,25 +29,22 @@ func (t *ar_TD) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ar_TD'
-func (t *ar_TD) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ar_TD'
+func (t *ar_TD) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 0 {
-		return locales.PluralRuleZero, nil
+		return locales.PluralRuleZero
 	} else if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if n == 2 {
-		return locales.PluralRuleTwo, nil
+		return locales.PluralRuleTwo
 	} else if n%100 >= 3 && n%100 <= 10 {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	} else if n%100 >= 11 && n%100 <= 99 {
-		return locales.PluralRuleMany, nil
+		return locales.PluralRuleMany
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ar_TN/ar_TN.go

@@ -1,6 +1,8 @@
 package ar_TN
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,25 +29,22 @@ func (t *ar_TN) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ar_TN'
-func (t *ar_TN) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ar_TN'
+func (t *ar_TN) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 0 {
-		return locales.PluralRuleZero, nil
+		return locales.PluralRuleZero
 	} else if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if n == 2 {
-		return locales.PluralRuleTwo, nil
+		return locales.PluralRuleTwo
 	} else if n%100 >= 3 && n%100 <= 10 {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	} else if n%100 >= 11 && n%100 <= 99 {
-		return locales.PluralRuleMany, nil
+		return locales.PluralRuleMany
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ar_YE/ar_YE.go

@@ -1,6 +1,8 @@
 package ar_YE
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,25 +29,22 @@ func (t *ar_YE) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ar_YE'
-func (t *ar_YE) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ar_YE'
+func (t *ar_YE) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 0 {
-		return locales.PluralRuleZero, nil
+		return locales.PluralRuleZero
 	} else if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if n == 2 {
-		return locales.PluralRuleTwo, nil
+		return locales.PluralRuleTwo
 	} else if n%100 >= 3 && n%100 <= 10 {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	} else if n%100 >= 11 && n%100 <= 99 {
-		return locales.PluralRuleMany, nil
+		return locales.PluralRuleMany
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/as/as.go

@@ -1,6 +1,8 @@
 package as
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,22 +29,15 @@ func (t *as) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'as'
-func (t *as) CardinalPluralRule(num string) (locales.PluralRule, error) {
-
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'as'
+func (t *as) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	i, err := locales.I(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
+	i := int64(n)
 
 	if (i == 0) || (n == 1) {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/as_IN/as_IN.go

@@ -1,6 +1,8 @@
 package as_IN
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,22 +29,15 @@ func (t *as_IN) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'as_IN'
-func (t *as_IN) CardinalPluralRule(num string) (locales.PluralRule, error) {
-
-	i, err := locales.I(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'as_IN'
+func (t *as_IN) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
+	i := int64(n)
 
 	if (i == 0) || (n == 1) {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/asa/asa.go

@@ -1,6 +1,8 @@
 package asa
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,17 +29,14 @@ func (t *asa) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'asa'
-func (t *asa) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'asa'
+func (t *asa) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/asa_TZ/asa_TZ.go

@@ -1,6 +1,8 @@
 package asa_TZ
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,17 +29,14 @@ func (t *asa_TZ) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'asa_TZ'
-func (t *asa_TZ) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'asa_TZ'
+func (t *asa_TZ) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ast/ast.go

@@ -1,6 +1,8 @@
 package ast
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,19 +29,15 @@ func (t *ast) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ast'
-func (t *ast) CardinalPluralRule(num string) (locales.PluralRule, error) {
-
-	i, err := locales.I(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ast'
+func (t *ast) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	v := locales.V(num)
+	n := math.Abs(num)
+	i := int64(n)
 
 	if i == 1 && v == 0 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ast_ES/ast_ES.go

@@ -1,6 +1,8 @@
 package ast_ES
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,19 +29,15 @@ func (t *ast_ES) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ast_ES'
-func (t *ast_ES) CardinalPluralRule(num string) (locales.PluralRule, error) {
-
-	i, err := locales.I(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ast_ES'
+func (t *ast_ES) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	v := locales.V(num)
+	n := math.Abs(num)
+	i := int64(n)
 
 	if i == 1 && v == 0 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/az/az.go

@@ -1,6 +1,8 @@
 package az
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,17 +29,14 @@ func (t *az) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'az'
-func (t *az) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'az'
+func (t *az) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/az_Cyrl/az_Cyrl.go

@@ -1,6 +1,8 @@
 package az_Cyrl
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,17 +29,14 @@ func (t *az_Cyrl) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'az_Cyrl'
-func (t *az_Cyrl) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'az_Cyrl'
+func (t *az_Cyrl) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/az_Cyrl_AZ/az_Cyrl_AZ.go

@@ -1,6 +1,8 @@
 package az_Cyrl_AZ
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,17 +29,14 @@ func (t *az_Cyrl_AZ) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'az_Cyrl_AZ'
-func (t *az_Cyrl_AZ) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'az_Cyrl_AZ'
+func (t *az_Cyrl_AZ) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/az_Latn/az_Latn.go

@@ -1,6 +1,8 @@
 package az_Latn
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,17 +29,14 @@ func (t *az_Latn) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'az_Latn'
-func (t *az_Latn) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'az_Latn'
+func (t *az_Latn) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/az_Latn_AZ/az_Latn_AZ.go

@@ -1,6 +1,8 @@
 package az_Latn_AZ
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,17 +29,14 @@ func (t *az_Latn_AZ) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'az_Latn_AZ'
-func (t *az_Latn_AZ) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'az_Latn_AZ'
+func (t *az_Latn_AZ) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/bas/bas.go

@@ -1,6 +1,8 @@
 package bas
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,7 +29,7 @@ func (t *bas) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'bas'
-func (t *bas) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'bas'
+func (t *bas) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 	return locales.PluralRuleUnknown, nil
 }

resources/locales/bas_CM/bas_CM.go

@@ -1,6 +1,8 @@
 package bas_CM
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,7 +29,7 @@ func (t *bas_CM) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'bas_CM'
-func (t *bas_CM) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'bas_CM'
+func (t *bas_CM) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 	return locales.PluralRuleUnknown, nil
 }

resources/locales/be/be.go

@@ -1,6 +1,8 @@
 package be
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,21 +29,18 @@ func (t *be) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'be'
-func (t *be) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'be'
+func (t *be) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n%10 == 1 && n%100 != 11 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if n%10 >= 2 && n%10 <= 4 && n%100 < 12 && n%100 > 14 {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	} else if (n%10 == 0) || (n%10 >= 5 && n%10 <= 9) || (n%100 >= 11 && n%100 <= 14) {
-		return locales.PluralRuleMany, nil
+		return locales.PluralRuleMany
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/be_BY/be_BY.go

@@ -1,6 +1,8 @@
 package be_BY
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,21 +29,18 @@ func (t *be_BY) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'be_BY'
-func (t *be_BY) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'be_BY'
+func (t *be_BY) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n%10 == 1 && n%100 != 11 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if n%10 >= 2 && n%10 <= 4 && n%100 < 12 && n%100 > 14 {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	} else if (n%10 == 0) || (n%10 >= 5 && n%10 <= 9) || (n%100 >= 11 && n%100 <= 14) {
-		return locales.PluralRuleMany, nil
+		return locales.PluralRuleMany
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/bem/bem.go

@@ -1,6 +1,8 @@
 package bem
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,17 +29,14 @@ func (t *bem) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'bem'
-func (t *bem) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'bem'
+func (t *bem) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/bem_ZM/bem_ZM.go

@@ -1,6 +1,8 @@
 package bem_ZM
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,17 +29,14 @@ func (t *bem_ZM) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'bem_ZM'
-func (t *bem_ZM) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'bem_ZM'
+func (t *bem_ZM) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/bez/bez.go

@@ -1,6 +1,8 @@
 package bez
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,17 +29,14 @@ func (t *bez) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'bez'
-func (t *bez) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'bez'
+func (t *bez) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/bez_TZ/bez_TZ.go

@@ -1,6 +1,8 @@
 package bez_TZ
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,17 +29,14 @@ func (t *bez_TZ) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'bez_TZ'
-func (t *bez_TZ) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'bez_TZ'
+func (t *bez_TZ) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/bg/bg.go

@@ -1,6 +1,8 @@
 package bg
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,17 +29,14 @@ func (t *bg) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'bg'
-func (t *bg) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'bg'
+func (t *bg) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/bg_BG/bg_BG.go

@@ -1,6 +1,8 @@
 package bg_BG
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,17 +29,14 @@ func (t *bg_BG) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'bg_BG'
-func (t *bg_BG) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'bg_BG'
+func (t *bg_BG) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/bm/bm.go

@@ -1,6 +1,8 @@
 package bm
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,8 +29,10 @@ func (t *bm) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'bm'
-func (t *bm) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'bm'
+func (t *bm) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
+
+	n := math.Abs(num)
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/bm_ML/bm_ML.go

@@ -1,6 +1,8 @@
 package bm_ML
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,8 +29,10 @@ func (t *bm_ML) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'bm_ML'
-func (t *bm_ML) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'bm_ML'
+func (t *bm_ML) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
+
+	n := math.Abs(num)
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/bn/bn.go

@@ -1,6 +1,8 @@
 package bn
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,22 +29,15 @@ func (t *bn) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'bn'
-func (t *bn) CardinalPluralRule(num string) (locales.PluralRule, error) {
-
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'bn'
+func (t *bn) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	i, err := locales.I(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
+	i := int64(n)
 
 	if (i == 0) || (n == 1) {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/bn_BD/bn_BD.go

@@ -1,6 +1,8 @@
 package bn_BD
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,22 +29,15 @@ func (t *bn_BD) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'bn_BD'
-func (t *bn_BD) CardinalPluralRule(num string) (locales.PluralRule, error) {
-
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'bn_BD'
+func (t *bn_BD) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	i, err := locales.I(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
+	i := int64(n)
 
 	if (i == 0) || (n == 1) {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/bn_IN/bn_IN.go

@@ -1,6 +1,8 @@
 package bn_IN
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,22 +29,15 @@ func (t *bn_IN) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'bn_IN'
-func (t *bn_IN) CardinalPluralRule(num string) (locales.PluralRule, error) {
-
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'bn_IN'
+func (t *bn_IN) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	i, err := locales.I(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
+	i := int64(n)
 
 	if (i == 0) || (n == 1) {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/bo/bo.go

@@ -1,6 +1,8 @@
 package bo
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,8 +29,10 @@ func (t *bo) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'bo'
-func (t *bo) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'bo'
+func (t *bo) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
+
+	n := math.Abs(num)
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/bo_CN/bo_CN.go

@@ -1,6 +1,8 @@
 package bo_CN
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,8 +29,10 @@ func (t *bo_CN) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'bo_CN'
-func (t *bo_CN) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'bo_CN'
+func (t *bo_CN) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
+
+	n := math.Abs(num)
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/bo_IN/bo_IN.go

@@ -1,6 +1,8 @@
 package bo_IN
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,8 +29,10 @@ func (t *bo_IN) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'bo_IN'
-func (t *bo_IN) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'bo_IN'
+func (t *bo_IN) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
+
+	n := math.Abs(num)
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/br/br.go

@@ -1,6 +1,8 @@
 package br
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,23 +29,20 @@ func (t *br) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'br'
-func (t *br) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'br'
+func (t *br) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n%10 == 1 && (n%100 != 11 && n%100 != 71 && n%100 != 91) {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if n%10 == 2 && (n%100 != 12 && n%100 != 72 && n%100 != 92) {
-		return locales.PluralRuleTwo, nil
+		return locales.PluralRuleTwo
 	} else if n%10 >= 3 && n%10 <= 4 && (n%10 == 9) && (n%100 < 10 && n%100 > 19) || (n%100 < 70 && n%100 > 79) || (n%100 < 90 && n%100 > 99) {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	} else if n != 0 && n%1000000 == 0 {
-		return locales.PluralRuleMany, nil
+		return locales.PluralRuleMany
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/br_FR/br_FR.go

@@ -1,6 +1,8 @@
 package br_FR
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,23 +29,20 @@ func (t *br_FR) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'br_FR'
-func (t *br_FR) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'br_FR'
+func (t *br_FR) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n%10 == 1 && (n%100 != 11 && n%100 != 71 && n%100 != 91) {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if n%10 == 2 && (n%100 != 12 && n%100 != 72 && n%100 != 92) {
-		return locales.PluralRuleTwo, nil
+		return locales.PluralRuleTwo
 	} else if n%10 >= 3 && n%10 <= 4 && (n%10 == 9) && (n%100 < 10 && n%100 > 19) || (n%100 < 70 && n%100 > 79) || (n%100 < 90 && n%100 > 99) {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	} else if n != 0 && n%1000000 == 0 {
-		return locales.PluralRuleMany, nil
+		return locales.PluralRuleMany
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/brx/brx.go

@@ -1,6 +1,8 @@
 package brx
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,17 +29,14 @@ func (t *brx) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'brx'
-func (t *brx) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'brx'
+func (t *brx) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/brx_IN/brx_IN.go

@@ -1,6 +1,8 @@
 package brx_IN
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,17 +29,14 @@ func (t *brx_IN) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'brx_IN'
-func (t *brx_IN) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'brx_IN'
+func (t *brx_IN) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/bs/bs.go

@@ -1,6 +1,8 @@
 package bs
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,26 +29,18 @@ func (t *bs) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'bs'
-func (t *bs) CardinalPluralRule(num string) (locales.PluralRule, error) {
-
-	i, err := locales.I(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'bs'
+func (t *bs) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	v := locales.V(num)
-
-	f, err := locales.F(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
+	i := int64(n)
+	f := locales.F(n, v)
 
 	if (v == 0 && i%10 == 1 && i%100 != 11) || (f%10 == 1 && f%100 != 11) {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if (v == 0 && i%10 >= 2 && i%10 <= 4 && i%100 < 12 && i%100 > 14) || (f%10 >= 2 && f%10 <= 4 && f%100 < 12 && f%100 > 14) {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/bs_Cyrl/bs_Cyrl.go

@@ -1,6 +1,8 @@
 package bs_Cyrl
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,26 +29,18 @@ func (t *bs_Cyrl) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'bs_Cyrl'
-func (t *bs_Cyrl) CardinalPluralRule(num string) (locales.PluralRule, error) {
-
-	i, err := locales.I(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'bs_Cyrl'
+func (t *bs_Cyrl) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	v := locales.V(num)
-
-	f, err := locales.F(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
+	i := int64(n)
+	f := locales.F(n, v)
 
 	if (v == 0 && i%10 == 1 && i%100 != 11) || (f%10 == 1 && f%100 != 11) {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if (v == 0 && i%10 >= 2 && i%10 <= 4 && i%100 < 12 && i%100 > 14) || (f%10 >= 2 && f%10 <= 4 && f%100 < 12 && f%100 > 14) {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/bs_Cyrl_BA/bs_Cyrl_BA.go

@@ -1,6 +1,8 @@
 package bs_Cyrl_BA
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,26 +29,18 @@ func (t *bs_Cyrl_BA) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'bs_Cyrl_BA'
-func (t *bs_Cyrl_BA) CardinalPluralRule(num string) (locales.PluralRule, error) {
-
-	i, err := locales.I(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'bs_Cyrl_BA'
+func (t *bs_Cyrl_BA) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	v := locales.V(num)
-
-	f, err := locales.F(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
+	i := int64(n)
+	f := locales.F(n, v)
 
 	if (v == 0 && i%10 == 1 && i%100 != 11) || (f%10 == 1 && f%100 != 11) {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if (v == 0 && i%10 >= 2 && i%10 <= 4 && i%100 < 12 && i%100 > 14) || (f%10 >= 2 && f%10 <= 4 && f%100 < 12 && f%100 > 14) {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/bs_Latn/bs_Latn.go

@@ -1,6 +1,8 @@
 package bs_Latn
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,26 +29,18 @@ func (t *bs_Latn) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'bs_Latn'
-func (t *bs_Latn) CardinalPluralRule(num string) (locales.PluralRule, error) {
-
-	i, err := locales.I(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'bs_Latn'
+func (t *bs_Latn) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	v := locales.V(num)
-
-	f, err := locales.F(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
+	i := int64(n)
+	f := locales.F(n, v)
 
 	if (v == 0 && i%10 == 1 && i%100 != 11) || (f%10 == 1 && f%100 != 11) {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if (v == 0 && i%10 >= 2 && i%10 <= 4 && i%100 < 12 && i%100 > 14) || (f%10 >= 2 && f%10 <= 4 && f%100 < 12 && f%100 > 14) {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/bs_Latn_BA/bs_Latn_BA.go

@@ -1,6 +1,8 @@
 package bs_Latn_BA
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,26 +29,18 @@ func (t *bs_Latn_BA) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'bs_Latn_BA'
-func (t *bs_Latn_BA) CardinalPluralRule(num string) (locales.PluralRule, error) {
-
-	i, err := locales.I(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'bs_Latn_BA'
+func (t *bs_Latn_BA) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	v := locales.V(num)
-
-	f, err := locales.F(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
+	i := int64(n)
+	f := locales.F(n, v)
 
 	if (v == 0 && i%10 == 1 && i%100 != 11) || (f%10 == 1 && f%100 != 11) {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if (v == 0 && i%10 >= 2 && i%10 <= 4 && i%100 < 12 && i%100 > 14) || (f%10 >= 2 && f%10 <= 4 && f%100 < 12 && f%100 > 14) {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ca/ca.go

@@ -1,6 +1,8 @@
 package ca
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,19 +29,15 @@ func (t *ca) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ca'
-func (t *ca) CardinalPluralRule(num string) (locales.PluralRule, error) {
-
-	i, err := locales.I(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ca'
+func (t *ca) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	v := locales.V(num)
+	n := math.Abs(num)
+	i := int64(n)
 
 	if i == 1 && v == 0 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ca_AD/ca_AD.go

@@ -1,6 +1,8 @@
 package ca_AD
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,19 +29,15 @@ func (t *ca_AD) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ca_AD'
-func (t *ca_AD) CardinalPluralRule(num string) (locales.PluralRule, error) {
-
-	v := locales.V(num)
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ca_AD'
+func (t *ca_AD) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	i, err := locales.I(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
+	i := int64(n)
 
 	if i == 1 && v == 0 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ca_ES/ca_ES.go

@@ -1,6 +1,8 @@
 package ca_ES
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,19 +29,15 @@ func (t *ca_ES) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ca_ES'
-func (t *ca_ES) CardinalPluralRule(num string) (locales.PluralRule, error) {
-
-	i, err := locales.I(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ca_ES'
+func (t *ca_ES) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	v := locales.V(num)
+	n := math.Abs(num)
+	i := int64(n)
 
 	if i == 1 && v == 0 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ca_ES_VALENCIA/ca_ES_VALENCIA.go

@@ -1,6 +1,8 @@
 package ca_ES_VALENCIA
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,19 +29,15 @@ func (t *ca_ES_VALENCIA) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ca_ES_VALENCIA'
-func (t *ca_ES_VALENCIA) CardinalPluralRule(num string) (locales.PluralRule, error) {
-
-	i, err := locales.I(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ca_ES_VALENCIA'
+func (t *ca_ES_VALENCIA) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	v := locales.V(num)
+	n := math.Abs(num)
+	i := int64(n)
 
 	if i == 1 && v == 0 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ca_FR/ca_FR.go

@@ -1,6 +1,8 @@
 package ca_FR
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,19 +29,15 @@ func (t *ca_FR) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ca_FR'
-func (t *ca_FR) CardinalPluralRule(num string) (locales.PluralRule, error) {
-
-	v := locales.V(num)
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ca_FR'
+func (t *ca_FR) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	i, err := locales.I(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
+	i := int64(n)
 
 	if i == 1 && v == 0 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ca_IT/ca_IT.go

@@ -1,6 +1,8 @@
 package ca_IT
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,19 +29,15 @@ func (t *ca_IT) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ca_IT'
-func (t *ca_IT) CardinalPluralRule(num string) (locales.PluralRule, error) {
-
-	i, err := locales.I(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ca_IT'
+func (t *ca_IT) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	v := locales.V(num)
+	n := math.Abs(num)
+	i := int64(n)
 
 	if i == 1 && v == 0 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ce/ce.go

@@ -1,6 +1,8 @@
 package ce
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,17 +29,14 @@ func (t *ce) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ce'
-func (t *ce) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ce'
+func (t *ce) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ce_RU/ce_RU.go

@@ -1,6 +1,8 @@
 package ce_RU
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,17 +29,14 @@ func (t *ce_RU) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ce_RU'
-func (t *ce_RU) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ce_RU'
+func (t *ce_RU) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/cgg/cgg.go

@@ -1,6 +1,8 @@
 package cgg
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,17 +29,14 @@ func (t *cgg) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'cgg'
-func (t *cgg) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'cgg'
+func (t *cgg) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/cgg_UG/cgg_UG.go

@@ -1,6 +1,8 @@
 package cgg_UG
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,17 +29,14 @@ func (t *cgg_UG) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'cgg_UG'
-func (t *cgg_UG) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'cgg_UG'
+func (t *cgg_UG) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/chr/chr.go

@@ -1,6 +1,8 @@
 package chr
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,17 +29,14 @@ func (t *chr) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'chr'
-func (t *chr) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'chr'
+func (t *chr) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/chr_US/chr_US.go

@@ -1,6 +1,8 @@
 package chr_US
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,17 +29,14 @@ func (t *chr_US) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'chr_US'
-func (t *chr_US) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'chr_US'
+func (t *chr_US) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ckb/ckb.go

@@ -1,6 +1,8 @@
 package ckb
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,17 +29,14 @@ func (t *ckb) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ckb'
-func (t *ckb) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ckb'
+func (t *ckb) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ckb_IQ/ckb_IQ.go

@@ -1,6 +1,8 @@
 package ckb_IQ
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,17 +29,14 @@ func (t *ckb_IQ) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ckb_IQ'
-func (t *ckb_IQ) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ckb_IQ'
+func (t *ckb_IQ) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/ckb_IR/ckb_IR.go

@@ -1,6 +1,8 @@
 package ckb_IR
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,17 +29,14 @@ func (t *ckb_IR) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'ckb_IR'
-func (t *ckb_IR) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'ckb_IR'
+func (t *ckb_IR) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/cs/cs.go

@@ -1,6 +1,8 @@
 package cs
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,23 +29,19 @@ func (t *cs) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'cs'
-func (t *cs) CardinalPluralRule(num string) (locales.PluralRule, error) {
-
-	i, err := locales.I(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'cs'
+func (t *cs) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	v := locales.V(num)
+	n := math.Abs(num)
+	i := int64(n)
 
 	if i == 1 && v == 0 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if i >= 2 && i <= 4 && v == 0 {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	} else if v != 0 {
-		return locales.PluralRuleMany, nil
+		return locales.PluralRuleMany
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/cs_CZ/cs_CZ.go

@@ -1,6 +1,8 @@
 package cs_CZ
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,23 +29,19 @@ func (t *cs_CZ) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'cs_CZ'
-func (t *cs_CZ) CardinalPluralRule(num string) (locales.PluralRule, error) {
-
-	v := locales.V(num)
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'cs_CZ'
+func (t *cs_CZ) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	i, err := locales.I(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
+	i := int64(n)
 
 	if i == 1 && v == 0 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if i >= 2 && i <= 4 && v == 0 {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	} else if v != 0 {
-		return locales.PluralRuleMany, nil
+		return locales.PluralRuleMany
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/cu/cu.go

@@ -1,6 +1,8 @@
 package cu
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,7 +29,7 @@ func (t *cu) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'cu'
-func (t *cu) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'cu'
+func (t *cu) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 	return locales.PluralRuleUnknown, nil
 }

resources/locales/cu_RU/cu_RU.go

@@ -1,6 +1,8 @@
 package cu_RU
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,7 +29,7 @@ func (t *cu_RU) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'cu_RU'
-func (t *cu_RU) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'cu_RU'
+func (t *cu_RU) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 	return locales.PluralRuleUnknown, nil
 }

resources/locales/cy/cy.go

@@ -1,6 +1,8 @@
 package cy
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,25 +29,22 @@ func (t *cy) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'cy'
-func (t *cy) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'cy'
+func (t *cy) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 0 {
-		return locales.PluralRuleZero, nil
+		return locales.PluralRuleZero
 	} else if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if n == 2 {
-		return locales.PluralRuleTwo, nil
+		return locales.PluralRuleTwo
 	} else if n == 3 {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	} else if n == 6 {
-		return locales.PluralRuleMany, nil
+		return locales.PluralRuleMany
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/cy_GB/cy_GB.go

@@ -1,6 +1,8 @@
 package cy_GB
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,25 +29,22 @@ func (t *cy_GB) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'cy_GB'
-func (t *cy_GB) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'cy_GB'
+func (t *cy_GB) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
 
 	if n == 0 {
-		return locales.PluralRuleZero, nil
+		return locales.PluralRuleZero
 	} else if n == 1 {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	} else if n == 2 {
-		return locales.PluralRuleTwo, nil
+		return locales.PluralRuleTwo
 	} else if n == 3 {
-		return locales.PluralRuleFew, nil
+		return locales.PluralRuleFew
 	} else if n == 6 {
-		return locales.PluralRuleMany, nil
+		return locales.PluralRuleMany
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }

resources/locales/da/da.go

@@ -1,6 +1,8 @@
 package da
 
 import (
+	"math"
+
 	"github.com/go-playground/universal-translator/resources/locales"
 )
 
@@ -27,27 +29,16 @@ func (t *da) Plurals() []locales.PluralRule {
 	return t.plurals
 }
 
-// CardinalPluralRule returns the PluralRule given 'num' for 'da'
-func (t *da) CardinalPluralRule(num string) (locales.PluralRule, error) {
-
-	n, err := locales.N(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
-
-	i, err := locales.I(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+// cardinalPluralRule returns the PluralRule given 'num' and digits/precision of 'v' for 'da'
+func (t *da) cardinalPluralRule(num float64, v uint64) locales.PluralRule {
 
-	t, err := locales.T(num)
-	if err != nil {
-		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
-	}
+	n := math.Abs(num)
+	i := int64(n)
+	t := locales.T(n, v)
 
 	if (n == 1) || (t != 0 && (i == 0 || i == 1)) {
-		return locales.PluralRuleOne, nil
+		return locales.PluralRuleOne
 	}
 
-	return locales.PluralRuleOther, nil
+	return locales.PluralRuleOther
 }