n2words 1.9.0 → 1.11.0

package/lib/i18n/HU.mjs

@@ -1,62 +1,64 @@
 import N2WordsBase from '../classes/N2WordsBase.mjs';
 
-export default function () {
-  N2WordsBase.call(this);
+export class N2WordsHU extends N2WordsBase {
+  constructor() {
+    super();
 
-  this.negative_word = 'mínusz';
-  this.separator_word = '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';
+    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';
+  }
 
-  this.tensToCardinal = (number) => {
+  tensToCardinal(number) {
     if (this.getValueFromCards(number)) {
       return this.getValueFromCards(number);
     } else {
@@ -64,9 +66,9 @@ export default function () {
       const units = number % 10;
       return this.getValueFromCards(tens * 10) + this.toCardinal(units);
     }
-  };
+  }
 
-  this.hundredsToCardinal = (number) => {
+  hundredsToCardinal(number) {
     const hundreds = Math.floor(number / 100);
     let prefix = 'száz';
     if (hundreds != 1) {
@@ -74,9 +76,9 @@ export default function () {
     }
     const postfix = this.toCardinal(number % 100, '');
     return prefix + postfix;
-  };
+  }
 
-  this.thousandsToCardinal = (number) => {
+  thousandsToCardinal(number) {
     const thousands = Math.floor(number / 1000);
     let prefix = 'ezer';
     if (thousands != 1) {
@@ -85,9 +87,9 @@ export default function () {
     let postfix = this.toCardinal(number % 1000, '');
     let middle = (number <= 2000 || postfix === '') ? '' : '-';
     return prefix + middle + postfix;
-  };
+  }
 
-  this.bigNumberToCardinal = (number) => {
+  bigNumberToCardinal(number) {
     const numberLength = String(number).length;
     let digits = (numberLength % 3 !== 0) ? numberLength : numberLength - 2;
     let exp = 10 ** (Math.floor(digits / 3) * 3);
@@ -95,9 +97,9 @@ export default function () {
     let rest = this.toCardinal(number % exp, '');
     let postfix = (rest !== '') ? ('-' + rest) : '';
     return prefix + this.getValueFromCards(exp) + postfix;
-  };
+  }
 
-  this.toCardinal = (number, zero = this.ZERO) => {
+  toCardinal(number, zero = this.zero) {
     let words = '';
 
     if (number == 0) {
@@ -117,5 +119,9 @@ export default function () {
     }
 
     return words;
-  };
+  }
+}
+
+export default function(n) {
+  return new N2WordsHU().floatToCardinal(n);
 }

package/lib/i18n/ID.mjs

@@ -0,0 +1,155 @@
+import N2WordsAbs from '../classes/N2WordsAbs.mjs';
+
+export class N2WordsID extends N2WordsAbs {
+  constructor() {
+    super();
+
+    this.negativeWord = 'min';
+    this.separatorWord = 'koma';
+    this.zero = 'nol';
+    this.base = {
+      0: [],
+      1: ['satu'],
+      2: ['dua'],
+      3: ['tiga'],
+      4: ['empat'],
+      5: ['lima'],
+      6: ['enam'],
+      7: ['tujuh'],
+      8: ['delapan'],
+      9: ['sembilan'],
+    };
+    this.thousands = {
+      3: 'ribu', // 10^3
+      6: 'juta', // 10^6
+      9: 'miliar', // 10^9
+      12: 'triliun',
+      15: 'kuadriliun',
+      18: 'kuantiliun',
+      21: 'sekstiliun',
+      24: 'septiliun',
+      27: 'oktiliun',
+      30: 'noniliun',
+      33: 'desiliun',
+    };
+  }
+
+  splitBy3(number) {
+    // Split to groups of 3 numbers: 1234567 -> [['1'], ['234'], ['567']]
+    let blocks = [];
+    let strNumber = String(number);
+    let length = strNumber.length;
+    let firstBlock;
+
+    if (length < 3) {
+      blocks.push([strNumber]);
+    } else {
+      let firstBlockLength = length % 3;
+
+      if (firstBlockLength > 0) {
+        firstBlock = [strNumber.slice(0, firstBlockLength)];
+        blocks.push(firstBlock);
+      }
+
+      for (let i = firstBlockLength; i < length; i += 3) {
+        let nextBlock = [strNumber.slice(i, i + 3)];
+        blocks.push(nextBlock);
+      }
+    }
+    return blocks;
+  }
+
+  spell(blocks) {
+    // Example:
+    // blocks: [['1'], ['234']]
+    // return: [['1', ['satu']], ['234', ['dua', 'ratus', 'tiga', 'puluh', ['empat']]]]
+    let wordBlocks = [];
+    let spelling;
+    let firstBlock = blocks[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) {
+      spelling = this.getTens(firstBlock[0]);
+    } else {
+      spelling = this.getHundreds(
+        firstBlock[0][0]
+      ).concat(this.getTens(firstBlock[0].slice(1, 3)));
+    }
+    wordBlocks = wordBlocks.concat([[firstBlock[0], spelling]]);
+    for (let i = 1; i < blocks.length; i++) {
+      let block = blocks[i];
+      spelling = this.getHundreds(block[0][0]).concat(
+        this.getTens(block[0].slice(1, 3))
+      );
+      block = block.concat([spelling]);
+      wordBlocks = wordBlocks.concat([block]);
+    }
+    return wordBlocks;
+  }
+
+  getHundreds(number) { // 'ratus'
+    if (number === '1') {
+      return ['seratus'];
+    } else if (number === '0') {
+      return [];
+    } else {
+      return this.base[parseInt(number)].concat(['ratus']);
+    }
+  }
+
+  getTens(number) { // 'puluh'
+    if (number[0] === '1') {
+      if (number[1] === '0') {
+        return ['sepuluh'];
+      } else if (number[1] === '1') {
+        return ['sebelas'];
+      } else {
+        return this.base[parseInt(number[1])].concat(['belas']);
+      }
+    } else if (number[0] === '0') {
+      return this.base[parseInt(number[1])];
+    } else {
+      return this.base[parseInt(number[0])].concat(['puluh']).concat(
+        [this.base[parseInt(number[1])]]
+      );
+    }
+  }
+
+  join(wordBlocks) {
+    let wordList = [];
+    let length = wordBlocks.length - 1;
+    let firstBlock = [wordBlocks[0]];
+    let start = 0;
+    if (length === 1 && firstBlock[0][0] === '1') {
+      wordList.push('seribu');
+      start = 1;
+    }
+    for (let i = start; i < length + 1; i++) {
+      wordList = wordList.concat(wordBlocks[i][1]);
+      if (!wordBlocks[i][1].length) {
+        continue;
+      }
+      if (i === length) {
+        break;
+      }
+      wordList = wordList.concat([this.thousands[(length - i) * 3]]);
+    }
+    return wordList.join(' ');
+  }
+
+  toCardinal(number) {
+    return this.join(
+      this.spell(
+        this.splitBy3(number)
+      )
+    ).trim();
+  }
+}
+
+export default function (n) {
+  return new N2WordsID().floatToCardinal(n);
+}

package/lib/i18n/IT.mjs

@@ -1,65 +1,67 @@
 import N2WordsBase from '../classes/N2WordsBase.mjs';
 
-export default function() {
-  N2WordsBase.call(this);
+export class N2WordsIT extends N2WordsBase {
+  constructor() {
+    super();
 
-  this.negative_word = 'meno';
-  this.separator_word = 'virgola';
-  this.ZERO = 'zero';
-  const CARDINAL_WORDS = [
-    this.ZERO, 'uno', 'due', 'tre', 'quattro', 'cinque', 'sei', 'sette', 'otto',
-    'nove', 'dieci', 'undici', 'dodici', 'tredici', 'quattordici', 'quindici',
-    'sedici', 'diciassette', 'diciotto', 'diciannove',
-  ];
-  const STR_TENS = {'2': 'venti', '3': 'trenta', '4': 'quaranta', '6': 'sessanta'};
-  const EXPONENT_PREFIXES = [this.ZERO, 'm', 'b', 'tr', 'quadr', 'quint', 'sest', 'sett', 'ott', 'nov', 'dec'];
+    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',
+      'sedici', 'diciassette', 'diciotto', 'diciannove',
+    ];
+    this.strTens = {'2': 'venti', '3': 'trenta', '4': 'quaranta', '6': 'sessanta'};
+    this.exponentPrefixes = [this.zero, 'm', 'b', 'tr', 'quadr', 'quint', 'sest', 'sett', 'ott', 'nov', 'dec'];
+  }
 
-  this.accentuate = (string) => {
+  accentuate(string) {
     const splittedString = string.split(' ');
 
-    const result = splittedString.map((word) => {
+    const result = splittedString.map(word => {
       if (word.slice(-3) == 'tre' && word.length > 3) return word.replace(/tré/g, 'tre').slice(0, -3) + 'tré';
       else return word.replace(/tré/g, 'tre');
     });
     return result.join(' ');
-  };
+  }
 
-  this.omitIfZero = (numberToString) => {
-    if (numberToString == this.ZERO) {
+  omitIfZero(numberToString) {
+    if (numberToString == this.zero) {
       return '';
     } else {
       return numberToString;
     }
-  };
+  }
 
-  this.phoneticContraction = (string) => {
+  phoneticContraction(string) {
     return string.replace(/oo/g, 'o').replace(/ao/g, 'o').replace(/io/g, 'o').replace(/au/g, 'u').replace(/iu/g, 'u');
-  };
+  }
 
-  this.tensToCardinal = (number) => {
+  tensToCardinal(number) {
     const tens = Math.floor(number / 10);
     const units = number % 10;
     let prefix;
-    if (Object.prototype.hasOwnProperty.call(STR_TENS, tens)) {
-      prefix = STR_TENS[tens];
+    if (Object.prototype.hasOwnProperty.call(this.strTens, tens)) {
+      prefix = this.strTens[tens];
     } else {
-      prefix = CARDINAL_WORDS[tens].slice(0, -1) + 'anta';
+      prefix = this.cardinalWords[tens].slice(0, -1) + 'anta';
     }
-    const postfix = this.omitIfZero(CARDINAL_WORDS[units]);
+    const postfix = this.omitIfZero(this.cardinalWords[units]);
     return this.phoneticContraction(prefix + postfix);
-  };
+  }
 
-  this.hundredsToCardinal = (number) => {
+  hundredsToCardinal(number) {
     const hundreds = Math.floor(number / 100);
     let prefix = 'cento';
     if (hundreds != 1) {
-      prefix = CARDINAL_WORDS[hundreds] + prefix;
+      prefix = this.cardinalWords[hundreds] + prefix;
     }
     const postfix = this.omitIfZero(this.toCardinal(number % 100));
     return this.phoneticContraction(prefix + postfix);
-  };
+  }
 
-  this.thousandsToCardinal = (number) => {
+  thousandsToCardinal(number) {
     const thousands = Math.floor(number / 1000);
     let prefix;
     if (thousands == 1) {
@@ -69,18 +71,18 @@ export default function() {
     }
     const postfix = this.omitIfZero(this.toCardinal(number % 1000));
     return prefix + postfix;
-  };
+  }
 
-  this.exponentLengthToString = (exponentLength) => {
-    const prefix = EXPONENT_PREFIXES[Math.floor(exponentLength / 6)];
+  exponentLengthToString(exponentLength) {
+    const prefix = this.exponentPrefixes[Math.floor(exponentLength / 6)];
     if (exponentLength % 6 == 0) {
       return prefix + 'ilione';
     } else {
       return prefix + 'iliardo';
     }
-  };
+  }
 
-  this.bigNumberToCardinal = (number) => {
+  bigNumberToCardinal(number) {
     const digits = Array.from(String(number));
     const predigits = (digits.length % 3 == 0) ? 3 : digits.length % 3;
     const multiplier = digits.slice(0, predigits); // first `predigits` elements
@@ -93,7 +95,7 @@ export default function() {
       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 ')) {
@@ -105,13 +107,13 @@ export default function() {
       postfix = '';
     }
     return prefix + infix + postfix;
-  };
+  }
 
-  this.toCardinal = (number) => {
+  toCardinal(number) {
     let words = '';
 
     if (number < 20) {
-      words = CARDINAL_WORDS[number];
+      words = this.cardinalWords[number];
     } else if (number < 100) {
       words = this.tensToCardinal(number);
     } else if (number < 1000) {
@@ -123,5 +125,9 @@ export default function() {
     }
 
     return this.accentuate(words);
-  };
+  }
+}
+
+export default function(n) {
+  return new N2WordsIT().floatToCardinal(n);
 }

package/lib/i18n/KO.mjs

@@ -1,39 +1,48 @@
 import N2WordsBase from '../classes/N2WordsBase.mjs';
 
-export default function () {
-  N2WordsBase.call(this);
+export class N2WordsKO extends N2WordsBase {
+  constructor() {
+    super();
 
-  this.negative_word = '마이너스';
-  this.separator_word = '점';
-  this.ZERO = '영';
-  this.cards = [
-    { '10000000000000000000000000000': '양' },
-    { '1000000000000000000000000': '자' },
-    { '100000000000000000000': '해' },
-    { '10000000000000000': '경' },
-    { '1000000000000': '조' },
-    { '100000000': '억' },
-    { '10000': '만' },
-    { '1000': '천' },
-    { '100': '백' },
-    { '10': '십' },
-    { '9': '구' },
-    { '8': '팔' },
-    { '7': '칠' },
-    { '6': '육' },
-    { '5': '오' },
-    { '4': '사' },
-    { '3': '삼' },
-    { '2': '이' },
-    { '1': '일' },
-    { '0': '영' }
-  ];
-  this.merge = (lpair, rpair) => {
-    const ltext = Object.keys(lpair)[0]; const lnum = parseInt(Object.values(lpair)[0]);
-    const rtext = Object.keys(rpair)[0]; const rnum = parseInt(Object.values(rpair)[0]);
-    if (lnum == 1 && rnum <= 10000) return { [rtext]: rnum };
-    else if (10000 > lnum && lnum > rnum) return { [`${ltext}${rtext}`]: lnum + rnum };
-    else if (lnum >= 10000 && lnum > rnum) return { [`${ltext} ${rtext}`]: lnum + rnum };
-    else return { [`${ltext}${rtext}`]: lnum * rnum };
-  };
+    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': '영' }
+    ];
+  }
+
+  merge(lPair, rPair) {
+    const lText = Object.keys(lPair)[0];
+    const rText = Object.keys(rPair)[0];
+    const lNum = parseInt(Object.values(lPair)[0]);
+    const rNum = parseInt(Object.values(rPair)[0]);
+    if (lNum == 1 && rNum <= 10000) return { [rText]: rNum };
+    else if (10000 > lNum && lNum > rNum) return { [`${lText}${rText}`]: lNum + rNum };
+    else if (lNum >= 10000 && lNum > rNum) return { [`${lText} ${rText}`]: lNum + rNum };
+    else return { [`${lText}${rText}`]: lNum * rNum };
+  }
+}
+
+export default function(n) {
+  return new N2WordsKO().floatToCardinal(n);
 }