n2words 1.12.2 → 1.14.0

package/lib/i18n/PT.mjs

@@ -1,48 +1,48 @@
-import N2WordsBase from '../classes/N2WordsBase.mjs';
+import BaseLanguage from '../classes/BaseLanguage.mjs';
 
-export class N2WordsPT extends N2WordsBase {
+export class N2WordsPT extends BaseLanguage {
   constructor() {
-    super();
+    super({
+      negativeWord: 'menos',
+      separatorWord: 'vírgula',
+      zero: 'zero'
+    },[
+      [1000000000000000000000000n, 'quatrilião'],
+      [1000000000000000000n, 'trilião'],
+      [1000000000000n, 'bilião'],
+      [1000000n, 'milião'],
+      [1000n, 'mil'],
+      [100n, 'cem'],
+      [90n, 'noventa'],
+      [80n, 'oitenta'],
+      [70n, 'setenta'],
+      [60n, 'sessenta'],
+      [50n, 'cinquenta'],
+      [40n, 'quarenta'],
+      [30n, 'trinta'],
+      [20n, 'vinte'],
+      [19n, 'dezanove'],
+      [18n, 'dezoito'],
+      [17n, 'dezassete'],
+      [16n, 'dezasseis'],
+      [15n, 'quinze'],
+      [14n, 'catorze'],
+      [13n, 'treze'],
+      [12n, 'doze'],
+      [11n, 'onze'],
+      [10n, 'dez'],
+      [9n, 'nove'],
+      [8n, 'oito'],
+      [7n, 'sete'],
+      [6n, 'seis'],
+      [5n, 'cinco'],
+      [4n, 'quatro'],
+      [3n, 'três'],
+      [2n, 'dois'],
+      [1n, 'um'],
+      [0n, 'zero']
+    ]);
 
-    this.negativeWord = 'menos';
-    this.separatorWord = 'vírgula';
-    this.zero = 'zero';
-    this.cards = [
-      { '1000000000000000000000000': 'quatrilião' },
-      { 1000000000000000000: 'trilião' },
-      { 1000000000000: 'bilião' },
-      { 1000000: 'milião' },
-      { 1000: 'mil' },
-      { 100: 'cem' },
-      { 90: 'noventa' },
-      { 80: 'oitenta' },
-      { 70: 'setenta' },
-      { 60: 'sessenta' },
-      { 50: 'cinquenta' },
-      { 40: 'quarenta' },
-      { 30: 'trinta' },
-      { 20: 'vinte' },
-      { 19: 'dezanove' },
-      { 18: 'dezoito' },
-      { 17: 'dezassete' },
-      { 16: 'dezasseis' },
-      { 15: 'quinze' },
-      { 14: 'catorze' },
-      { 13: 'treze' },
-      { 12: 'doze' },
-      { 11: 'onze' },
-      { 10: 'dez' },
-      { 9: 'nove' },
-      { 8: 'oito' },
-      { 7: 'sete' },
-      { 6: 'seis' },
-      { 5: 'cinco' },
-      { 4: 'quatro' },
-      { 3: 'três' },
-      { 2: 'dois' },
-      { 1: 'um' },
-      { 0: 'zero' }
-    ];
     this.hundreds = {
       1: 'cento',
       2: 'duzentos',
@@ -102,6 +102,12 @@ export class N2WordsPT extends N2WordsBase {
   }
 }
 
-export default function(n) {
-  return new N2WordsPT().floatToCardinal(n);
+/**
+ * Converts a value to cardinal (written) form.
+ * @param {number|string} value Number to be convert.
+ * @throws {Error} Value cannot be invalid.
+ * @returns {string} Value in cardinal (written) format.
+ */
+export default function(value) {
+  return new N2WordsPT().floatToCardinal(value);
 }

package/lib/i18n/RU.mjs

@@ -1,166 +1,196 @@
-import N2WordsAbs from '../classes/N2WordsAbs.mjs';
-
-export class N2WordsRU extends N2WordsAbs {
-  constructor() {
-    super();
-
-    this.feminine = false;
-    this.negativeWord = 'минус';
-    this.separatorWord = 'запятая';
-    this.zero = 'ноль';
-    this.ones = {
-      1: 'один',
-      2: 'два',
-      3: 'три',
-      4: 'четыре',
-      5: 'пять',
-      6: 'шесть',
-      7: 'семь',
-      8: 'восемь',
-      9: 'девять'
-    };
-    this.onesFeminine = {
-      1: 'одна',
-      2: 'две',
-      3: 'три',
-      4: 'четыре',
-      5: 'пять',
-      6: 'шесть',
-      7: 'семь',
-      8: 'восемь',
-      9: 'девять'
-    };
-    this.tens = {
-      0: 'десять',
-      1: 'одиннадцать',
-      2: 'двенадцать',
-      3: 'тринадцать',
-      4: 'четырнадцать',
-      5: 'пятнадцать',
-      6: 'шестнадцать',
-      7: 'семнадцать',
-      8: 'восемнадцать',
-      9: 'девятнадцать'
-    };
-    this.twenties = {
-      2: 'двадцать',
-      3: 'тридцать',
-      4: 'сорок',
-      5: 'пятьдесят',
-      6: 'шестьдесят',
-      7: 'семьдесят',
-      8: 'восемьдесят',
-      9: 'девяносто'
-    };
-    this.hundreds = {
-      1: 'сто',
-      2: 'двести',
-      3: 'триста',
-      4: 'четыреста',
-      5: 'пятьсот',
-      6: 'шестьсот',
-      7: 'семьсот',
-      8: 'восемьсот',
-      9: 'девятьсот'
-    };
-    this.thousands = {
-      1: ['тысяча', 'тысячи', 'тысяч'], // 10^ 3
-      2: ['миллион', 'миллиона', 'миллионов'], // 10^ 6
-      3: ['миллиард', 'миллиарда', 'миллиардов'], // 10^ 9
-      4: ['триллион', 'триллиона', 'триллионов'], // 10^ 12
-      5: ['квадриллион', 'квадриллиона', 'квадриллионов'], // 10^ 15
-      6: ['квинтиллион', 'квинтиллиона', 'квинтиллионов'], // 10^ 18
-      7: ['секстиллион', 'секстиллиона', 'секстиллионов'], // 10^ 21
-      8: ['септиллион', 'септиллиона', 'септиллионов'], // 10^ 24
-      9: ['октиллион', 'октиллиона', 'октиллионов'], // 10^ 27
-      10: ['нониллион', 'нониллиона', 'нониллионов'], // 10^ 30
-    };
+import AbstractLanguage from '../classes/AbstractLanguage.mjs';
+
+export class N2WordsRU extends AbstractLanguage {
+  feminine = false;
+
+  ones = {
+    1: 'один',
+    2: 'два',
+    3: 'три',
+    4: 'четыре',
+    5: 'пять',
+    6: 'шесть',
+    7: 'семь',
+    8: 'восемь',
+    9: 'девять'
+  };
+
+  onesFeminine = {
+    1: 'одна',
+    2: 'две',
+    3: 'три',
+    4: 'четыре',
+    5: 'пять',
+    6: 'шесть',
+    7: 'семь',
+    8: 'восемь',
+    9: 'девять'
+  };
+
+  tens = {
+    0: 'десять',
+    1: 'одиннадцать',
+    2: 'двенадцать',
+    3: 'тринадцать',
+    4: 'четырнадцать',
+    5: 'пятнадцать',
+    6: 'шестнадцать',
+    7: 'семнадцать',
+    8: 'восемнадцать',
+    9: 'девятнадцать'
+  };
+
+  twenties = {
+    2: 'двадцать',
+    3: 'тридцать',
+    4: 'сорок',
+    5: 'пятьдесят',
+    6: 'шестьдесят',
+    7: 'семьдесят',
+    8: 'восемьдесят',
+    9: 'девяносто'
+  };
+
+  hundreds = {
+    1: 'сто',
+    2: 'двести',
+    3: 'триста',
+    4: 'четыреста',
+    5: 'пятьсот',
+    6: 'шестьсот',
+    7: 'семьсот',
+    8: 'восемьсот',
+    9: 'девятьсот'
+  };
+
+  thousands = {
+    1: ['тысяча', 'тысячи', 'тысяч'], // 10^ 3
+    2: ['миллион', 'миллиона', 'миллионов'], // 10^ 6
+    3: ['миллиард', 'миллиарда', 'миллиардов'], // 10^ 9
+    4: ['триллион', 'триллиона', 'триллионов'], // 10^ 12
+    5: ['квадриллион', 'квадриллиона', 'квадриллионов'], // 10^ 15
+    6: ['квинтиллион', 'квинтиллиона', 'квинтиллионов'], // 10^ 18
+    7: ['секстиллион', 'секстиллиона', 'секстиллионов'], // 10^ 21
+    8: ['септиллион', 'септиллиона', 'септиллионов'], // 10^ 24
+    9: ['октиллион', 'октиллиона', 'октиллионов'], // 10^ 27
+    10: ['нониллион', 'нониллиона', 'нониллионов'], // 10^ 30
+  };
+
+  constructor(options = {}) {
+    super(Object.assign({
+      negativeWord: 'минус',
+      separatorWord: 'запятая',
+      zero: 'ноль'
+    }, options));
+  }
+
+  toCardinal(number) {
+    if (number == 0) {
+      return this.zero;
+    }
+
+    const words = [];
+
+    const chunks = this.splitByX(number.toString(), 3);
+
+    let i = chunks.length;
+
+    for (let j = 0; j < chunks.length; j++) {
+      const x = chunks[j];
+      let ones = [];
+      i = i - 1;
+
+      if (x == 0) {
+        continue;
+      }
+
+      const [n1, n2, n3] = this.getDigits(x);
+
+      if (n3 > 0) {
+        words.push(this.hundreds[n3]);
+      }
+
+      if (n2 > 1) {
+        words.push(this.twenties[n2]);
+      }
+
+      if (n2 == 1) {
+        words.push(this.tens[n1]);
+      } else if (n1 > 0) {
+        ones = (i == 1 || this.feminine && i == 0) ? this.onesFeminine : this.ones;
+        words.push(ones[n1]);
+      }
+
+      if (i > 0) {
+        words.push(this.pluralize(x, this.thousands[i]));
+      }
+    }
+
+    return words.join(' ');
   }
 
   splitByX(n, x, formatInt = true) {
     const results = [];
     const l = n.length;
     let result;
+
     if (l > x) {
       const start = l % x;
+
       if (start > 0) {
         result = n.slice(0, start);
+
         if (formatInt) {
-          results.push(parseInt(result));
+          results.push(BigInt(result));
         } else {
           results.push(result);
         }
       }
+
       for (let i = start; i < l; i += x) {
         result = n.slice(i, i + x);
+
         if (formatInt) {
-          results.push(parseInt(result));
+          results.push(BigInt(result));
         } else {
           results.push(result);
         }
       }
     } else {
       if (formatInt) {
-        results.push(parseInt(n));
+        results.push(BigInt(n));
       } else {
         results.push(n);
       }
     }
+
     return results;
   }
 
-  getDigits(n) {
-    const a = Array.from(JSON.stringify(n).padStart(3, '0').slice(-3)).reverse();
-    return a.map(e => parseInt(e));
+  getDigits(value) {
+    const a = Array.from(value.toString().padStart(3, '0').slice(-3)).reverse();
+    return a.map(e => BigInt(e));
   }
 
   pluralize(n, forms) {
     let form = 2;
-    if ((n % 100 < 10) || (n % 100 > 20)) {
-      if (n % 10 == 1) {
+    if ((n % 100n < 10n) || (n % 100n > 20n)) {
+      if (n % 10n == 1n) {
         form = 0;
-      } else if ((n % 10 < 5) && (n % 10 > 1)) {
+      } else if ((n % 10n < 5n) && (n % 10n > 1n)) {
         form = 1;
       }
     }
     return forms[form];
   }
-
-  toCardinal(number) {
-    if (parseInt(number) == 0) {
-      return this.zero;
-    }
-    const words = [];
-    const chunks = this.splitByX(JSON.stringify(number), 3);
-    let i = chunks.length;
-    for (let j = 0; j < chunks.length; j++) {
-      const x = chunks[j];
-      let ones = [];
-      i = i - 1;
-      if (x == 0) {
-        continue;
-      }
-      const [n1, n2, n3] = this.getDigits(x);
-      if (n3 > 0) {
-        words.push(this.hundreds[n3]);
-      }
-      if (n2 > 1) {
-        words.push(this.twenties[n2]);
-      }
-      if (n2 == 1) {
-        words.push(this.tens[n1]);
-      } else if (n1 > 0) {
-        ones = (i == 1 || this.feminine && i == 0) ? this.onesFeminine : this.ones;
-        words.push(ones[n1]);
-      }
-      if (i > 0) {
-        words.push(this.pluralize(x, this.thousands[i]));
-      }
-    }
-    return words.join(' ');
-  }
 }
 
-export default function(n) {
-  return new N2WordsRU().floatToCardinal(n);
+/**
+ * Converts a value to cardinal (written) form.
+ * @param {number|string} value Number to be convert.
+ * @throws {Error} Value cannot be invalid.
+ * @returns {string} Value in cardinal (written) format.
+ */
+export default function(value) {
+  return new N2WordsRU().floatToCardinal(value);
 }

package/lib/i18n/SR.mjs

@@ -1,78 +1,84 @@
 import {N2WordsRU} from './RU.mjs';
 
 export class N2WordsSR extends N2WordsRU {
-  constructor() {
-    super();
+  ones = {
+    1: ['jedan', 'jedna'],
+    2: ['dva', 'dve'],
+    3: ['tri', 'tri'],
+    4: ['četiri', 'četiri'],
+    5: ['pet', 'pet'],
+    6: ['šest', 'šest'],
+    7: ['sedam', 'sedam'],
+    8: ['osam', 'osam'],
+    9: ['devet', 'devet']
+  };
+
+  tens = {
+    0: 'deset',
+    1: 'jedanaest',
+    2: 'dvanaest',
+    3: 'trinaest',
+    4: 'četrnaest',
+    5: 'petnaest',
+    6: 'šesnaest',
+    7: 'sedamnaest',
+    8: 'osamnaest',
+    9: 'devetnaest'
+  };
+
+  twenties = {
+    2: 'dvadeset',
+    3: 'trideset',
+    4: 'četrdeset',
+    5: 'pedeset',
+    6: 'šezdeset',
+    7: 'sedamdeset',
+    8: 'osamdeset',
+    9: 'devedeset'
+  };
+
+  hundreds = {
+    1: 'sto',
+    2: 'dvesta',
+    3: 'trista',
+    4: 'četiristo',
+    5: 'petsto',
+    6: 'šesto',
+    7: 'sedamsto',
+    8: 'osamsto',
+    9: 'devetsto'
+  };
 
-    this.negativeWord = 'minus';
-    this.separatorWord = 'zapeta';
-    this.zero = 'nula';
-    this.ones = {
-      1: ['jedan', 'jedna'],
-      2: ['dva', 'dve'],
-      3: ['tri', 'tri'],
-      4: ['četiri', 'četiri'],
-      5: ['pet', 'pet'],
-      6: ['šest', 'šest'],
-      7: ['sedam', 'sedam'],
-      8: ['osam', 'osam'],
-      9: ['devet', 'devet']
-    };
-    this.tens = {
-      0: 'deset',
-      1: 'jedanaest',
-      2: 'dvanaest',
-      3: 'trinaest',
-      4: 'četrnaest',
-      5: 'petnaest',
-      6: 'šesnaest',
-      7: 'sedamnaest',
-      8: 'osamnaest',
-      9: 'devetnaest'
-    };
-    this.twenties = {
-      2: 'dvadeset',
-      3: 'trideset',
-      4: 'četrdeset',
-      5: 'pedeset',
-      6: 'šezdeset',
-      7: 'sedamdeset',
-      8: 'osamdeset',
-      9: 'devedeset'
-    };
-    this.hundreds = {
-      1: 'sto',
-      2: 'dvesta',
-      3: 'trista',
-      4: 'četiristo',
-      5: 'petsto',
-      6: 'šesto',
-      7: 'sedamsto',
-      8: 'osamsto',
-      9: 'devetsto'
-    };
-    this.SCALE = {
-      0: ['', '', '', false],
-      1: ['hiljada', 'hiljade', 'hiljada', true], // 10 ^ 3
-      2: ['milion', 'miliona', 'miliona', false], // 10 ^ 6
-      3: ['milijarda', 'milijarde', 'milijarda', false], // 10 ^ 9
-      4: ['bilion', 'biliona', 'biliona', false], // 10 ^ 12
-      5: ['bilijarda', 'bilijarde', 'bilijarda', false], // 10 ^ 15
-      6: ['trilion', 'triliona', 'triliona', false], // 10 ^ 18
-      7: ['trilijarda', 'trilijarde', 'trilijarda', false], // 10 ^ 21
-      8: ['kvadrilion', 'kvadriliona', 'kvadriliona', false], // 10 ^ 24
-      9: ['kvadrilijarda', 'kvadrilijarde', 'kvadrilijarda', false], // 10 ^ 27
-      10: ['kvintilion', 'kvintiliona', 'kvintiliona', false], // 10 ^ 30
-    };
-    this.feminine = false;
+  SCALE = {
+    0: ['', '', '', false],
+    1: ['hiljada', 'hiljade', 'hiljada', true], // 10 ^ 3
+    2: ['milion', 'miliona', 'miliona', false], // 10 ^ 6
+    3: ['milijarda', 'milijarde', 'milijarda', false], // 10 ^ 9
+    4: ['bilion', 'biliona', 'biliona', false], // 10 ^ 12
+    5: ['bilijarda', 'bilijarde', 'bilijarda', false], // 10 ^ 15
+    6: ['trilion', 'triliona', 'triliona', false], // 10 ^ 18
+    7: ['trilijarda', 'trilijarde', 'trilijarda', false], // 10 ^ 21
+    8: ['kvadrilion', 'kvadriliona', 'kvadriliona', false], // 10 ^ 24
+    9: ['kvadrilijarda', 'kvadrilijarde', 'kvadrilijarda', false], // 10 ^ 27
+    10: ['kvintilion', 'kvintiliona', 'kvintiliona', false], // 10 ^ 30
+  };
+
+  feminine = false;
+
+  constructor() {
+    super({
+      negativeWord: 'minus',
+      separatorWord: 'zapeta',
+      zero: 'nula'
+    });
   }
 
   pluralize(n, forms) {
     let form = 2;
-    if ((n % 100 < 10) || (n % 100 > 20)) {
-      if (n % 10 == 1) {
+    if ((n % 100n < 10n) || (n % 100n > 20n)) {
+      if (n % 10n == 1n) {
         form = 0;
-      } else if ((n % 10 > 1) && (n % 10 < 5)) {
+      } else if ((n % 10n > 1n) && (n % 10n < 5n)) {
         form = 1;
       }
     }
@@ -80,11 +86,11 @@ export class N2WordsSR extends N2WordsRU {
   }
 
   toCardinal(number) {
-    if (parseInt(number) == 0) {
+    if (number == 0) {
       return this.zero;
     }
     const words = [];
-    const chunks = this.splitByX(JSON.stringify(number), 3);
+    const chunks = this.splitByX(number.toString(), 3);
     let i = chunks.length;
     for (let j = 0; j < chunks.length; j++) {
       const x = chunks[j];
@@ -112,6 +118,12 @@ export class N2WordsSR extends N2WordsRU {
   }
 }
 
-export default function(n) {
-  return new N2WordsSR().floatToCardinal(n);
+/**
+ * Converts a value to cardinal (written) form.
+ * @param {number|string} value Number to be convert.
+ * @throws {Error} Value cannot be invalid.
+ * @returns {string} Value in cardinal (written) format.
+ */
+export default function(value) {
+  return new N2WordsSR().floatToCardinal(value);
 }