some cleanup and add function to return plurals associated with Translator

cmd/resources/generate_resources.go

@@ -7,6 +7,8 @@ import (
 	"os/exec"
 	"strings"
 
+	"github.com/go-playground/universal-translator/resources/locales"
+
 	"golang.org/x/text/unicode/cldr"
 
 	"text/template"
@@ -84,6 +86,7 @@ var (
 
 type translator struct {
 	Locale       string
+	Plurals      string
 	CardinalFunc string
 }
 
@@ -132,10 +135,12 @@ func main() {
 		baseLocale := strings.SplitN(l, "_", 2)[0]
 
 		trans := &translator{
-			Locale:       l,
-			CardinalFunc: parseCardinalPluralRuleFunc(cldr, baseLocale),
+			Locale: l,
 		}
 
+		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
@@ -192,7 +197,7 @@ func main() {
 
 // 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) {
+func parseCardinalPluralRuleFunc(current *cldr.CLDR, baseLocale string) (results string, plurals string) {
 
 	var prCardinal *struct {
 		cldr.Common
@@ -203,6 +208,8 @@ func parseCardinalPluralRuleFunc(current *cldr.CLDR, baseLocale string) (results
 		} "xml:\"pluralRule\""
 	}
 
+	var pluralArr []locales.PluralRule
+
 	for _, p := range current.Supplemental().Plurals {
 
 		for _, pr := range p.PluralRules {
@@ -220,6 +227,8 @@ func parseCardinalPluralRuleFunc(current *cldr.CLDR, baseLocale string) (results
 
 	// no plural rules for locale
 	if prCardinal == nil {
+		plurals = "nil"
+		results = "return locales.PluralRuleUnknown,nil"
 		return
 	}
 
@@ -229,16 +238,22 @@ func parseCardinalPluralRuleFunc(current *cldr.CLDR, baseLocale string) (results
 	// pre parse for variables
 	for _, rule := range prCardinal.PluralRule {
 
+		ps1 := pluralStringToString(rule.Count)
+		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." + pluralStringToString(rule.Count) + ", nil"
+				results = "return locales." + ps1 + ", nil"
 
 			} else {
 
-				results += "\n\nreturn locales." + pluralStringToString(rule.Count) + ", nil"
+				results += "\n\nreturn locales." + ps1 + ", nil"
 				// results += "else {\nreturn locales." + locales.PluralStringToString(rule.Count) + ", nil\n}"
 			}
 
@@ -269,8 +284,6 @@ func parseCardinalPluralRuleFunc(current *cldr.CLDR, baseLocale string) (results
 			vals[prVarFuncs["t"]] = struct{}{}
 		}
 
-		// fmt.Println(rule.Count, data)
-
 		if first {
 			results += "if "
 			first = false
@@ -393,7 +406,7 @@ func parseCardinalPluralRuleFunc(current *cldr.CLDR, baseLocale string) (results
 		results += " {\n"
 
 		// return plural rule here
-		results += "return locales." + pluralStringToString(rule.Count) + ", nil\n"
+		results += "return locales." + ps1 + ", nil\n"
 
 		results += "}"
 	}
@@ -412,9 +425,36 @@ func parseCardinalPluralRuleFunc(current *cldr.CLDR, baseLocale string) (results
 
 	results = pre + results
 
+	if len(pluralArr) == 0 {
+		plurals = "nil"
+	} else {
+		plurals = fmt.Sprintf("%#v", pluralArr)
+	}
+
 	return
 }
 
+// pluralStringToInt returns the enum value of 'plural' provided
+func pluralStringToInt(plural string) locales.PluralRule {
+
+	switch plural {
+	case "zero":
+		return locales.PluralRuleZero
+	case "one":
+		return locales.PluralRuleOne
+	case "two":
+		return locales.PluralRuleTwo
+	case "few":
+		return locales.PluralRuleFew
+	case "many":
+		return locales.PluralRuleMany
+	case "other":
+		return locales.PluralRuleOther
+	default:
+		return locales.PluralRuleUnknown
+	}
+}
+
 func pluralStringToString(pr string) string {
 
 	pr = strings.TrimSpace(pr)

cmd/resources/translator.tmpl

@@ -6,23 +6,30 @@ import (
 )
 
 type {{ .Locale }} struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the '{{ .Locale }}' locale
 func New() locales.Translator {
 	return &{{ .Locale }}{
-		locale: "{{ .Locale }}",
+		locale:  "{{ .Locale }}",
+		plurals: {{ .Plurals }},
 	}
 }
 
 // Locale returns the current translators string locale
-func(l *{{ .Locale }}) Locale() string {
-	return l.locale
+func(t *{{ .Locale }}) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func(l *{{ .Locale }}) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with '{{ .Locale }}'
+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) {
 	{{ .CardinalFunc }}
 }
 

resources/locales/af/af.go

@@ -5,23 +5,30 @@ import (
 )
 
 type af struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'af' locale
 func New() locales.Translator {
 	return &af{
-		locale: "af",
+		locale:  "af",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *af) Locale() string {
-	return l.locale
+func (t *af) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *af) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'af'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/af_NA/af_NA.go

@@ -5,23 +5,30 @@ import (
 )
 
 type af_NA struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'af_NA' locale
 func New() locales.Translator {
 	return &af_NA{
-		locale: "af_NA",
+		locale:  "af_NA",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *af_NA) Locale() string {
-	return l.locale
+func (t *af_NA) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *af_NA) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'af_NA'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/af_ZA/af_ZA.go

@@ -5,23 +5,30 @@ import (
 )
 
 type af_ZA struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'af_ZA' locale
 func New() locales.Translator {
 	return &af_ZA{
-		locale: "af_ZA",
+		locale:  "af_ZA",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *af_ZA) Locale() string {
-	return l.locale
+func (t *af_ZA) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *af_ZA) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'af_ZA'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/agq/agq.go

@@ -5,22 +5,29 @@ import (
 )
 
 type agq struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'agq' locale
 func New() locales.Translator {
 	return &agq{
-		locale: "agq",
+		locale:  "agq",
+		plurals: nil,
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *agq) Locale() string {
-	return l.locale
+func (t *agq) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *agq) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'agq'
+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) {
+	return locales.PluralRuleUnknown, nil
 }

resources/locales/agq_CM/agq_CM.go

@@ -5,22 +5,29 @@ import (
 )
 
 type agq_CM struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'agq_CM' locale
 func New() locales.Translator {
 	return &agq_CM{
-		locale: "agq_CM",
+		locale:  "agq_CM",
+		plurals: nil,
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *agq_CM) Locale() string {
-	return l.locale
+func (t *agq_CM) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *agq_CM) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'agq_CM'
+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) {
+	return locales.PluralRuleUnknown, nil
 }

resources/locales/ak/ak.go

@@ -5,23 +5,30 @@ import (
 )
 
 type ak struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ak' locale
 func New() locales.Translator {
 	return &ak{
-		locale: "ak",
+		locale:  "ak",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ak) Locale() string {
-	return l.locale
+func (t *ak) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ak) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ak'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/ak_GH/ak_GH.go

@@ -5,23 +5,30 @@ import (
 )
 
 type ak_GH struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ak_GH' locale
 func New() locales.Translator {
 	return &ak_GH{
-		locale: "ak_GH",
+		locale:  "ak_GH",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ak_GH) Locale() string {
-	return l.locale
+func (t *ak_GH) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ak_GH) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ak_GH'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/am/am.go

@@ -5,23 +5,30 @@ import (
 )
 
 type am struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'am' locale
 func New() locales.Translator {
 	return &am{
-		locale: "am",
+		locale:  "am",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *am) Locale() string {
-	return l.locale
+func (t *am) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *am) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'am'
+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 {

resources/locales/am_ET/am_ET.go

@@ -5,23 +5,30 @@ import (
 )
 
 type am_ET struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'am_ET' locale
 func New() locales.Translator {
 	return &am_ET{
-		locale: "am_ET",
+		locale:  "am_ET",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *am_ET) Locale() string {
-	return l.locale
+func (t *am_ET) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *am_ET) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'am_ET'
+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 {

resources/locales/ar/ar.go

@@ -5,23 +5,30 @@ import (
 )
 
 type ar struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ar' locale
 func New() locales.Translator {
 	return &ar{
-		locale: "ar",
+		locale:  "ar",
+		plurals: []locales.PluralRule{1, 2, 3, 4, 5, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ar) Locale() string {
-	return l.locale
+func (t *ar) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ar) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ar'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/ar_001/ar_001.go

@@ -5,23 +5,30 @@ import (
 )
 
 type ar_001 struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ar_001' locale
 func New() locales.Translator {
 	return &ar_001{
-		locale: "ar_001",
+		locale:  "ar_001",
+		plurals: []locales.PluralRule{1, 2, 3, 4, 5, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ar_001) Locale() string {
-	return l.locale
+func (t *ar_001) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ar_001) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ar_001'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/ar_AE/ar_AE.go

@@ -5,23 +5,30 @@ import (
 )
 
 type ar_AE struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ar_AE' locale
 func New() locales.Translator {
 	return &ar_AE{
-		locale: "ar_AE",
+		locale:  "ar_AE",
+		plurals: []locales.PluralRule{1, 2, 3, 4, 5, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ar_AE) Locale() string {
-	return l.locale
+func (t *ar_AE) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ar_AE) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ar_AE'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/ar_BH/ar_BH.go

@@ -5,23 +5,30 @@ import (
 )
 
 type ar_BH struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ar_BH' locale
 func New() locales.Translator {
 	return &ar_BH{
-		locale: "ar_BH",
+		locale:  "ar_BH",
+		plurals: []locales.PluralRule{1, 2, 3, 4, 5, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ar_BH) Locale() string {
-	return l.locale
+func (t *ar_BH) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ar_BH) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ar_BH'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/ar_DJ/ar_DJ.go

@@ -5,23 +5,30 @@ import (
 )
 
 type ar_DJ struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ar_DJ' locale
 func New() locales.Translator {
 	return &ar_DJ{
-		locale: "ar_DJ",
+		locale:  "ar_DJ",
+		plurals: []locales.PluralRule{1, 2, 3, 4, 5, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ar_DJ) Locale() string {
-	return l.locale
+func (t *ar_DJ) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ar_DJ) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ar_DJ'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/ar_DZ/ar_DZ.go

@@ -5,23 +5,30 @@ import (
 )
 
 type ar_DZ struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ar_DZ' locale
 func New() locales.Translator {
 	return &ar_DZ{
-		locale: "ar_DZ",
+		locale:  "ar_DZ",
+		plurals: []locales.PluralRule{1, 2, 3, 4, 5, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ar_DZ) Locale() string {
-	return l.locale
+func (t *ar_DZ) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ar_DZ) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ar_DZ'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/ar_EG/ar_EG.go

@@ -5,23 +5,30 @@ import (
 )
 
 type ar_EG struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ar_EG' locale
 func New() locales.Translator {
 	return &ar_EG{
-		locale: "ar_EG",
+		locale:  "ar_EG",
+		plurals: []locales.PluralRule{1, 2, 3, 4, 5, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ar_EG) Locale() string {
-	return l.locale
+func (t *ar_EG) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ar_EG) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ar_EG'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/ar_EH/ar_EH.go

@@ -5,23 +5,30 @@ import (
 )
 
 type ar_EH struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ar_EH' locale
 func New() locales.Translator {
 	return &ar_EH{
-		locale: "ar_EH",
+		locale:  "ar_EH",
+		plurals: []locales.PluralRule{1, 2, 3, 4, 5, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ar_EH) Locale() string {
-	return l.locale
+func (t *ar_EH) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ar_EH) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ar_EH'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/ar_ER/ar_ER.go

@@ -5,23 +5,30 @@ import (
 )
 
 type ar_ER struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ar_ER' locale
 func New() locales.Translator {
 	return &ar_ER{
-		locale: "ar_ER",
+		locale:  "ar_ER",
+		plurals: []locales.PluralRule{1, 2, 3, 4, 5, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ar_ER) Locale() string {
-	return l.locale
+func (t *ar_ER) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ar_ER) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ar_ER'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/ar_IL/ar_IL.go

@@ -5,23 +5,30 @@ import (
 )
 
 type ar_IL struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ar_IL' locale
 func New() locales.Translator {
 	return &ar_IL{
-		locale: "ar_IL",
+		locale:  "ar_IL",
+		plurals: []locales.PluralRule{1, 2, 3, 4, 5, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ar_IL) Locale() string {
-	return l.locale
+func (t *ar_IL) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ar_IL) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ar_IL'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/ar_IQ/ar_IQ.go

@@ -5,23 +5,30 @@ import (
 )
 
 type ar_IQ struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ar_IQ' locale
 func New() locales.Translator {
 	return &ar_IQ{
-		locale: "ar_IQ",
+		locale:  "ar_IQ",
+		plurals: []locales.PluralRule{1, 2, 3, 4, 5, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ar_IQ) Locale() string {
-	return l.locale
+func (t *ar_IQ) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ar_IQ) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ar_IQ'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/ar_JO/ar_JO.go

@@ -5,23 +5,30 @@ import (
 )
 
 type ar_JO struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ar_JO' locale
 func New() locales.Translator {
 	return &ar_JO{
-		locale: "ar_JO",
+		locale:  "ar_JO",
+		plurals: []locales.PluralRule{1, 2, 3, 4, 5, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ar_JO) Locale() string {
-	return l.locale
+func (t *ar_JO) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ar_JO) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ar_JO'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/ar_KM/ar_KM.go

@@ -5,23 +5,30 @@ import (
 )
 
 type ar_KM struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ar_KM' locale
 func New() locales.Translator {
 	return &ar_KM{
-		locale: "ar_KM",
+		locale:  "ar_KM",
+		plurals: []locales.PluralRule{1, 2, 3, 4, 5, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ar_KM) Locale() string {
-	return l.locale
+func (t *ar_KM) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ar_KM) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ar_KM'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/ar_KW/ar_KW.go

@@ -5,23 +5,30 @@ import (
 )
 
 type ar_KW struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ar_KW' locale
 func New() locales.Translator {
 	return &ar_KW{
-		locale: "ar_KW",
+		locale:  "ar_KW",
+		plurals: []locales.PluralRule{1, 2, 3, 4, 5, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ar_KW) Locale() string {
-	return l.locale
+func (t *ar_KW) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ar_KW) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ar_KW'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/ar_LB/ar_LB.go

@@ -5,23 +5,30 @@ import (
 )
 
 type ar_LB struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ar_LB' locale
 func New() locales.Translator {
 	return &ar_LB{
-		locale: "ar_LB",
+		locale:  "ar_LB",
+		plurals: []locales.PluralRule{1, 2, 3, 4, 5, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ar_LB) Locale() string {
-	return l.locale
+func (t *ar_LB) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ar_LB) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ar_LB'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/ar_LY/ar_LY.go

@@ -5,23 +5,30 @@ import (
 )
 
 type ar_LY struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ar_LY' locale
 func New() locales.Translator {
 	return &ar_LY{
-		locale: "ar_LY",
+		locale:  "ar_LY",
+		plurals: []locales.PluralRule{1, 2, 3, 4, 5, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ar_LY) Locale() string {
-	return l.locale
+func (t *ar_LY) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ar_LY) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ar_LY'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/ar_MA/ar_MA.go

@@ -5,23 +5,30 @@ import (
 )
 
 type ar_MA struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ar_MA' locale
 func New() locales.Translator {
 	return &ar_MA{
-		locale: "ar_MA",
+		locale:  "ar_MA",
+		plurals: []locales.PluralRule{1, 2, 3, 4, 5, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ar_MA) Locale() string {
-	return l.locale
+func (t *ar_MA) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ar_MA) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ar_MA'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/ar_MR/ar_MR.go

@@ -5,23 +5,30 @@ import (
 )
 
 type ar_MR struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ar_MR' locale
 func New() locales.Translator {
 	return &ar_MR{
-		locale: "ar_MR",
+		locale:  "ar_MR",
+		plurals: []locales.PluralRule{1, 2, 3, 4, 5, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ar_MR) Locale() string {
-	return l.locale
+func (t *ar_MR) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ar_MR) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ar_MR'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/ar_OM/ar_OM.go

@@ -5,23 +5,30 @@ import (
 )
 
 type ar_OM struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ar_OM' locale
 func New() locales.Translator {
 	return &ar_OM{
-		locale: "ar_OM",
+		locale:  "ar_OM",
+		plurals: []locales.PluralRule{1, 2, 3, 4, 5, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ar_OM) Locale() string {
-	return l.locale
+func (t *ar_OM) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ar_OM) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ar_OM'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/ar_PS/ar_PS.go

@@ -5,23 +5,30 @@ import (
 )
 
 type ar_PS struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ar_PS' locale
 func New() locales.Translator {
 	return &ar_PS{
-		locale: "ar_PS",
+		locale:  "ar_PS",
+		plurals: []locales.PluralRule{1, 2, 3, 4, 5, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ar_PS) Locale() string {
-	return l.locale
+func (t *ar_PS) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ar_PS) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ar_PS'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/ar_QA/ar_QA.go

@@ -5,23 +5,30 @@ import (
 )
 
 type ar_QA struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ar_QA' locale
 func New() locales.Translator {
 	return &ar_QA{
-		locale: "ar_QA",
+		locale:  "ar_QA",
+		plurals: []locales.PluralRule{1, 2, 3, 4, 5, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ar_QA) Locale() string {
-	return l.locale
+func (t *ar_QA) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ar_QA) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ar_QA'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/ar_SA/ar_SA.go

@@ -5,23 +5,30 @@ import (
 )
 
 type ar_SA struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ar_SA' locale
 func New() locales.Translator {
 	return &ar_SA{
-		locale: "ar_SA",
+		locale:  "ar_SA",
+		plurals: []locales.PluralRule{1, 2, 3, 4, 5, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ar_SA) Locale() string {
-	return l.locale
+func (t *ar_SA) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ar_SA) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ar_SA'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/ar_SD/ar_SD.go

@@ -5,23 +5,30 @@ import (
 )
 
 type ar_SD struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ar_SD' locale
 func New() locales.Translator {
 	return &ar_SD{
-		locale: "ar_SD",
+		locale:  "ar_SD",
+		plurals: []locales.PluralRule{1, 2, 3, 4, 5, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ar_SD) Locale() string {
-	return l.locale
+func (t *ar_SD) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ar_SD) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ar_SD'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/ar_SO/ar_SO.go

@@ -5,23 +5,30 @@ import (
 )
 
 type ar_SO struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ar_SO' locale
 func New() locales.Translator {
 	return &ar_SO{
-		locale: "ar_SO",
+		locale:  "ar_SO",
+		plurals: []locales.PluralRule{1, 2, 3, 4, 5, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ar_SO) Locale() string {
-	return l.locale
+func (t *ar_SO) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ar_SO) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ar_SO'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/ar_SS/ar_SS.go

@@ -5,23 +5,30 @@ import (
 )
 
 type ar_SS struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ar_SS' locale
 func New() locales.Translator {
 	return &ar_SS{
-		locale: "ar_SS",
+		locale:  "ar_SS",
+		plurals: []locales.PluralRule{1, 2, 3, 4, 5, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ar_SS) Locale() string {
-	return l.locale
+func (t *ar_SS) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ar_SS) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ar_SS'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/ar_SY/ar_SY.go

@@ -5,23 +5,30 @@ import (
 )
 
 type ar_SY struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ar_SY' locale
 func New() locales.Translator {
 	return &ar_SY{
-		locale: "ar_SY",
+		locale:  "ar_SY",
+		plurals: []locales.PluralRule{1, 2, 3, 4, 5, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ar_SY) Locale() string {
-	return l.locale
+func (t *ar_SY) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ar_SY) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ar_SY'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/ar_TD/ar_TD.go

@@ -5,23 +5,30 @@ import (
 )
 
 type ar_TD struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ar_TD' locale
 func New() locales.Translator {
 	return &ar_TD{
-		locale: "ar_TD",
+		locale:  "ar_TD",
+		plurals: []locales.PluralRule{1, 2, 3, 4, 5, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ar_TD) Locale() string {
-	return l.locale
+func (t *ar_TD) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ar_TD) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ar_TD'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/ar_TN/ar_TN.go

@@ -5,23 +5,30 @@ import (
 )
 
 type ar_TN struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ar_TN' locale
 func New() locales.Translator {
 	return &ar_TN{
-		locale: "ar_TN",
+		locale:  "ar_TN",
+		plurals: []locales.PluralRule{1, 2, 3, 4, 5, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ar_TN) Locale() string {
-	return l.locale
+func (t *ar_TN) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ar_TN) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ar_TN'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/ar_YE/ar_YE.go

@@ -5,23 +5,30 @@ import (
 )
 
 type ar_YE struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ar_YE' locale
 func New() locales.Translator {
 	return &ar_YE{
-		locale: "ar_YE",
+		locale:  "ar_YE",
+		plurals: []locales.PluralRule{1, 2, 3, 4, 5, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ar_YE) Locale() string {
-	return l.locale
+func (t *ar_YE) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ar_YE) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ar_YE'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/as/as.go

@@ -5,23 +5,30 @@ import (
 )
 
 type as struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'as' locale
 func New() locales.Translator {
 	return &as{
-		locale: "as",
+		locale:  "as",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *as) Locale() string {
-	return l.locale
+func (t *as) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *as) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'as'
+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 {

resources/locales/as_IN/as_IN.go

@@ -5,23 +5,30 @@ import (
 )
 
 type as_IN struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'as_IN' locale
 func New() locales.Translator {
 	return &as_IN{
-		locale: "as_IN",
+		locale:  "as_IN",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *as_IN) Locale() string {
-	return l.locale
+func (t *as_IN) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *as_IN) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'as_IN'
+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 {

resources/locales/asa/asa.go

@@ -5,23 +5,30 @@ import (
 )
 
 type asa struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'asa' locale
 func New() locales.Translator {
 	return &asa{
-		locale: "asa",
+		locale:  "asa",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *asa) Locale() string {
-	return l.locale
+func (t *asa) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *asa) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'asa'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/asa_TZ/asa_TZ.go

@@ -5,23 +5,30 @@ import (
 )
 
 type asa_TZ struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'asa_TZ' locale
 func New() locales.Translator {
 	return &asa_TZ{
-		locale: "asa_TZ",
+		locale:  "asa_TZ",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *asa_TZ) Locale() string {
-	return l.locale
+func (t *asa_TZ) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *asa_TZ) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'asa_TZ'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/ast/ast.go

@@ -5,23 +5,30 @@ import (
 )
 
 type ast struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ast' locale
 func New() locales.Translator {
 	return &ast{
-		locale: "ast",
+		locale:  "ast",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ast) Locale() string {
-	return l.locale
+func (t *ast) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ast) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ast'
+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 {

resources/locales/ast_ES/ast_ES.go

@@ -5,23 +5,30 @@ import (
 )
 
 type ast_ES struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ast_ES' locale
 func New() locales.Translator {
 	return &ast_ES{
-		locale: "ast_ES",
+		locale:  "ast_ES",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ast_ES) Locale() string {
-	return l.locale
+func (t *ast_ES) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ast_ES) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ast_ES'
+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 {

resources/locales/az/az.go

@@ -5,23 +5,30 @@ import (
 )
 
 type az struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'az' locale
 func New() locales.Translator {
 	return &az{
-		locale: "az",
+		locale:  "az",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *az) Locale() string {
-	return l.locale
+func (t *az) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *az) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'az'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/az_Cyrl/az_Cyrl.go

@@ -5,23 +5,30 @@ import (
 )
 
 type az_Cyrl struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'az_Cyrl' locale
 func New() locales.Translator {
 	return &az_Cyrl{
-		locale: "az_Cyrl",
+		locale:  "az_Cyrl",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *az_Cyrl) Locale() string {
-	return l.locale
+func (t *az_Cyrl) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *az_Cyrl) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'az_Cyrl'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/az_Cyrl_AZ/az_Cyrl_AZ.go

@@ -5,23 +5,30 @@ import (
 )
 
 type az_Cyrl_AZ struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'az_Cyrl_AZ' locale
 func New() locales.Translator {
 	return &az_Cyrl_AZ{
-		locale: "az_Cyrl_AZ",
+		locale:  "az_Cyrl_AZ",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *az_Cyrl_AZ) Locale() string {
-	return l.locale
+func (t *az_Cyrl_AZ) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *az_Cyrl_AZ) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'az_Cyrl_AZ'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/az_Latn/az_Latn.go

@@ -5,23 +5,30 @@ import (
 )
 
 type az_Latn struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'az_Latn' locale
 func New() locales.Translator {
 	return &az_Latn{
-		locale: "az_Latn",
+		locale:  "az_Latn",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *az_Latn) Locale() string {
-	return l.locale
+func (t *az_Latn) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *az_Latn) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'az_Latn'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/az_Latn_AZ/az_Latn_AZ.go

@@ -5,23 +5,30 @@ import (
 )
 
 type az_Latn_AZ struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'az_Latn_AZ' locale
 func New() locales.Translator {
 	return &az_Latn_AZ{
-		locale: "az_Latn_AZ",
+		locale:  "az_Latn_AZ",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *az_Latn_AZ) Locale() string {
-	return l.locale
+func (t *az_Latn_AZ) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *az_Latn_AZ) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'az_Latn_AZ'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/bas/bas.go

@@ -5,22 +5,29 @@ import (
 )
 
 type bas struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'bas' locale
 func New() locales.Translator {
 	return &bas{
-		locale: "bas",
+		locale:  "bas",
+		plurals: nil,
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *bas) Locale() string {
-	return l.locale
+func (t *bas) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *bas) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'bas'
+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) {
+	return locales.PluralRuleUnknown, nil
 }

resources/locales/bas_CM/bas_CM.go

@@ -5,22 +5,29 @@ import (
 )
 
 type bas_CM struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'bas_CM' locale
 func New() locales.Translator {
 	return &bas_CM{
-		locale: "bas_CM",
+		locale:  "bas_CM",
+		plurals: nil,
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *bas_CM) Locale() string {
-	return l.locale
+func (t *bas_CM) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *bas_CM) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'bas_CM'
+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) {
+	return locales.PluralRuleUnknown, nil
 }

resources/locales/be/be.go

@@ -5,23 +5,30 @@ import (
 )
 
 type be struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'be' locale
 func New() locales.Translator {
 	return &be{
-		locale: "be",
+		locale:  "be",
+		plurals: []locales.PluralRule{2, 4, 5, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *be) Locale() string {
-	return l.locale
+func (t *be) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *be) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'be'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/be_BY/be_BY.go

@@ -5,23 +5,30 @@ import (
 )
 
 type be_BY struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'be_BY' locale
 func New() locales.Translator {
 	return &be_BY{
-		locale: "be_BY",
+		locale:  "be_BY",
+		plurals: []locales.PluralRule{2, 4, 5, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *be_BY) Locale() string {
-	return l.locale
+func (t *be_BY) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *be_BY) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'be_BY'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/bem/bem.go

@@ -5,23 +5,30 @@ import (
 )
 
 type bem struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'bem' locale
 func New() locales.Translator {
 	return &bem{
-		locale: "bem",
+		locale:  "bem",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *bem) Locale() string {
-	return l.locale
+func (t *bem) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *bem) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'bem'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/bem_ZM/bem_ZM.go

@@ -5,23 +5,30 @@ import (
 )
 
 type bem_ZM struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'bem_ZM' locale
 func New() locales.Translator {
 	return &bem_ZM{
-		locale: "bem_ZM",
+		locale:  "bem_ZM",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *bem_ZM) Locale() string {
-	return l.locale
+func (t *bem_ZM) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *bem_ZM) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'bem_ZM'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/bez/bez.go

@@ -5,23 +5,30 @@ import (
 )
 
 type bez struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'bez' locale
 func New() locales.Translator {
 	return &bez{
-		locale: "bez",
+		locale:  "bez",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *bez) Locale() string {
-	return l.locale
+func (t *bez) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *bez) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'bez'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/bez_TZ/bez_TZ.go

@@ -5,23 +5,30 @@ import (
 )
 
 type bez_TZ struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'bez_TZ' locale
 func New() locales.Translator {
 	return &bez_TZ{
-		locale: "bez_TZ",
+		locale:  "bez_TZ",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *bez_TZ) Locale() string {
-	return l.locale
+func (t *bez_TZ) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *bez_TZ) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'bez_TZ'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/bg/bg.go

@@ -5,23 +5,30 @@ import (
 )
 
 type bg struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'bg' locale
 func New() locales.Translator {
 	return &bg{
-		locale: "bg",
+		locale:  "bg",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *bg) Locale() string {
-	return l.locale
+func (t *bg) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *bg) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'bg'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/bg_BG/bg_BG.go

@@ -5,23 +5,30 @@ import (
 )
 
 type bg_BG struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'bg_BG' locale
 func New() locales.Translator {
 	return &bg_BG{
-		locale: "bg_BG",
+		locale:  "bg_BG",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *bg_BG) Locale() string {
-	return l.locale
+func (t *bg_BG) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *bg_BG) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'bg_BG'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/bm/bm.go

@@ -5,23 +5,30 @@ import (
 )
 
 type bm struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'bm' locale
 func New() locales.Translator {
 	return &bm{
-		locale: "bm",
+		locale:  "bm",
+		plurals: []locales.PluralRule{6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *bm) Locale() string {
-	return l.locale
+func (t *bm) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *bm) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'bm'
+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) {
 
 	return locales.PluralRuleOther, nil
 }

resources/locales/bm_ML/bm_ML.go

@@ -5,23 +5,30 @@ import (
 )
 
 type bm_ML struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'bm_ML' locale
 func New() locales.Translator {
 	return &bm_ML{
-		locale: "bm_ML",
+		locale:  "bm_ML",
+		plurals: []locales.PluralRule{6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *bm_ML) Locale() string {
-	return l.locale
+func (t *bm_ML) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *bm_ML) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'bm_ML'
+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) {
 
 	return locales.PluralRuleOther, nil
 }

resources/locales/bn/bn.go

@@ -5,23 +5,30 @@ import (
 )
 
 type bn struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'bn' locale
 func New() locales.Translator {
 	return &bn{
-		locale: "bn",
+		locale:  "bn",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *bn) Locale() string {
-	return l.locale
+func (t *bn) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *bn) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'bn'
+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 {

resources/locales/bn_BD/bn_BD.go

@@ -5,23 +5,30 @@ import (
 )
 
 type bn_BD struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'bn_BD' locale
 func New() locales.Translator {
 	return &bn_BD{
-		locale: "bn_BD",
+		locale:  "bn_BD",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *bn_BD) Locale() string {
-	return l.locale
+func (t *bn_BD) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *bn_BD) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'bn_BD'
+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 {

resources/locales/bn_IN/bn_IN.go

@@ -5,23 +5,30 @@ import (
 )
 
 type bn_IN struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'bn_IN' locale
 func New() locales.Translator {
 	return &bn_IN{
-		locale: "bn_IN",
+		locale:  "bn_IN",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *bn_IN) Locale() string {
-	return l.locale
+func (t *bn_IN) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *bn_IN) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'bn_IN'
+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 {

resources/locales/bo/bo.go

@@ -5,23 +5,30 @@ import (
 )
 
 type bo struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'bo' locale
 func New() locales.Translator {
 	return &bo{
-		locale: "bo",
+		locale:  "bo",
+		plurals: []locales.PluralRule{6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *bo) Locale() string {
-	return l.locale
+func (t *bo) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *bo) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'bo'
+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) {
 
 	return locales.PluralRuleOther, nil
 }

resources/locales/bo_CN/bo_CN.go

@@ -5,23 +5,30 @@ import (
 )
 
 type bo_CN struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'bo_CN' locale
 func New() locales.Translator {
 	return &bo_CN{
-		locale: "bo_CN",
+		locale:  "bo_CN",
+		plurals: []locales.PluralRule{6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *bo_CN) Locale() string {
-	return l.locale
+func (t *bo_CN) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *bo_CN) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'bo_CN'
+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) {
 
 	return locales.PluralRuleOther, nil
 }

resources/locales/bo_IN/bo_IN.go

@@ -5,23 +5,30 @@ import (
 )
 
 type bo_IN struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'bo_IN' locale
 func New() locales.Translator {
 	return &bo_IN{
-		locale: "bo_IN",
+		locale:  "bo_IN",
+		plurals: []locales.PluralRule{6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *bo_IN) Locale() string {
-	return l.locale
+func (t *bo_IN) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *bo_IN) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'bo_IN'
+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) {
 
 	return locales.PluralRuleOther, nil
 }

resources/locales/br/br.go

@@ -5,23 +5,30 @@ import (
 )
 
 type br struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'br' locale
 func New() locales.Translator {
 	return &br{
-		locale: "br",
+		locale:  "br",
+		plurals: []locales.PluralRule{2, 3, 4, 5, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *br) Locale() string {
-	return l.locale
+func (t *br) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *br) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'br'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/br_FR/br_FR.go

@@ -5,23 +5,30 @@ import (
 )
 
 type br_FR struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'br_FR' locale
 func New() locales.Translator {
 	return &br_FR{
-		locale: "br_FR",
+		locale:  "br_FR",
+		plurals: []locales.PluralRule{2, 3, 4, 5, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *br_FR) Locale() string {
-	return l.locale
+func (t *br_FR) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *br_FR) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'br_FR'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/brx/brx.go

@@ -5,23 +5,30 @@ import (
 )
 
 type brx struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'brx' locale
 func New() locales.Translator {
 	return &brx{
-		locale: "brx",
+		locale:  "brx",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *brx) Locale() string {
-	return l.locale
+func (t *brx) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *brx) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'brx'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/brx_IN/brx_IN.go

@@ -5,23 +5,30 @@ import (
 )
 
 type brx_IN struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'brx_IN' locale
 func New() locales.Translator {
 	return &brx_IN{
-		locale: "brx_IN",
+		locale:  "brx_IN",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *brx_IN) Locale() string {
-	return l.locale
+func (t *brx_IN) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *brx_IN) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'brx_IN'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/bs/bs.go

@@ -5,23 +5,30 @@ import (
 )
 
 type bs struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'bs' locale
 func New() locales.Translator {
 	return &bs{
-		locale: "bs",
+		locale:  "bs",
+		plurals: []locales.PluralRule{2, 4, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *bs) Locale() string {
-	return l.locale
+func (t *bs) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *bs) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'bs'
+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 {

resources/locales/bs_Cyrl/bs_Cyrl.go

@@ -5,32 +5,39 @@ import (
 )
 
 type bs_Cyrl struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'bs_Cyrl' locale
 func New() locales.Translator {
 	return &bs_Cyrl{
-		locale: "bs_Cyrl",
+		locale:  "bs_Cyrl",
+		plurals: []locales.PluralRule{2, 4, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *bs_Cyrl) Locale() string {
-	return l.locale
+func (t *bs_Cyrl) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *bs_Cyrl) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'bs_Cyrl'
+func (t *bs_Cyrl) Plurals() []locales.PluralRule {
+	return t.plurals
+}
 
-	v := locales.V(num)
+// CardinalPluralRule returns the PluralRule given 'num' for 'bs_Cyrl'
+func (t *bs_Cyrl) CardinalPluralRule(num string) (locales.PluralRule, error) {
 
-	f, err := locales.F(num)
+	i, err := locales.I(num)
 	if err != nil {
 		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
 	}
 
-	i, err := locales.I(num)
+	v := locales.V(num)
+
+	f, err := locales.F(num)
 	if err != nil {
 		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
 	}

resources/locales/bs_Cyrl_BA/bs_Cyrl_BA.go

@@ -5,23 +5,30 @@ import (
 )
 
 type bs_Cyrl_BA struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'bs_Cyrl_BA' locale
 func New() locales.Translator {
 	return &bs_Cyrl_BA{
-		locale: "bs_Cyrl_BA",
+		locale:  "bs_Cyrl_BA",
+		plurals: []locales.PluralRule{2, 4, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *bs_Cyrl_BA) Locale() string {
-	return l.locale
+func (t *bs_Cyrl_BA) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *bs_Cyrl_BA) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'bs_Cyrl_BA'
+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 {

resources/locales/bs_Latn/bs_Latn.go

@@ -5,23 +5,30 @@ import (
 )
 
 type bs_Latn struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'bs_Latn' locale
 func New() locales.Translator {
 	return &bs_Latn{
-		locale: "bs_Latn",
+		locale:  "bs_Latn",
+		plurals: []locales.PluralRule{2, 4, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *bs_Latn) Locale() string {
-	return l.locale
+func (t *bs_Latn) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *bs_Latn) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'bs_Latn'
+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 {

resources/locales/bs_Latn_BA/bs_Latn_BA.go

@@ -5,23 +5,30 @@ import (
 )
 
 type bs_Latn_BA struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'bs_Latn_BA' locale
 func New() locales.Translator {
 	return &bs_Latn_BA{
-		locale: "bs_Latn_BA",
+		locale:  "bs_Latn_BA",
+		plurals: []locales.PluralRule{2, 4, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *bs_Latn_BA) Locale() string {
-	return l.locale
+func (t *bs_Latn_BA) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *bs_Latn_BA) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'bs_Latn_BA'
+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 {

resources/locales/ca/ca.go

@@ -5,23 +5,30 @@ import (
 )
 
 type ca struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ca' locale
 func New() locales.Translator {
 	return &ca{
-		locale: "ca",
+		locale:  "ca",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ca) Locale() string {
-	return l.locale
+func (t *ca) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ca) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ca'
+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 {

resources/locales/ca_AD/ca_AD.go

@@ -5,31 +5,38 @@ import (
 )
 
 type ca_AD struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ca_AD' locale
 func New() locales.Translator {
 	return &ca_AD{
-		locale: "ca_AD",
+		locale:  "ca_AD",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ca_AD) Locale() string {
-	return l.locale
+func (t *ca_AD) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ca_AD) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ca_AD'
+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)
 
 	i, err := locales.I(num)
 	if err != nil {
 		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
 	}
 
-	v := locales.V(num)
-
 	if i == 1 && v == 0 {
 		return locales.PluralRuleOne, nil
 	}

resources/locales/ca_ES/ca_ES.go

@@ -5,23 +5,30 @@ import (
 )
 
 type ca_ES struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ca_ES' locale
 func New() locales.Translator {
 	return &ca_ES{
-		locale: "ca_ES",
+		locale:  "ca_ES",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ca_ES) Locale() string {
-	return l.locale
+func (t *ca_ES) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ca_ES) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ca_ES'
+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 {

resources/locales/ca_ES_VALENCIA/ca_ES_VALENCIA.go

@@ -5,23 +5,30 @@ import (
 )
 
 type ca_ES_VALENCIA struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ca_ES_VALENCIA' locale
 func New() locales.Translator {
 	return &ca_ES_VALENCIA{
-		locale: "ca_ES_VALENCIA",
+		locale:  "ca_ES_VALENCIA",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ca_ES_VALENCIA) Locale() string {
-	return l.locale
+func (t *ca_ES_VALENCIA) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ca_ES_VALENCIA) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ca_ES_VALENCIA'
+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 {

resources/locales/ca_FR/ca_FR.go

@@ -5,31 +5,38 @@ import (
 )
 
 type ca_FR struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ca_FR' locale
 func New() locales.Translator {
 	return &ca_FR{
-		locale: "ca_FR",
+		locale:  "ca_FR",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ca_FR) Locale() string {
-	return l.locale
+func (t *ca_FR) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ca_FR) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ca_FR'
+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)
 
 	i, err := locales.I(num)
 	if err != nil {
 		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
 	}
 
-	v := locales.V(num)
-
 	if i == 1 && v == 0 {
 		return locales.PluralRuleOne, nil
 	}

resources/locales/ca_IT/ca_IT.go

@@ -5,31 +5,38 @@ import (
 )
 
 type ca_IT struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ca_IT' locale
 func New() locales.Translator {
 	return &ca_IT{
-		locale: "ca_IT",
+		locale:  "ca_IT",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ca_IT) Locale() string {
-	return l.locale
+func (t *ca_IT) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ca_IT) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ca_IT'
+func (t *ca_IT) Plurals() []locales.PluralRule {
+	return t.plurals
+}
 
-	v := locales.V(num)
+// 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}
 	}
 
+	v := locales.V(num)
+
 	if i == 1 && v == 0 {
 		return locales.PluralRuleOne, nil
 	}

resources/locales/ce/ce.go

@@ -5,23 +5,30 @@ import (
 )
 
 type ce struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ce' locale
 func New() locales.Translator {
 	return &ce{
-		locale: "ce",
+		locale:  "ce",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ce) Locale() string {
-	return l.locale
+func (t *ce) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ce) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ce'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/ce_RU/ce_RU.go

@@ -5,23 +5,30 @@ import (
 )
 
 type ce_RU struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ce_RU' locale
 func New() locales.Translator {
 	return &ce_RU{
-		locale: "ce_RU",
+		locale:  "ce_RU",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ce_RU) Locale() string {
-	return l.locale
+func (t *ce_RU) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ce_RU) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ce_RU'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/cgg/cgg.go

@@ -5,23 +5,30 @@ import (
 )
 
 type cgg struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'cgg' locale
 func New() locales.Translator {
 	return &cgg{
-		locale: "cgg",
+		locale:  "cgg",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *cgg) Locale() string {
-	return l.locale
+func (t *cgg) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *cgg) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'cgg'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/cgg_UG/cgg_UG.go

@@ -5,23 +5,30 @@ import (
 )
 
 type cgg_UG struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'cgg_UG' locale
 func New() locales.Translator {
 	return &cgg_UG{
-		locale: "cgg_UG",
+		locale:  "cgg_UG",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *cgg_UG) Locale() string {
-	return l.locale
+func (t *cgg_UG) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *cgg_UG) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'cgg_UG'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/chr/chr.go

@@ -5,23 +5,30 @@ import (
 )
 
 type chr struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'chr' locale
 func New() locales.Translator {
 	return &chr{
-		locale: "chr",
+		locale:  "chr",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *chr) Locale() string {
-	return l.locale
+func (t *chr) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *chr) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'chr'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/chr_US/chr_US.go

@@ -5,23 +5,30 @@ import (
 )
 
 type chr_US struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'chr_US' locale
 func New() locales.Translator {
 	return &chr_US{
-		locale: "chr_US",
+		locale:  "chr_US",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *chr_US) Locale() string {
-	return l.locale
+func (t *chr_US) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *chr_US) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'chr_US'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/ckb/ckb.go

@@ -5,23 +5,30 @@ import (
 )
 
 type ckb struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ckb' locale
 func New() locales.Translator {
 	return &ckb{
-		locale: "ckb",
+		locale:  "ckb",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ckb) Locale() string {
-	return l.locale
+func (t *ckb) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ckb) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ckb'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/ckb_IQ/ckb_IQ.go

@@ -5,23 +5,30 @@ import (
 )
 
 type ckb_IQ struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ckb_IQ' locale
 func New() locales.Translator {
 	return &ckb_IQ{
-		locale: "ckb_IQ",
+		locale:  "ckb_IQ",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ckb_IQ) Locale() string {
-	return l.locale
+func (t *ckb_IQ) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ckb_IQ) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ckb_IQ'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/ckb_IR/ckb_IR.go

@@ -5,23 +5,30 @@ import (
 )
 
 type ckb_IR struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'ckb_IR' locale
 func New() locales.Translator {
 	return &ckb_IR{
-		locale: "ckb_IR",
+		locale:  "ckb_IR",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *ckb_IR) Locale() string {
-	return l.locale
+func (t *ckb_IR) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *ckb_IR) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'ckb_IR'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/cs/cs.go

@@ -5,31 +5,38 @@ import (
 )
 
 type cs struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'cs' locale
 func New() locales.Translator {
 	return &cs{
-		locale: "cs",
+		locale:  "cs",
+		plurals: []locales.PluralRule{2, 4, 5, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *cs) Locale() string {
-	return l.locale
+func (t *cs) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *cs) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'cs'
+func (t *cs) Plurals() []locales.PluralRule {
+	return t.plurals
+}
 
-	v := locales.V(num)
+// 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}
 	}
 
+	v := locales.V(num)
+
 	if i == 1 && v == 0 {
 		return locales.PluralRuleOne, nil
 	} else if i >= 2 && i <= 4 && v == 0 {

resources/locales/cs_CZ/cs_CZ.go

@@ -5,31 +5,38 @@ import (
 )
 
 type cs_CZ struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'cs_CZ' locale
 func New() locales.Translator {
 	return &cs_CZ{
-		locale: "cs_CZ",
+		locale:  "cs_CZ",
+		plurals: []locales.PluralRule{2, 4, 5, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *cs_CZ) Locale() string {
-	return l.locale
+func (t *cs_CZ) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *cs_CZ) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'cs_CZ'
+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)
 
 	i, err := locales.I(num)
 	if err != nil {
 		return locales.PluralRuleUnknown, &locales.ErrBadNumberValue{NumberValue: num, InnerError: err}
 	}
 
-	v := locales.V(num)
-
 	if i == 1 && v == 0 {
 		return locales.PluralRuleOne, nil
 	} else if i >= 2 && i <= 4 && v == 0 {

resources/locales/cu/cu.go

@@ -5,22 +5,29 @@ import (
 )
 
 type cu struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'cu' locale
 func New() locales.Translator {
 	return &cu{
-		locale: "cu",
+		locale:  "cu",
+		plurals: nil,
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *cu) Locale() string {
-	return l.locale
+func (t *cu) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *cu) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'cu'
+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) {
+	return locales.PluralRuleUnknown, nil
 }

resources/locales/cu_RU/cu_RU.go

@@ -5,22 +5,29 @@ import (
 )
 
 type cu_RU struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'cu_RU' locale
 func New() locales.Translator {
 	return &cu_RU{
-		locale: "cu_RU",
+		locale:  "cu_RU",
+		plurals: nil,
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *cu_RU) Locale() string {
-	return l.locale
+func (t *cu_RU) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *cu_RU) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'cu_RU'
+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) {
+	return locales.PluralRuleUnknown, nil
 }

resources/locales/cy/cy.go

@@ -5,23 +5,30 @@ import (
 )
 
 type cy struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'cy' locale
 func New() locales.Translator {
 	return &cy{
-		locale: "cy",
+		locale:  "cy",
+		plurals: []locales.PluralRule{1, 2, 3, 4, 5, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *cy) Locale() string {
-	return l.locale
+func (t *cy) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *cy) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'cy'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/cy_GB/cy_GB.go

@@ -5,23 +5,30 @@ import (
 )
 
 type cy_GB struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'cy_GB' locale
 func New() locales.Translator {
 	return &cy_GB{
-		locale: "cy_GB",
+		locale:  "cy_GB",
+		plurals: []locales.PluralRule{1, 2, 3, 4, 5, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *cy_GB) Locale() string {
-	return l.locale
+func (t *cy_GB) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *cy_GB) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'cy_GB'
+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) {
 
 	n, err := locales.N(num)
 	if err != nil {

resources/locales/da/da.go

@@ -5,23 +5,30 @@ import (
 )
 
 type da struct {
-	locale string
+	locale  string
+	plurals []locales.PluralRule
 }
 
 // New returns a new instance of translator for the 'da' locale
 func New() locales.Translator {
 	return &da{
-		locale: "da",
+		locale:  "da",
+		plurals: []locales.PluralRule{2, 6},
 	}
 }
 
 // Locale returns the current translators string locale
-func (l *da) Locale() string {
-	return l.locale
+func (t *da) Locale() string {
+	return t.locale
 }
 
-// CardinalPluralRule returns the PluralRule given 'num'
-func (l *da) CardinalPluralRule(num string) (locales.PluralRule, error) {
+// Plurals returns the list of plurals associated with 'da'
+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 {