n2words 1.23.1 → 2.0.0

package/lib/languages/sr-Cyrl.js

@@ -0,0 +1,113 @@
+import { SlavicLanguage } from '../classes/slavic-language.js'
+
+/**
+ * Serbian language converter (Cyrillic script).
+ *
+ * Supports:
+ * - Three-form pluralization (one/few/many)
+ * - Gender agreement (један/једна, два/две)
+ * - Cyrillic script representation
+ */
+export class SerbianCyrillic 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: 'девестo'
+  }
+
+  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
+  }
+
+  /**
+   * Maps segment indices to whether they are grammatically feminine.
+   * In Serbian, thousands (index 1) are feminine, others are masculine.
+   * @type {Object.<number, boolean>}
+   */
+  scaleGenders = {
+    1: true // thousands are feminine (others default to false)
+  }
+
+  /** Selects Serbian plural form: 1 = singular, 2-4 = few, else = many. */
+  pluralize (n, forms) {
+    const lastDigit = n % 10n
+    const lastTwoDigits = n % 100n
+
+    if ((lastTwoDigits < 10n || lastTwoDigits > 20n) && lastDigit === 1n) {
+      return forms[0]
+    }
+
+    if ((lastTwoDigits < 10n || lastTwoDigits > 20n) && lastDigit > 1n && lastDigit < 5n) {
+      return forms[1]
+    }
+
+    return forms[2]
+  }
+}

package/lib/{i18n/cz.d.ts → languages/sr-Latn.d.ts}

@@ -1,13 +1,13 @@
 /**
- * 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.
- * @throws {Error} Value cannot be invalid.
+ * Serbian Latin language converter.
+ *
+ * Supports:
+ * - Three-form pluralization (one/few/many)
+ * - Gender agreement (jedan/jedna, dva/dve)
+ * - Latin script representation
  */
