n2words 1.12.2 → 1.14.0

package/lib/i18n/HU.mjs

@@ -1,70 +1,69 @@
-import N2WordsBase from '../classes/N2WordsBase.mjs';
+import BaseLanguage from '../classes/BaseLanguage.mjs';
 
-export class N2WordsHU extends N2WordsBase {
+export class N2WordsHU extends BaseLanguage {
   constructor() {
-    super();
-
-    this.negativeWord = 'mínusz';
-    this.separatorWord = 'egész';
-    this.cards = [
-      { '1000000000000000000000000000': 'quadrilliárd' },
-      { '1000000000000000000000000': 'quadrillió' },
-      { '1000000000000000000000': 'trilliárd' },
-      { '1000000000000000000': 'trillió' },
-      { '1000000000000000': 'billiárd' },
-      { '1000000000000': 'billió' },
-      { '1000000000': 'milliárd' },
-      { '1000000': 'millió' },
-      { '1000': 'ezer' },
-      { '100': 'száz' },
-      { '90': 'kilencven' },
-      { '80': 'nyolcvan' },
-      { '70': 'hetven' },
-      { '60': 'hatvan' },
-      { '50': 'ötven' },
-      { '40': 'negyven' },
-      { '30': 'harminc' },
-      { '29': 'huszonkilenc' },
-      { '28': 'huszonnyolc' },
-      { '27': 'huszonhét' },
-      { '26': 'huszonhat' },
-      { '25': 'huszonöt' },
-      { '24': 'huszonnégy' },
-      { '23': 'huszonhárom' },
-      { '22': 'huszonkettő' },
-      { '21': 'huszonegy' },
-      { '20': 'húsz' },
-      { '19': 'tizenkilenc' },
-      { '18': 'tizennyolc' },
-      { '17': 'tizenhét' },
-      { '16': 'tizenhat' },
-      { '15': 'tizenöt' },
-      { '14': 'tizennégy' },
-      { '13': 'tizenhárom' },
-      { '12': 'tizenkettő' },
-      { '11': 'tizenegy' },
-      { '10': 'tíz' },
-      { '9': 'kilenc' },
-      { '8': 'nyolc' },
-      { '7': 'hét' },
-      { '6': 'hat' },
-      { '5': 'öt' },
-      { '4': 'négy' },
-      { '3': 'három' },
-      { '2': 'kettő' },
-      { '1': 'egy' },
-      { '0': 'nulla' }
-    ];
-    this.zero = 'nulla';
+    super({
+      negativeWord: 'mínusz',
+      separatorWord: 'egész',
+      zero: 'nulla'
+    },[
+      [1000000000000000000000000000n, 'quadrilliárd'],
+      [1000000000000000000000000n, 'quadrillió'],
+      [1000000000000000000000n, 'trilliárd'],
+      [1000000000000000000n, 'trillió'],
+      [1000000000000000n, 'billiárd'],
+      [1000000000000n, 'billió'],
+      [1000000000n, 'milliárd'],
+      [1000000n, 'millió'],
+      [1000n, 'ezer'],
+      [100n, 'száz'],
+      [90n, 'kilencven'],
+      [80n, 'nyolcvan'],
+      [70n, 'hetven'],
+      [60n, 'hatvan'],
+      [50n, 'ötven'],
+      [40n, 'negyven'],
+      [30n, 'harminc'],
+      [29n, 'huszonkilenc'],
+      [28n, 'huszonnyolc'],
+      [27n, 'huszonhét'],
+      [26n, 'huszonhat'],
+      [25n, 'huszonöt'],
+      [24n, 'huszonnégy'],
+      [23n, 'huszonhárom'],
+      [22n, 'huszonkettő'],
+      [21n, 'huszonegy'],
+      [20n, 'húsz'],
+      [19n, 'tizenkilenc'],
+      [18n, 'tizennyolc'],
+      [17n, 'tizenhét'],
+      [16n, 'tizenhat'],
+      [15n, 'tizenöt'],
+      [14n, 'tizennégy'],
+      [13n, 'tizenhárom'],
+      [12n, 'tizenkettő'],
+      [11n, 'tizenegy'],
+      [10n, 'tíz'],
+      [9n, 'kilenc'],
+      [8n, 'nyolc'],
+      [7n, 'hét'],
+      [6n, 'hat'],
+      [5n, 'öt'],
+      [4n, 'négy'],
+      [3n, 'három'],
+      [2n, 'kettő'],
+      [1n, 'egy'],
+      [0n, 'nulla']
+    ]);
   }
 
   tensToCardinal(number) {
-    if (this.getValueFromCards(number)) {
-      return this.getValueFromCards(number);
+    if (this.getCardWord(number)) {
+      return this.getCardWord(number);
     } else {
       const tens = Math.floor(number / 10);
       const units = number % 10;
-      return this.getValueFromCards(tens * 10) + this.toCardinal(units);
+      return this.getCardWord(tens * 10) + this.toCardinal(units);
     }
   }
 
@@ -85,35 +84,35 @@ export class N2WordsHU extends N2WordsBase {
       prefix = this.toCardinal(thousands, '') + prefix;
     }
     let postfix = this.toCardinal(number % 1000, '');
-    let middle = (number <= 2000 || postfix === '') ? '' : '-';
+    let middle = (number <= 2000 || postfix == '') ? '' : '-';
     return prefix + middle + postfix;
   }
 
   bigNumberToCardinal(number) {
-    const numberLength = String(number).length;
+    const numberLength = number.toString().length;
     let digits = (numberLength % 3 !== 0) ? numberLength : numberLength - 2;
     let exp = 10 ** (Math.floor(digits / 3) * 3);
-    let prefix = this.toCardinal(Math.floor(number / exp), '');
-    let rest = this.toCardinal(number % exp, '');
+    let prefix = this.toCardinal(number / BigInt(exp), '');
+    let rest = this.toCardinal(number % BigInt(exp), '');
     let postfix = (rest !== '') ? ('-' + rest) : '';
-    return prefix + this.getValueFromCards(exp) + postfix;
+    return prefix + this.getCardWord(exp) + postfix;
   }
 
   toCardinal(number, zero = this.zero) {
     let words = '';
 
-    if (number == 0) {
+    if (number == 0n) {
       words = zero;
     } else if (zero == '' && number == 2) {
       words = 'két';
-    } else if (number < 30) {
-      words = this.getValueFromCards(number);
-    } else if (number < 100) {
-      words = this.tensToCardinal(number);
-    } else if (number < 1000) {
-      words = this.hundredsToCardinal(number);
-    } else if (number < 1000000) {
-      words = this.thousandsToCardinal(number);
+    } else if (number < 30n) {
+      words = this.getCardWord(Number(number));
+    } else if (number < 100n) {
+      words = this.tensToCardinal(Number(number));
+    } else if (number < 1000n) {
+      words = this.hundredsToCardinal(Number(number));
+    } else if (number < 1000000n) {
+      words = this.thousandsToCardinal(Number(number));
     } else {
       words = this.bigNumberToCardinal(number);
     }
@@ -122,6 +121,12 @@ export class N2WordsHU extends N2WordsBase {
   }
 }
 
-export default function(n) {
-  return new N2WordsHU().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 N2WordsHU().floatToCardinal(value);
 }

package/lib/i18n/ID.mjs

@@ -1,12 +1,13 @@
-import N2WordsAbs from '../classes/N2WordsAbs.mjs';
+import AbstractLanguage from '../classes/AbstractLanguage.mjs';
 
-export class N2WordsID extends N2WordsAbs {
+export class N2WordsID extends AbstractLanguage {
   constructor() {
-    super();
+    super({
+      negativeWord: 'min',
+      separatorWord: 'koma',
+      zero: 'nol'
+    });
 
-    this.negativeWord = 'min';
-    this.separatorWord = 'koma';
-    this.zero = 'nol';
     this.base = {
       0: [],
       1: ['satu'],
@@ -37,7 +38,7 @@ export class N2WordsID extends N2WordsAbs {
   splitBy3(number) {
     // Split to groups of 3 numbers: 1234567 -> [['1'], ['234'], ['567']]
     let blocks = [];
-    let strNumber = String(number);
+    let strNumber = number.toString();
     let length = strNumber.length;
     let firstBlock;
 
@@ -66,13 +67,13 @@ export class N2WordsID extends N2WordsAbs {
     let wordBlocks = [];
     let spelling;
     let firstBlock = blocks[0];
-    if (firstBlock[0].length === 1) {
-      if (firstBlock[0] === '0') {
+    if (firstBlock[0].length == 1) {
+      if (firstBlock[0] == '0') {
         spelling = ['nol'];
       } else {
         spelling = this.base[parseInt(firstBlock[0])];
       }
-    } else if (firstBlock[0].length === 2) {
+    } else if (firstBlock[0].length == 2) {
       spelling = this.getTens(firstBlock[0]);
     } else {
       spelling = this.getHundreds(
@@ -92,9 +93,9 @@ export class N2WordsID extends N2WordsAbs {
   }
 
   getHundreds(number) { // 'ratus'
-    if (number === '1') {
+    if (number == '1') {
       return ['seratus'];
-    } else if (number === '0') {
+    } else if (number == '0') {
       return [];
     } else {
       return this.base[parseInt(number)].concat(['ratus']);
@@ -102,15 +103,15 @@ export class N2WordsID extends N2WordsAbs {
   }
 
   getTens(number) { // 'puluh'
-    if (number[0] === '1') {
-      if (number[1] === '0') {
+    if (number[0] == '1') {
+      if (number[1] == '0') {
         return ['sepuluh'];
-      } else if (number[1] === '1') {
+      } else if (number[1] == '1') {
         return ['sebelas'];
       } else {
         return this.base[parseInt(number[1])].concat(['belas']);
       }
-    } else if (number[0] === '0') {
+    } else if (number[0] == '0') {
       return this.base[parseInt(number[1])];
     } else {
       return this.base[parseInt(number[0])].concat(['puluh']).concat(
@@ -124,7 +125,7 @@ export class N2WordsID extends N2WordsAbs {
     let length = wordBlocks.length - 1;
     let firstBlock = [wordBlocks[0]];
     let start = 0;
-    if (length === 1 && firstBlock[0][0] === '1') {
+    if (length == 1 && firstBlock[0][0] == '1') {
       wordList.push('seribu');
       start = 1;
     }
@@ -133,7 +134,7 @@ export class N2WordsID extends N2WordsAbs {
       if (!wordBlocks[i][1].length) {
         continue;
       }
-      if (i === length) {
+      if (i == length) {
         break;
       }
       wordList = wordList.concat([this.thousands[(length - i) * 3]]);
@@ -150,6 +151,12 @@ export class N2WordsID extends N2WordsAbs {
   }
 }
 
-export default function (n) {
-  return new N2WordsID().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 N2WordsID().floatToCardinal(value);
 }

package/lib/i18n/IT.mjs

@@ -1,12 +1,15 @@
-import N2WordsBase from '../classes/N2WordsBase.mjs';
+import BaseLanguage from '../classes/BaseLanguage.mjs';
 
-export class N2WordsIT extends N2WordsBase {
+export class N2WordsIT extends BaseLanguage {
   constructor() {
-    super();
+    super({
+      negativeWord: 'meno',
+      separatorWord: 'virgola',
+      zero: 'zero'
+    },[]);
+
+    /** @todo Adapt language to work with {@link BaseLanguage} better */
 
-    this.negativeWord = 'meno';
-    this.separatorWord = 'virgola';
-    this.zero = 'zero';
     this.cardinalWords = [
       this.zero, 'uno', 'due', 'tre', 'quattro', 'cinque', 'sei', 'sette', 'otto',
       'nove', 'dieci', 'undici', 'dodici', 'tredici', 'quattordici', 'quindici',
@@ -83,7 +86,7 @@ export class N2WordsIT extends N2WordsBase {
   }
 
   bigNumberToCardinal(number) {
-    const digits = Array.from(String(number));
+    const digits = Array.from(number.toString());
     const predigits = (digits.length % 3 == 0) ? 3 : digits.length % 3;
     const multiplier = digits.slice(0, predigits); // first `predigits` elements
     const exponent = digits.slice(predigits); // without the first `predigits` elements
@@ -95,7 +98,7 @@ export class N2WordsIT extends N2WordsBase {
       prefix = this.toCardinal(parseInt(multiplier.join('')));
       infix = ' ' + infix.slice(0, -1) + 'i'; // without last element
     }
-    const isSetsEqual = (a, b) => a.size === b.size && [...a].every(value => b.has(value));
+    const isSetsEqual = (a, b) => a.size == b.size && [...a].every(value => b.has(value));
     if (!isSetsEqual(new Set(exponent), new Set(['0']))) {
       postfix = this.toCardinal(parseInt(exponent.join('')));
       if (postfix.includes(' e ')) {
@@ -112,14 +115,14 @@ export class N2WordsIT extends N2WordsBase {
   toCardinal(number) {
     let words = '';
 
-    if (number < 20) {
+    if (number < 20n) {
       words = this.cardinalWords[number];
-    } else if (number < 100) {
-      words = this.tensToCardinal(number);
-    } else if (number < 1000) {
-      words = this.hundredsToCardinal(number);
-    } else if (number < 1000000) {
-      words = this.thousandsToCardinal(number);
+    } else if (number < 100n) {
+      words = this.tensToCardinal(Number(number));
+    } else if (number < 1000n) {
+      words = this.hundredsToCardinal(Number(number));
+    } else if (number < 1000000n) {
+      words = this.thousandsToCardinal(Number(number));
     } else {
       words = this.bigNumberToCardinal(number);
     }
@@ -128,6 +131,12 @@ export class N2WordsIT extends N2WordsBase {
   }
 }
 
-export default function(n) {
-  return new N2WordsIT().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 N2WordsIT().floatToCardinal(value);
 }

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

package/lib/i18n/LT.mjs

@@ -1,70 +1,77 @@
 import {N2WordsRU} from './RU.mjs';
 
 export class N2WordsLT extends N2WordsRU {
-  constructor() {
-    super();
+  feminine = false;
+
+  ones = {
+    1: 'vienas',
+    2: 'du',
+    3: 'trys',
+    4: 'keturi',
+    5: 'penki',
+    6: 'šeši',
+    7: 'septyni',
+    8: 'aštuoni',
+    9: 'devyni'
+  };
+
+  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'
+  };
 
-    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ų'],
-    };
+  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() {
+    super({
+      negativeWord: 'minus',
+      separatorWord: 'kablelis',
+      zero: 'nulis'
+    });
   }
 
   pluralize(n, forms) {
@@ -79,11 +86,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 +127,12 @@ 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.
+ * @throws {Error} Value cannot be invalid.
+ * @returns {string} Value in cardinal (written) format.
+ */
+export default function(value) {
+  return new N2WordsLT().floatToCardinal(value);
 }