n2words 1.13.0 → 1.14.0

package/lib/i18n/LV.mjs

@@ -1,64 +1,69 @@
 import {N2WordsRU} from './RU.mjs';
 
 export class N2WordsLV extends N2WordsRU{
-  constructor() {
-    super();
+  ones = {
+    1: 'viens',
+    2: 'divi',
+    3: 'trīs',
+    4: 'četri',
+    5: 'pieci',
+    6: 'seši',
+    7: 'septiņi',
+    8: 'astoņi',
+    9: 'deviņi'
+  };
+
+  tens = {
+    0: 'desmit',
+    1: 'vienpadsmit',
+    2: 'divpadsmit',
+    3: 'trīspadsmit',
+    4: 'četrpadsmit',
+    5: 'piecpadsmit',
+    6: 'sešpadsmit',
+    7: 'septiņpadsmit',
+    8: 'astoņpadsmit',
+    9: 'deviņpadsmit'
+  };
+
+  twenties = {
+    2: 'divdesmit',
+    3: 'trīsdesmit',
+    4: 'četrdesmit',
+    5: 'piecdesmit',
+    6: 'sešdesmit',
+    7: 'septiņdesmit',
+    8: 'astoņdesmit',
+    9: 'deviņdesmit'
+  };
 
-    this.negativeWord = 'mīnus';
-    this.separatorWord = 'komats';
-    this.zero = 'nulle';
-    this.ones = {
-      1: 'viens',
-      2: 'divi',
-      3: 'trīs',
-      4: 'četri',
-      5: 'pieci',
-      6: 'seši',
-      7: 'septiņi',
-      8: 'astoņi',
-      9: 'deviņi'
-    };
-    this.tens = {
-      0: 'desmit',
-      1: 'vienpadsmit',
-      2: 'divpadsmit',
-      3: 'trīspadsmit',
-      4: 'četrpadsmit',
-      5: 'piecpadsmit',
-      6: 'sešpadsmit',
-      7: 'septiņpadsmit',
-      8: 'astoņpadsmit',
-      9: 'deviņpadsmit'
-    };
-    this.twenties = {
-      2: 'divdesmit',
-      3: 'trīsdesmit',
-      4: 'četrdesmit',
-      5: 'piecdesmit',
-      6: 'sešdesmit',
-      7: 'septiņdesmit',
-      8: 'astoņdesmit',
-      9: 'deviņdesmit'
-    };
-    this.hundreds = ['simts', 'simti', 'simtu'];
-    this.thousands = {
-      1: ['tūkstotis', 'tūkstoši', 'tūkstošu'],
-      2: ['miljons', 'miljoni', 'miljonu'],
-      3: ['miljards', 'miljardi', 'miljardu'],
-      4: ['triljons', 'triljoni', 'triljonu'],
-      5: ['kvadriljons', 'kvadriljoni', 'kvadriljonu'],
-      6: ['kvintiljons', 'kvintiljoni', 'kvintiljonu'],
-      7: ['sikstiljons', 'sikstiljoni', 'sikstiljonu'],
-      8: ['septiljons', 'septiljoni', 'septiljonu'],
-      9: ['oktiljons', 'oktiljoni', 'oktiljonu'],
-      10: ['nontiljons', 'nontiljoni', 'nontiljonu'],
-    };
+  hundreds = ['simts', 'simti', 'simtu'];
+
+  thousands = {
+    1: ['tūkstotis', 'tūkstoši', 'tūkstošu'],
+    2: ['miljons', 'miljoni', 'miljonu'],
+    3: ['miljards', 'miljardi', 'miljardu'],
+    4: ['triljons', 'triljoni', 'triljonu'],
+    5: ['kvadriljons', 'kvadriljoni', 'kvadriljonu'],
+    6: ['kvintiljons', 'kvintiljoni', 'kvintiljonu'],
+    7: ['sikstiljons', 'sikstiljoni', 'sikstiljonu'],
+    8: ['septiljons', 'septiljoni', 'septiljonu'],
+    9: ['oktiljons', 'oktiljoni', 'oktiljonu'],
+    10: ['nontiljons', 'nontiljoni', 'nontiljonu'],
+  };
+
+  constructor() {
+    super({
+      negativeWord: 'mīnus',
+      separatorWord: 'komats',
+      zero: 'nulle'
+    });
   }
 
   pluralize(n, forms) {
     let form = 2;
-    if (n != 0) {
-      if (n % 10 == 1 && n % 100 != 11) {
+    if (n != 0n) {
+      if (n % 10n == 1n && n % 100n != 11n) {
         form = 0;
       } else {
         form = 1;
@@ -68,11 +73,11 @@ export class N2WordsLV 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];
@@ -107,6 +112,12 @@ export class N2WordsLV extends N2WordsRU{
   }
 }
 
-export default function(n) {
-  return new N2WordsLV().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 N2WordsLV().floatToCardinal(value);
 }

package/lib/i18n/NL.mjs

@@ -1,58 +1,62 @@
-import N2WordsBase from '../classes/N2WordsBase.mjs';
+import BaseLanguage from '../classes/BaseLanguage.mjs';
 
-export class N2WordsNL extends N2WordsBase {
-  constructor(options) {
-    super();
+export class N2WordsNL extends BaseLanguage {
+  includeOptionalAnd = false;
+  noHundredPairs = false;
 
-    this.negativeWord = 'min';
-    this.separatorWord = 'komma';
-    this.zero = 'nul';
+  constructor(options) {
+    super({
+      negativeWord: 'min',
+      separatorWord: 'komma',
+      zero: 'nul'
+    },[
+      [1000000000000000000000000000n, 'quadriljard'],
+      [1000000000000000000000000n, 'quadriljoen'],
+      [1000000000000000000000n, 'triljard'],
+      [1000000000000000000n, 'triljoen'],
+      [1000000000000000n, 'biljard'],
+      [1000000000000n, 'biljoen'],
+      [1000000000n, 'miljard'],
+      [1000000n, 'miljoen'],
+      [1000n, 'duizend'],
+      [100n, 'honderd'],
+      [90n, 'negentig'],
+      [80n, 'tachtig'],
+      [70n, 'zeventig'],
+      [60n, 'zestig'],
+      [50n, 'vijftig'],
+      [40n, 'veertig'],
+      [30n, 'dertig'],
+      [20n, 'twintig'],
+      [19n, 'negentien'],
+      [18n, 'achttien'],
+      [17n, 'zeventien'],
+      [16n, 'zestien'],
+      [15n, 'vijftien'],
+      [14n, 'veertien'],
+      [13n, 'dertien'],
+      [12n, 'twaalf'],
+      [11n, 'elf'],
+      [10n, 'tien'],
+      [9n, 'negen'],
+      [8n, 'acht'],
+      [7n, 'zeven'],
+      [6n, 'zes'],
+      [5n, 'vijf'],
+      [4n, 'vier'],
+      [3n, 'drie'],
+      [2n, 'twee'],
+      [1n, 'een'],
+      [0n, 'nul'],
+    ]);
 
-    this.options = Object.assign({
-      includeOptionalAnd: false,
-      noHundredPairs: false,
-    }, options);
+    if (options.includeOptionalAnd === true) {
+      this.includeOptionalAnd = true;
+    }
 
-    this.cards = [
-      {'1000000000000000000000000000': 'quadriljard'},
-      {'1000000000000000000000000': 'quadriljoen'},
-      {'1000000000000000000000': 'triljard'},
-      {1000000000000000000: 'triljoen'},
-      {1000000000000000: 'biljard'},
-      {1000000000000: 'biljoen'},
-      {1000000000: 'miljard'},
-      {1000000: 'miljoen'},
-      {1000: 'duizend'},
-      {100: 'honderd'},
-      {90: 'negentig'},
-      {80: 'tachtig'},
-      {70: 'zeventig'},
-      {60: 'zestig'},
-      {50: 'vijftig'},
-      {40: 'veertig'},
-      {30: 'dertig'},
-      {20: 'twintig'},
-      {19: 'negentien'},
-      {18: 'achttien'},
-      {17: 'zeventien'},
-      {16: 'zestien'},
-      {15: 'vijftien'},
-      {14: 'veertien'},
-      {13: 'dertien'},
-      {12: 'twaalf'},
-      {11: 'elf'},
-      {10: 'tien'},
-      {9: 'negen'},
-      {8: 'acht'},
-      {7: 'zeven'},
-      {6: 'zes'},
-      {5: 'vijf'},
-      {4: 'vier'},
-      {3: 'drie'},
-      {2: 'twee'},
-      {1: 'een'},
-      {0: 'nul'},
-    ];
+    if (options.noHundredPairs === true) {
+      this.noHundredPairs = true;
+    }
   }
 
   merge(curr, next) {
@@ -81,14 +85,14 @@ export class N2WordsNL extends N2WordsBase {
         nText = cText;
         const andTxt = temp.endsWith('e') ? 'ën' : 'en';
         cText = `${temp}${andTxt}`;
-      } else if (nNum < 13 && cNum < 1000 && this.options.includeOptionalAnd) {
+      } else if (nNum < 13 && cNum < 1000 && this.includeOptionalAnd) {
         cText = `${cText}en`;
-      } else if (nNum < 13 && cNum >= 1000 && this.options.includeOptionalAnd) {
+      } else if (nNum < 13 && cNum >= 1000 && this.includeOptionalAnd) {
         nText = ` en ${nText}`;
       } else if (cNum >= 1000000) {
         cText += ' ';
       } else {
-        if (cNum === 1000) {
+        if (cNum == 1000) {
           cText += ' ';
         }
       }
@@ -98,18 +102,25 @@ export class N2WordsNL extends N2WordsBase {
   }
 
   toCardinal(value) {
-    if (value >= 1100 && value < 10000 && !this.options.noHundredPairs) {
-      const high = Math.floor(value / 100);
-      const low = value % 100;
-      if (high % 10 !== 0) {
+    if (value >= 1100n && value < 10000n && !this.noHundredPairs) {
+      const high = value / 100n;
+      const low = value % 100n;
+      if (high % 10n !== 0n) {
         return super.toCardinal(high) + 'honderd' +
-          (low ? (this.options.includeOptionalAnd ? ' en ' : ' ') + super.toCardinal(low) : '');
+          (low ? (this.includeOptionalAnd ? ' en ' : ' ') + super.toCardinal(low) : '');
       }
     }
     return super.toCardinal(value);
   }
 }
 
-export default function(n, options = {}) {
-  return new N2WordsNL(options).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 N2WordsNL(options).floatToCardinal(value);
 }

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 {
+export class N2WordsNO extends BaseLanguage {
   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' }
-    ];
+    super({
+      negativeWord: 'minus',
+      separatorWord: 'komma',
+      zero: 'null'
+    },[
+      [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,12 @@ 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.
+ * @throws {Error} Value cannot be invalid.
+ * @returns {string} Value in cardinal (written) format.
+ */
+export default function(value) {
+  return new N2WordsNO().floatToCardinal(value);
 }

package/lib/i18n/PL.mjs

@@ -1,87 +1,93 @@
 import {N2WordsRU} from './RU.mjs';
 
 export class N2WordsPL extends N2WordsRU {
-  constructor() {
-    super();
+  feminine = false;
+
+  ones = {
+    1: 'jeden',
+    2: 'dwa',
+    3: 'trzy',
+    4: 'cztery',
+    5: 'pięć',
+    6: 'sześć',
+    7: 'siedem',
+    8: 'osiem',
+    9: 'dziewięć'
+  };
+
+  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'
+  };
 
-    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
-    };
+  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() {
+    super({
+      negativeWord: 'minus',
+      separatorWord: 'przecinek',
+      zero: 'zero'
+    });
   }
 
   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 +115,12 @@ 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.
+ * @throws {Error} Value cannot be invalid.
+ * @returns {string} Value in cardinal (written) format.
+ */
+export default function(value) {
+  return new N2WordsPL().floatToCardinal(value);
 }