-export default function floatToCardinal(value: number | string | bigint, options?: object): string;
-export class N2WordsCZ extends N2WordsRU {
-    ones: {
+export class SerbianLatin extends SlavicLanguage {
+    onesWords: {
         1: string;
         2: string;
         3: string;
@@ -18,7 +18,18 @@ export class N2WordsCZ extends N2WordsRU {
         8: string;
         9: string;
     };
-    tens: {
+    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;
@@ -30,7 +41,7 @@ export class N2WordsCZ extends N2WordsRU {
         8: string;
         9: string;
     };
-    twenties: {
+    twentiesWords: {
         2: string;
         3: string;
         4: string;
@@ -40,7 +51,7 @@ export class N2WordsCZ extends N2WordsRU {
         8: string;
         9: string;
     };
-    hundreds: {
+    hundredsWords: {
         1: string;
         2: string;
         3: string;
@@ -51,7 +62,7 @@ export class N2WordsCZ extends N2WordsRU {
         8: string;
         9: string;
     };
-    thousands: {
+    pluralForms: {
         1: string[];
         2: string[];
         3: string[];
@@ -63,6 +74,7 @@ export class N2WordsCZ extends N2WordsRU {
         9: string[];
         10: string[];
     };
-    get separatorWord(): "celá" | "celé" | "celých";
+    /** Selects Serbian plural form: 1 = singular, 2-4 = few, else = many. */
+    pluralize(n: any, forms: any): any;
 }
-import { N2WordsRU } from './ru.js';
+import { SlavicLanguage } from '../classes/slavic-language.js';

package/lib/languages/sr-Latn.js

@@ -0,0 +1,113 @@
+import { SlavicLanguage } from '../classes/slavic-language.js'
+
+/**
+ * Serbian Latin language converter.
+ *
+ * Supports:
+ * - Three-form pluralization (one/few/many)
+ * - Gender agreement (jedan/jedna, dva/dve)
+ * - Latin script representation
+ */
+export class SerbianLatin extends SlavicLanguage {
+  negativeWord = 'minus'
+  decimalSeparatorWord = 'zapeta'
+  zeroWord = 'nula'
+
+  onesWords = {
+    1: 'jedan',
+    2: 'dva',
+    3: 'tri',
+    4: 'četiri',
+    5: 'pet',
+    6: 'šest',
+    7: 'sedam',
+    8: 'osam',
+    9: 'devet'
+  }
+
+  onesFeminineWords = {
+    1: 'jedna',
+    2: 'dve',
+    3: 'tri',
+    4: 'četiri',
+    5: 'pet',
+    6: 'šest',
+    7: 'sedam',
+    8: 'osam',
+    9: 'devet'
+  }
+
+  teensWords = {
+    0: 'deset',
+    1: 'jedanaest',
+    2: 'dvanaest',
+    3: 'trinaest',
+    4: 'četrnaest',
+    5: 'petnaest',
+    6: 'šesnaest',
+    7: 'sedamnaest',
+    8: 'osamnaest',
+    9: 'devetnaest'
+  }
+
+  twentiesWords = {
+    2: 'dvadeset',
+    3: 'trideset',
+    4: 'četrdeset',
+    5: 'pedeset',
+    6: 'šezdeset',
+    7: 'sedamdeset',
+    8: 'osamdeset',
+    9: 'devedeset'
+  }
+
+  hundredsWords = {
+    1: 'sto',
+    2: 'dvesta',
+    3: 'trista',
+    4: 'četiristo',
+    5: 'petsto',
+    6: 'šesto',
+    7: 'sedamsto',
+    8: 'osamsto',
+    9: 'devetsto'
+  }
+
+  pluralForms = {
+    1: ['hiljada', 'hiljade', 'hiljada'], // 10 ^ 3
+    2: ['milion', 'miliona', 'miliona'], // 10 ^ 6
+    3: ['milijarda', 'milijarde', 'milijarda'], // 10 ^ 9
+    4: ['bilion', 'biliona', 'biliona'], // 10 ^ 12
+    5: ['bilijarda', 'bilijarde', 'bilijarda'], // 10 ^ 15
+    6: ['trilion', 'triliona', 'triliona'], // 10 ^ 18
+    7: ['trilijarda', 'trilijarde', 'trilijarda'], // 10 ^ 21
+    8: ['kvadrilion', 'kvadriliona', 'kvadriliona'], // 10 ^ 24
+    9: ['kvadrilijarda', 'kvadrilijarde', 'kvadrilijarda'], // 10 ^ 27
+    10: ['kvintilion', 'kvintiliona', 'kvintiliona'] // 10 ^ 30
+  }
+
+  /**
+   * Maps segment indices to whether they are grammatically feminine.
+   * In Serbian, thousands (index 1) are feminine, others are masculine.
+   * @type {Object.<number, boolean>}
+   */
+  scaleGenders = {
+    1: true // thousands are feminine (others default to false)
+  }
+
+  /** Selects Serbian plural form: 1 = singular, 2-4 = few, else = many. */
+  pluralize (n, forms) {
+    const lastDigit = n % 10n
+    const lastTwoDigits = n % 100n
+
+    if ((lastTwoDigits < 10n || lastTwoDigits > 20n) && lastDigit === 1n) {
+      return forms[0]
+    }
+
+    if ((lastTwoDigits < 10n || lastTwoDigits > 20n) && lastDigit > 1n && lastDigit < 5n) {
+      return forms[1]
+    }
+
+    return forms[2]
+  }
+}

package/lib/languages/sv.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Swedish language converter.
+ *
+ * Supports:
+ * - Hyphenation for compound tens (tjugo-tre)
+ * - "och" (and) after hundreds
+ * - Space-separated larger composites
+ */
+export class Swedish extends GreedyScaleLanguage {
+    scaleWords: (string | bigint)[][];
+    /** Combines two word-sets according to Swedish grammar rules. */
+    combineWordSets(preceding: any, following: any): any;
+}
+import { GreedyScaleLanguage } from '../classes/greedy-scale-language.js';

package/lib/languages/sv.js

@@ -0,0 +1,90 @@
+import { GreedyScaleLanguage } from '../classes/greedy-scale-language.js'
+
+/**
+ * Swedish language converter.
+ *
+ * Supports:
+ * - Hyphenation for compound tens (tjugo-tre)
+ * - "och" (and) after hundreds
+ * - Space-separated larger composites
+ */
+export class Swedish extends GreedyScaleLanguage {
+  negativeWord = 'minus'
+  decimalSeparatorWord = 'komma'
+  zeroWord = 'noll'
+  wordSeparator = ' '
+
+  scaleWords = [
+    [1_000_000_000_000_000_000_000_000_000n, 'kvadriljon'],
+    [1_000_000_000_000_000_000_000_000n, 'triljon'],
+    [1_000_000_000_000_000_000_000n, 'biljon'],
+    [1_000_000_000_000_000_000n, 'miljard'],
+    [1_000_000_000_000n, 'biljon'],
+    [1_000_000_000n, 'miljard'],
+    [1_000_000n, 'miljon'],
+    [1000n, 'tusen'],
+    [100n, 'hundra'],
+    [90n, 'nittio'],
+    [80n, 'åttio'],
+    [70n, 'sjuttio'],
+    [60n, 'sextio'],
+    [50n, 'femtio'],
+    [40n, 'fyrtio'],
+    [30n, 'trettio'],
+    [20n, 'tjugo'],
+    [19n, 'nitton'],
+    [18n, 'arton'],
+    [17n, 'sjutton'],
+    [16n, 'sexton'],
+    [15n, 'femton'],
+    [14n, 'fjorton'],
+    [13n, 'tretton'],
+    [12n, 'tolv'],
+    [11n, 'elva'],
+    [10n, 'tio'],
+    [9n, 'nio'],
+    [8n, 'åtta'],
+    [7n, 'sju'],
+    [6n, 'sex'],
+    [5n, 'fem'],
+    [4n, 'fyra'],
+    [3n, 'tre'],
+    [2n, 'två'],
+    [1n, 'ett'],
+    [0n, 'noll']
+  ]
+
+  /** Combines two word-sets according to Swedish grammar rules. */
+  combineWordSets (preceding, following) {
+    const precedingWord = Object.keys(preceding)[0]
+    const followingWord = Object.keys(following)[0]
+    const precedingValue = Object.values(preceding)[0]
+    const followingValue = Object.values(following)[0]
+
+    if (precedingValue === 1n && followingValue < 100n) {
+      return following
+    }
+
+    // Omit 'ett' before 'hundra' and 'tusen'
+    if (precedingValue === 1n && (followingValue === 100n || followingValue === 1000n)) {
+      return following
+    }
+
+    if (precedingValue < 100n && precedingValue > followingValue) {
+      return { [`${precedingWord}-${followingWord}`]: precedingValue + followingValue }
+    }
+
+    if (precedingValue >= 100n && followingValue < 100n) {
+      return { [`${precedingWord} och ${followingWord}`]: precedingValue + followingValue }
+    }
+
+    if (followingValue > precedingValue) {
+      if (precedingValue === 1n && followingValue >= 1_000_000n) {
+        return { [`en ${followingWord}`]: precedingValue * followingValue }
+      }
+      return { [`${precedingWord} ${followingWord}`]: precedingValue * followingValue }
+    }
+
+    return { [`${precedingWord} ${followingWord}`]: precedingValue + followingValue }
+  }
+}

package/lib/languages/sw.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Swahili language converter.
+ *
+ * Supports:
+ * - Swahili number words (moja, mbili, tatu)
+ * - Space-separated components
+ * - Simple decimal point notation
+ */
+export class Swahili extends AbstractLanguage {
+    onesWords: {
+        0: string;
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    tensWords: {
+        10: string;
+        20: string;
+        30: string;
+        40: string;
+        50: string;
+        60: string;
+        70: string;
+        80: string;
+        90: string;
+    };
+    scaleWords: string[];
+    wordsUnder100(n: any): any;
+    wordsUnder1000(n: any): any;
+    splitBy3(number: any): number[];
+    integerToWords(integerPart: any): string;
+}
+import { AbstractLanguage } from '../classes/abstract-language.js';

package/lib/languages/sw.js

@@ -0,0 +1,126 @@
+import { AbstractLanguage } from '../classes/abstract-language.js'
+
+/**
+ * Swahili language converter.
+ *
+ * Supports:
+ * - Swahili number words (moja, mbili, tatu)
+ * - Space-separated components
+ * - Simple decimal point notation
+ */
+export class Swahili extends AbstractLanguage {
+  negativeWord = 'minus'
+  decimalSeparatorWord = 'nukta'
+  zeroWord = 'sifuri'
+
+  onesWords = {
+    0: 'sifuri',
+    1: 'moja',
+    2: 'mbili',
+    3: 'tatu',
+    4: 'nne',
+    5: 'tano',
+    6: 'sita',
+    7: 'saba',
+    8: 'nane',
+    9: 'tisa'
+  }
+
+  tensWords = {
+    10: 'kumi',
+    20: 'ishirini',
+    30: 'thelathini',
+    40: 'arobaini',
+    50: 'hamsini',
+    60: 'sitini',
+    70: 'sabini',
+    80: 'themanini',
+    90: 'tisini'
+  }
+
+  scaleWords = [
+    '',
+    'elfu',
+    'milioni',
+    'bilioni',
+    'trilioni'
+  ]
+
+  wordsUnder100 (n) {
+    if (n < 10) return this.onesWords[n]
+    if (n === 10) return this.tensWords[10]
+    if (n < 20) {
+      // 11-19: 'kumi na <digit>'
+      return this.tensWords[10] + ' na ' + this.onesWords[n - 10]
+    }
+    const tens = Math.trunc(n / 10) * 10
+    const ones = n % 10
+    if (ones === 0) return this.tensWords[tens]
+    return this.tensWords[tens] + ' na ' + this.onesWords[ones]
+  }
+
+  wordsUnder1000 (n) {
+    if (n < 100) return this.wordsUnder100(n)
+    if (n === 100) return 'mia moja'
+    const hundreds = Math.trunc(n / 100)
+    const rest = n % 100
+    const parts = []
+
+    // Hundreds: 'mia <digit>'
+    parts.push('mia ' + this.onesWords[hundreds])
+    if (rest > 0) {
+      if (rest < 10) {
+        parts.push('na ' + this.onesWords[rest])
+      } else {
+        parts.push(this.wordsUnder100(rest))
+      }
+    }
+
+    return parts.join(' ')
+  }
+
+  splitBy3 (number) {
+    const s = number.toString()
+    if (s.length <= 3) return [Number(s)]
+    const groups = []
+    const last3 = s.slice(-3)
+    groups.unshift(Number(last3))
+    let remaining = s.slice(0, -3)
+    while (remaining.length > 0) {
+      const group = remaining.slice(-3)
+      groups.unshift(Number(group))
+      remaining = remaining.slice(0, -3)
+    }
+    return groups
+  }
+
+  integerToWords (integerPart) {
+    if (integerPart === 0n) return this.zeroWord
+
+    const groups = this.splitBy3(integerPart)
+    const parts = []
+
+    for (let i = 0; i < groups.length; i++) {
+      const val = groups[i]
+      if (val === 0) continue
+      const scaleIndex = groups.length - i - 1
+      // scale word
+      if (scaleIndex === 0) {
+        if (val < 10 && parts.length > 0) {
+          parts.push('na ' + this.onesWords[val])
+        } else if (val === 100 && parts.length > 0) {
+          // In compound numbers (e.g., 1100 -> 'elfu moja mia'), use 'mia' not 'mia moja'
+          parts.push('mia')
+        } else {
+          parts.push(this.wordsUnder1000(val))
+        }
+      } else {
+        // e.g., 'elfu moja', 'milioni mbili'
+        const unit = (val === 1) ? 'moja' : this.wordsUnder1000(val)
+        parts.push(this.scaleWords[scaleIndex] + ' ' + unit)
+      }
+    }
+
+    return parts.join(' ').trim()
+  }
+}

package/lib/languages/ta.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Tamil language converter.
+ *
+ * Supports:
+ * - Tamil numbering system
+ * - Tamil script
+ * - Complete word forms for 0-99
+ */
+export class Tamil extends AbstractLanguage {
+    belowHundredWords: string[];
+    hundredsWords: string[];
+    onesWords: string[];
+    scaleWords: string[];
+    /** Convert numbers below 100 to Tamil words. */
+    convertBelowHundred(number: any): string;
+    convertBelowThousand(number: any): string;
+    splitIndian(number: any): number[];
+    integerToWords(integerPart: any): string;
+}
+import { AbstractLanguage } from '../classes/abstract-language.js';