n2words 1.16.4 → 1.18.0

package/lib/classes/AbstractLanguage.d.ts

@@ -38,10 +38,10 @@ export default class _default {
     get wholeNumber(): number;
     /**
      * Convert decimal number to a string array of cardinal numbers.
-     * @param {number} decimal Decimal number to convert.
+     * @param {string} decimal Decimal string to convert.
      * @returns {string} Value in written format.
      */
-    decimalToCardinal(decimal: number): string;
+    decimalToCardinal(decimal: string): string;
     /**
      * Converts a number to written form.
      * @param {number|string} value Number to be convert.

package/lib/classes/AbstractLanguage.js

@@ -21,7 +21,7 @@ export default class {
     options = Object.assign({
       negativeWord: '',
       separatorWord: undefined,
-      zeroWord: undefined,
+      zero: undefined,
       spaceSeparator: ' '
     }, options);
 
@@ -69,21 +69,30 @@ export default class {
 
   /**
    * Convert decimal number to a string array of cardinal numbers.
-   * @param {number} decimal Decimal number to convert.
+   * @param {string} decimal Decimal string to convert.
    * @returns {string} Value in written format.
    */
   decimalToCardinal(decimal) {
     const words = [];
+    let allZero = true;
 
     // Split decimal portion into an array of characters in reverse
-    const chars = decimal.split('').reverse();
+    const chars = decimal.split('');
+
+    // Loop through array (from the end) adding leading zeros to output array
+    chars.forEach(char => {
+      if (char === '0') {
+        words.push(this.zero);
+      } else {
+        allZero = false;
+      }
+    });
 
-    // Loop through array (from the end) adding words to output array
-    while (chars.pop() == '0') {
-      words.push(this.zero);
+    // Add decimal number to word array
+    if (allZero) {
+      return words;
     }
 
-    // Add decimal number to word array
     return words.concat(this.toCardinal(BigInt(decimal)));
   }
 

package/lib/classes/BaseLanguage.d.ts

@@ -45,7 +45,6 @@ export default class _default extends AbstractLanguage {
      * @todo Simplify return object.
      */
     toCardMatches(value: number): object;
-    scanNum(value: any): any;
     clean(words: any): any;
     postClean(out0: any): any;
     /**

package/lib/classes/BaseLanguage.js

@@ -108,10 +108,6 @@ export default class extends AbstractLanguage {
     return out;
   }
 
-  scanNum(value) {
-    return value.split('').map(v => this.getCardWord(Number(v)));
-  }
-
   clean(words) {
     let out = words;
 

package/lib/i18n/ar.d.ts

@@ -8,11 +8,12 @@
 export default function _default(value: number | string, options?: object): string;
 export class Arabic extends AbstractLanguage {
     constructor(options: any);
-    integerValue: number;
-    decimalValue: number;
-    number: number;
-    arabicOnes: string[];
-    arabicFeminineOnes: string[];
+    number: any;
+    feminine: any;
+    ones: {
+        masculine: string[];
+        feminine: string[];
+    };
     arabicTens: string[];
     arabicHundreds: string[];
     arabicAppendedTwos: string[];

package/lib/i18n/ar.js

@@ -1,27 +1,54 @@
 import AbstractLanguage from '../classes/AbstractLanguage.js';
 
 export class Arabic extends AbstractLanguage {
-  integerValue = 0;
-
-  decimalValue = 0;
-
-  number = 0;
-
-  arabicOnes = [
-    '', 'واحد', 'اثنان', 'ثلاثة', 'أربعة', 'خمسة', 'ستة', 'سبعة', 'ثمانية',
-    'تسعة',
-    'عشرة', 'أحد عشر', 'اثنا عشر', 'ثلاثة عشر', 'أربعة عشر', 'خمسة عشر',
-    'ستة عشر', 'سبعة عشر', 'ثمانية عشر',
-    'تسعة عشر',
-  ];
-
-  arabicFeminineOnes = [
-    '', 'إحدى', 'اثنتان', 'ثلاث', 'أربع', 'خمس', 'ست', 'سبع', 'ثمان',
-    'تسع',
-    'عشر', 'إحدى عشرة', 'اثنتا عشرة', 'ثلاث عشرة', 'أربع عشرة',
-    'خمس عشرة', 'ست عشرة', 'سبع عشرة', 'ثماني عشرة',
-    'تسع عشرة',
-  ];
+  number;
+
+  feminine;
+
+  ones = {
+    masculine: [
+      'واحد',
+      'اثنان',
+      'ثلاثة',
+      'أربعة',
+      'خمسة',
+      'ستة',
+      'سبعة',
+      'ثمانية',
+      'تسعة',
+      'عشرة',
+      'أحد عشر',
+      'اثنا عشر',
+      'ثلاثة عشر',
+      'أربعة عشر',
+      'خمسة عشر',
+      'ستة عشر',
+      'سبعة عشر',
+      'ثمانية عشر',
+      'تسعة عشر',
+    ],
+    feminine: [
+      'إحدى',
+      'اثنتان',
+      'ثلاث',
+      'أربع',
+      'خمس',
+      'ست',
+      'سبع',
+      'ثمان',
+      'تسع',
+      'عشر',
+      'إحدى عشرة',
+      'اثنتا عشرة',
+      'ثلاث عشرة',
+      'أربع عشرة',
+      'خمس عشرة',
+      'ست عشرة',
+      'سبع عشرة',
+      'ثماني عشرة',
+      'تسع عشرة',
+    ]
+  };
 
   arabicTens = ['عشرون', 'ثلاثون', 'أربعون', 'خمسون', 'ستون', 'سبعون', 'ثمانون', 'تسعون'];
 
@@ -42,18 +69,23 @@ export class Arabic extends AbstractLanguage {
   // isCurrencyNameFeminine = false
 
   constructor(options) {
-    super(Object.assign({
+    options = Object.assign({
       negativeWord: 'ناقص',
       separatorWord: 'فاصلة',
-      zero: 'صفر'
-    }, options));
+      zero: 'صفر',
+      feminine: false,
+    }, options);
+
+    super(options);
+
+    this.feminine = options.feminine;
   }
 
-  digitFeminineStatus(digit/* , groupLevel */) {
+  digitFeminineStatus(digit) {
     // if ((groupLevel == -1 && this.isCurrencyPartNameFeminine) || (groupLevel == 0 && this.isCurrencyNameFeminine)) {
     //   return this.arabicFeminineOnes[digit]
     // }
-    return this.arabicOnes[digit];
+    return this.ones[this.feminine ? 'feminine' : 'masculine'][digit - 1];
   }
 
   processArabicGroup(groupNumber, groupLevel, remainingNumber) {
@@ -61,10 +93,8 @@ export class Arabic extends AbstractLanguage {
     const hundreds = groupNumber / 100;
     let retVal = '';
 
-    if (Math.trunc(hundreds) > 0) {
-      retVal = (
-        tens == 0 && Math.trunc(hundreds) == 2
-      ) ? this.arabicAppendedTwos[0] : this.arabicHundreds[Math.trunc(hundreds)];
+    if (hundreds > 0) {
+      retVal = (tens == 0 && Math.trunc(hundreds) == 2 ? this.arabicAppendedTwos[0] : this.arabicHundreds[Math.trunc(hundreds)]);
     }
 
     if (tens > 0) {
@@ -72,13 +102,13 @@ export class Arabic extends AbstractLanguage {
         if (tens == 2 && Math.trunc(hundreds) == 0 && groupLevel > 0) {
           retVal = ([
             2000, 2000000, 2000000000, 2000000000000, 2000000000000000, 2000000000000000000
-          ].indexOf(this.integerValue) != -1) ? this.arabicAppendedTwos[
-              Math.trunc(groupLevel)] : this.arabicTwos[Math.trunc(groupLevel)
-            ];
+          ].indexOf(this.number) != -1) ? this.arabicAppendedTwos[groupLevel] : this.arabicTwos[groupLevel];
         } else {
+          // Add divider
           if (retVal != '') {
             retVal += ' و ';
           }
+
           if (tens == 1 && groupLevel > 0 && hundreds == 0) {
             retVal += '';
           } else if (
@@ -114,30 +144,35 @@ export class Arabic extends AbstractLanguage {
   }
 
   toCardinal(number) {
-    /** @todo Convert class to work with BigInt */
-    number = Number(number);
-
     if (number == 0) {
       return this.zero;
     }
 
+    this.number = number;
     let tempNumber = number;
-    this.integerValue = number;
-    let retVal = '';
     let group = 0;
+    let retVal = '';
 
+    // Loop until number has been reduced to zero or less
     while (tempNumber > 0) {
-      const numberToProcess = tempNumber % 1000;
-      tempNumber = Math.trunc(tempNumber / 1000);
+      // Get the remaining value after dividing by 1000
+      const numberToProcess = Number(tempNumber % 1000n); // Maximum: 999
+      // Divide number by 1000
+      tempNumber = tempNumber / 1000n;
 
-      const groupDescription = this.processArabicGroup(numberToProcess, group, Math.floor(tempNumber));
+      // Process "group"
+      const groupDescription = this.processArabicGroup(numberToProcess, group, tempNumber);
 
+      // Did the group return anything?
       if (groupDescription != '') {
+        // Is this after the first "group"?
         if (group > 0) {
+          // Is the return value still empty?
           if (retVal != '') {
             retVal = ' و ' + retVal;
           }
 
+          // Process every number other than 2
           if (numberToProcess != 2) {
             if (numberToProcess % 100 != 1) {
               if (numberToProcess >= 3 && numberToProcess <= 10) {
@@ -155,10 +190,13 @@ export class Arabic extends AbstractLanguage {
           }
         }
 
+        // Add "group" return to output variable
+        // NOTE: Language is right-to-left
         retVal = groupDescription + ' ' + retVal;
       }
 
-      group += 1;
+      // Increase group level/number
+      group++;
     }
 
     return retVal.trim();

package/lib/i18n/az.js

@@ -2,11 +2,13 @@ import BaseLanguage from '../classes/BaseLanguage.js';
 
 export class N2WordsAZ extends BaseLanguage {
   constructor(options) {
-    super(Object.assign({
+    options = Object.assign({
       negativeWord: 'mənfi',
       separatorWord: 'nöqtə',
       zero: 'sıfır'
-    }, options), [
+    }, options);
+
+    super(options, [
       [1000000000000000000n, 'kentilyon'],
       [1000000000000000n, 'katrilyon'],
       [1000000000000n, 'trilyon'],

package/lib/i18n/cz.d.ts

@@ -7,6 +7,62 @@
  */
 export default function _default(value: number | string, options?: object): string;
 export class N2WordsCZ extends N2WordsRU {
+    ones: {
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    tens: {
+        0: string;
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    twenties: {
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    hundreds: {
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    thousands: {
+        1: string[];
+        2: string[];
+        3: string[];
+        4: string[];
+        5: string[];
+        6: string[];
+        7: string[];
+        8: string[];
+        9: string[];
+        10: string[];
+    };
     get separatorWord(): "celá" | "celé" | "celých";
 }
 import { N2WordsRU } from './ru.js';

package/lib/i18n/cz.js

@@ -63,10 +63,12 @@ export class N2WordsCZ extends N2WordsRU {
   };
 
   constructor(options) {
-    super(Object.assign({
+    options = Object.assign({
       negativeWord: 'mínus',
       zero: 'nula'
-    }, options));
+    }, options);
+
+    super(options);
   }
 
   get separatorWord() {

package/lib/i18n/de.js

@@ -2,11 +2,13 @@ import BaseLanguage from '../classes/BaseLanguage.js';
 
 export class N2WordsDE extends BaseLanguage {
   constructor(options) {
-    super(Object.assign({
+    options = Object.assign({
       negativeWord: 'minus',
       separatorWord: 'komma',
       zero: 'null'
-    }, options), [
+    }, options);
+
+    super(options, [
       [1000000000000000000000000000n, 'Quadrilliarde'],
       [1000000000000000000000000n, 'Quadrillion'],
       [1000000000000000000000n, 'Trilliarde'],

package/lib/i18n/dk.js

@@ -60,7 +60,7 @@ export class N2WordsDK extends BaseLanguage {
     let nText = Object.keys(next)[0];
     const cNum = BigInt(Object.values(curr)[0]);
     const nNum = BigInt(Object.values(next)[0]);
-    let val = 1;
+    let val;
     if (nNum == 100 || nNum == 1000) {
       next = { [`et${nText}`]: nNum };
     }

package/lib/i18n/en.js

@@ -5,11 +5,13 @@ import BaseLanguage from '../classes/BaseLanguage.js';
  */
 export class English extends BaseLanguage {
   constructor(options) {
-    super(Object.assign({
+    options = Object.assign({
       negativeWord: 'minus',
       separatorWord: 'point',
       zero: 'zero'
-    }, options), [
+    }, options);
+
+    super(options, [
       [1000000000000000000000000000n, 'octillion'],
       [1000000000000000000000000n, 'septillion'],
       [1000000000000000000000n, 'sextillion'],

package/lib/i18n/fa.js

@@ -44,11 +44,13 @@ export class N2WordsFA extends AbstractLanguage {
   };
 
   constructor(options) {
-    super(Object.assign({
+    options = Object.assign({
       negativeWord: 'منفى',
       separatorWord: 'ممیّز',
       zero: 'صفر'
-    }, options));
+    }, options);
+
+    super(options);
   }
 
   toCardinal(number) {

package/lib/i18n/fr-BE.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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 _default(value: number | string, options?: object): string;
+export class N2WordsFRBE extends N2WordsFR {
+}
+import { N2WordsFR } from './fr.js';

package/lib/i18n/fr-BE.js

@@ -0,0 +1,20 @@
+import { N2WordsFR } from './fr.js';
+
+export class N2WordsFRBE extends N2WordsFR {
+  constructor(options) {
+    options = Object.assign({}, options, { _region: 'BE' });
+
+    super(options);
+  }
+}
+
+/**
+ * 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 N2WordsFRBE(options).floatToCardinal(value);
+}

package/lib/i18n/fr.js

@@ -2,11 +2,14 @@ import BaseLanguage from '../classes/BaseLanguage.js';
 
 export class N2WordsFR extends BaseLanguage {
   constructor(options) {
-    super(Object.assign({
+    options = Object.assign({
       negativeWord: 'moins',
       separatorWord: 'virgule',
-      zero: 'zéro'
-    }, options), [
+      zero: 'zéro',
+      _region: 'FR'
+    }, options);
+
+    super(options, [
       [1000000000000000000000000000n, 'quadrilliard'],
       [1000000000000000000000000n, 'quadrillion'],
       [1000000000000000000000n, 'trilliard'],
@@ -17,7 +20,9 @@ export class N2WordsFR extends BaseLanguage {
       [1000000n, 'million'],
       [1000n, 'mille'],
       [100n, 'cent'],
+      ...(['BE'].includes(options._region) ? [[90n, 'nonante']] : []),
       [80n, 'quatre-vingts'],
+      ...(['BE'].includes(options._region) ? [[70n, 'septante']] : []),
       [60n, 'soixante'],
       [50n, 'cinquante'],
       [40n, 'quarante'],

package/lib/i18n/he.d.ts

@@ -8,6 +8,39 @@
 export default function _default(value: number | string, options?: object): string;
 export class N2WordsHE extends N2WordsRU {
     and: any;
+    ones: {
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    tens: {
+        0: string;
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    twenties: {
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
     hundreds: {
         1: string;
         2: string;

package/lib/i18n/he.js

@@ -87,11 +87,15 @@ export class N2WordsHE extends N2WordsRU {
       if (x == 0) {
         continue;
       }
+
       const [n1, n2, n3] = this.getDigits(x);
+
       if (i > 0) {
         words.push(this.thousands[n1]);
         continue;
       }
+
+
       if (n3 > 0) {
         if (n3 <= 2) {
           words.push(this.hundreds[n3]);
@@ -99,21 +103,22 @@ export class N2WordsHE extends N2WordsRU {
           words.push(this.ones[n3] + ' ' + this.hundreds[3]);
         }
       }
+
       if (n2 > 1) {
         words.push(this.twenties[n2]);
       }
+
       if (n2 == 1) {
         words.push(this.tens[n1]);
-      } else if (n1 > 0 && !(i > 0 && x == 1)) {
+      } else if (n1 > 0) {
         words.push(this.ones[n1]);
       }
-      if (i > 0) {
-        words.push(this.thousands[i]);
-      }
     }
+
     if (words.length > 1) {
       words[words.length - 1] = this.and + words[words.length - 1];
     }
+
     return words.join(' ');
   }
 }

package/lib/i18n/hr.d.ts

@@ -18,6 +18,39 @@ export class N2WordsHR extends N2WordsRU {
         8: string[];
         9: string[];
     };
+    tens: {
+        0: string;
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    twenties: {
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    hundreds: {
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
     SCALE: {
         0: (string | boolean)[];
         1: (string | boolean)[];

package/lib/i18n/hr.js

@@ -64,11 +64,13 @@ export class N2WordsHR extends N2WordsRU {
   };
 
   constructor(options) {
-    super(Object.assign({
+    options = Object.assign({
       negativeWord: 'minus',
       separatorWord: 'zarez',
       zero: 'nula'
-    }, options));
+    }, options);
+
+    super(options);
   }
 
   pluralize(n, forms) {

package/lib/i18n/hu.js

@@ -2,11 +2,13 @@ import BaseLanguage from '../classes/BaseLanguage.js';
 
 export class N2WordsHU extends BaseLanguage {
   constructor(options) {
-    super(Object.assign({
+    options = Object.assign({
       negativeWord: 'mínusz',
       separatorWord: 'egész',
       zero: 'nulla'
-    }, options), [
+    }, options);
+
+    super(options, [
       [1000000000000000000000000000n, 'quadrilliárd'],
       [1000000000000000000000000n, 'quadrillió'],
       [1000000000000000000000n, 'trilliárd'],