n2words 1.23.1 → 2.0.0

package/lib/languages/hr.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Croatian language converter.
+ *
+ * Supports:
+ * - Three-form pluralization (one/few/many)
+ * - Gender agreement (jedan/jedna, dva/dvije)
+ * - Croatian-specific declension endings
+ */
+export class Croatian 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 Croatian plural form: 1 = singular, 2-4 = few, else = many. */
+    pluralize(n: any, forms: any): any;
+}
+import { SlavicLanguage } from '../classes/slavic-language.js';

package/lib/languages/hr.js

@@ -0,0 +1,113 @@
+import { SlavicLanguage } from '../classes/slavic-language.js'
+
+/**
+ * Croatian language converter.
+ *
+ * Supports:
+ * - Three-form pluralization (one/few/many)
+ * - Gender agreement (jedan/jedna, dva/dvije)
+ * - Croatian-specific declension endings
+ */
+export class Croatian extends SlavicLanguage {
+  negativeWord = 'minus'
+  decimalSeparatorWord = 'zarez'
+  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: 'dvije',
+    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: 'dvjesto',
+    3: 'tristo',
+    4: 'četiristo',
+    5: 'petsto',
+    6: 'šesto',
+    7: 'sedamsto',
+    8: 'osamsto',
+    9: 'devetsto'
+  }
+
+  pluralForms = {
+    1: ['tisuća', 'tisuće', 'tisuća'], // 10 ^ 3
+    2: ['milijun', 'milijuna', 'milijuna'], // 10 ^ 6
+    3: ['milijarda', 'milijarde', 'milijarda'], // 10 ^ 9
+    4: ['bilijun', 'bilijuna', 'bilijuna'], // 10 ^ 12
+    5: ['bilijarda', 'bilijarde', 'bilijarda'], // 10 ^ 15
+    6: ['trilijun', 'trilijuna', 'trilijuna'], // 10 ^ 18
+    7: ['trilijarda', 'trilijarde', 'trilijarda'], // 10 ^ 21
+    8: ['kvadrilijun', 'kvadrilijuna', 'kvadrilijuna'], // 10 ^ 24
+    9: ['kvadrilijarda', 'kvadrilijarde', 'kvadrilijarda'], // 10 ^ 27
+    10: ['kvintilijun', 'kvintilijuna', 'kvintilijuna'] // 10 ^ 30
+  }
+
+  /**
+   * Maps segment indices to whether they are grammatically feminine.
+   * In Croatian, thousands (index 1) are feminine, others are masculine.
+   * @type {Object.<number, boolean>}
+   */
+  scaleGenders = {
+    1: true // thousands are feminine (others default to false)
+  }
+
+  /** Selects Croatian 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/hu.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Hungarian language converter.
+ *
+ * Supports:
+ * - Agglutinative structure (no spaces between compound parts)
+ * - Special handling for "egy" (one) omission
+ * - Pre-composed twenties (huszonegy through huszonkilenc)
+ */
+export class Hungarian extends GreedyScaleLanguage {
+    scaleWords: (string | bigint)[][];
+    /** Converts tens (30-99) with agglutinative composition. */
+    tensToCardinal(number: any): string | undefined;
+    /** Converts hundreds (100-999) with "száz" composition. */
+    hundredsToCardinal(number: any): string;
+    /** Converts thousands (1000-999999) with "ezer" composition. */
+    thousandsToCardinal(number: any): string;
+    /** Converts large numbers (millions and above) with scale words. */
+    bigNumberToCardinal(number: any): string;
+    /** Converts integer part using Hungarian agglutinative rules. */
+    integerToWords(integerPart: any, zeroWord?: string): string;
+}
+import { GreedyScaleLanguage } from '../classes/greedy-scale-language.js';

package/lib/languages/hu.js

