n2words 1.13.0 → 1.14.0

package/lib/i18n/FA.mjs

@@ -1,92 +1,103 @@
-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() {
+    super({
+      negativeWord: 'منفى',
+      separatorWord: 'ممیّز',
+      zero: 'صفر'
+    });
   }
 
   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.
+ * @throws {Error} Value cannot be invalid.
+ * @returns {string} Value in cardinal (written) format.
+ */
+export default function(value) {
+  return new N2WordsFA().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 {
+export class N2WordsFR extends BaseLanguage {
   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' }
-    ];
+    super({
+      negativeWord: 'moins',
+      separatorWord: 'virgule',
+      zero: 'zéro'
+    },[
+      [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,12 @@ 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.
+ * @throws {Error} Value cannot be invalid.
+ * @returns {string} Value in cardinal (written) format.
+ */
+export default function(value) {
+  return new N2WordsFR().floatToCardinal(value);
 }

package/lib/i18n/HE.mjs

@@ -1,34 +1,80 @@
 import {N2WordsRU} from './RU.mjs';
 
 export class N2WordsHE extends N2WordsRU {
-  constructor() {
-    super();
+  and = 'ו';
+
+  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: 'תשעים'
+  };
 
-    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: 'תשעת אלפים'
-    };
+  hundreds = {
+    1: 'מאה',
+    2: 'מאתיים',
+    3: 'מאות'
+  };
+
+  thousands = {
+    1: 'אלף',
+    2: 'אלפיים',
+    3: 'שלשת אלפים',
+    4: 'ארבעת אלפים',
+    5: 'חמשת אלפים',
+    6: 'ששת אלפים',
+    7: 'שבעת אלפים',
+    8: 'שמונת אלפים',
+    9: 'תשעת אלפים'
+  };
+
+  constructor() {
+    /**
+     * @todo Confirm `negativeWord`
+     * @todo Set `separatorWord`
+     */
+    super({
+      negativeWord: 'מינוס',
+      //separatorWord: ,
+      zero: 'אפס'
+    });
   }
 
   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 +113,12 @@ 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.
+ * @throws {Error} Value cannot be invalid.
+ * @returns {string} Value in cardinal (written) format.
+ */
+export default function(value) {
+  return new N2WordsHE().floatToCardinal(value);
 }

package/lib/i18n/HR.mjs

@@ -1,78 +1,84 @@
 import {N2WordsRU} from './RU.mjs';
 
 export class N2WordsHR extends N2WordsRU {
-  constructor() {
-    super();
+  ones = {
+    1: ['jedan', 'jedna'],
+    2: ['dva', 'dvije'],
+    3: ['tri', 'tri'],
+    4: ['četiri', 'četiri'],
+    5: ['pet', 'pet'],
+    6: ['šest', 'šest'],
+    7: ['sedam', 'sedam'],
+    8: ['osam', 'osam'],
+    9: ['devet', 'devet']
+  };
+
+  tens = {
+    0: 'deset',
+    1: 'jedanaest',
+    2: 'dvanaest',
+    3: 'trinaest',
+    4: 'četrnaest',
+    5: 'petnaest',
+    6: 'šesnaest',
+    7: 'sedamnaest',
+    8: 'osamnaest',
+    9: 'devetnaest'
+  };
+
+  twenties = {
+    2: 'dvadeset',
+    3: 'trideset',
+    4: 'četrdeset',
+    5: 'pedeset',
+    6: 'šezdeset',
+    7: 'sedamdeset',
+    8: 'osamdeset',
+    9: 'devedeset'
+  };
+
+  hundreds = {
+    1: 'sto',
+    2: 'dvjesto',
+    3: 'tristo',
+    4: 'četiristo',
+    5: 'petsto',
+    6: 'šesto',
+    7: 'sedamsto',
+    8: 'osamsto',
+    9: 'devetsto'
+  };
 
-    this.negativeWord = 'minus';
-    this.separatorWord = 'zarez';
-    this.zero = 'nula';
-    this.ones = {
-      1: ['jedan', 'jedna'],
-      2: ['dva', 'dvije'],
-      3: ['tri', 'tri'],
-      4: ['četiri', 'četiri'],
-      5: ['pet', 'pet'],
-      6: ['šest', 'šest'],
-      7: ['sedam', 'sedam'],
-      8: ['osam', 'osam'],
-      9: ['devet', 'devet']
-    };
-    this.tens = {
-      0: 'deset',
-      1: 'jedanaest',
-      2: 'dvanaest',
-      3: 'trinaest',
-      4: 'četrnaest',
-      5: 'petnaest',
-      6: 'šesnaest',
-      7: 'sedamnaest',
-      8: 'osamnaest',
-      9: 'devetnaest'
-    };
-    this.twenties = {
-      2: 'dvadeset',
-      3: 'trideset',
-      4: 'četrdeset',
-      5: 'pedeset',
-      6: 'šezdeset',
-      7: 'sedamdeset',
-      8: 'osamdeset',
-      9: 'devedeset'
-    };
-    this.hundreds = {
-      1: 'sto',
-      2: 'dvjesto',
-      3: 'tristo',
-      4: 'četiristo',
-      5: 'petsto',
-      6: 'šesto',
-      7: 'sedamsto',
-      8: 'osamsto',
-      9: 'devetsto'
-    };
-    this.SCALE = {
-      0: ['', '', '', false],
-      1: ['tisuća', 'tisuće', 'tisuća', true], // 10 ^ 3
-      2: ['milijun', 'milijuna', 'milijuna', false], // 10 ^ 6
-      3: ['milijarda', 'milijarde', 'milijarda', false], // 10 ^ 9
-      4: ['bilijun', 'bilijuna', 'bilijuna', false], // 10 ^ 12
-      5: ['bilijarda', 'bilijarde', 'bilijarda', false], // 10 ^ 15
-      6: ['trilijun', 'trilijuna', 'trilijuna', false], // 10 ^ 18
-      7: ['trilijarda', 'trilijarde', 'trilijarda', false], // 10 ^ 21
-      8: ['kvadrilijun', 'kvadrilijuna', 'kvadrilijuna', false], // 10 ^ 24
-      9: ['kvadrilijarda', 'kvadrilijarde', 'kvadrilijarda', false], // 10 ^ 27
-      10: ['kvintilijun', 'kvintilijuna', 'kvintilijuna', false], // 10 ^ 30
-    };
-    this.feminine = false;
+  SCALE = {
+    0: ['', '', '', false],
+    1: ['tisuća', 'tisuće', 'tisuća', true], // 10 ^ 3
+    2: ['milijun', 'milijuna', 'milijuna', false], // 10 ^ 6
+    3: ['milijarda', 'milijarde', 'milijarda', false], // 10 ^ 9
+    4: ['bilijun', 'bilijuna', 'bilijuna', false], // 10 ^ 12
+    5: ['bilijarda', 'bilijarde', 'bilijarda', false], // 10 ^ 15
+    6: ['trilijun', 'trilijuna', 'trilijuna', false], // 10 ^ 18
+    7: ['trilijarda', 'trilijarde', 'trilijarda', false], // 10 ^ 21
+    8: ['kvadrilijun', 'kvadrilijuna', 'kvadrilijuna', false], // 10 ^ 24
+    9: ['kvadrilijarda', 'kvadrilijarde', 'kvadrilijarda', false], // 10 ^ 27
+    10: ['kvintilijun', 'kvintilijuna', 'kvintilijuna', false], // 10 ^ 30
+  };
+
+  feminine = false;
+
+  constructor() {
+    super({
+      negativeWord: 'minus',
+      separatorWord: 'zarez',
+      zero: 'nula'
+    });
   }
 
   pluralize(n, forms) {
     let form = 2;
-    if ((n % 100 < 10) || (n % 100 > 20)) {
-      if (n % 10 == 1) {
+    if ((n % 100n < 10n) || (n % 100n > 20n)) {
+      if (n % 10n == 1n) {
         form = 0;
-      } else if ((n % 10 > 1) && (n % 10 < 5)) {
+      } else if ((n % 10n > 1n) && (n % 10n < 5n)) {
         form = 1;
       }
     }
@@ -80,11 +86,11 @@ export class N2WordsHR 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];
@@ -112,6 +118,12 @@ export class N2WordsHR extends N2WordsRU {
   }
 }
 
-export default function(n) {
-  return new N2WordsHR().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 N2WordsHR().floatToCardinal(value);
 }