n2words 1.23.1 → 2.0.0

package/lib/{i18n/lt.d.ts → languages/lv.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.
+ * Latvian language converter.
+ *
+ * Supports:
+ * - Three-form pluralization (one/few/many)
+ * - Latvian diacritical marks (ī, ā, ē, ū)
+ * - Compound number formation (divdesmit, trīsdesmit)
  */
-export default function floatToCardinal(value: number | string | bigint, options?: object): string;
-export class N2WordsLT extends N2WordsRU {
-    ones: {
+export class Latvian extends SlavicLanguage {
+    onesWords: {
         1: string;
         2: string;
         3: string;
@@ -18,7 +18,7 @@ export class N2WordsLT extends N2WordsRU {
         8: string;
         9: string;
     };
-    onesFeminine: {
+    onesFeminineWords: {
         1: string;
         2: string;
         3: string;
@@ -29,7 +29,7 @@ export class N2WordsLT extends N2WordsRU {
         8: string;
         9: string;
     };
-    tens: {
+    teensWords: {
         0: string;
         1: string;
         2: string;
@@ -41,7 +41,7 @@ export class N2WordsLT extends N2WordsRU {
         8: string;
         9: string;
     };
-    twenties: {
+    twentiesWords: {
         2: string;
         3: string;
         4: string;
@@ -51,8 +51,8 @@ export class N2WordsLT extends N2WordsRU {
         8: string;
         9: string;
     };
-    hundreds: string[];
-    thousands: {
+    hundredsWords: string[];
+    pluralForms: {
         1: string[];
         2: string[];
         3: string[];
@@ -64,5 +64,7 @@ export class N2WordsLT extends N2WordsRU {
         9: string[];
         10: string[];
     };
+    pluralize(n: any, forms: any): any;
+    integerToWords(integerPart: any): string;
 }
-import { N2WordsRU } from './ru.js';
+import { SlavicLanguage } from '../classes/slavic-language.js';

package/lib/languages/lv.js

@@ -0,0 +1,130 @@
+import { SlavicLanguage } from '../classes/slavic-language.js'
+
+/**
+ * Latvian language converter.
+ *
+ * Supports:
+ * - Three-form pluralization (one/few/many)
+ * - Latvian diacritical marks (ī, ā, ē, ū)
+ * - Compound number formation (divdesmit, trīsdesmit)
+ */
+export class Latvian extends SlavicLanguage {
+  negativeWord = 'mīnus'
+  decimalSeparatorWord = 'komats'
+  zeroWord = 'nulle'
+
+  onesWords = {
+    1: 'viens',
+    2: 'divi',
+    3: 'trīs',
+    4: 'četri',
+    5: 'pieci',
+    6: 'seši',
+    7: 'septiņi',
+    8: 'astoņi',
+    9: 'deviņi'
+  }
+
+  onesFeminineWords = {
+    1: 'viena',
+    2: 'divas',
+    3: 'trīs',
+    4: 'četras',
+    5: 'piecas',
+    6: 'sešas',
+    7: 'septiņas',
+    8: 'astoņas',
+    9: 'deviņas'
+  }
+
+  teensWords = {
+    0: 'desmit',
+    1: 'vienpadsmit',
+    2: 'divpadsmit',
+    3: 'trīspadsmit',
+    4: 'četrpadsmit',
+    5: 'piecpadsmit',
+    6: 'sešpadsmit',
+    7: 'septiņpadsmit',
+    8: 'astoņpadsmit',
+    9: 'deviņpadsmit'
+  }
+
+  twentiesWords = {
+    2: 'divdesmit',
+    3: 'trīsdesmit',
+    4: 'četrdesmit',
+    5: 'piecdesmit',
+    6: 'sešdesmit',
+    7: 'septiņdesmit',
+    8: 'astoņdesmit',
+    9: 'deviņdesmit'
+  }
+
+  hundredsWords = ['simts', 'simti', 'simtu']
+
+  pluralForms = {
+    1: ['tūkstotis', 'tūkstoši', 'tūkstošu'],
+    2: ['miljons', 'miljoni', 'miljonu'],
+    3: ['miljards', 'miljardi', 'miljardu'],
+    4: ['triljons', 'triljoni', 'triljonu'],
+    5: ['kvadriljons', 'kvadriljoni', 'kvadriljonu'],
+    6: ['kvintiljons', 'kvintiljoni', 'kvintiljonu'],
+    7: ['sikstiljons', 'sikstiljoni', 'sikstiljonu'],
+    8: ['septiljons', 'septiljoni', 'septiljonu'],
+    9: ['oktiljons', 'oktiljoni', 'oktiljonu'],
+    10: ['nontiljons', 'nontiljoni', 'nontiljonu']
+  }
+
+  pluralize (n, forms) {
+    if (n === 0n) {
+      return forms[2]
+    }
+
+    const lastDigit = n % 10n
+    const lastTwoDigits = n % 100n
+
+    if (lastDigit === 1n && lastTwoDigits !== 11n) {
+      return forms[0]
+    }
+
+    return forms[1]
+  }
+
+  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) {
+      index = index - 1
+      if (x === 0n) {
+        continue
+      }
+      const [n1, n2, n3] = this.extractDigits(x)
+      if (n3 > 0n) {
+        if (n3 === 1n && n2 === 0n && n1 > 0n) {
+          words.push(this.hundredsWords[2])
+        } else if (n3 > 1n) {
+          words.push(this.onesWords[n3], this.hundredsWords[1])
+        } else {
+          words.push(this.hundredsWords[0])
+        }
+      }
+      if (n2 > 1n) {
+        words.push(this.twentiesWords[n2])
+      }
+      if (n2 === 1n) {
+        words.push(this.teensWords[n1])
+      } else if (n1 > 0n && !(index > 0 && x === 1n)) {
+        words.push(this.onesWords[n1])
+      }
+      if (index > 0) {
+        words.push(this.pluralize(x, this.pluralForms[index]))
+      }
+    }
+    return words.join(' ')
+  }
+}

package/lib/languages/mr.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Marathi language converter.
+ *
+ * Supports:
+ * - Indian numbering system (हजार, लाख, कोटी)
+ * - Devanagari script
+ * - Complete word forms for 0-99
+ */
+export class Marathi extends SouthAsianLanguage {
+}
+import { SouthAsianLanguage } from '../classes/south-asian-language.js';

package/lib/languages/mr.js

@@ -0,0 +1,132 @@
+import { SouthAsianLanguage } from '../classes/south-asian-language.js'
+
+/**
+ * Marathi language converter.
+ *
+ * Supports:
+ * - Indian numbering system (हजार, लाख, कोटी)
+ * - Devanagari script
+ * - Complete word forms for 0-99
+ */
+export class Marathi extends SouthAsianLanguage {
+  negativeWord = 'उणे'
+  decimalSeparatorWord = 'दशांश'
+  zeroWord = 'शून्य'
+  hundredWord = 'शंभर'
+  usePerDigitDecimals = true
+
+  belowHundredWords = [
+    'शून्य',
+    'एक',
+    'दोन',
+    'तीन',
+    'चार',
+    'पाच',
+    'सहा',
+    'सात',
+    'आठ',
+    'नऊ',
+    'दहा',
+    'अकरा',
+    'बारा',
+    'तेरा',
+    'चौदा',
+    'पंधरा',
+    'सोळा',
+    'सतरा',
+    'अठरा',
+    'एकोणीस',
+    'वीस',
+    'एकवीस',
+    'बावीस',
+    'तेवीस',
+    'चोवीस',
+    'पंचवीस',
+    'सव्वीस',
+    'सत्तावीस',
+    'अठ्ठावीस',
+    'एकोणतीस',
+    'तीस',
+    'एकतीस',
+    'बत्तीस',
+    'तेहेतीस',
+    'चौतीस',
+    'पस्तीस',
+    'छत्तीस',
+    'सदतीस',
+    'अडतीस',
+    'एकोणचाळीस',
+    'चाळीस',
+    'एकेचाळीस',
+    'बेचाळीस',
+    'त्रेचाळीस',
+    'चव्वेचाळीस',
+    'पंचेचाळीस',
+    'सेहेचाळीस',
+    'सत्तेचाळीस',
+    'अठ्ठेचाळीस',
+    'एकोणपन्नास',
+    'पन्नास',
+    'एक्काव्वन',
+    'बावन्न',
+    'त्रेपन्न',
+    'चोपन्न',
+    'पंचाव्वन',
+    'छप्पन्न',
+    'सत्तावन्न',
+    'अठ्ठावन्न',
+    'एकोणसाठ',
+    'साठ',
+    'एकसष्ठ',
+    'बासष्ठ',
+    'त्रेसष्ठ',
+    'चौसष्ठ',
+    'पासष्ठ',
+    'सहासष्ठ',
+    'सदुसष्ठ',
+    'अडुसष्ठ',
+    'एकोणसत्तर',
+    'सत्तर',
+    'एकाहत्तर',
+    'बाहत्तर',
+    'त्र्याहत्तर',
+    'चौऱ्याहत्तर',
+    'पंच्याहत्तर',
+    'शहात्तर',
+    'सत्याहत्तर',
+    'अठ्ठ्याहत्तर',
+    'एकोणऐंशी',
+    'ऐंशी',
+    'एक्याऐंशी',
+    'ब्याऐंशी',
+    'त्र्याऐंशी',
+    'चौऱ्याऐंशी',
+    'पंच्याऐंशी',
+    'शहाऐंशी',
+    'सत्याऐंशी',
+    'अठ्ठ्याऐंशी',
+    'एकोणनव्वद',
+    'नव्वद',
+    'एक्याण्णव',
+    'ब्याण्णव',
+    'त्र्याण्णव',
+    'चौऱ्याण्णव',
+    'पंच्याण्णव',
+    'शहाण्णव',
+    'सत्याण्णव',
+    'अठ्ठ्याण्णव',
+    'नव्याण्णव'
+  ]
+
+  scaleWords = [
+    '',
+    'हजार',
+    'लाख',
+    'कोटी',
+    'अब्ज',
+    'खर्व',
+    'निखर्व',
+    'महापद्म',
+    'शंकू'
+  ]
+}

package/lib/languages/ms.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Malay (Bahasa Melayu) language converter.
+ *
+ * Supports:
+ * - "Se-" prefix for singular units (seratus, seribu, sejuta)
+ * - Regular patterns (puluh for tens, ratus for hundreds)
+ * - Space-separated number components
+ */
+export class Malay 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;
+    };
+    splitBy3(number: any): any[][];
+    spell(blocks: any): any[];
+    getHundreds(number: any): string[];
+    getTens(number: any): string[];
+    join(wordBlocks: any): string;
+    integerToWords(integerPart: any): string;
+}
+import { AbstractLanguage } from '../classes/abstract-language.js';

package/lib/languages/ms.js

@@ -0,0 +1,150 @@
+import { AbstractLanguage } from '../classes/abstract-language.js'
+
+/**
+ * Malay (Bahasa Melayu) language converter.
+ *
+ * Supports:
+ * - "Se-" prefix for singular units (seratus, seribu, sejuta)
+ * - Regular patterns (puluh for tens, ratus for hundreds)
+ * - Space-separated number components
+ */
+export class Malay extends AbstractLanguage {
+  negativeWord = 'minus'
+  decimalSeparatorWord = 'perpuluhan'
+  zeroWord = 'sifar'
+
+  /**
+   * 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: ['lapan'],
+    9: ['sembilan']
+  }
+
+  /**
+   * Scale magnitude words keyed by exponent (10^n).
+   * @type {Object.<number, string>}
+   */
+  scaleWords = {
+    3: 'ribu',
+    6: 'juta',
+    9: 'bilion',
+    12: 'trilion'
+  }
+
+  splitBy3 (number) {
+    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
+  }
+
+  spell (blocks) {
+    let wordBlocks = []
+    let spelling
+    const firstBlock = blocks[0]
+    if (firstBlock[0].length === 1) {
+      spelling = firstBlock[0] === '0' ? ['sifar'] : 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
+  }
+
+  getHundreds (number) { // 'ratus'
+    if (number === '1') {
+      return ['seratus']
+    } else if (number === '0') {
+      return []
+    } else {
+      return [...this.digitWords[Math.trunc(number)], 'ratus']
+    }
+  }
+
+  getTens (number) { // 'puluh' and 'belas'
+    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])]]
+  }
+
+  join (wordBlocks) {
+    const wordList = []
+    const length = wordBlocks.length - 1
+
+    for (let index = 0; index <= length; index++) {
+      const words = wordBlocks[index][1]
+      const isLast = index === length
+      const scaleWord = isLast ? null : this.scaleWords[(length - index) * 3]
+
+      if (!isLast && words.length === 1 && words[0] === 'satu') {
+        // Use se- prefix for singular scale units: seribu, sejuta, sebilion, setrilion
+        wordList.push('se' + scaleWord)
+        continue
+      }
+
+      // Add current block words
+      for (const w of words) wordList.push(w)
+
+      // Append scale word if applicable and current block contributed words
+      if (!isLast && words.length > 0) {
+        wordList.push(scaleWord)
+      }
+    }
+
+    return wordList.join(' ')
+  }
+
+  integerToWords (integerPart) {
+    return this.join(
+      this.spell(
+        this.splitBy3(integerPart)
+      )
+    ).trim()
+  }
+}

package/lib/languages/nb.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Norwegian Bokmål language converter.
+ *
+ * Supports:
+ * - Hyphenation for compound numbers (tjue-en)
+ * - "og" (and) for hundreds combinations
+ * - Implicit '1' omission before tens and magnitudes
+ */
+export class NorwegianBokmal extends GreedyScaleLanguage {
+    scaleWords: (string | bigint)[][];
+}
+import { GreedyScaleLanguage } from '../classes/greedy-scale-language.js';

package/lib/languages/nb.js

@@ -0,0 +1,100 @@
+import { GreedyScaleLanguage } from '../classes/greedy-scale-language.js'
+
+/**
+ * Norwegian Bokmål language converter.
+ *
+ * Supports:
+ * - Hyphenation for compound numbers (tjue-en)
+ * - "og" (and) for hundreds combinations
+ * - Implicit '1' omission before tens and magnitudes
+ */
+export class NorwegianBokmal extends GreedyScaleLanguage {
+  negativeWord = 'minus'
+  decimalSeparatorWord = 'komma'
+  zeroWord = 'null'
+
+  scaleWords = [
+    [1_000_000_000_000_000_000_000_000_000n, 'oktillion'],
+    [1_000_000_000_000_000_000_000_000n, 'septillion'],
+    [1_000_000_000_000_000_000_000n, 'sekstillion'],
+    [1_000_000_000_000_000_000n, 'kvintillion'],
+    [1_000_000_000_000_000n, 'kvadrillion'],
+    [1_000_000_000_000n, 'billion'],
+    [1_000_000_000n, 'milliard'],
+    [1_000_000n, 'million'],
+    [1000n, 'tusen'],
+    [100n, 'hundre'],
+    [90n, 'nitti'],
+    [80n, 'åtti'],
+    [70n, 'sytti'],
+    [60n, 'seksti'],
+    [50n, 'femti'],
+    [40n, 'førti'],
+    [30n, 'tretti'],
+    [20n, 'tjue'],
+    [19n, 'nitten'],
+    [18n, 'atten'],
+    [17n, 'sytten'],
+    [16n, 'seksten'],
+    [15n, 'femten'],
+    [14n, 'fjorten'],
+    [13n, 'tretten'],
+    [12n, 'tolv'],
+    [11n, 'elleve'],
+    [10n, 'ti'],
+    [9n, 'ni'],
+    [8n, 'åtte'],
+    [7n, 'syv'],
+    [6n, 'seks'],
+    [5n, 'fem'],
+    [4n, 'fire'],
+    [3n, 'tre'],
+    [2n, 'to'],
+    [1n, 'en'],
+    [0n, 'null']
+  ]
+
+  /**
+   * Merges two adjacent word-sets according to Norwegian grammar rules.
+   *
+   * Norwegian-specific rules:
+   * - Implicit "en": `combineWordSets({ 'en': 1n }, { 'hundre': 100n })` → `{ 'hundre': 100n }`
+   * - Hyphenation for compound tens: `combineWordSets({ 'tjue': 20n }, { 'en': 1n })` → `{ 'tjue-en': 21n }`
+   * - "og" (and) after hundreds: `combineWordSets({ 'hundre': 100n }, { 'en': 1n })` → `{ 'hundre og en': 101n }`
+   * - Space-separated for large numbers (thousands+)
+   * - Comma separator for non-magnitude additions (e.g., \"tusen, en\")
+   *
+   * @param {Object} preceding The preceding word-set as `{ word: BigInt }`.
+   * @param {Object} following The following word-set as `{ word: BigInt }`.
+   * @returns {Object} Merged pair with combined word and resulting numeric value.
+   *
+   * @example
+   * combineWordSets({ 'en': 1n }, { 'hundre': 100n }); // { 'hundre': 100n }
+   * combineWordSets({ 'tjue': 20n }, { 'tre': 3n }); // { 'tjue-tre': 23n }
+   */
+  // Norwegian merge rules mirror the former Scandinavian base logic
+  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
+    }
+
+    if (precedingValue < 100n && precedingValue > followingValue) {
+      return { [`${precedingWord}-${followingWord}`]: precedingValue + followingValue }
+    }
+
+    if (precedingValue >= 100n && followingValue < 100n) {
+      return { [`${precedingWord} og ${followingWord}`]: precedingValue + followingValue }
+    }
+
+    if (followingValue > precedingValue) {
+      return { [`${precedingWord} ${followingWord}`]: precedingValue * followingValue }
+    }
+
+    return { [`${precedingWord}, ${followingWord}`]: precedingValue + followingValue }
+  }
+}

package/lib/languages/nl.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Dutch language converter.
+ *
+ * Supports:
+ * - Optional "en" (and) separator for tens
+ * - Optional comma before hundreds
+ * - Compound word formation without hyphenation
+ */
+export class Dutch extends GreedyScaleLanguage {
+    constructor(options?: {});
+    scaleWords: (string | bigint)[][];
+    /** Combines two word-sets according to Dutch grammar rules. */
+    combineWordSets(preceding: any, following: any): any;
+    integerToWords(integerPart: any): string;
+}
+import { GreedyScaleLanguage } from '../classes/greedy-scale-language.js';