n2words 1.9.0 → 1.11.0

package/lib/i18n/LT.mjs

@@ -1,87 +1,89 @@
-import Num2Word_RU from './RU.mjs';
+import {N2WordsRU} from './RU.mjs';
 
-export default function () {
-  Num2Word_RU.call(this);
+export class N2WordsLT extends N2WordsRU {
+  constructor() {
+    super();
 
-  this.negative_word = 'minus';
-  this.separator_word = '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.ONES_FEMININE = {
-    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ų'],
-  };
+    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ų'],
+    };
+  }
 
-  this.pluralize = (n, forms) => {
+  pluralize(n, forms) {
     let form = 1;
-    const [n1, n2] = this.get_digits(n);
+    const [n1, n2] = this.getDigits(n);
     if (n2 == 1 || n1 == 0 || n == 0) {
       form = 2;
     } else if (n1 == 1) {
       form = 0;
     }
     return forms[form];
-  };
+  }
 
-  this.toCardinal = (number) => {
+  toCardinal(number) {
     if (parseInt(number) == 0) {
-      return this.ZERO;
+      return this.zero;
     }
     const words = [];
-    const chunks = this.splitbyx(JSON.stringify(number), 3);
+    const chunks = this.splitByX(JSON.stringify(number), 3);
     let i = chunks.length;
     for (let j = 0; j < chunks.length; j++) {
       const x = chunks[j];
@@ -89,31 +91,35 @@ export default function () {
       if (x == 0) {
         continue;
       }
-      const [n1, n2, n3] = this.get_digits(x);
+      const [n1, n2, n3] = this.getDigits(x);
       if (n3 > 0) {
-        words.push(this.ONES[n3]);
+        words.push(this.ones[n3]);
         if (n3 > 1) {
-          words.push(this.HUNDREDS[1]);
+          words.push(this.hundreds[1]);
         } else {
-          words.push(this.HUNDREDS[0]);
+          words.push(this.hundreds[0]);
         }
       }
       if (n2 > 1) {
-        words.push(this.TWENTIES[n2]);
+        words.push(this.twenties[n2]);
       }
       if (n2 == 1) {
-        words.push(this.TENS[n1]);
+        words.push(this.tens[n1]);
       } else if (n1 > 0) {
         if ((i == 1 || this.feminine && i == 0) && number < 1000) {
-          words.push(this.ONES_FEMININE[n1]);
+          words.push(this.onesFeminine[n1]);
         } else {
-          words.push(this.ONES[n1]);
+          words.push(this.ones[n1]);
         }
       }
       if (i > 0) {
-        words.push(this.pluralize(x, this.THOUSANDS[i]));
+        words.push(this.pluralize(x, this.thousands[i]));
       }
     }
     return words.join(' ');
-  };
+  }
+}
+
+export default function(n) {
+  return new N2WordsLT().floatToCardinal(n);
 }

package/lib/i18n/LV.mjs

@@ -1,58 +1,61 @@
-import Num2Word_RU from './RU.mjs';
+import {N2WordsRU} from './RU.mjs';
 
-export default function () {
-  Num2Word_RU.call(this);
+export class N2WordsLV extends N2WordsRU{
+  constructor() {
+    super();
 
-  this.negative_word = 'mīnus';
-  this.separator_word = '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'],
-  };
-  this.pluralize = (n, forms) => {
+    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'],
+    };
+  }
+
+  pluralize(n, forms) {
     let form = 2;
     if (n != 0) {
       if (n % 10 == 1 && n % 100 != 11) {
@@ -62,14 +65,14 @@ export default function () {
       }
     }
     return forms[form];
-  };
+  }
 
-  this.toCardinal = (number) => {
+  toCardinal(number) {
     if (parseInt(number) == 0) {
-      return this.ZERO;
+      return this.zero;
     }
     const words = [];
-    const chunks = this.splitbyx(JSON.stringify(number), 3);
+    const chunks = this.splitByX(JSON.stringify(number), 3);
     let i = chunks.length;
     for (let j = 0; j < chunks.length; j++) {
       const x = chunks[j];
@@ -77,29 +80,33 @@ export default function () {
       if (x == 0) {
         continue;
       }
-      const [n1, n2, n3] = this.get_digits(x);
+      const [n1, n2, n3] = this.getDigits(x);
       if (n3 > 0) {
         if (n3 == 1 && n2 == 0 && n1 > 0) {
-          words.push(this.HUNDREDS[2]);
+          words.push(this.hundreds[2]);
         } else if (n3 > 1) {
-          words.push(this.ONES[n3]);
-          words.push(this.HUNDREDS[1]);
+          words.push(this.ones[n3]);
+          words.push(this.hundreds[1]);
         } else {
-          words.push(this.HUNDREDS[0]);
+          words.push(this.hundreds[0]);
         }
       }
       if (n2 > 1) {
-        words.push(this.TWENTIES[n2]);
+        words.push(this.twenties[n2]);
       }
       if (n2 == 1) {
-        words.push(this.TENS[n1]);
+        words.push(this.tens[n1]);
       } else if (n1 > 0 && !(i > 0 && x == 1)) {
-        words.push(this.ONES[n1]);
+        words.push(this.ones[n1]);
       }
       if (i > 0) {
-        words.push(this.pluralize(x, this.THOUSANDS[i]));
+        words.push(this.pluralize(x, this.thousands[i]));
       }
     }
     return words.join(' ');
-  };
+  }
+}
+
+export default function(n) {
+  return new N2WordsLV().floatToCardinal(n);
 }

