n2words 1.13.0 → 1.15.0

package/lib/i18n/KO.mjs

@@ -1,34 +1,33 @@
-import N2WordsBase from '../classes/N2WordsBase.mjs';
+import BaseLanguage from '../classes/BaseLanguage.mjs';
 
-export class N2WordsKO extends N2WordsBase {
-  constructor() {
-    super();
-
-    this.negativeWord = '마이너스';
-    this.separatorWord = '점';
-    this.zero = '영';
-    this.cards = [
-      { '10000000000000000000000000000': '양' },
-      { '1000000000000000000000000': '자' },
-      { '100000000000000000000': '해' },
-      { '10000000000000000': '경' },
-      { '1000000000000': '조' },
-      { '100000000': '억' },
-      { '10000': '만' },
-      { '1000': '천' },
-      { '100': '백' },
-      { '10': '십' },
-      { '9': '구' },
-      { '8': '팔' },
-      { '7': '칠' },
-      { '6': '육' },
-      { '5': '오' },
-      { '4': '사' },
-      { '3': '삼' },
-      { '2': '이' },
-      { '1': '일' },
-      { '0': '영' }
-    ];
+export class N2WordsKO extends BaseLanguage {
+  constructor(options) {
+    super(Object.assign({
+      negativeWord: '마이너스',
+      separatorWord: '점',
+      zero: '영'
+    }, options), [
+      [10000000000000000000000000000n, '양'],
+      [1000000000000000000000000n, '자'],
+      [100000000000000000000n, '해'],
+      [10000000000000000n, '경'],
+      [1000000000000n, '조'],
+      [100000000n, '억'],
+      [10000n, '만'],
+      [1000n, '천'],
+      [100n, '백'],
+      [10n, '십'],
+      [9n, '구'],
+      [8n, '팔'],
+      [7n, '칠'],
+      [6n, '육'],
+      [5n, '오'],
+      [4n, '사'],
+      [3n, '삼'],
+      [2n, '이'],
+      [1n, '일'],
+      [0n, '영']
+    ]);
   }
 
   merge(lPair, rPair) {
@@ -43,6 +42,13 @@ export class N2WordsKO extends N2WordsBase {
   }
 }
 
-export default function(n) {
-  return new N2WordsKO().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 N2WordsKO(options).floatToCardinal(value);
 }

package/lib/i18n/LT.mjs

@@ -1,70 +1,75 @@
 import {N2WordsRU} from './RU.mjs';
 
 export class N2WordsLT extends N2WordsRU {
-  constructor() {
-    super();
+  ones = {
+    1: 'vienas',
+    2: 'du',
+    3: 'trys',
+    4: 'keturi',
+    5: 'penki',
+    6: 'šeši',
+    7: 'septyni',
+    8: 'aštuoni',
+    9: 'devyni'
+  };
 
-    this.negativeWord = 'minus';
-    this.separatorWord = 'kablelis';
-    this.feminine = false;
-    this.zero = 'nulis';
-    this.ones = {
-      1: 'vienas',
-      2: 'du',
-      3: 'trys',
-      4: 'keturi',
-      5: 'penki',
-      6: 'šeši',
-      7: 'septyni',
-      8: 'aštuoni',
-      9: 'devyni'
-    };
-    this.onesFeminine = {
-      1: 'viena',
-      2: 'dvi',
-      3: 'trys',
-      4: 'keturios',
-      5: 'penkios',
-      6: 'šešios',
-      7: 'septynios',
-      8: 'aštuonios',
-      9: 'devynios'
-    };
-    this.tens = {
-      0: 'dešimt',
-      1: 'vienuolika',
-      2: 'dvylika',
-      3: 'trylika',
-      4: 'keturiolika',
-      5: 'penkiolika',
-      6: 'šešiolika',
-      7: 'septyniolika',
-      8: 'aštuoniolika',
-      9: 'devyniolika'
-    };
-    this.twenties = {
-      2: 'dvidešimt',
-      3: 'trisdešimt',
-      4: 'keturiasdešimt',
-      5: 'penkiasdešimt',
-      6: 'šešiasdešimt',
-      7: 'septyniasdešimt',
-      8: 'aštuoniasdešimt',
-      9: 'devyniasdešimt'
-    };
-    this.hundreds = ['šimtas', 'šimtai'];
-    this.thousands = {
-      1: ['tūkstantis', 'tūkstančiai', 'tūkstančių'],
-      2: ['milijonas', 'milijonai', 'milijonų'],
-      3: ['milijardas', 'milijardai', 'milijardų'],
-      4: ['trilijonas', 'trilijonai', 'trilijonų'],
-      5: ['kvadrilijonas', 'kvadrilijonai', 'kvadrilijonų'],
-      6: ['kvintilijonas', 'kvintilijonai', 'kvintilijonų'],
-      7: ['sikstilijonas', 'sikstilijonai', 'sikstilijonų'],
-      8: ['septilijonas', 'septilijonai', 'septilijonų'],
-      9: ['oktilijonas', 'oktilijonai', 'oktilijonų'],
-      10: ['naintilijonas', 'naintilijonai', 'naintilijonų'],
-    };
+  onesFeminine = {
+    1: 'viena',
+    2: 'dvi',
+    3: 'trys',
+    4: 'keturios',
+    5: 'penkios',
+    6: 'šešios',
+    7: 'septynios',
+    8: 'aštuonios',
+    9: 'devynios'
+  };
+
+  tens = {
+    0: 'dešimt',
+    1: 'vienuolika',
+    2: 'dvylika',
+    3: 'trylika',
+    4: 'keturiolika',
+    5: 'penkiolika',
+    6: 'šešiolika',
+    7: 'septyniolika',
+    8: 'aštuoniolika',
+    9: 'devyniolika'
+  };
+
+  twenties = {
+    2: 'dvidešimt',
+    3: 'trisdešimt',
+    4: 'keturiasdešimt',
+    5: 'penkiasdešimt',
+    6: 'šešiasdešimt',
+    7: 'septyniasdešimt',
+    8: 'aštuoniasdešimt',
+    9: 'devyniasdešimt'
+  };
+
+  hundreds = ['šimtas', 'šimtai'];
+
+  thousands = {
+    1: ['tūkstantis', 'tūkstančiai', 'tūkstančių'],
+    2: ['milijonas', 'milijonai', 'milijonų'],
+    3: ['milijardas', 'milijardai', 'milijardų'],
+    4: ['trilijonas', 'trilijonai', 'trilijonų'],
+    5: ['kvadrilijonas', 'kvadrilijonai', 'kvadrilijonų'],
+    6: ['kvintilijonas', 'kvintilijonai', 'kvintilijonų'],
+    7: ['sikstilijonas', 'sikstilijonai', 'sikstilijonų'],
+    8: ['septilijonas', 'septilijonai', 'septilijonų'],
+    9: ['oktilijonas', 'oktilijonai', 'oktilijonų'],
+    10: ['naintilijonas', 'naintilijonai', 'naintilijonų'],
+  };
+
+  constructor(options) {
+    super(Object.assign({
+      negativeWord: 'minus',
+      separatorWord: 'kablelis',
+      zero: 'nulis'
+    }, options));
   }
 
   pluralize(n, forms) {
@@ -79,11 +84,11 @@ export class N2WordsLT 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];
@@ -120,6 +125,13 @@ export class N2WordsLT extends N2WordsRU {
   }
 }
 
-export default function(n) {
-  return new N2WordsLT().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 N2WordsLT(options).floatToCardinal(value);
 }

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'
+  };
 
-    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'],
-    };
+  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'
+  };
+
+  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(options) {
+    super(Object.assign({
+      negativeWord: 'mīnus',
+      separatorWord: 'komats',
+      zero: 'nulle'
+    }, options));
   }
 
   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,13 @@ 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.
+ * @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 N2WordsLV(options).floatToCardinal(value);
 }

package/lib/i18n/NL.mjs

@@ -1,58 +1,61 @@
-import N2WordsBase from '../classes/N2WordsBase.mjs';
+import BaseLanguage from '../classes/BaseLanguage.mjs';
 
-export class N2WordsNL extends N2WordsBase {
-  constructor(options) {
-    super();
-
-    this.negativeWord = 'min';
-    this.separatorWord = 'komma';
-    this.zero = 'nul';
+export class N2WordsNL extends BaseLanguage {
+  includeOptionalAnd;
+  noHundredPairs;
 
-    this.options = Object.assign({
+  constructor(options) {
+    options = Object.assign({
+      negativeWord: 'min',
+      separatorWord: 'komma',
+      zero: 'nul',
       includeOptionalAnd: false,
-      noHundredPairs: false,
+      noHundredPairs: false
     }, options);
 
-    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'},
-    ];
+    super(options, [
+      [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.includeOptionalAnd = options.includeOptionalAnd;
+    this.noHundredPairs = options.noHundredPairs;
   }
 
   merge(curr, next) {
@@ -81,14 +84,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 +101,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);
 }