n2words 1.20.0 → 1.22.0

package/lib/i18n/no.js

@@ -1,4 +1,4 @@
-import BaseLanguage from '../classes/BaseLanguage.js';
+import BaseLanguage from '../classes/base-language.js';
 
 export class N2WordsNO extends BaseLanguage {
   constructor(options) {
@@ -9,16 +9,16 @@ export class N2WordsNO extends BaseLanguage {
     }, options);
 
     super(options, [
-      [1000000000000000000000000000000000n, 'quintillard'],
-      [1000000000000000000000000000000n, 'quintillion'],
-      [1000000000000000000000000000n, 'quadrillard'],
-      [1000000000000000000000000n, 'quadrillion'],
-      [1000000000000000000000n, 'trillard'],
-      [1000000000000000000n, 'trillion'],
-      [1000000000000000n, 'billard'],
-      [1000000000000n, 'billion'],
-      [1000000000n, 'millard'],
-      [1000000n, 'million'],
+      [1_000_000_000_000_000_000_000_000_000_000_000n, 'quintillard'],
+      [1_000_000_000_000_000_000_000_000_000_000n, 'quintillion'],
+      [1_000_000_000_000_000_000_000_000_000n, 'quadrillard'],
+      [1_000_000_000_000_000_000_000_000n, 'quadrillion'],
+      [1_000_000_000_000_000_000_000n, 'trillard'],
+      [1_000_000_000_000_000_000n, 'trillion'],
+      [1_000_000_000_000_000n, 'billard'],
+      [1_000_000_000_000n, 'billion'],
+      [1_000_000_000n, 'millard'],
+      [1_000_000n, 'million'],
       [1000n, 'tusen'],
       [100n, 'hundre'],
       [90n, 'nitti'],
@@ -55,13 +55,13 @@ export class N2WordsNO extends BaseLanguage {
   merge(lPair, rPair) { // {'one':1}, {'hundred':100}
     const lText = Object.keys(lPair)[0];
     const rText = Object.keys(rPair)[0];
-    const lNum = BigInt(Object.values(lPair)[0]);
-    const rNum = BigInt(Object.values(rPair)[0]);
-    if (lNum == 1 && rNum < 100) return { [rText]: rNum };
-    else if (lNum < 100 && lNum > rNum) return { [`${lText}-${rText}`]: lNum + rNum };
-    else if (lNum >= 100 && rNum < 100) return { [`${lText} og ${rText}`]: lNum + rNum };
-    else if (rNum > lNum) return { [`${lText} ${rText}`]: lNum * rNum };
-    return { [`${lText}, ${rText}`]: lNum + rNum };
+    const lNumber = BigInt(Object.values(lPair)[0]);
+    const rNumber = BigInt(Object.values(rPair)[0]);
+    if (lNumber == 1 && rNumber < 100) return { [rText]: rNumber };
+    else if (lNumber < 100 && lNumber > rNumber) return { [`${lText}-${rText}`]: lNumber + rNumber };
+    else if (lNumber >= 100 && rNumber < 100) return { [`${lText} og ${rText}`]: lNumber + rNumber };
+    else if (rNumber > lNumber) return { [`${lText} ${rText}`]: lNumber * rNumber };
+    return { [`${lText}, ${rText}`]: lNumber + rNumber };
   }
 }
 
@@ -69,9 +69,9 @@ export class N2WordsNO extends BaseLanguage {
  * Converts a value to cardinal (written) form.
  * @param {number|string|bigint} value Number to be convert.
  * @param {object} [options] Options for class.
- * @throws {Error} Value cannot be invalid.
  * @returns {string} Value in cardinal (written) format.
+ * @throws {Error} Value cannot be invalid.
  */
-export default function (value, options = {}) {
+export default function floatToCardinal (value, options = {}) {
   return new N2WordsNO(options).floatToCardinal(value);
 }

package/lib/i18n/pl.d.ts

@@ -2,10 +2,10 @@
  * Converts a value to cardinal (written) form.
  * @param {number|string|bigint} value Number to be convert.
  * @param {object} [options] Options for class.
- * @throws {Error} Value cannot be invalid.
  * @returns {string} Value in cardinal (written) format.
+ * @throws {Error} Value cannot be invalid.
  */
-export default function _default(value: number | string | bigint, options?: object): string;
+export default function floatToCardinal(value: number | string | bigint, options?: object): string;
 export class N2WordsPL extends N2WordsRU {
     ones: {
         1: string;

package/lib/i18n/pl.js

@@ -88,10 +88,9 @@ export class N2WordsPL extends N2WordsRU {
     }
     const words = [];
     const chunks = this.splitByX(number.toString(), 3);
-    let i = chunks.length;
-    for (let j = 0; j < chunks.length; j++) {
-      const x = chunks[j];
-      i = i - 1;
+    let index = chunks.length;
+    for (const x of chunks) {
+      index = index - 1;
       if (x == 0) {
         continue;
       }
@@ -104,11 +103,11 @@ export class N2WordsPL extends N2WordsRU {
       }
       if (n2 == 1) {
         words.push(this.tens[n1]);
-      } else if (n1 > 0 && !(i > 0 && x == 1)) {
+      } else if (n1 > 0 && !(index > 0 && x == 1)) {
         words.push(this.ones[n1]);
       }
-      if (i > 0) {
-        words.push(this.pluralize(x, this.thousands[i]));
+      if (index > 0) {
+        words.push(this.pluralize(x, this.thousands[index]));
       }
     }
     return words.join(' ');
@@ -119,9 +118,9 @@ export class N2WordsPL extends N2WordsRU {
  * Converts a value to cardinal (written) form.
  * @param {number|string|bigint} value Number to be convert.
  * @param {object} [options] Options for class.
- * @throws {Error} Value cannot be invalid.
  * @returns {string} Value in cardinal (written) format.
+ * @throws {Error} Value cannot be invalid.
  */
-export default function (value, options = {}) {
+export default function floatToCardinal (value, options = {}) {
   return new N2WordsPL(options).floatToCardinal(value);
 }

package/lib/i18n/pt.d.ts

@@ -2,10 +2,10 @@
  * Converts a value to cardinal (written) form.
  * @param {number|string|bigint} value Number to be convert.
  * @param {object} [options] Options for class.
- * @throws {Error} Value cannot be invalid.
  * @returns {string} Value in cardinal (written) format.
+ * @throws {Error} Value cannot be invalid.
  */
-export default function _default(value: number | string | bigint, options?: object): string;
+export default function floatToCardinal(value: number | string | bigint, options?: object): string;
 export class N2WordsPT extends BaseLanguage {
     constructor(options: any);
     hundreds: {
@@ -19,8 +19,8 @@ export class N2WordsPT extends BaseLanguage {
         8: string;
         9: string;
     };
-    merge(curr: any, next: any): {
+    merge(current: any, next: any): {
         [x: string]: bigint;
     };
 }
-import BaseLanguage from '../classes/BaseLanguage.js';
+import BaseLanguage from '../classes/base-language.js';

package/lib/i18n/pt.js

@@ -1,4 +1,4 @@
-import BaseLanguage from '../classes/BaseLanguage.js';
+import BaseLanguage from '../classes/base-language.js';
 
 export class N2WordsPT extends BaseLanguage {
   hundreds = {
@@ -21,10 +21,10 @@ export class N2WordsPT extends BaseLanguage {
     }, options);
 
     super(options, [
-      [1000000000000000000000000n, 'quatrilião'],
-      [1000000000000000000n, 'trilião'],
-      [1000000000000n, 'bilião'],
-      [1000000n, 'milião'],
+      [1_000_000_000_000_000_000_000_000n, 'quatrilião'],
+      [1_000_000_000_000_000_000n, 'trilião'],
+      [1_000_000_000_000n, 'bilião'],
+      [1_000_000n, 'milião'],
       [1000n, 'mil'],
       [100n, 'cem'],
       [90n, 'noventa'],
@@ -61,48 +61,48 @@ export class N2WordsPT extends BaseLanguage {
   postClean(words) {
     const transforms = ['mil', 'milhão', 'milhões', 'mil milhões', 'bilião', 'biliões', 'mil biliões'];
 
-    transforms.forEach(transform => {
-      if (words.match(new RegExp(`.*${transform} e \\w*entos? (?=.*e)`))) {
-        words = words.replace(new RegExp(`${transform} e`, 'g'), `${transform}`);
+    for (const transform of transforms) {
+      if (new RegExp(`.*${transform} e \\w*entos? (?=.*e)`).test(words)) {
+        words = words.replaceAll(new RegExp(`${transform} e`, 'g'), `${transform}`);
       }
-    });
+    }
 
     return words;
   }
 
-  merge(curr, next) {
-    let cText = Object.keys(curr)[0];
+  merge(current, next) {
+    let cText = Object.keys(current)[0];
     let nText = Object.keys(next)[0];
-    const cNum = BigInt(Object.values(curr)[0]);
-    const nNum = BigInt(Object.values(next)[0]);
+    const cNumber = BigInt(Object.values(current)[0]);
+    const nNumber = BigInt(Object.values(next)[0]);
 
-    if (cNum == 1) {
-      if (nNum < 1000000) return { [nText]: nNum };
+    if (cNumber == 1) {
+      if (nNumber < 1_000_000) return { [nText]: nNumber };
       cText = 'um';
-    } else if (cNum == 100 && nNum % 1000n != 0) {
+    } else if (cNumber == 100 && nNumber % 1000n != 0) {
       cText = 'cento';
     }
 
-    if (nNum < cNum) {
+    if (nNumber < cNumber) {
       // if (cNum < 100) {
       //   return { [`${cText} e ${nText}`]: cNum + nNum }
       // }
-      return { [`${cText} e ${nText}`]: cNum + nNum };
-    } else if (nNum % 1000000000n == 0 && cNum > 1) {
+      return { [`${cText} e ${nText}`]: cNumber + nNumber };
+    } else if (nNumber % 1_000_000_000n == 0 && cNumber > 1) {
       nText = nText.slice(0, -4) + 'liões';
-    } else if (nNum % 1000000n == 0 && cNum > 1) {
+    } else if (nNumber % 1_000_000n == 0 && cNumber > 1) {
       nText = nText.slice(0, -4) + 'lhões';
     }
 
     if (nText == 'milião') nText = 'milhão';
 
-    if (nNum == 100) {
-      cText = this.hundreds[cNum];
+    if (nNumber == 100) {
+      cText = this.hundreds[cNumber];
       nText = '';
     } else {
       nText = ' ' + nText;
     }
-    return { [`${cText}${nText}`]: cNum * nNum };
+    return { [`${cText}${nText}`]: cNumber * nNumber };
   }
 }
 
@@ -110,9 +110,9 @@ export class N2WordsPT extends BaseLanguage {
  * Converts a value to cardinal (written) form.
  * @param {number|string|bigint} value Number to be convert.
  * @param {object} [options] Options for class.
- * @throws {Error} Value cannot be invalid.
  * @returns {string} Value in cardinal (written) format.
+ * @throws {Error} Value cannot be invalid.
  */
-export default function (value, options = {}) {
+export default function floatToCardinal (value, options = {}) {
   return new N2WordsPT(options).floatToCardinal(value);
 }

package/lib/i18n/ro.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Converts a value to cardinal (written) form.
+ * @param {number|string|bigint} value Number to be convert.
+ * @param {object} [options] Options for class.
+ * @returns {string} Value in cardinal (written) format.
+ */
+export default function floatToCardinal(value: number | string | bigint, options?: object): string;
+export class N2WordsRO extends AbstractLanguage {
+    constructor(options: any);
+    /** @type {boolean} */
+    feminine: boolean;
+    /** @type {object} */
+    ones: object;
+    /** @type {object} */
+    onesFeminine: object;
+    /** @type {object} */
+    tens: object;
+    /** @type {object} */
+    tensMasculine: object;
+    /** @type {object} */
+    twenties: object;
+    /** @type {object} */
+    hundreds: object;
+    /**
+     * Romanian big units.
+     * For each power group we keep: singular, plural, feminineUnits?, needsDe?
+     * - 10^3: mie/mii (feminine units in chunk; "de" for chunk >= 20)
+     * - 10^6: milion/milioane ("de" for chunk >= 20)
+     * - 10^9: miliard/miliarde ("de" for chunk >= 20)
+     */
+    thousands: {
+        1: {
+            singular: string;
+            plural: string;
+            feminine: boolean;
+            needsDe: boolean;
+        };
+        2: {
+            singular: string;
+            plural: string;
+            feminine: boolean;
+            needsDe: boolean;
+        };
+        3: {
+            singular: string;
+            plural: string;
+            feminine: boolean;
+            needsDe: boolean;
+        };
+        4: {
+            singular: string;
+            plural: string;
+            feminine: boolean;
+            needsDe: boolean;
+        };
+        5: {
+            singular: string;
+            plural: string;
+            feminine: boolean;
+            needsDe: boolean;
+        };
+        6: {
+            singular: string;
+            plural: string;
+            feminine: boolean;
+            needsDe: boolean;
+        };
+        7: {
+            singular: string;
+            plural: string;
+            feminine: boolean;
+            needsDe: boolean;
+        };
+        8: {
+            singular: string;
+            plural: string;
+            feminine: boolean;
+            needsDe: boolean;
+        };
+    };
+    toCardinal(number: any): any;
+    /**
+     * Split numeric string into BigInt groups of size x from left to right.
+     * @param {string} n - The numeric string to split
+     * @param {number} x - The size of each group
+     * @returns {bigint[]} Array of BigInt groups
+     */
+    splitByX(n: string, x: number): bigint[];
+    getDigits(value: any): any;
+    /**
+     * Romanian pluralization & "de" rule for big units.
+     * - 1 → singular with article ("o mie", "un milion", "un miliard", …)
+     * - otherwise → spell chunk + (optional "de") + plural
+     * "de" is inserted when chunk >= 20 (e.g., "douăzeci de mii/milioane/miliarde").
+     * @param {bigint} chunk - The chunk value
+     * @param {object} form - The form object with singular, plural, feminine, needsDe properties
+     * @returns {string} The pluralized form
+     */
+    romanianPluralize(chunk: bigint, form: object): string;
+    spellUnder100(n: any, feminineUnits?: boolean): any;
+    spellUnder1000(n: any, feminineUnits?: boolean): any;
+    /**
+     * Convert number to cardinal form using masculine units
+     * @param {bigint} number Number to convert
+     * @returns {string} Value in written format
+     */
+    toCardinalWithMasculine(number: bigint): string;
+}
+import AbstractLanguage from '../classes/abstract-language.js';