package/lib/i18n/NL.mjs

@@ -1,110 +1,115 @@
 import N2WordsBase from '../classes/N2WordsBase.mjs';
 
-export default function(options) {
-  N2WordsBase.call(this);
+export class N2WordsNL extends N2WordsBase {
+  constructor(options) {
+    super();
 
-  this.negative_word = 'min';
-  this.separator_word = 'komma';
-  this.ZERO = 'nul';
+    this.negativeWord = 'min';
+    this.separatorWord = 'komma';
+    this.zero = 'nul';
 
-  const defaultOptions = {
-    includeOptionalAnd: false,
-    noHundredPairs: false,
-  };
+    this.options = Object.assign({
+      includeOptionalAnd: false,
+      noHundredPairs: false,
+    }, options);
 
-  const localOptions = Object.assign({}, defaultOptions, 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'},
+    ];
+  }
 
-  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: 'achtien'},
-    {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'},
-  ];
-
-  this.merge = (curr, next) => {
-    let ctext = Object.keys(curr)[0]; const cnum = parseInt(Object.values(curr)[0]);
-    let ntext = Object.keys(next)[0]; const nnum = parseInt(Object.values(next)[0]);
-    if (cnum == 1) {
-      if (nnum < 1000000) {
-        return {[ntext]: nnum};
+  merge(curr, next) {
+    let cText = Object.keys(curr)[0];
+    let nText = Object.keys(next)[0];
+    const cNum = parseInt(Object.values(curr)[0]);
+    const nNum = parseInt(Object.values(next)[0]);
+    if (cNum == 1) {
+      if (nNum < 1000000) {
+        return {[nText]: nNum};
       }
-      ctext = 'een';
+      cText = 'een';
     }
 
     let val = 0;
-    if (nnum > cnum) {
-      if (nnum >= 1000000) {
-        ctext += ' ';
-      } else if (nnum > 100) {
-        ntext += ' ';
+    if (nNum > cNum) {
+      if (nNum >= 1000000) {
+        cText += ' ';
+      } else if (nNum > 100) {
+        nText += ' ';
       }
-      val = cnum * nnum;
+      val = cNum * nNum;
     } else {
-      if (nnum < 10 && cnum > 10 && cnum < 100) {
-        const temp = ntext;
-        ntext = ctext;
-        const andtxt = temp.endsWith('e') ? 'ën' : 'en';
-        ctext = `${temp}${andtxt}`;
-      } else if (nnum < 13 && cnum < 1000 && localOptions.includeOptionalAnd) {
-        ctext = `${ctext}en`;
-      } else if (nnum < 13 && cnum >= 1000 && localOptions.includeOptionalAnd) {
-        ntext = ` en ${ntext}`;
-      } else if (cnum >= 1000000) {
-        ctext += ' ';
+      if (nNum < 10 && cNum > 10 && cNum < 100) {
+        const temp = nText;
+        nText = cText;
+        const andTxt = temp.endsWith('e') ? 'ën' : 'en';
+        cText = `${temp}${andTxt}`;
+      } else if (nNum < 13 && cNum < 1000 && this.options.includeOptionalAnd) {
+        cText = `${cText}en`;
+      } else if (nNum < 13 && cNum >= 1000 && this.options.includeOptionalAnd) {
+        nText = ` en ${nText}`;
+      } else if (cNum >= 1000000) {
+        cText += ' ';
       } else {
-        if (cnum === 1000) {
-          ctext += ' ';
+        if (cNum === 1000) {
+          cText += ' ';
         }
       }
-      val = cnum + nnum;
+      val = cNum + nNum;
     }
-    return {[`${ctext}${ntext}`]: val};
-  };
+    return {[`${cText}${nText}`]: val};
+  }
 
-  const old_toCardinal = this.toCardinal;
-  this.toCardinal = (value) => {
-    if (value >= 1100 && value < 10000 && !localOptions.noHundredPairs) {
+  toCardinal(value) {
+    if (value >= 1100 && value < 10000 && !this.options.noHundredPairs) {
       const high = Math.floor(value / 100);
       const low = value % 100;
       if (high % 10 !== 0) {
-        return old_toCardinal(high) + 'honderd' +
-          (low ? (localOptions.includeOptionalAnd ? ' en ' : ' ') + old_toCardinal(low) : '');
+        return super.toCardinal(high) + 'honderd' +
+          (low ? (this.options.includeOptionalAnd ? ' en ' : ' ') + super.toCardinal(low) : '');
       }
     }
-    return old_toCardinal(value);
-  };
+    return super.toCardinal(value);
+  }
+}
+
+export default function(n, options = {}) {
+  return new N2WordsNL(options).floatToCardinal(n);
 }