n2words 1.20.0 → 1.22.0

package/lib/i18n/ro.js

@@ -0,0 +1,360 @@
+import AbstractLanguage from '../classes/abstract-language.js';
+
+export class N2WordsRO extends AbstractLanguage {
+  /** @type {boolean} */
+  feminine;
+
+  /** @type {object} */
+  ones = {
+    1: 'unu',
+    2: 'doi',
+    3: 'trei',
+    4: 'patru',
+    5: 'cinci',
+    6: 'șase',
+    7: 'șapte',
+    8: 'opt',
+    9: 'nouă'
+  };
+
+  /** @type {object} */
+  onesFeminine = {
+    1: 'una',
+    2: 'două',
+    3: 'trei',
+    4: 'patru',
+    5: 'cinci',
+    6: 'șase',
+    7: 'șapte',
+    8: 'opt',
+    9: 'nouă'
+  };
+
+  /** @type {object} */
+  tens = {
+    0: 'zece',
+    1: 'unsprezece',
+    2: 'douăsprezece',
+    3: 'treisprezece',
+    4: 'paisprezece',
+    5: 'cincisprezece',
+    6: 'șaisprezece',
+    7: 'șaptesprezece',
+    8: 'optsprezece',
+    9: 'nouăsprezece'
+  };
+
+  /** @type {object} */
+  tensMasculine = {
+    0: 'zece',
+    1: 'unsprezece',
+    2: 'doisprezece',
+    3: 'treisprezece',
+    4: 'paisprezece',
+    5: 'cincisprezece',
+    6: 'șaisprezece',
+    7: 'șaptesprezece',
+    8: 'optsprezece',
+    9: 'nouăsprezece'
+  };
+
+  /** @type {object} */
+  twenties = {
+    2: 'douăzeci',
+    3: 'treizeci',
+    4: 'patruzeci',
+    5: 'cincizeci',
+    6: 'șaizeci',
+    7: 'șaptezeci',
+    8: 'optzeci',
+    9: 'nouăzeci'
+  };
+
+  /** @type {object} */
+  hundreds = {
+    1: 'o sută',
+    2: 'două sute',
+    3: 'trei sute',
+    4: 'patru sute',
+    5: 'cinci sute',
+    6: 'șase sute',
+    7: 'șapte sute',
+    8: 'opt sute',
+    9: 'nouă sute'
+  };
+
+  /**
+   * 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: 'mie', plural: 'mii', feminine: true, needsDe: true },          // 10^3
+    2: { singular: 'milion', plural: 'milioane', feminine: false, needsDe: true }, // 10^6
+    3: { singular: 'miliard', plural: 'miliarde', feminine: false, needsDe: true },// 10^9
+    4: { singular: 'trilion', plural: 'trilioane', feminine: false, needsDe: true }, // 10^12
+    5: { singular: 'cvadrilion', plural: 'cvadrilioane', feminine: false, needsDe: true }, // 10^15
+    6: { singular: 'cvintilion', plural: 'cvintilioane', feminine: false, needsDe: true }, // 10^18
+    7: { singular: 'sextilion', plural: 'sextilioane', feminine: false, needsDe: true }, // 10^21
+    8: { singular: 'septilion', plural: 'septilioane', feminine: false, needsDe: true }, // 10^24
+  };
+
+  constructor(options) {
+    options = Object.assign({
+      negativeWord: 'minus',
+      separatorWord: 'virgulă',
+      zero: 'zero',
+      feminine: false
+    }, options);
+
+    super(options);
+    this.feminine = options.feminine;
+  }
+
+  toCardinal(number) {
+    if (number == 0) {
+      return this.zero;
+    }
+
+    const words = [];
+    const chunks = this.splitByX(number.toString(), 3);
+    let index = chunks.length;
+
+    for (const x of chunks) {
+      let onesMap = [];
+      index = index - 1;
+
+      if (x == 0n) continue;
+
+      const [n1, n2, n3] = this.getDigits(x); // units, tens, hundreds (as BigInt)
+
+      // hundreds (only for the last group, not for thousands)
+      if (n3 > 0n && index === 0) {
+        words.push(this.hundreds[Number(n3)]);
+      }
+
+      // tens & teens (only for the last group, not for thousands)
+      if (index === 0) {
+        if (n2 > 1n) {
+          words.push(this.twenties[Number(n2)]);
+        }
+
+        if (n2 == 1n) {
+          words.push(this.tens[Number(n1)]);
+        } else if (n1 > 0n) {
+          // pick masculine/feminine units (only for the last group, not for thousands)
+          const feminineUnits = this.feminine && index === 0;
+          onesMap = feminineUnits ? this.onesFeminine : this.ones;
+
+          // if there is a twenty/treizeci/etc AND ones > 0 → add "și"
+          if (n2 > 1n) words.push('și');
+          words.push(onesMap[Number(n1)]);
+        }
+      }
+
+      // big unit name (mie/mii, milion/milioane, …)
+      if (index > 0) {
+        const form = this.thousands[index];
+        if (form) {
+          words.push(this.romanianPluralize(x, form));
+        } else {
+          // For very large numbers beyond our defined units, just spell out the number
+          words.push(this.spellUnder1000(Number(x), true));
+        }
+      }
+    }
+
+    return words.join(' ').replaceAll(/\s+/g, ' ').trim();
+  }
+
+  /**
+   * 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, x) {
+    const results = [];
+    const l = n.length;
+    let result;
+
+    if (l > x) {
+      const start = l % x;
+      if (start > 0) {
+        result = n.slice(0, start);
+        results.push(BigInt(result));
+      }
+      for (let index = start; index < l; index += x) {
+        result = n.slice(index, index + x);
+        results.push(BigInt(result));
+      }
+    } else {
+      results.push(BigInt(n));
+    }
+    return results;
+  }
+
+  getDigits(value) {
+    // returns [units, tens, hundreds] as BigInt
+    const stringValue = value.toString().padStart(3, '0').slice(-3);
+    const a = [...stringValue].toReversed();
+    return a.map(BigInt);
+  }
+
+  /**
+   * 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, form) {
+    const n = Number(chunk);
+
+    if (n === 1) {
+      // article differs for feminine "mie" (o mie) vs the rest (un milion/miliard…)
+      const article = form.feminine ? 'o' : 'un';
+      return `${article} ${form.singular}`;
+    }
+
+    // For 21 with big units, use feminine "una" with plural nouns
+    if (n === 21 && form.needsDe) {
+      return `douăzeci și una de ${form.plural}`;
+    }
+
+    // spell the chunk itself (use feminine units for big numbers)
+    const words = this.spellUnder1000(n, true);
+
+    // "de" after >= 20 (covers 20, 21, 100, 101, 999, etc.)
+    const needsDe = form.needsDe && n >= 20;
+    const de = needsDe ? ' de ' : ' ';
+
+    return `${words}${de}${form.plural}`;
+  }
+
+  spellUnder100(n, feminineUnits = false) {
+    if (n < 10) {
+      return (feminineUnits ? this.onesFeminine : this.ones)[n];
+    }
+    if (n < 20) {
+      return this.tens[n - 10];
+    }
+    const t = Math.floor(n / 10);
+    const u = n % 10;
+    return u
+      ? `${this.twenties[t]} și ${(feminineUnits ? this.onesFeminine : this.ones)[u]}`
+      : this.twenties[t];
+  }
+
+  spellUnder1000(n, feminineUnits = false) {
+    if (n < 100) return this.spellUnder100(n, feminineUnits);
+    const h = Math.floor(n / 100);
+    const r = n % 100;
+    const hundredWords = this.hundreds[h];
+    if (!r) return hundredWords;
+    // Standard readable form: "o sută unu" (for units) or "o sută cincizeci" (for tens)
+    const separator = r < 20 ? ' ' : ' ';
+    return `${hundredWords}${separator}${this.spellUnder100(r, feminineUnits)}`;
+  }
+
+  /**
+   * Override decimalToCardinal to use masculine forms for decimal places
+   * @param {string} decimal Decimal string to convert
+   * @returns {string} Value in written format
+   */
+  decimalToCardinal(decimal) {
+    const words = [];
+
+    // Split decimal string into an array of characters
+    const chars = [...decimal];
+
+    // Loop through characters adding leading zeros to words array
+    let index = 0;
+    while (index < chars.length && chars[index] === '0') {
+      words.push(this.zero);
+      index++;
+    }
+
+    // Prevent further processing if entire string was zeros
+    if (index === chars.length) {
+      return words;
+    }
+
+    // Convert and add remaining using masculine forms for decimal places
+    const decimalNumber = BigInt(decimal);
+    const masculineWords = this.toCardinalWithMasculine(decimalNumber);
+    return [...words, masculineWords];
+  }
+
+  /**
+   * Convert number to cardinal form using masculine units
+   * @param {bigint} number Number to convert
+   * @returns {string} Value in written format
+   */
+  toCardinalWithMasculine(number) {
+    if (number == 0) {
+      return this.zero;
+    }
+
+    const words = [];
+    const chunks = this.splitByX(number.toString(), 3);
+    let index = chunks.length;
+
+    for (const x of chunks) {
+      let onesMap = [];
+      index = index - 1;
+
+      if (x == 0n) continue;
+
+      const [n1, n2, n3] = this.getDigits(x); // units, tens, hundreds (as BigInt)
+
+      // hundreds
+      if (n3 > 0n) {
+        words.push(this.hundreds[Number(n3)]);
+      }
+
+      // tens & teens
+      if (n2 > 1n) {
+        words.push(this.twenties[Number(n2)]);
+      }
+
+      if (n2 == 1n) {
+        words.push(this.tensMasculine[Number(n1)]);
+      } else if (n1 > 0n) {
+        // Always use masculine units for decimal places
+        onesMap = this.ones;
+
+        // if there is a twenty/treizeci/etc AND ones > 0 → add "și"
+        if (n2 > 1n) words.push('și');
+        words.push(onesMap[Number(n1)]);
+      }
+
+      // big unit name (mie/mii, milion/milioane, …)
+      if (index > 0) {
+        const form = this.thousands[index];
+        if (form) {
+          words.push(this.romanianPluralize(x, form));
+        } else {
+          // For very large numbers beyond our defined units, just spell out the number
+          words.push(this.spellUnder1000(Number(x), false));
+        }
+      }
+    }
+
+    return words.join(' ').replaceAll(/\s+/g, ' ').trim();
+  }
+}
+
+/**
+ * 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, options = {}) {
+  return new N2WordsRO(options).floatToCardinal(value);
+}

package/lib/i18n/ru.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 N2WordsRU extends AbstractLanguage {
     constructor(options: any);
     /** @type {boolean} */
