n2words 1.23.1 → 2.0.0

package/lib/languages/ro.d.ts

@@ -0,0 +1,158 @@
+/**
+ * Romanian language converter.
+ *
+ * Supports:
+ * - Gender agreement (unu/una, doi/două)
+ * - Complex pluralization (singular/plural forms)
+ * - "De" preposition insertion for groups >= 20
+ */
+export class Romanian extends AbstractLanguage {
+    constructor(options?: {});
+    onesWords: {
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    onesFeminineWords: {
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    teensWords: {
+        0: string;
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    teensMasculineWords: {
+        0: string;
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    twentiesWords: {
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    hundredsWords: {
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    /**
+     * Romanian big units.
+     * For each power group we keep: singular, plural, feminineUnits?, needsDe?
+     * - 10^3: mie/mii (feminine units in segment; "de" for segment >= 20)
+     * - 10^6: milion/milioane ("de" for segment >= 20)
+     * - 10^9: miliard/miliarde ("de" for segment >= 20)
+     */
+    scaleMetadata: {
+        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;
+        };
+        9: {
+            singular: string;
+            plural: string;
+            feminine: boolean;
+            needsDe: boolean;
+        };
+        10: {
+            singular: string;
+            plural: string;
+            feminine: boolean;
+            needsDe: boolean;
+        };
+    };
+    /** Split numeric string into BigInt segments of specified size from left to right. */
+    splitToSegments(n: any, x: any): bigint[];
+    extractDigits(value: any): any;
+    /** Romanian pluralization & "de" rule for big units. */
+    romanianPluralize(segment: any, form: any): string;
+    spellUnder100(n: any, feminineUnits?: boolean, masculineTeens?: boolean): any;
+    spellUnder1000(n: any, feminineUnits?: boolean, masculineTeens?: boolean): any;
+    /** Decimals always use masculine forms regardless of gender option. */
+    decimalIntegerToWords(integerPart: any): any;
+    integerToWords(integerPart: any): string;
+}
+import { AbstractLanguage } from '../classes/abstract-language.js';

package/lib/languages/ro.js

@@ -0,0 +1,273 @@
+import { AbstractLanguage } from '../classes/abstract-language.js'
+
+/**
+ * Romanian language converter.
+ *
+ * Supports:
+ * - Gender agreement (unu/una, doi/două)
+ * - Complex pluralization (singular/plural forms)
+ * - "De" preposition insertion for groups >= 20
+ */
+export class Romanian extends AbstractLanguage {
+  negativeWord = 'minus'
+  decimalSeparatorWord = 'virgulă'
+  zeroWord = 'zero'
+
+  onesWords = {
+    1: 'unu',
+    2: 'doi',
+    3: 'trei',
+    4: 'patru',
+    5: 'cinci',
+    6: 'șase',
+    7: 'șapte',
+    8: 'opt',
+    9: 'nouă'
+  }
+
+  onesFeminineWords = {
+    1: 'una',
+    2: 'două',
+    3: 'trei',
+    4: 'patru',
+    5: 'cinci',
+    6: 'șase',
+    7: 'șapte',
+    8: 'opt',
+    9: 'nouă'
+  }
+
+  teensWords = {
+    0: 'zece',
+    1: 'unsprezece',
+    2: 'douăsprezece',
+    3: 'treisprezece',
+    4: 'paisprezece',
+    5: 'cincisprezece',
+    6: 'șaisprezece',
+    7: 'șaptesprezece',
+    8: 'optsprezece',
+    9: 'nouăsprezece'
+  }
+
+  teensMasculineWords = {
+    0: 'zece',
+    1: 'unsprezece',
+    2: 'doisprezece',
+    3: 'treisprezece',
+    4: 'paisprezece',
+    5: 'cincisprezece',
+    6: 'șaisprezece',
+    7: 'șaptesprezece',
+    8: 'optsprezece',
+    9: 'nouăsprezece'
+  }
+
+  twentiesWords = {
+    2: 'douăzeci',
+    3: 'treizeci',
+    4: 'patruzeci',
+    5: 'cincizeci',
+    6: 'șaizeci',
+    7: 'șaptezeci',
+    8: 'optzeci',
+    9: 'nouăzeci'
+  }
+
+  hundredsWords = {
+    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 segment; "de" for segment >= 20)
+   * - 10^6: milion/milioane ("de" for segment >= 20)
+   * - 10^9: miliard/miliarde ("de" for segment >= 20)
+   */
+  scaleMetadata = {
+    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
+    9: { singular: 'octilion', plural: 'octilioane', feminine: false, needsDe: true }, // 10^27
+    10: { singular: 'decilion', plural: 'decilioane', feminine: false, needsDe: true } // 10^33
+  }
+
+  constructor (options = {}) {
+    super()
+
+    this.setOptions({
+      gender: 'masculine'
+    }, options)
+  }
+
+  /** Split numeric string into BigInt segments of specified size from left to right. */
+  splitToSegments (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
+  }
+
+  extractDigits (value) {
+    const stringValue = value.toString().padStart(3, '0').slice(-3)
+    const a = [...stringValue].toReversed()
+    return a.map(BigInt)
+  }
+
+  /** Romanian pluralization & "de" rule for big units. */
+  romanianPluralize (segment, form) {
+    const n = Number(segment)
+
+    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 segment 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, masculineTeens = false) {
+    if (n < 10) {
+      return (feminineUnits ? this.onesFeminineWords : this.onesWords)[n]
+    }
+    if (n < 20) {
+      return (masculineTeens ? this.teensMasculineWords : this.teensWords)[n - 10]
+    }
+    const t = Math.floor(n / 10)
+    const u = n % 10
+    return u
+      ? `${this.twentiesWords[t]} și ${(feminineUnits ? this.onesFeminineWords : this.onesWords)[u]}`
+      : this.twentiesWords[t]
+  }
+
+  spellUnder1000 (n, feminineUnits = false, masculineTeens = false) {
+    if (n < 100) return this.spellUnder100(n, feminineUnits, masculineTeens)
+    const h = Math.floor(n / 100)
+    const r = n % 100
+    const hundredWords = this.hundredsWords[h]
+    if (!r) return hundredWords
+    // Standard readable form: "o sută unu" (for units) or "o sută cincizeci" (for tens)
+    const separator = ' '
+    return `${hundredWords}${separator}${this.spellUnder100(r, feminineUnits, masculineTeens)}`
+  }
+
+  /** Decimals always use masculine forms regardless of gender option. */
+  decimalIntegerToWords (integerPart) {
+    if (integerPart === 0n) return this.zeroWord
+    // Use spellUnder1000 with masculine forms (feminineUnits=false, masculineTeens=true)
+    if (integerPart < 1000n) return this.spellUnder1000(Number(integerPart), false, true)
+    // For larger decimals, process segments with masculine forms
+    const words = []
+    const segments = this.splitToSegments(integerPart.toString(), 3)
+    let index = segments.length
+    for (const x of segments) {
+      index = index - 1
+      if (x === 0n) continue
+      const [n1, n2, n3] = this.extractDigits(x)
+      if (n3 > 0n) words.push(this.hundredsWords[Number(n3)])
+      if (n2 > 1n) words.push(this.twentiesWords[Number(n2)])
+      if (n2 === 1n) {
+        words.push(this.teensMasculineWords[Number(n1)])
+      } else if (n1 > 0n) {
+        if (n2 > 1n) words.push('și')
+        words.push(this.onesWords[Number(n1)])
+      }
+      if (index > 0) {
+        const form = this.scaleMetadata[index]
+        if (form) {
+          words.push(this.romanianPluralize(x, form))
+        } else {
+          words.push(this.spellUnder1000(Number(x), false))
+        }
+      }
+    }
+    return words.join(' ').replaceAll(/\s+/g, ' ').trim()
+  }
+
+  integerToWords (integerPart) {
+    if (integerPart === 0n) {
+      return this.zeroWord
+    }
+    const words = []
+    const segments = this.splitToSegments(integerPart.toString(), 3)
+    let index = segments.length
+    for (const x of segments) {
+      let onesMap = []
+      index = index - 1
+      if (x === 0n) continue
+      const [n1, n2, n3] = this.extractDigits(x) // units, tens, hundreds (as BigInt)
+      // hundreds (only for the last group, not for thousands)
+      if (n3 > 0n && index === 0) {
+        words.push(this.hundredsWords[Number(n3)])
+      }
+      // tens & teens (only for the last group, not for thousands)
+      if (index === 0) {
+        if (n2 > 1n) {
+          words.push(this.twentiesWords[Number(n2)])
+        }
+        if (n2 === 1n) {
+          words.push(this.teensWords[Number(n1)])
+        } else if (n1 > 0n) {
+          // pick masculine/feminine units (only for the last group, not for thousands)
+          const feminineUnits = this.options.gender === 'feminine' && index === 0
+          onesMap = feminineUnits ? this.onesFeminineWords : this.onesWords
+          // 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.scaleMetadata[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()
+  }
+}

package/lib/languages/ru.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Russian language converter.
+ *
+ * Supports:
+ * - Gender agreement (masculine/feminine forms)
+ * - Three-form pluralization (one/few/many)
+ * - Large numbers up to nonillions
+ */
+export class Russian extends SlavicLanguage {
+    onesWords: {
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    onesFeminineWords: {
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    teensWords: {
+        0: string;
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    twentiesWords: {
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    hundredsWords: {
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    pluralForms: {
+        1: string[];
+        2: string[];
+        3: string[];
+        4: string[];
+        5: string[];
+        6: string[];
+        7: string[];
+        8: string[];
+        9: string[];
+        10: string[];
+    };
+    /**
+     * Russian thousands (тысяча) are feminine, requiring одна/две forms.
+     * Other scales (million, billion, etc.) are masculine.
+     */
+    scaleGenders: {
+        1: boolean;
+    };
+}
+import { SlavicLanguage } from '../classes/slavic-language.js';

package/lib/languages/ru.js

@@ -0,0 +1,96 @@
+import { SlavicLanguage } from '../classes/slavic-language.js'
+
+/**
+ * Russian language converter.
+ *
+ * Supports:
+ * - Gender agreement (masculine/feminine forms)
+ * - Three-form pluralization (one/few/many)
+ * - Large numbers up to nonillions
+ */
+export class Russian extends SlavicLanguage {
+  negativeWord = 'минус'
+  decimalSeparatorWord = 'запятая'
+  zeroWord = 'ноль'
+
+  onesWords = {
+    1: 'один',
+    2: 'два',
+    3: 'три',
+    4: 'четыре',
+    5: 'пять',
+    6: 'шесть',
+    7: 'семь',
+    8: 'восемь',
+    9: 'девять'
+  }
+
+  onesFeminineWords = {
+    1: 'одна',
+    2: 'две',
+    3: 'три',
+    4: 'четыре',
+    5: 'пять',
+    6: 'шесть',
+    7: 'семь',
+    8: 'восемь',
+    9: 'девять'
+  }
+
+  teensWords = {
+    0: 'десять',
+    1: 'одиннадцать',
+    2: 'двенадцать',
+    3: 'тринадцать',
+    4: 'четырнадцать',
+    5: 'пятнадцать',
+    6: 'шестнадцать',
+    7: 'семнадцать',
+    8: 'восемнадцать',
+    9: 'девятнадцать'
+  }
+
+  twentiesWords = {
+    2: 'двадцать',
+    3: 'тридцать',
+    4: 'сорок',
+    5: 'пятьдесят',
+    6: 'шестьдесят',
+    7: 'семьдесят',
+    8: 'восемьдесят',
+    9: 'девяносто'
+  }
+
+  hundredsWords = {
+    1: 'сто',
+    2: 'двести',
+    3: 'триста',
+    4: 'четыреста',
+    5: 'пятьсот',
+    6: 'шестьсот',
+    7: 'семьсот',
+    8: 'восемьсот',
+    9: 'девятьсот'
+  }
+
+  pluralForms = {
+    1: ['тысяча', 'тысячи', 'тысяч'], // 10^ 3
+    2: ['миллион', 'миллиона', 'миллионов'], // 10^ 6
+    3: ['миллиард', 'миллиарда', 'миллиардов'], // 10^ 9
+    4: ['триллион', 'триллиона', 'триллионов'], // 10^ 12
+    5: ['квадриллион', 'квадриллиона', 'квадриллионов'], // 10^ 15
+    6: ['квинтиллион', 'квинтиллиона', 'квинтиллионов'], // 10^ 18
+    7: ['секстиллион', 'секстиллиона', 'секстиллионов'], // 10^ 21
+    8: ['септиллион', 'септиллиона', 'септиллионов'], // 10^ 24
+    9: ['октиллион', 'октиллиона', 'октиллионов'], // 10^ 27
+    10: ['нониллион', 'нониллиона', 'нониллионов'] // 10^ 30
+  }
+
+  /**
+   * Russian thousands (тысяча) are feminine, requiring одна/две forms.
+   * Other scales (million, billion, etc.) are masculine.
+   */
+  scaleGenders = {
+    1: true // thousands are feminine
+  }
+}

package/lib/languages/sr-Cyrl.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Serbian language converter (Cyrillic script).
+ *
+ * Supports:
+ * - Three-form pluralization (one/few/many)
+ * - Gender agreement (један/једна, два/две)
+ * - Cyrillic script representation
+ */
+export class SerbianCyrillic extends SlavicLanguage {
+    onesWords: {
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    onesFeminineWords: {
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    teensWords: {
+        0: string;
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    twentiesWords: {
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    hundredsWords: {
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    pluralForms: {
+        1: string[];
+        2: string[];
+        3: string[];
+        4: string[];
+        5: string[];
+        6: string[];
+        7: string[];
+        8: string[];
+        9: string[];
+        10: string[];
+    };
+    /** Selects Serbian plural form: 1 = singular, 2-4 = few, else = many. */
+    pluralize(n: any, forms: any): any;
+}
+import { SlavicLanguage } from '../classes/slavic-language.js';