@@ -0,0 +1,137 @@
+import { GreedyScaleLanguage } from '../classes/greedy-scale-language.js'
+
+/**
+ * Hungarian language converter.
+ *
+ * Supports:
+ * - Agglutinative structure (no spaces between compound parts)
+ * - Special handling for "egy" (one) omission
+ * - Pre-composed twenties (huszonegy through huszonkilenc)
+ */
+export class Hungarian extends GreedyScaleLanguage {
+  negativeWord = 'mínusz'
+  decimalSeparatorWord = 'egész'
+  zeroWord = 'nulla'
+
+  scaleWords = [
+    [1_000_000_000_000_000_000_000_000_000n, 'quadrilliárd'],
+    [1_000_000_000_000_000_000_000_000n, 'quadrillió'],
+    [1_000_000_000_000_000_000_000n, 'trilliárd'],
+    [1_000_000_000_000_000_000n, 'trillió'],
+    [1_000_000_000_000_000n, 'billiárd'],
+    [1_000_000_000_000n, 'billió'],
+    [1_000_000_000n, 'milliárd'],
+    [1_000_000n, 'millió'],
+    [1000n, 'ezer'],
+    [100n, 'száz'],
+    [90n, 'kilencven'],
+    [80n, 'nyolcvan'],
+    [70n, 'hetven'],
+    [60n, 'hatvan'],
+    [50n, 'ötven'],
+    [40n, 'negyven'],
+    [30n, 'harminc'],
+    [29n, 'huszonkilenc'],
+    [28n, 'huszonnyolc'],
+    [27n, 'huszonhét'],
+    [26n, 'huszonhat'],
+    [25n, 'huszonöt'],
+    [24n, 'huszonnégy'],
+    [23n, 'huszonhárom'],
+    [22n, 'huszonkettő'],
+    [21n, 'huszonegy'],
+    [20n, 'húsz'],
+    [19n, 'tizenkilenc'],
+    [18n, 'tizennyolc'],
+    [17n, 'tizenhét'],
+    [16n, 'tizenhat'],
+    [15n, 'tizenöt'],
+    [14n, 'tizennégy'],
+    [13n, 'tizenhárom'],
+    [12n, 'tizenkettő'],
+    [11n, 'tizenegy'],
+    [10n, 'tíz'],
+    [9n, 'kilenc'],
+    [8n, 'nyolc'],
+    [7n, 'hét'],
+    [6n, 'hat'],
+    [5n, 'öt'],
+    [4n, 'négy'],
+    [3n, 'három'],
+    [2n, 'kettő'],
+    [1n, 'egy'],
+    [0n, 'nulla']
+  ]
+
+  /** Converts tens (30-99) with agglutinative composition. */
+  tensToCardinal (number) {
+    // Expecting `number` as bigint when called from integerToWords
+    if (this.wordForScale(number)) {
+      return this.wordForScale(number)
+    } else {
+      const tens = number / 10n
+      const units = number % 10n
+      return this.wordForScale(tens * 10n) + this.integerToWords(units)
+    }
+  }
+
+  /** Converts hundreds (100-999) with "száz" composition. */
+  hundredsToCardinal (number) {
+    const hundreds = number / 100n
+    let prefix = 'száz'
+    if (hundreds !== 1n) {
+      prefix = this.integerToWords(hundreds, '') + prefix
+    }
+    const postfix = this.integerToWords(number % 100n, '')
+    return prefix + postfix
+  }
+
+  /** Converts thousands (1000-999999) with "ezer" composition. */
+  thousandsToCardinal (number) {
+    const thousands = number / 1000n
+    let prefix = 'ezer'
+    if (thousands !== 1n) {
+      prefix = this.integerToWords(thousands, '') + prefix
+    }
+    const postfix = this.integerToWords(number % 1000n, '')
+    const middle = (number <= 2000n || postfix === '') ? '' : '-'
+    return prefix + middle + postfix
+  }
+
+  /** Converts large numbers (millions and above) with scale words. */
+  bigNumberToCardinal (number) {
+    const numberLength = number.toString().length
+    const digits = (numberLength % 3 === 0) ? numberLength - 2 : numberLength
+    const exp = 10 ** (Math.floor(digits / 3) * 3)
+    const prefix = this.integerToWords(number / BigInt(exp), '')
+    const rest = this.integerToWords(number % BigInt(exp), '')
+    const postfix = (rest === '') ? '' : ('-' + rest)
+    return prefix + this.wordForScale(BigInt(exp)) + postfix
+  }
+
+  /** Converts integer part using Hungarian agglutinative rules. */
+  integerToWords (integerPart, zeroWord = this.zeroWord) {
+    let words = ''
+
+    // Normalize to BigInt for consistent comparisons
+    if (typeof integerPart !== 'bigint') integerPart = BigInt(integerPart)
+
+    if (integerPart === 0n) {
+      words = zeroWord
+    } else if (zeroWord === '' && integerPart === 2n) {
+      words = 'két'
+    } else if (integerPart < 30n) {
+      words = this.wordForScale(integerPart)
+    } else if (integerPart < 100n) {
+      words = this.tensToCardinal(integerPart)
+    } else if (integerPart < 1000n) {
+      words = this.hundredsToCardinal(integerPart)
+    } else if (integerPart < 1_000_000n) {
+      words = this.thousandsToCardinal(integerPart)
+    } else {
+      words = this.bigNumberToCardinal(integerPart)
+    }
+
+    return words
+  }
+}

