n2words 1.16.2 → 1.16.4

package/lib/classes/AbstractLanguage.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Creates new language class that processes decimals separately.
+ * Requires implementing `toCardinal`.
+ */
+export default class _default {
+    /**
+     * @param {object} options Options for class.
+     * @param {string} [options.negativeWord] Word that precedes a negative number (if any).
+     * @param {string} options.separatorWord Word that separates cardinal numbers (i.e. "and").
+     * @param {string} options.zero Word for 0 (i.e. "zero").
+     * @param {string} [options.spaceSeparator] Character that separates words.
+     */
+    constructor(options: {
+        negativeWord?: string;
+        separatorWord: string;
+        zero: string;
+        spaceSeparator?: string;
+    });
+    /**
+     * @returns {string} Word that precedes a negative number (if any).
+     */
+    get negativeWord(): string;
+    /**
+     * @returns {string} Word that separates cardinal numbers (i.e. "and").
+     */
+    get separatorWord(): string;
+    /**
+     * @returns {string} Word for 0 (i.e. "zero").
+     */
+    get zero(): string;
+    /**
+     * @returns {string} Character that separates words.
+     */
+    get spaceSeparator(): string;
+    /**
+     * @returns {number} Input value without decimal.
+     */
+    get wholeNumber(): number;
+    /**
+     * Convert decimal number to a string array of cardinal numbers.
+     * @param {number} decimal Decimal number to convert.
+     * @returns {string} Value in written format.
+     */
+    decimalToCardinal(decimal: number): string;
+    /**
+     * Converts a number to written form.
+     * @param {number|string} value Number to be convert.
+     * @throws {Error} Value must be a valid number.
+     * @returns {string} Value in written format.
+     */
+    floatToCardinal(value: number | string): string;
+    #private;
+}

package/lib/classes/BaseLanguage.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Creates new common language class that uses a highest matching word value algorithm.
+ * Number matching word {@link cards} must be provided for this to work.
+ * See {@link AbstractLanguage} for further requirements.
+ * @classdesc Common class for (mostly european) languages.
+ */
+export default class _default extends AbstractLanguage {
+    /**
+     * @param {object} options Options for class.
+     * @param {string} [options.negativeWord] Word that precedes a negative number (if any).
+     * @param {string} options.separatorWord Word that separates cardinal numbers (i.e. "and").
+     * @param {string} options.zero Word for 0 (i.e. "zero").
+     * @param {string} [options.spaceSeparator] Character that separates words.
+     * @param {Array} cards Array of number matching "cards" from highest-to-lowest.
+     */
+    constructor(options: {
+        negativeWord?: string;
+        separatorWord: string;
+        zero: string;
+        spaceSeparator?: string;
+    }, cards: any[]);
+    /**
+     * Get array of number matching "cards" from highest-to-lowest.
+     * First element in card array is the number to match while the second is the word to use.
+     * @example
+     * [
+     *   ...
+     *   [100, 'hundred'],
+     *   ...
+     *   [1, 'one'],
+     * ]
+     * @returns {Array} Array of number matching "cards" from highest-to-lowest.
+     */
+    get cards(): any[];
+    /**
+     * Get word for number if it matches a language card.
+     * @param {number} number Card number value.
+     * @returns {string|undefined} Return card word or undefined if no card.
+     */
+    getCardWord(number: number): string | undefined;
+    /**
+     * Get array of card matches.
+     * @param {number} value The number value to convert to cardinal form.
+     * @returns {object} Word sets (and pairs) from value.
+     * @todo Simplify return object.
+     */
+    toCardMatches(value: number): object;
+    scanNum(value: any): any;
+    clean(words: any): any;
+    postClean(out0: any): any;
+    /**
+     * Convert a whole number to written format.
+     * @param {number} value The number value to convert to cardinal form.
+     * @returns {string} Value in written format.
+     */
+    toCardinal(value: number): string;
+    #private;
+}
+import AbstractLanguage from './AbstractLanguage.js';

