n2words 1.13.0 → 1.15.0

package/lib/i18n/NO.mjs

@@ -1,54 +1,53 @@
-import N2WordsBase from '../classes/N2WordsBase.mjs';
+import BaseLanguage from '../classes/BaseLanguage.mjs';
 
-export class N2WordsNO extends N2WordsBase {
-  constructor() {
-    super();
-
-    this.negativeWord = 'minus';
-    this.separatorWord = 'komma';
-    this.zero = 'null';
-    this.cards = [
-      { '1000000000000000000000000000000000': 'quintillard' },
-      { '1000000000000000000000000000000': 'quintillion' },
-      { '1000000000000000000000000000': 'quadrillard' },
-      { '1000000000000000000000000': 'quadrillion' },
-      { '1000000000000000000000': 'trillard' },
-      { 1000000000000000000: 'trillion' },
-      { 1000000000000000: 'billard' },
-      { 1000000000000: 'billion' },
-      { 1000000000: 'millard' },
-      { 1000000: 'million' },
-      { 1000: 'tusen' },
-      { 100: 'hundre' },
-      { 90: 'nitti' },
-      { 80: 'åtti' },
-      { 70: 'sytti' },
-      { 60: 'seksti' },
-      { 50: 'femti' },
-      { 40: 'førti' },
-      { 30: 'tretti' },
-      { 20: 'tjue' },
-      { 19: 'nitten' },
-      { 18: 'atten' },
-      { 17: 'sytten' },
-      { 16: 'seksten' },
-      { 15: 'femten' },
-      { 14: 'fjorten' },
-      { 13: 'tretten' },
-      { 12: 'tolv' },
-      { 11: 'elleve' },
-      { 10: 'ti' },
-      { 9: 'ni' },
-      { 8: 'åtte' },
-      { 7: 'syv' },
-      { 6: 'seks' },
-      { 5: 'fem' },
-      { 4: 'fire' },
-      { 3: 'tre' },
-      { 2: 'to' },
-      { 1: 'en' },
-      { 0: 'null' }
-    ];
+export class N2WordsNO extends BaseLanguage {
+  constructor(options) {
+    super(Object.assign({
+      negativeWord: 'minus',
+      separatorWord: 'komma',
+      zero: 'null'
+    }, options), [
+      [1000000000000000000000000000000000n, 'quintillard'],
+      [1000000000000000000000000000000n, 'quintillion'],
+      [1000000000000000000000000000n, 'quadrillard'],
+      [1000000000000000000000000n, 'quadrillion'],
+      [1000000000000000000000n, 'trillard'],
+      [1000000000000000000n, 'trillion'],
+      [1000000000000000n, 'billard'],
+      [1000000000000n, 'billion'],
+      [1000000000n, 'millard'],
+      [1000000n, 'million'],
+      [1000n, 'tusen'],
+      [100n, 'hundre'],
+      [90n, 'nitti'],
+      [80n, 'åtti'],
+      [70n, 'sytti'],
+      [60n, 'seksti'],
+      [50n, 'femti'],
+      [40n, 'førti'],
+      [30n, 'tretti'],
+      [20n, 'tjue'],
+      [19n, 'nitten'],
+      [18n, 'atten'],
+      [17n, 'sytten'],
+      [16n, 'seksten'],
+      [15n, 'femten'],
+      [14n, 'fjorten'],
+      [13n, 'tretten'],
+      [12n, 'tolv'],
+      [11n, 'elleve'],
+      [10n, 'ti'],
+      [9n, 'ni'],
+      [8n, 'åtte'],
+      [7n, 'syv'],
+      [6n, 'seks'],
+      [5n, 'fem'],
+      [4n, 'fire'],
+      [3n, 'tre'],
+      [2n, 'to'],
+      [1n, 'en'],
+      [0n, 'null']
+    ]);
   }
 
   merge(lPair, rPair) { // {'one':1}, {'hundred':100}
@@ -64,6 +63,13 @@ export class N2WordsNO extends N2WordsBase {
   }
 }
 
-export default function(n) {
-  return new N2WordsNO().floatToCardinal(n);
+/**
+ * Converts a value to cardinal (written) form.
+ * @param {number|string} value Number to be convert.
+ * @param {object} options Options for class.
+ * @throws {Error} Value cannot be invalid.
+ * @returns {string} Value in cardinal (written) format.
+ */
+export default function(value, options) {
+  return new N2WordsNO(options).floatToCardinal(value);
 }

package/lib/i18n/PL.mjs

@@ -1,87 +1,91 @@
 import {N2WordsRU} from './RU.mjs';
 
 export class N2WordsPL extends N2WordsRU {
-  constructor() {
-    super();
+  ones = {
+    1: 'jeden',
+    2: 'dwa',
+    3: 'trzy',
+    4: 'cztery',
+    5: 'pięć',
+    6: 'sześć',
+    7: 'siedem',
+    8: 'osiem',
+    9: 'dziewięć'
+  };
 
-    this.feminine = false;
-    this.negativeWord = 'minus';
-    this.separatorWord = 'przecinek';
-    this.zero = 'zero';
-    this.ones = {
-      1: 'jeden',
-      2: 'dwa',
-      3: 'trzy',
-      4: 'cztery',
-      5: 'pięć',
-      6: 'sześć',
-      7: 'siedem',
-      8: 'osiem',
-      9: 'dziewięć'
-    };
-    this.tens = {
-      0: 'dziesięć',
-      1: 'jedenaście',
-      2: 'dwanaście',
-      3: 'trzynaście',
-      4: 'czternaście',
-      5: 'piętnaście',
-      6: 'szesnaście',
-      7: 'siedemnaście',
-      8: 'osiemnaście',
-      9: 'dziewiętnaście'
-    };
-    this.twenties = {
-      2: 'dwadzieścia',
-      3: 'trzydzieści',
-      4: 'czterdzieści',
-      5: 'pięćdziesiąt',
-      6: 'sześćdziesiąt',
-      7: 'siedemdziesiąt',
-      8: 'osiemdziesiąt',
-      9: 'dziewięćdzisiąt'
-    };
-    this.hundreds = {
-      1: 'sto',
-      2: 'dwieście',
-      3: 'trzysta',
-      4: 'czterysta',
-      5: 'pięćset',
-      6: 'sześćset',
-      7: 'siedemset',
-      8: 'osiemset',
-      9: 'dziewięćset'
-    };
-    this.thousands = {
-      1: ['tysiąc', 'tysiące', 'tysięcy'], // 10^ 3
-      2: ['milion', 'miliony', 'milionów'], // 10^ 6
-      3: ['miliard', 'miliardy', 'miliardów'], // 10^ 9
-      4: ['bilion', 'biliony', 'bilionów'], // 10^ 12
-      5: ['biliard', 'biliardy', 'biliardów'], // 10^ 15
-      6: ['trylion', 'tryliony', 'trylionów'], // 10^ 18
-      7: ['tryliard', 'tryliardy', 'tryliardów'], // 10^ 21
-      8: ['kwadrylion', 'kwadryliony', 'kwadrylionów'], // 10^ 24
-      9: ['kwaryliard', 'kwadryliardy', 'kwadryliardów'], // 10^ 27
-      10: ['kwintylion', 'kwintyliony', 'kwintylionów'], // 10^ 30
-    };
+  tens = {
+    0: 'dziesięć',
+    1: 'jedenaście',
+    2: 'dwanaście',
+    3: 'trzynaście',
+    4: 'czternaście',
+    5: 'piętnaście',
+    6: 'szesnaście',
+    7: 'siedemnaście',
+    8: 'osiemnaście',
+    9: 'dziewiętnaście'
+  };
+
+  twenties = {
+    2: 'dwadzieścia',
+    3: 'trzydzieści',
+    4: 'czterdzieści',
+    5: 'pięćdziesiąt',
+    6: 'sześćdziesiąt',
+    7: 'siedemdziesiąt',
+    8: 'osiemdziesiąt',
+    9: 'dziewięćdzisiąt'
+  };
+
+  hundreds = {
+    1: 'sto',
+    2: 'dwieście',
+    3: 'trzysta',
+    4: 'czterysta',
+    5: 'pięćset',
+    6: 'sześćset',
+    7: 'siedemset',
+    8: 'osiemset',
+    9: 'dziewięćset'
+  };
+
+  thousands = {
+    1: ['tysiąc', 'tysiące', 'tysięcy'], // 10^ 3
+    2: ['milion', 'miliony', 'milionów'], // 10^ 6
+    3: ['miliard', 'miliardy', 'miliardów'], // 10^ 9
+    4: ['bilion', 'biliony', 'bilionów'], // 10^ 12
+    5: ['biliard', 'biliardy', 'biliardów'], // 10^ 15
+    6: ['trylion', 'tryliony', 'trylionów'], // 10^ 18
+    7: ['tryliard', 'tryliardy', 'tryliardów'], // 10^ 21
+    8: ['kwadrylion', 'kwadryliony', 'kwadrylionów'], // 10^ 24
+    9: ['kwaryliard', 'kwadryliardy', 'kwadryliardów'], // 10^ 27
+    10: ['kwintylion', 'kwintyliony', 'kwintylionów'], // 10^ 30
+  };
+
+  constructor(options) {
+    super(Object.assign({
+      negativeWord: 'minus',
+      separatorWord: 'przecinek',
+      zero: 'zero'
+    }, options));
   }
 
   pluralize(n, forms) {
     let form = 2;
     if (n == 1) {
       form = 0;
-    } else if ((n % 10 < 5) && (n % 10 > 1) && ((n % 100 < 10) || (n % 100 > 20))) {
+    } else if ((n % 10n < 5n) && (n % 10n > 1n) && ((n % 100n < 10n) || (n % 100n > 20n))) {
       form = 1;
     }
     return forms[form];
   }
 
   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];
@@ -109,6 +113,13 @@ export class N2WordsPL extends N2WordsRU {
   }
 }
 
-export default function(n) {
-  return new N2WordsPL().floatToCardinal(n);
+/**
+ * Converts a value to cardinal (written) form.
+ * @param {number|string} value Number to be convert.
+ * @param {object} options Options for class.
+ * @throws {Error} Value cannot be invalid.
+ * @returns {string} Value in cardinal (written) format.
+ */
+export default function(value, options) {
+  return new N2WordsPL(options).floatToCardinal(value);
 }

package/lib/i18n/PT.mjs

@@ -1,59 +1,59 @@
-import N2WordsBase from '../classes/N2WordsBase.mjs';
+import BaseLanguage from '../classes/BaseLanguage.mjs';
 
-export class N2WordsPT extends N2WordsBase {
-  constructor() {
-    super();
+export class N2WordsPT extends BaseLanguage {
+  hundreds = {
+    1: 'cento',
+    2: 'duzentos',
+    3: 'trezentos',
+    4: 'quatrocentos',
+    5: 'quinhentos',
+    6: 'seiscentos',
+    7: 'setecentos',
+    8: 'oitocentos',
+    9: 'novecentos'
+  };
 
-    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',
-      3: 'trezentos',
-      4: 'quatrocentos',
-      5: 'quinhentos',
-      6: 'seiscentos',
-      7: 'setecentos',
-      8: 'oitocentos',
-      9: 'novecentos'
-    };
+  constructor(options) {
+    super(Object.assign({
+      negativeWord: 'menos',
+      separatorWord: 'vírgula',
+      zero: 'zero'
+    }, options), [
+      [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']
+    ]);
   }
 
   postClean(words) {
@@ -102,6 +102,13 @@ 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.
+ * @param {object} options Options for class.
+ * @throws {Error} Value cannot be invalid.
+ * @returns {string} Value in cardinal (written) format.
+ */
+export default function(value, options) {
+  return new N2WordsPT(options).floatToCardinal(value);
 }