@@ -24,7 +24,7 @@ export class N2WordsRU extends AbstractLanguage {
     thousands: object;
     toCardinal(number: any): string;
     splitByX(n: any, x: any): bigint[];
-    getDigits(value: any): bigint[];
+    getDigits(value: any): any;
     pluralize(n: any, forms: any): any;
 }
-import AbstractLanguage from '../classes/AbstractLanguage.js';
+import AbstractLanguage from '../classes/abstract-language.js';

package/lib/i18n/ru.js

@@ -1,4 +1,4 @@
-import AbstractLanguage from '../classes/AbstractLanguage.js';
+import AbstractLanguage from '../classes/abstract-language.js';
 
 export class N2WordsRU extends AbstractLanguage {
   /** @type {boolean} */
@@ -105,12 +105,11 @@ export class N2WordsRU extends AbstractLanguage {
 
     const chunks = this.splitByX(number.toString(), 3);
 
-    let i = chunks.length;
+    let index = chunks.length;
 
-    for (let j = 0; j < chunks.length; j++) {
-      const x = chunks[j];
+    for (const x of chunks) {
       let ones = [];
-      i = i - 1;
+      index = index - 1;
 
       if (x == 0) {
         continue;
@@ -129,12 +128,12 @@ export class N2WordsRU extends AbstractLanguage {
       if (n2 == 1) {
         words.push(this.tens[n1]);
       } else if (n1 > 0) {
-        ones = (i == 1 || this.feminine && i == 0) ? this.onesFeminine : this.ones;
+        ones = (index == 1 || this.feminine && index == 0) ? this.onesFeminine : this.ones;
         words.push(ones[n1]);
       }
 
-      if (i > 0) {
-        words.push(this.pluralize(x, this.thousands[i]));
+      if (index > 0) {
+        words.push(this.pluralize(x, this.thousands[index]));
       }
     }
 
@@ -155,8 +154,8 @@ export class N2WordsRU extends AbstractLanguage {
         results.push(BigInt(result));
       }
 
-      for (let i = start; i < l; i += x) {
-        result = n.slice(i, i + x);
+      for (let index = start; index < l; index += x) {
+        result = n.slice(index, index + x);
 
         results.push(BigInt(result));
       }
@@ -168,8 +167,10 @@ export class N2WordsRU extends AbstractLanguage {
   }
 
   getDigits(value) {
-    const a = Array.from(value.toString().padStart(3, '0').slice(-3)).reverse();
-    return a.map(e => BigInt(e));
+    // TODO ESLint suggestion
+    // eslint-disable-next-line unicorn/no-useless-spread
+    const a = [...value.toString().padStart(3, '0').slice(-3)].toReversed();
+    return a.map(BigInt);
   }
 
   pluralize(n, forms) {
@@ -189,9 +190,9 @@ export class N2WordsRU extends AbstractLanguage {
  * 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 N2WordsRU(options).floatToCardinal(value);
 }

package/lib/i18n/sr.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 N2WordsSR extends N2WordsRU {
     ones: {
         1: string[];

package/lib/i18n/sr.js

@@ -89,10 +89,9 @@ export class N2WordsSR 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; }
       const [n1, n2, n3] = this.getDigits(x);
       if (n3 > 0) {
@@ -104,12 +103,12 @@ export class N2WordsSR extends N2WordsRU {
       if (n2 == 1) {
         words.push(this.tens[n1]);
       } else if (n1 > 0) {
-        const isFeminine = (this.feminine || this.SCALE[i][3]);
-        const genderIdx = isFeminine ? 1 : 0;
-        words.push(this.ones[n1][genderIdx]);
+        const isFeminine = (this.feminine || this.SCALE[index][3]);
+        const genderIndex = isFeminine ? 1 : 0;
+        words.push(this.ones[n1][genderIndex]);
       }
-      if ((i > 0) && (x != 0)) {
-        words.push(this.pluralize(x, this.SCALE[i]));
+      if ((index > 0) && (x != 0)) {
+        words.push(this.pluralize(x, this.SCALE[index]));
       }
     }
     return words.join(' ');
@@ -120,9 +119,9 @@ export class N2WordsSR 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 N2WordsSR(options).floatToCardinal(value);
 }

package/lib/i18n/tr.d.ts

@@ -2,14 +2,14 @@
  * 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 N2WordsTR extends BaseLanguage {
     constructor(options?: {});
     merge(lPair: any, rPair: any): {
         [x: string]: bigint;
     };
 }
-import BaseLanguage from '../classes/BaseLanguage.js';
+import BaseLanguage from '../classes/base-language.js';

package/lib/i18n/tr.js

@@ -1,4 +1,4 @@
-import BaseLanguage from '../classes/BaseLanguage.js';
+import BaseLanguage from '../classes/base-language.js';
 
 export class N2WordsTR extends BaseLanguage {
   constructor(options = {}) {
@@ -8,11 +8,11 @@ export class N2WordsTR extends BaseLanguage {
       zero: 'sıfır',
       spaceSeparator: (options.dropSpaces === true ? '' : ' '),
     }, options), [
-      [1000000000000000000n, 'kentilyon'],
-      [1000000000000000n, 'katrilyon'],
-      [1000000000000n, 'trilyon'],
-      [1000000000n, 'milyar'],
-      [1000000n, 'milyon'],
+      [1_000_000_000_000_000_000n, 'kentilyon'],
+      [1_000_000_000_000_000n, 'katrilyon'],
+      [1_000_000_000_000n, 'trilyon'],
+      [1_000_000_000n, 'milyar'],
+      [1_000_000n, 'milyon'],
       [1000n, 'bin'],
       [100n, 'yüz'],
       [90n, 'doksan'],
@@ -40,14 +40,14 @@ export class N2WordsTR extends BaseLanguage {
   merge(lPair, rPair) {
     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 || rNum == 1000)) {
-      return { [rText]: rNum };
-    } else if (rNum > lNum) {
-      return { [`${lText}${this.spaceSeparator}${rText}`]: lNum * rNum };
+    const lNumber = BigInt(Object.values(lPair)[0]);
+    const rNumber = BigInt(Object.values(rPair)[0]);
+    if (lNumber == 1 && (rNumber <= 100 || rNumber == 1000)) {
+      return { [rText]: rNumber };
+    } else if (rNumber > lNumber) {
+      return { [`${lText}${this.spaceSeparator}${rText}`]: lNumber * rNumber };
     } else {
-      return { [`${lText}${this.spaceSeparator}${rText}`]: lNum + rNum };
+      return { [`${lText}${this.spaceSeparator}${rText}`]: lNumber + rNumber };
     }
   }
 }
@@ -56,9 +56,9 @@ export class N2WordsTR 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 N2WordsTR(options).floatToCardinal(value);
 }

package/lib/i18n/uk.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 N2WordsUK extends N2WordsRU {
     ones: {
         1: string;

package/lib/i18n/uk.js

@@ -87,9 +87,9 @@ export class N2WordsUK 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 N2WordsUK(options).floatToCardinal(value);
 }

package/lib/i18n/vi.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 N2WordsID extends AbstractLanguage {
     constructor(options: any);
     base: {
@@ -67,4 +67,4 @@ export class N2WordsID extends AbstractLanguage {
     convertMore1000(number: any): any;
     toCardinal(number: any): any;
 }
-import AbstractLanguage from '../classes/AbstractLanguage.js';
+import AbstractLanguage from '../classes/abstract-language.js';

package/lib/i18n/vi.js

@@ -1,4 +1,4 @@
-import AbstractLanguage from '../classes/AbstractLanguage.js';
+import AbstractLanguage from '../classes/abstract-language.js';
 
 export class N2WordsID extends AbstractLanguage {
   base = {
@@ -133,11 +133,7 @@ export class N2WordsID extends AbstractLanguage {
       if (number < 100n) {
         return this.convertLess100(Number(number));
       } else {
-        if (number < 1000n) {
-          return this.convertLess1000(Number(number));
-        } else { // number >= 1000
-          return this.convertMore1000(number);
-        }
+        return (number < 1000n ? this.convertLess1000(Number(number)) : this.convertMore1000(number));
       }
     }
   }
@@ -147,9 +143,9 @@ export class N2WordsID extends AbstractLanguage {
  * 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 N2WordsID(options).floatToCardinal(value);
 }