package/lib/languages/id.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Indonesian language converter.
+ *
+ * Supports:
+ * - "Se-" prefix for one (seratus, seribu, sejuta)
+ * - Regular patterns (puluh for tens, ratus for hundreds)
+ * - Space-separated number components
+ */
+export class Indonesian extends AbstractLanguage {
+    /**
+     * Word forms for digits 0-9.
+     * @type {Object.<number, string[]>}
+     */
+    digitWords: {
+        [x: number]: string[];
+    };
+    /**
+     * Scale magnitude words keyed by exponent (10^n).
+     * @type {Object.<number, string>}
+     */
+    scaleWords: {
+        [x: number]: string;
+    };
+    /** Splits number into groups of 3 digits. */
+    splitBy3(number: any): any[][];
+    /** Converts digit blocks to Indonesian words. */
+    spell(blocks: any): any[];
+    /** Converts hundreds digit with "seratus" or "ratus" suffix. */
+    getHundreds(number: any): string[];
+    /** Converts tens and units digits with "puluh" or "belas" suffix. */
+    getTens(number: any): string[];
+    /** Joins word blocks with magnitude scale words. */
+    join(wordBlocks: any): string;
+    /** Converts integer part using Indonesian group-based conversion. */
+    integerToWords(integerPart: any): string;
+}
+import { AbstractLanguage } from '../classes/abstract-language.js';

package/lib/languages/id.js

