n2words 1.13.0 → 1.15.0

package/lib/i18n/ES.mjs

@@ -1,58 +1,63 @@
-import N2WordsBase from '../classes/N2WordsBase.mjs';
+import BaseLanguage from '../classes/BaseLanguage.mjs';
 
-export class N2WordsES extends N2WordsBase {
-  constructor() {
-    super();
+export class N2WordsES extends BaseLanguage {
+  genderStem;
 
-    this.genderStem = 'o';
-    this.negativeWord = 'menos';
-    this.separatorWord = 'punto';
-    this.zero = 'cero';
-    this.cards = [
-      { '1000000000000000000000000': 'cuatrillón' },
-      { '1000000000000000000': 'trillón' },
-      { '1000000000000': 'billón' },
-      { '1000000': 'millón' },
-      { '1000': 'mil' },
-      { '100': 'cien' },
-      { '90': 'noventa' },
-      { '80': 'ochenta' },
-      { '70': 'setenta' },
-      { '60': 'sesenta' },
-      { '50': 'cincuenta' },
-      { '40': 'cuarenta' },
-      { '30': 'treinta' },
-      { '29': 'veintinueve' },
-      { '28': 'veintiocho' },
-      { '27': 'veintisiete' },
-      { '26': 'veintiséis' },
-      { '25': 'veinticinco' },
-      { '24': 'veinticuatro' },
-      { '23': 'veintitrés' },
-      { '22': 'veintidós' },
-      { '21': 'veintiuno' },
-      { '20': 'veinte' },
-      { '19': 'diecinueve' },
-      { '18': 'dieciocho' },
-      { '17': 'diecisiete' },
-      { '16': 'dieciseis' },
-      { '15': 'quince' },
-      { '14': 'catorce' },
-      { '13': 'trece' },
-      { '12': 'doce' },
-      { '11': 'once' },
-      { '10': 'diez' },
-      { '9': 'nueve' },
-      { '8': 'ocho' },
-      { '7': 'siete' },
-      { '6': 'seis' },
-      { '5': 'cinco' },
-      { '4': 'cuatro' },
-      { '3': 'tres' },
-      { '2': 'dos' },
-      { '1': 'uno' },
-      { '0': 'cero' }
-    ];
+  constructor(options) {
+    options = Object.assign({
+      negativeWord: 'menos',
+      separatorWord: 'punto',
+      zero: 'cero',
+      genderStem: 'o'
+    }, options);
+
+    super(options, [
+      [1000000000000000000000000n, 'cuatrillón'],
+      [1000000000000000000n, 'trillón'],
+      [1000000000000n, 'billón'],
+      [1000000n, 'millón'],
+      [1000n, 'mil'],
+      [100n, 'cien'],
+      [90n, 'noventa'],
+      [80n, 'ochenta'],
+      [70n, 'setenta'],
+      [60n, 'sesenta'],
+      [50n, 'cincuenta'],
+      [40n, 'cuarenta'],
+      [30n, 'treinta'],
+      [29n, 'veintinueve'],
+      [28n, 'veintiocho'],
+      [27n, 'veintisiete'],
+      [26n, 'veintiséis'],
+      [25n, 'veinticinco'],
+      [24n, 'veinticuatro'],
+      [23n, 'veintitrés'],
+      [22n, 'veintidós'],
+      [21n, 'veintiuno'],
+      [20n, 'veinte'],
+      [19n, 'diecinueve'],
+      [18n, 'dieciocho'],
+      [17n, 'diecisiete'],
+      [16n, 'dieciseis'],
+      [15n, 'quince'],
+      [14n, 'catorce'],
+      [13n, 'trece'],
+      [12n, 'doce'],
+      [11n, 'once'],
+      [10n, 'diez'],
+      [9n, 'nueve'],
+      [8n, 'ocho'],
+      [7n, 'siete'],
+      [6n, 'seis'],
+      [5n, 'cinco'],
+      [4n, 'cuatro'],
+      [3n, 'tres'],
+      [2n, 'dos'],
+      [1n, 'uno'],
+      [0n, 'cero']
+    ]);
+
+    this.genderStem = options.genderStem;
   }
 
   merge(curr, next) {
@@ -93,6 +98,13 @@ export class N2WordsES extends N2WordsBase {
   }
 }
 
-export default function(n) {
-  return new N2WordsES().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 N2WordsES(options).floatToCardinal(value);
 }

package/lib/i18n/FA.mjs

@@ -1,92 +1,104 @@
-import N2WordsAbs from '../classes/N2WordsAbs.mjs';
+import AbstractLanguage from '../classes/AbstractLanguage.mjs';
 
-export class N2WordsFA extends N2WordsAbs {
-  constructor() {
-    super();
+export class N2WordsFA extends AbstractLanguage {
+  namedNumbers = {
+    0: 'صفر',
+    1: 'یک',
+    2: 'دو',
+    3: 'سه',
+    4: 'چهار',
+    5: 'پنج',
+    6: 'شش',
+    7: 'هفت',
+    8: 'هشت',
+    9: 'نه',
+    10: 'ده',
+    11: 'یازده',
+    12: 'دوازده',
+    13: 'سیزده',
+    14: 'چهارده',
+    15: 'پانزده',
+    16: 'شانزده',
+    17: 'هفده',
+    18: 'هجده',
+    19: 'نوزده',
+    20: 'بیست',
+    30: 'سی',
+    40: 'چهل',
+    50: 'پنجاه',
+    60: 'شصت',
+    70: 'هفتاد',
+    80: 'هشتاد',
+    90: 'نود',
+    100: 'صد',
+    200: 'دویست',
+    300: 'سيصد',
+    400: 'چهار صد',
+    500: 'پانصد',
+    600: 'ششصد',
+    700: 'هفتصد',
+    800: 'هشتصد',
+    900: 'نهصد',
+    1000: 'هزار',
+    1000000: 'میلیون',
+  };
 
-    this.negativeWord = 'منفى';
-    this.separatorWord = 'ممیّز';
-    this.zero = 'صفر';
-    this.namedNumbers = {
-      0: 'صفر',
-      1: 'یک',
-      2: 'دو',
-      3: 'سه',
-      4: 'چهار',
-      5: 'پنج',
-      6: 'شش',
-      7: 'هفت',
-      8: 'هشت',
-      9: 'نه',
-      10: 'ده',
-      11: 'یازده',
-      12: 'دوازده',
-      13: 'سیزده',
-      14: 'چهارده',
-      15: 'پانزده',
-      16: 'شانزده',
-      17: 'هفده',
-      18: 'هجده',
-      19: 'نوزده',
-      20: 'بیست',
-      30: 'سی',
-      40: 'چهل',
-      50: 'پنجاه',
-      60: 'شصت',
-      70: 'هفتاد',
-      80: 'هشتاد',
-      90: 'نود',
-      100: 'صد',
-      200: 'دویست',
-      300: 'سيصد',
-      400: 'چهار صد',
-      500: 'پانصد',
-      600: 'ششصد',
-      700: 'هفتصد',
-      800: 'هشتصد',
-      900: 'نهصد',
-      1000: 'هزار',
-      1000000: 'میلیون',
-    };
+  constructor(options) {
+    super(Object.assign({
+      negativeWord: 'منفى',
+      separatorWord: 'ممیّز',
+      zero: 'صفر'
+    }, options));
   }
 
   toCardinal(number) {
     if (this.namedNumbers[number]) {
       return this.namedNumbers[number];
     }
-    if (number > 20 && number < 100) {
-      let xone = number % 10;
+
+    if (number > 20n && number < 100n) {
+      let xone = number % 10n;
       let xten = number - xone;
       return `${this.namedNumbers[xten]} و ${this.namedNumbers[xone]}`;
     }
-    if (number > 100 && number < 1000) {
-      let xhundred = 100 * parseInt(number / 100);
+
+    if (number > 100n && number < 1000n) {
+      let xhundred = 100n * (number / 100n);
       let tail = this.toCardinal(number - xhundred);
       return `${this.namedNumbers[xhundred]} و ${tail}`;
     }
-    if (number > 1000 && number < 1000000) {
-      let thousandMultiplier = parseInt(number / 1000);
+
+    if (number > 1000n && number < 1000000n) {
+      let thousandMultiplier = number / 1000n;
       let namedThousandMultiplier =
-        (thousandMultiplier === 1
+        (thousandMultiplier == 1n
           ? ''
           : this.toCardinal(thousandMultiplier)) +
         ' ' +
         this.namedNumbers[1000];
-      let tailNumber = number - thousandMultiplier * 1000;
-      let tail = tailNumber === 0 ? '' : ' ' + this.toCardinal(tailNumber);
+      let tailNumber = number - thousandMultiplier * 1000n;
+      let tail = tailNumber == 0n ? '' : ' ' + this.toCardinal(tailNumber);
       return `${namedThousandMultiplier}${tail}`;
     }
-    if (number > 1000000) {
-      let millionMultiplier = parseInt(number / 1000000);
+
+    if (number > 1000000n) {
+      let millionMultiplier = number / 1000000n;
       let namedMillion =
         this.toCardinal(millionMultiplier) + ' ' + this.namedNumbers[1000000];
-      let tailNumber = number - millionMultiplier * 1000000;
-      let tail = tailNumber === 0 ? '' : ' و ' + this.toCardinal(tailNumber);
+      let tailNumber = number - millionMultiplier * 1000000n;
+      let tail = tailNumber == 0n ? '' : ' و ' + this.toCardinal(tailNumber);
       return `${namedMillion}${tail}`;
     }
   }
 }
 
-export default function(n) {
-  return new N2WordsFA().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 N2WordsFA(options).floatToCardinal(value);
 }

package/lib/i18n/FR.mjs

@@ -1,50 +1,49 @@
-import N2WordsBase from '../classes/N2WordsBase.mjs';
+import BaseLanguage from '../classes/BaseLanguage.mjs';
 
-export class N2WordsFR extends N2WordsBase {
-  constructor() {
-    super();
-
-    this.negativeWord = 'moins';
-    this.separatorWord = 'virgule';
-    this.zero = 'zéro';
-    this.cards = [
-      { '1000000000000000000000000000': 'quadrilliard' },
-      { '1000000000000000000000000': 'quadrillion' },
-      { '1000000000000000000000': 'trilliard' },
-      { '1000000000000000000': 'trillion' },
-      { '1000000000000000': 'billiard' },
-      { '1000000000000': 'billion' },
-      { '1000000000': 'milliard' },
-      { '1000000': 'million' },
-      { '1000': 'mille' },
-      { '100': 'cent' },
-      { '80': 'quatre-vingts' },
-      { '60': 'soixante' },
-      { '50': 'cinquante' },
-      { '40': 'quarante' },
-      { '30': 'trente' },
-      { '20': 'vingt' },
-      { '19': 'dix-neuf' },
-      { '18': 'dix-huit' },
-      { '17': 'dix-sept' },
-      { '16': 'seize' },
-      { '15': 'quinze' },
-      { '14': 'quatorze' },
-      { '13': 'treize' },
-      { '12': 'douze' },
-      { '11': 'onze' },
-      { '10': 'dix' },
-      { '9': 'neuf' },
-      { '8': 'huit' },
-      { '7': 'sept' },
-      { '6': 'six' },
-      { '5': 'cinq' },
-      { '4': 'quatre' },
-      { '3': 'trois' },
-      { '2': 'deux' },
-      { '1': 'un' },
-      { '0': 'zéro' }
-    ];
+export class N2WordsFR extends BaseLanguage {
+  constructor(options) {
+    super(Object.assign({
+      negativeWord: 'moins',
+      separatorWord: 'virgule',
+      zero: 'zéro'
+    }, options), [
+      [1000000000000000000000000000n, 'quadrilliard'],
+      [1000000000000000000000000n, 'quadrillion'],
+      [1000000000000000000000n, 'trilliard'],
+      [1000000000000000000n, 'trillion'],
+      [1000000000000000n, 'billiard'],
+      [1000000000000n, 'billion'],
+      [1000000000n, 'milliard'],
+      [1000000n, 'million'],
+      [1000n, 'mille'],
+      [100n, 'cent'],
+      [80n, 'quatre-vingts'],
+      [60n, 'soixante'],
+      [50n, 'cinquante'],
+      [40n, 'quarante'],
+      [30n, 'trente'],
+      [20n, 'vingt'],
+      [19n, 'dix-neuf'],
+      [18n, 'dix-huit'],
+      [17n, 'dix-sept'],
+      [16n, 'seize'],
+      [15n, 'quinze'],
+      [14n, 'quatorze'],
+      [13n, 'treize'],
+      [12n, 'douze'],
+      [11n, 'onze'],
+      [10n, 'dix'],
+      [9n, 'neuf'],
+      [8n, 'huit'],
+      [7n, 'sept'],
+      [6n, 'six'],
+      [5n, 'cinq'],
+      [4n, 'quatre'],
+      [3n, 'trois'],
+      [2n, 'deux'],
+      [1n, 'un'],
+      [0n, 'zéro']
+    ]);
   }
 
   merge(curr, next) { // {'cent':100}, {'vingt-cinq':25}
@@ -81,6 +80,13 @@ export class N2WordsFR extends N2WordsBase {
   }
 }
 
-export default function(n) {
-  return new N2WordsFR().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 N2WordsFR(options).floatToCardinal(value);
 }

package/lib/i18n/HE.mjs

@@ -1,34 +1,85 @@
 import {N2WordsRU} from './RU.mjs';
 
 export class N2WordsHE extends N2WordsRU {
-  constructor() {
-    super();
+  and;
 
-    this.negativeWord = 'מינוס'; //TODO: Needs confirmation
-    this.separatorWord; //TODO
-    this.zero = 'אפס';
-    this.and = 'ו';
-    this.ones = { 1: 'אחת', 2: 'שתים', 3: 'שלש', 4: 'ארבע', 5: 'חמש', 6: 'שש', 7: 'שבע', 8: 'שמונה', 9: 'תשע' };
-    this.tens = {
-      0: 'עשר', 1: 'אחת עשרה', 2: 'שתים עשרה', 3: 'שלש עשרה', 4: 'ארבע עשרה',
-      5: 'חמש עשרה', 6: 'שש עשרה', 7: 'שבע עשרה', 8: 'שמונה עשרה', 9: 'תשע עשרה'
-    };
-    this.twenties = {
-      2: 'עשרים', 3: 'שלשים', 4: 'ארבעים', 5: 'חמישים', 6: 'ששים', 7: 'שבעים', 8: 'שמונים', 9: 'תשעים'
-    };
-    this.hundreds = { 1: 'מאה', 2: 'מאתיים', 3: 'מאות' };
-    this.thousands = {
-      1: 'אלף', 2: 'אלפיים', 3: 'שלשת אלפים', 4: 'ארבעת אלפים',
-      5: 'חמשת אלפים', 6: 'ששת אלפים', 7: 'שבעת אלפים', 8: 'שמונת אלפים', 9: 'תשעת אלפים'
-    };
+  ones = {
+    1: 'אחת',
+    2: 'שתים',
+    3: 'שלש',
+    4: 'ארבע',
+    5: 'חמש',
+    6: 'שש',
+    7: 'שבע',
+    8: 'שמונה',
+    9: 'תשע'
+  };
+
+  tens = {
+    0: 'עשר',
+    1: 'אחת עשרה',
+    2: 'שתים עשרה',
+    3: 'שלש עשרה',
+    4: 'ארבע עשרה',
+    5: 'חמש עשרה',
+    6: 'שש עשרה',
+    7: 'שבע עשרה',
+    8: 'שמונה עשרה',
+    9: 'תשע עשרה'
+  };
+
+  twenties = {
+    2: 'עשרים',
+    3: 'שלשים',
+    4: 'ארבעים',
+    5: 'חמישים',
+    6: 'ששים',
+    7: 'שבעים',
+    8: 'שמונים',
+    9: 'תשעים'
+  };
+
+  hundreds = {
+    1: 'מאה',
+    2: 'מאתיים',
+    3: 'מאות'
+  };
+
+  thousands = {
+    1: 'אלף',
+    2: 'אלפיים',
+    3: 'שלשת אלפים',
+    4: 'ארבעת אלפים',
+    5: 'חמשת אלפים',
+    6: 'ששת אלפים',
+    7: 'שבעת אלפים',
+    8: 'שמונת אלפים',
+    9: 'תשעת אלפים'
+  };
+
+  constructor(options) {
+    /**
+     * @todo Confirm `negativeWord`
+     * @todo Set `separatorWord`
+     */
+    options = Object.assign({
+      negativeWord: 'מינוס',
+      //separatorWord: ,
+      zero: 'אפס',
+      and: 'ו'
+    }, options);
+
+    super(options);
+
+    this.and = options.and;
   }
 
   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];
@@ -67,6 +118,13 @@ export class N2WordsHE extends N2WordsRU {
   }
 }
 
-export default function(n) {
-  return new N2WordsHE().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 N2WordsHE(options).floatToCardinal(value);
 }