package/lib/i18n/ar.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 Arabic extends AbstractLanguage {
+    constructor(options: any);
+    integerValue: number;
+    decimalValue: number;
+    number: number;
+    arabicOnes: string[];
+    arabicFeminineOnes: string[];
+    arabicTens: string[];
+    arabicHundreds: string[];
+    arabicAppendedTwos: string[];
+    arabicTwos: string[];
+    arabicGroup: string[];
+    arabicAppendedGroup: string[];
+    arabicPluralGroups: string[];
+    digitFeminineStatus(digit: any): string;
+    processArabicGroup(groupNumber: any, groupLevel: any, remainingNumber: any): string;
+    toCardinal(number: any): string;
+}
+import AbstractLanguage from '../classes/AbstractLanguage.js';

package/lib/i18n/ar.js

@@ -51,27 +51,29 @@ export class Arabic extends AbstractLanguage {
 
   digitFeminineStatus(digit/* , groupLevel */) {
     // if ((groupLevel == -1 && this.isCurrencyPartNameFeminine) || (groupLevel == 0 && this.isCurrencyNameFeminine)) {
-    //   return this.arabicFeminineOnes[parseInt(digit)]
+    //   return this.arabicFeminineOnes[digit]
     // }
-    return this.arabicOnes[parseInt(digit)];
+    return this.arabicOnes[digit];
   }
 
   processArabicGroup(groupNumber, groupLevel, remainingNumber) {
     let tens = groupNumber % 100;
     const hundreds = groupNumber / 100;
     let retVal = '';
-    if (parseInt(hundreds) > 0) {
+
+    if (Math.trunc(hundreds) > 0) {
       retVal = (
-        tens == 0 && parseInt(hundreds) == 2
-      ) ? this.arabicAppendedTwos[0] : this.arabicHundreds[parseInt(hundreds)];
+        tens == 0 && Math.trunc(hundreds) == 2
+      ) ? this.arabicAppendedTwos[0] : this.arabicHundreds[Math.trunc(hundreds)];
     }
+
     if (tens > 0) {
       if (tens < 20) {
-        if (tens == 2 && parseInt(hundreds) == 0 && groupLevel > 0) {
+        if (tens == 2 && Math.trunc(hundreds) == 0 && groupLevel > 0) {
           retVal = ([
             2000, 2000000, 2000000000, 2000000000000, 2000000000000000, 2000000000000000000
           ].indexOf(this.integerValue) != -1) ? this.arabicAppendedTwos[
-              parseInt(groupLevel)] : this.arabicTwos[parseInt(groupLevel)
+              Math.trunc(groupLevel)] : this.arabicTwos[Math.trunc(groupLevel)
             ];
         } else {
           if (retVal != '') {
@@ -80,29 +82,34 @@ export class Arabic extends AbstractLanguage {
           if (tens == 1 && groupLevel > 0 && hundreds == 0) {
             retVal += '';
           } else if (
-            (tens == 1 || tens == 2) && (groupLevel == 0 || groupLevel == -1) &&
+            (tens == 1 || tens == 2) &&
+            (groupLevel == 0 || groupLevel == -1) &&
             (hundreds == 0 && remainingNumber == 0)
           ) {
             retVal += '';
           } else {
-            retVal += this.digitFeminineStatus(parseInt(tens), groupLevel);
+            retVal += this.digitFeminineStatus(Math.trunc(tens), groupLevel);
           }
         }
       } else {
         const ones = tens % 10;
         tens = (tens / 10) - 2;
+
         if (ones > 0) {
           if (retVal != '' && tens < 4) {
             retVal += ' و ';
           }
+
           retVal += this.digitFeminineStatus(ones, groupLevel);
         }
         if (retVal != '' && ones != 0) {
           retVal += ' و ';
         }
-        retVal += this.arabicTens[parseInt(tens)];
+
+        retVal += this.arabicTens[Math.trunc(tens)];
       }
     }
+
     return retVal;
   }
 
@@ -113,19 +120,24 @@ export class Arabic extends AbstractLanguage {
     if (number == 0) {
       return this.zero;
     }
+
     let tempNumber = number;
     this.integerValue = number;
     let retVal = '';
     let group = 0;
+
     while (tempNumber > 0) {
-      const numberToProcess = parseInt(tempNumber % 1000);
-      tempNumber = parseInt(tempNumber / 1000);
+      const numberToProcess = tempNumber % 1000;
+      tempNumber = Math.trunc(tempNumber / 1000);
+
       const groupDescription = this.processArabicGroup(numberToProcess, group, Math.floor(tempNumber));
+
       if (groupDescription != '') {
         if (group > 0) {
           if (retVal != '') {
             retVal = ' و ' + retVal;
           }
+
           if (numberToProcess != 2) {
             if (numberToProcess % 100 != 1) {
               if (numberToProcess >= 3 && numberToProcess <= 10) {
@@ -142,10 +154,13 @@ export class Arabic extends AbstractLanguage {
             }
           }
         }
+
         retVal = groupDescription + ' ' + retVal;
       }
+
       group += 1;
     }
+
     return retVal.trim();
   }
 }
@@ -153,10 +168,10 @@ export class Arabic extends AbstractLanguage {
 /**
  * Converts a value to cardinal (written) form.
  * @param {number|string} value Number to be convert.
- * @param {object} options Options for class.
+ * @param {object} [options] Options for class.
  * @throws {Error} Value cannot be invalid.
  * @returns {string} Value in cardinal (written) format.
  */
-export default function(value, options) {
+export default function (value, options = {}) {
   return new Arabic(options).floatToCardinal(value);
 }

package/lib/i18n/az.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 N2WordsAZ extends BaseLanguage {
+    constructor(options: any);
+    merge(lPair: any, rPair: any): {
+        [x: string]: bigint;
+    };
+}
+import BaseLanguage from '../classes/BaseLanguage.js';

package/lib/i18n/az.js

@@ -39,8 +39,9 @@ export class N2WordsAZ extends BaseLanguage {
   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]);
+    const lNum = BigInt(Object.values(lPair)[0]);
+    const rNum = BigInt(Object.values(rPair)[0]);
+
     if (lNum == 1 && (rNum <= 100 || rNum == 1000)) {
       return { [rText]: rNum };
     } else if (rNum > lNum) {
@@ -54,10 +55,10 @@ export class N2WordsAZ extends BaseLanguage {
 /**
  * Converts a value to cardinal (written) form.
  * @param {number|string} value Number to be convert.
- * @param {object} options Options for class.
+ * @param {object} [options] Options for class.
  * @throws {Error} Value cannot be invalid.
  * @returns {string} Value in cardinal (written) format.
  */
-export default function(value, options) {
+export default function (value, options = {}) {
   return new N2WordsAZ(options).floatToCardinal(value);
 }

package/lib/i18n/cz.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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 N2WordsCZ extends N2WordsRU {
+    get separatorWord(): "celá" | "celé" | "celých";
+}
+import { N2WordsRU } from './ru.js';

package/lib/i18n/cz.js

@@ -1,4 +1,4 @@
-import {N2WordsRU} from './ru.js';
+import { N2WordsRU } from './ru.js';
 
 export class N2WordsCZ extends N2WordsRU {
   ones = {
@@ -125,10 +125,10 @@ export class N2WordsCZ extends N2WordsRU {
 /**
  * Converts a value to cardinal (written) form.
  * @param {number|string} value Number to be convert.
- * @param {object} options Options for class.
+ * @param {object} [options] Options for class.
  * @throws {Error} Value cannot be invalid.
  * @returns {string} Value in cardinal (written) format.
  */
-export default function(value, options) {
+export default function (value, options = {}) {
   return new N2WordsCZ(options).floatToCardinal(value);
 }

package/lib/i18n/de.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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 N2WordsDE extends BaseLanguage {
+    constructor(options: any);
+    merge(curr: any, next: any): {
+        [x: string]: bigint;
+    } | {
+        [x: string]: number;
+    };
+}
+import BaseLanguage from '../classes/BaseLanguage.js';

package/lib/i18n/de.js

@@ -51,8 +51,8 @@ export class N2WordsDE extends BaseLanguage {
   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]);
+    const cNum = BigInt(Object.values(curr)[0]);
+    const nNum = BigInt(Object.values(next)[0]);
     if (cNum == 1) {
       if (nNum == 100 || nNum == 1000) {
         return { [`ein${nText}`]: nNum };
@@ -96,10 +96,10 @@ export class N2WordsDE extends BaseLanguage {
 /**
  * Converts a value to cardinal (written) form.
  * @param {number|string} value Number to be convert.
- * @param {object} options Options for class.
+ * @param {object} [options] Options for class.
  * @throws {Error} Value cannot be invalid.
  * @returns {string} Value in cardinal (written) format.
  */
-export default function(value, options) {
+export default function (value, options = {}) {
   return new N2WordsDE(options).floatToCardinal(value);
 }

package/lib/i18n/dk.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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 N2WordsDK extends BaseLanguage {
+    constructor(options: any);
+    ordFlag: any;
+    merge(curr: any, next: any): any;
+}
+import BaseLanguage from '../classes/BaseLanguage.js';

package/lib/i18n/dk.js

@@ -58,8 +58,8 @@ export class N2WordsDK extends BaseLanguage {
   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]);
+    const cNum = BigInt(Object.values(curr)[0]);
+    const nNum = BigInt(Object.values(next)[0]);
     let val = 1;
     if (nNum == 100 || nNum == 1000) {
       next = { [`et${nText}`]: nNum };
@@ -101,10 +101,10 @@ export class N2WordsDK extends BaseLanguage {
 /**
  * Converts a value to cardinal (written) form.
  * @param {number|string} value Number to be convert.
- * @param {object} options Options for class.
+ * @param {object} [options] Options for class.
  * @throws {Error} Value cannot be invalid.
  * @returns {string} Value in cardinal (written) format.
  */
-export default function(value, options) {
+export default function (value, options = {}) {
   return new N2WordsDK(options).floatToCardinal(value);
 }

package/lib/i18n/en.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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;
+/**
+ * This class is for converting numbers to english words.
+ */
+export class English extends BaseLanguage {
+    constructor(options: any);
+    /**
+     * Merge word set pairs
+     * @param {object} lPair {'one':1}
+     * @param {object} rPair {'hundred':100}
+     * @returns {object} {'one hundred': 100}
+     */
+    merge(lPair: object, rPair: object): object;
+}
+import BaseLanguage from '../classes/BaseLanguage.js';

package/lib/i18n/en.js

@@ -75,10 +75,10 @@ export class English extends BaseLanguage {
 /**
  * Converts a value to cardinal (written) form.
  * @param {number|string} value Number to be convert.
- * @param {object} options Options for class.
+ * @param {object} [options] Options for class.
  * @throws {Error} Value cannot be invalid.
  * @returns {string} Value in cardinal (written) format.
  */
-export default function(value, options) {
+export default function (value, options = {}) {
   return new English(options).floatToCardinal(value);
 }

package/lib/i18n/es.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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 N2WordsES extends BaseLanguage {
+    constructor(options: any);
+    genderStem: any;
+    merge(curr: any, next: any): {
+        [x: string]: bigint;
+    };
+}
+import BaseLanguage from '../classes/BaseLanguage.js';

package/lib/i18n/es.js

@@ -63,12 +63,12 @@ export class N2WordsES extends BaseLanguage {
   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]);
+    const cNum = BigInt(Object.values(curr)[0]);
+    const nNum = BigInt(Object.values(next)[0]);
     if (cNum == 1) {
       if (nNum < 1000000) return { [nText]: nNum };
       cText = 'un';
-    } else if (cNum == 100 && nNum % 1000 != 0) {
+    } else if (cNum == 100 && nNum % 1000n != 0) {
       cText += 't' + this.genderStem;
     }
 
@@ -77,7 +77,7 @@ export class N2WordsES extends BaseLanguage {
         return { [`${cText} y ${nText}`]: cNum + nNum };
       }
       return { [`${cText} ${nText}`]: cNum + nNum };
-    } else if (nNum % 1000000 == 0 && cNum > 1) {
+    } else if (nNum % 1000000n == 0 && cNum > 1) {
       nText = nText.slice(0, -3) + 'lones';
     }
 
@@ -101,10 +101,10 @@ export class N2WordsES extends BaseLanguage {
 /**
  * Converts a value to cardinal (written) form.
  * @param {number|string} value Number to be convert.
- * @param {object} options Options for class.
+ * @param {object} [options] Options for class.
  * @throws {Error} Value cannot be invalid.
  * @returns {string} Value in cardinal (written) format.
  */
-export default function(value, options) {
+export default function (value, options = {}) {
   return new N2WordsES(options).floatToCardinal(value);
 }

package/lib/i18n/fa.d.ts

@@ -0,0 +1,54 @@
+/**
+ * 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 N2WordsFA extends AbstractLanguage {
+    constructor(options: any);
+    namedNumbers: {
+        0: string;
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+        10: string;
+        11: string;
+        12: string;
+        13: string;
+        14: string;
+        15: string;
+        16: string;
+        17: string;
+        18: string;
+        19: string;
+        20: string;
+        30: string;
+        40: string;
+        50: string;
+        60: string;
+        70: string;
+        80: string;
+        90: string;
+        100: string;
+        200: string;
+        300: string;
+        400: string;
+        500: string;
+        600: string;
+        700: string;
+        800: string;
+        900: string;
+        1000: string;
+        1000000: string;
+    };
+    toCardinal(number: any): any;
+}
+import AbstractLanguage from '../classes/AbstractLanguage.js';

package/lib/i18n/fa.js

@@ -95,10 +95,10 @@ export class N2WordsFA extends AbstractLanguage {
 /**
  * Converts a value to cardinal (written) form.
  * @param {number|string} value Number to be convert.
- * @param {object} options Options for class.
+ * @param {object} [options] Options for class.
  * @throws {Error} Value cannot be invalid.
  * @returns {string} Value in cardinal (written) format.
  */
-export default function(value, options) {
+export default function (value, options = {}) {
   return new N2WordsFA(options).floatToCardinal(value);
 }

package/lib/i18n/fr.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 N2WordsFR extends BaseLanguage {
+    constructor(options: any);
+    merge(curr: any, next: any): {
+        [x: string]: bigint;
+    };
+}
+import BaseLanguage from '../classes/BaseLanguage.js';

package/lib/i18n/fr.js

@@ -49,15 +49,15 @@ export class N2WordsFR extends BaseLanguage {
   merge(curr, next) { // {'cent':100}, {'vingt-cinq':25}
     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]);
+    const cNum = BigInt(Object.values(curr)[0]);
+    const nNum = BigInt(Object.values(next)[0]);
     if (cNum == 1) {
       if (nNum < 1000000) {
         return { [nText]: nNum };
       }
     } else {
       if (
-        ((cNum - 80) % 100 == 0 || (cNum % 100 == 0 && cNum < 1000)) &&
+        ((cNum - 80n) % 100n == 0 || (cNum % 100n == 0 && cNum < 1000)) &&
         nNum < 1000000 &&
         cText[cText.length - 1] == 's'
       ) {
@@ -66,13 +66,13 @@ export class N2WordsFR extends BaseLanguage {
       if (
         cNum < 1000 && nNum != 1000 &&
         nText[nText.length - 1] != 's' &&
-        nNum % 100 == 0
+        nNum % 100n == 0
       ) {
         nText += 's';
       }
     }
     if (nNum < cNum && cNum < 100) {
-      if (nNum % 10 == 1 && cNum != 80) return { [`${cText} et ${nText}`]: cNum + nNum };
+      if (nNum % 10n == 1 && cNum != 80) return { [`${cText} et ${nText}`]: cNum + nNum };
       return { [`${cText}-${nText}`]: cNum + nNum };
     }
     if (nNum > cNum) return { [`${cText} ${nText}`]: cNum * nNum };
@@ -83,10 +83,10 @@ export class N2WordsFR extends BaseLanguage {
 /**
  * Converts a value to cardinal (written) form.
  * @param {number|string} value Number to be convert.
- * @param {object} options Options for class.
+ * @param {object} [options] Options for class.
  * @throws {Error} Value cannot be invalid.
  * @returns {string} Value in cardinal (written) format.
  */
-export default function(value, options) {
+export default function (value, options = {}) {
   return new N2WordsFR(options).floatToCardinal(value);
 }