@@ -0,0 +1,159 @@
+import { AbstractLanguage } from '../classes/abstract-language.js'
+
+/**
+ * Indonesian language converter.
+ *
+ * Supports:
+ * - "Se-" prefix for one (seratus, seribu, sejuta)
+ * - Regular patterns (puluh for tens, ratus for hundreds)
+ * - Space-separated number components
+ */
+export class Indonesian extends AbstractLanguage {
+  negativeWord = 'min'
+  decimalSeparatorWord = 'koma'
+  zeroWord = 'nol'
+
+  /**
+   * Word forms for digits 0-9.
+   * @type {Object.<number, string[]>}
+   */
+  digitWords = {
+    0: [],
+    1: ['satu'],
+    2: ['dua'],
+    3: ['tiga'],
+    4: ['empat'],
+    5: ['lima'],
+    6: ['enam'],
+    7: ['tujuh'],
+    8: ['delapan'],
+    9: ['sembilan']
+  }
+
+  /**
+   * Scale magnitude words keyed by exponent (10^n).
+   * @type {Object.<number, string>}
+   */
+  scaleWords = {
+    3: 'ribu', // 10^3
+    6: 'juta', // 10^6
+    9: 'miliar', // 10^9
+    12: 'triliun',
+    15: 'kuadriliun',
+    18: 'kuantiliun',
+    21: 'sekstiliun',
+    24: 'septiliun',
+    27: 'oktiliun',
+    30: 'noniliun',
+    33: 'desiliun'
+  }
+
+  /** Splits number into groups of 3 digits. */
+  splitBy3 (number) {
+    // Split to groups of 3 numbers: 1234567 -> [['1'], ['234'], ['567']]
+    const blocks = []
+    const stringNumber = number.toString()
+    const length = stringNumber.length
+    let firstBlock
+
+    if (length < 3) {
+      blocks.push([stringNumber])
+    } else {
+      const firstBlockLength = length % 3
+
+      if (firstBlockLength > 0) {
+        firstBlock = [stringNumber.slice(0, firstBlockLength)]
+        blocks.push(firstBlock)
+      }
+
+      for (let index = firstBlockLength; index < length; index += 3) {
+        const nextBlock = [stringNumber.slice(index, index + 3)]
+        blocks.push(nextBlock)
+      }
+    }
+    return blocks
+  }
+
+  /** Converts digit blocks to Indonesian words. */
+  spell (blocks) {
+    let wordBlocks = []
+    let spelling
+    const firstBlock = blocks[0]
+    if (firstBlock[0].length === 1) {
+      spelling = firstBlock[0] === '0' ? ['nol'] : this.digitWords[Math.trunc(firstBlock[0])]
+    } else if (firstBlock[0].length === 2) {
+      spelling = this.getTens(firstBlock[0])
+    } else {
+      spelling = [...this.getHundreds(firstBlock[0][0]), ...this.getTens(firstBlock[0].slice(1, 3))]
+    }
+    wordBlocks = [...wordBlocks, [firstBlock[0], spelling]]
+    for (let index = 1; index < blocks.length; index++) {
+      let block = blocks[index]
+      spelling = [...this.getHundreds(block[0][0]), ...this.getTens(block[0].slice(1, 3))]
+      block = [...block, spelling]
+      wordBlocks = [...wordBlocks, block]
+    }
+    return wordBlocks
+  }
+
+  /** Converts hundreds digit with "seratus" or "ratus" suffix. */
+  getHundreds (number) {
+    if (number === '1') {
+      return ['seratus']
+    } else if (number === '0') {
+      return []
+    } else {
+      return [...this.digitWords[Math.trunc(number)], 'ratus']
+    }
+  }
+
+  /** Converts tens and units digits with "puluh" or "belas" suffix. */
+  getTens (number) {
+    if (number[0] === '1') {
+      if (number[1] === '0') {
+        return ['sepuluh']
+      } else if (number[1] === '1') {
+        return ['sebelas']
+      }
+      return [...this.digitWords[Math.trunc(number[1])], 'belas']
+    }
+
+    if (number[0] === '0') {
+      return this.digitWords[Math.trunc(number[1])]
+    }
+
+    return [...this.digitWords[Math.trunc(number[0])], 'puluh', ...this.digitWords[Math.trunc(number[1])]]
+  }
+
+  /** Joins word blocks with magnitude scale words. */
+  join (wordBlocks) {
+    let wordList = []
+    const length = wordBlocks.length - 1
+    const firstBlock = [wordBlocks[0]]
+    let start = 0
+    if (length === 1 && firstBlock[0][0] === '1') {
+      wordList.push('seribu')
+      start = 1
+    }
+    for (let index = start; index < length + 1; index++) {
+      wordList = [...wordList, ...wordBlocks[index][1]]
+      if (wordBlocks[index][1].length === 0) {
+        continue
+      }
+      if (index === length) {
+        break
+      }
+      wordList = [...wordList, this.scaleWords[(length - index) * 3]]
+    }
+    return wordList.join(' ')
+  }
+
+  /** Converts integer part using Indonesian group-based conversion. */
+  integerToWords (integerPart) {
+    return this.join(
+      this.spell(
+        this.splitBy3(integerPart)
+      )
+    ).trim()
+  }
+}

package/lib/languages/it.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Italian language converter.
+ *
+ * Supports:
+ * - Phonetic contractions (vowel elision: "ventotto" not "ventiotto")
+ * - Accentuation rules for "tre" in compounds ("ventitré")
+ * - Custom word construction for irregular patterns
+ */
+export class Italian extends AbstractLanguage {
+    onesWords: string[];
+    tensWords: {
+        2: string;
+        3: string;
+        4: string;
+        6: string;
+    };
+    exponentPrefixes: string[];
+    /** Adds accent to final "tre" in compound words (ventitré). */
+    accentuate(string: any): any;
+    /** Omits word if it represents zero. */
+    omitIfZero(numberToString: any): any;
+    /** Removes duplicate vowels for phonetic contractions. */
+    phoneticContraction(string: any): any;
+    /** Converts tens (20-99) with phonetic contractions. */
+    tensToCardinal(number: any): any;
+    /** Converts hundreds (100-999) with "cento" composition. */
+    hundredsToCardinal(number: any): any;
+    /** Converts thousands (1000-999999) with "mille/mila" composition. */
+    thousandsToCardinal(number: any): string;
+    /** Converts exponent length to Italian scale word (milione, miliardo, etc.). */
+    exponentLengthToString(exponentLength: any): string;
+    /** Converts large numbers (millions and above) with exponent-based naming. */
+    bigNumberToCardinal(number: any): string;
+    /** Converts integer part using Italian custom algorithm with accentuation. */
+    integerToWords(integerPart: any): any;
+}
+import { AbstractLanguage } from '../classes/abstract-language.js';