n2words 1.24.0 → 2.0.0

package/lib/languages/lv.js

@@ -1,40 +1,19 @@
-import SlavicLanguage from '../classes/slavic-language.js'
-
-/**
- * @typedef {Object} SlavicOptions
- * @property {boolean} [feminine=false] Use feminine forms for numbers.
- */
+import { SlavicLanguage } from '../classes/slavic-language.js'
 
 /**
  * Latvian language converter.
  *
- * Implements Latvian number words using the Slavic language pattern:
- * - Latvian number words (viens, divi, trīs, četri, pieci...)
- * - Latvian-specific pluralization patterns
- * - Baltic grammatical structure
- * - Simplified gender handling compared to Lithuanian
- *
- * Key Features:
- * - Three-form pluralization system shared across Slavic/Baltic languages
- *   * Form 1 (singular): 1 (e.g., "tūkstotis")
- *   * Form 2 (few): 2-4, 22-24, 32-34... excluding teens (e.g., "tūkstoši")
- *   * Form 3 (many): all other numbers (e.g., "tūkstošu")
- * - Chunk-based decomposition (splits into groups of 3 digits: ones, thousands, millions, etc.)
- * - Large number handling via thousands[] array with indexed [singular, few, many] forms
- *
- * Features:
- * - Latvian diacritical marks (ī, ā, ē, ū, etc.)
- * - Three-form pluralization (adapted for Latvian)
- * - Baltic number naming conventions
+ * Supports:
+ * - Three-form pluralization (one/few/many)
+ * - Latvian diacritical marks (ī, ā, ē, ū)
  * - Compound number formation (divdesmit, trīsdesmit)
- *
- * Inherits from SlavicLanguage for pluralization algorithms.
  */
 export class Latvian extends SlavicLanguage {
   negativeWord = 'mīnus'
   decimalSeparatorWord = 'komats'
   zeroWord = 'nulle'
-  ones = {
+
+  onesWords = {
     1: 'viens',
     2: 'divi',
     3: 'trīs',
@@ -46,7 +25,19 @@ export class Latvian extends SlavicLanguage {
     9: 'deviņi'
   }
 
-  tens = {
+  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',
@@ -59,7 +50,7 @@ export class Latvian extends SlavicLanguage {
     9: 'deviņpadsmit'
   }
 
-  twenties = {
+  twentiesWords = {
     2: 'divdesmit',
     3: 'trīsdesmit',
     4: 'četrdesmit',
@@ -70,9 +61,9 @@ export class Latvian extends SlavicLanguage {
     9: 'deviņdesmit'
   }
 
-  hundreds = ['simts', 'simti', 'simtu']
+  hundredsWords = ['simts', 'simti', 'simtu']
 
-  thousands = {
+  pluralForms = {
     1: ['tūkstotis', 'tūkstoši', 'tūkstošu'],
     2: ['miljons', 'miljoni', 'miljonu'],
     3: ['miljards', 'miljardi', 'miljardu'],
@@ -100,54 +91,40 @@ export class Latvian extends SlavicLanguage {
     return forms[1]
   }
 
-  convertWholePart (number) {
-    if (number === 0n) {
+  integerToWords (integerPart) {
+    if (integerPart === 0n) {
       return this.zeroWord
     }
     const words = []
-    const chunks = this.splitByX(number.toString(), 3)
-    let index = chunks.length
-    for (const x of chunks) {
+    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.getDigits(x)
+      const [n1, n2, n3] = this.extractDigits(x)
       if (n3 > 0n) {
         if (n3 === 1n && n2 === 0n && n1 > 0n) {
-          words.push(this.hundreds[2])
+          words.push(this.hundredsWords[2])
         } else if (n3 > 1n) {
-          words.push(this.ones[n3], this.hundreds[1])
+          words.push(this.onesWords[n3], this.hundredsWords[1])
         } else {
-          words.push(this.hundreds[0])
+          words.push(this.hundredsWords[0])
         }
       }
       if (n2 > 1n) {
-        words.push(this.twenties[n2])
+        words.push(this.twentiesWords[n2])
       }
       if (n2 === 1n) {
-        words.push(this.tens[n1])
+        words.push(this.teensWords[n1])
       } else if (n1 > 0n && !(index > 0 && x === 1n)) {
-        words.push(this.ones[n1])
+        words.push(this.onesWords[n1])
       }
       if (index > 0) {
-        words.push(this.pluralize(x, this.thousands[index]))
+        words.push(this.pluralize(x, this.pluralForms[index]))
       }
     }
     return words.join(' ')
   }
 }
-
-/**
- * Converts a number to Latvian cardinal (written) form.
- *
- * @param {number|string|bigint} value The number to convert.
- * @param {Object} [options={}] Configuration options.
- * @param {boolean} [options.feminine=false] Use feminine forms for numbers.
- * @returns {string} The number expressed in Latvian words.
- * @throws {TypeError} If value is NaN or invalid type.
- * @throws {Error} If value is an invalid number string.
- */
-export default function convertToWords (value, options = {}) {
-  return new Latvian(options).convertToWords(value)
-}

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

@@ -1,30 +1,21 @@
-/**
- * Marathi language implementation for n2words
- *
- * Marathi uses Indian-style number grouping (3 digits, then 2-2 from right).
- * Numbers: शून्य (0), एक (1), दोन (2), तीन (3), चार (4), पाच (5)...
- *
- * @module lib/languages/mr
- * @example
- * import mr from './lib/languages/mr.js'
- * mr(42) // 'बेचाळीस'
- * mr(1000) // 'एक हजार'
- */
-
-import SouthAsianLanguage from '../classes/south-asian-language.js'
+import { SouthAsianLanguage } from '../classes/south-asian-language.js'
 
 /**
- * Marathi language implementation
- * Extends SouthAsianLanguage for Indian-style grouping
+ * Marathi language converter.
+ *
+ * Supports:
+ * - Indian numbering system (हजार, लाख, कोटी)
+ * - Devanagari script
+ * - Complete word forms for 0-99
  */
-class MarathiLanguage extends SouthAsianLanguage {
+export class Marathi extends SouthAsianLanguage {
   negativeWord = 'उणे'
   decimalSeparatorWord = 'दशांश'
   zeroWord = 'शून्य'
   hundredWord = 'शंभर'
-  convertDecimalsPerDigit = true
+  usePerDigitDecimals = true
 
-  belowHundred = [
+  belowHundredWords = [
     'शून्य',
     'एक',
     'दोन',
@@ -139,18 +130,3 @@ class MarathiLanguage extends SouthAsianLanguage {
     'शंकू'
   ]
 }
-
-/**
- * Convert a number to Marathi words
- *
- * @param {number|string|bigint} value - The number to convert
- * @param {Object} [options={}] - Conversion options
- * @returns {string} The Marathi word representation
- * @example
- * convertToWords(42) // 'बेचाळीस'
- * convertToWords(1000) // 'एक हजार'
- * convertToWords(100000) // 'एक लाख'
- */
-export default function convertToWords (value, options = {}) {
-  return new MarathiLanguage(options).convertToWords(value)
-}

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

@@ -1,19 +1,23 @@
-import AbstractLanguage from '../classes/abstract-language.js'
+import { AbstractLanguage } from '../classes/abstract-language.js'
 
 /**
  * Malay (Bahasa Melayu) language converter.
  *
- * Conventions:
- * - Base-10 structure
- * - "Se-" prefix for singular units (seratus, seribu, sejuta, sebilion, setrilion)
- * - Space-separated components (no conjunction like "dan" for tens/ones)
- * - Grouping by thousands (ribu, juta, bilion, trilion)
+ * 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'
-  base = {
+
+  /**
+   * Word forms for digits 0-9.
+   * @type {Object.<number, string[]>}
+   */
+  digitWords = {
     0: [],
     1: ['satu'],
     2: ['dua'],
@@ -26,7 +30,11 @@ export class Malay extends AbstractLanguage {
     9: ['sembilan']
   }
 
-  thousands = {
+  /**
+   * Scale magnitude words keyed by exponent (10^n).
+   * @type {Object.<number, string>}
+   */
+  scaleWords = {
     3: 'ribu',
     6: 'juta',
     9: 'bilion',
@@ -62,7 +70,7 @@ export class Malay extends AbstractLanguage {
     let spelling
     const firstBlock = blocks[0]
     if (firstBlock[0].length === 1) {
-      spelling = firstBlock[0] === '0' ? ['sifar'] : this.base[Math.trunc(firstBlock[0])]
+      spelling = firstBlock[0] === '0' ? ['sifar'] : this.digitWords[Math.trunc(firstBlock[0])]
     } else if (firstBlock[0].length === 2) {
       spelling = this.getTens(firstBlock[0])
     } else {
@@ -84,7 +92,7 @@ export class Malay extends AbstractLanguage {
     } else if (number === '0') {
       return []
     } else {
-      return [...this.base[Math.trunc(number)], 'ratus']
+      return [...this.digitWords[Math.trunc(number)], 'ratus']
     }
   }
 
@@ -95,14 +103,14 @@ export class Malay extends AbstractLanguage {
       } else if (number[1] === '1') {
         return ['sebelas']
       }
-      return [...this.base[Math.trunc(number[1])], 'belas']
+      return [...this.digitWords[Math.trunc(number[1])], 'belas']
     }
 
     if (number[0] === '0') {
-      return this.base[Math.trunc(number[1])]
+      return this.digitWords[Math.trunc(number[1])]
     }
 
-    return [...this.base[Math.trunc(number[0])], 'puluh', ...this.base[Math.trunc(number[1])]]
+    return [...this.digitWords[Math.trunc(number[0])], 'puluh', ...this.digitWords[Math.trunc(number[1])]]
   }
 
   join (wordBlocks) {
@@ -112,7 +120,7 @@ export class Malay extends AbstractLanguage {
     for (let index = 0; index <= length; index++) {
       const words = wordBlocks[index][1]
       const isLast = index === length
-      const scaleWord = isLast ? null : this.thousands[(length - index) * 3]
+      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
@@ -132,15 +140,11 @@ export class Malay extends AbstractLanguage {
     return wordList.join(' ')
   }
 
-  convertWholePart (number) {
+  integerToWords (integerPart) {
     return this.join(
       this.spell(
-        this.splitBy3(number)
+        this.splitBy3(integerPart)
       )
     ).trim()
   }
 }
-
-export default function convertToWords (value, options = {}) {
-  return new Malay(options).convertToWords(value)
-}

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

@@ -1,29 +1,26 @@
-import GreedyScaleLanguage from '../classes/greedy-scale-language.js'
+import { GreedyScaleLanguage } from '../classes/greedy-scale-language.js'
 
 /**
- * Norwegian language converter.
+ * Norwegian Bokmål language converter.
  *
- * GreedyScaleLanguage with inline Norwegian merge rules:
- * - Hyphenation for compound numbers (e.g., "tjueen")
+ * Supports:
+ * - Hyphenation for compound numbers (tjue-en)
  * - "og" (and) for hundreds combinations
- * - Comma separation for non-magnitude additions
- * - Implicit '1' before tens and magnitudes
- * - Space separators for large numbers
+ * - Implicit '1' omission before tens and magnitudes
  */
-export class Norwegian extends GreedyScaleLanguage {
+export class NorwegianBokmal extends GreedyScaleLanguage {
   negativeWord = 'minus'
   decimalSeparatorWord = 'komma'
   zeroWord = 'null'
-  scaleWordPairs = [
-    [1_000_000_000_000_000_000_000_000_000_000_000n, 'quintillard'],
-    [1_000_000_000_000_000_000_000_000_000_000n, 'quintillion'],
-    [1_000_000_000_000_000_000_000_000_000n, 'quadrillard'],
-    [1_000_000_000_000_000_000_000_000n, 'quadrillion'],
-    [1_000_000_000_000_000_000_000n, 'trillard'],
-    [1_000_000_000_000_000_000n, 'trillion'],
-    [1_000_000_000_000_000n, 'billard'],
+
+  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, 'millard'],
+    [1_000_000_000n, 'milliard'],
     [1_000_000n, 'million'],
     [1000n, 'tusen'],
     [100n, 'hundre'],
@@ -58,63 +55,46 @@ export class Norwegian extends GreedyScaleLanguage {
   ]
 
   /**
-   * Merges two adjacent word-number pairs according to Norwegian grammar rules.
+   * Merges two adjacent word-sets according to Norwegian grammar rules.
    *
    * Norwegian-specific rules:
-   * - Implicit \"en\": `mergeScales({ 'en': 1n }, { 'hundre': 100n })` → `{ 'hundre': 100n }`
-   * - Hyphenation for compound tens: `mergeScales({ 'tjue': 20n }, { 'en': 1n })` → `{ 'tjue-en': 21n }`
-   * - \"og\" (and) after hundreds: `mergeScales({ 'hundre': 100n }, { 'en': 1n })` → `{ 'hundre og en': 101n }`
+   * - 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} leftPair The left operand as `{ word: BigInt }`.
-   * @param {Object} rightPair The right operand as `{ word: BigInt }`.
+   * @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
-   * mergeScales({ 'en': 1n }, { 'hundre': 100n }); // { 'hundre': 100n }
-   * mergeScales({ 'tjue': 20n }, { 'tre': 3n }); // { 'tjue-tre': 23n }
+   * combineWordSets({ 'en': 1n }, { 'hundre': 100n }); // { 'hundre': 100n }
+   * combineWordSets({ 'tjue': 20n }, { 'tre': 3n }); // { 'tjue-tre': 23n }
    */
   // Norwegian merge rules mirror the former Scandinavian base logic
-  mergeScales (leftPair, rightPair) {
-    const leftWord = Object.keys(leftPair)[0]
-    const rightWord = Object.keys(rightPair)[0]
-    const leftNumber = Object.values(leftPair)[0]
-    const rightNumber = Object.values(rightPair)[0]
+  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 (leftNumber === 1n && rightNumber < 100n) {
-      return rightPair
+    if (precedingValue === 1n && followingValue < 100n) {
+      return following
     }
 
-    if (leftNumber < 100n && leftNumber > rightNumber) {
-      return { [`${leftWord}-${rightWord}`]: leftNumber + rightNumber }
+    if (precedingValue < 100n && precedingValue > followingValue) {
+      return { [`${precedingWord}-${followingWord}`]: precedingValue + followingValue }
     }
 
-    if (leftNumber >= 100n && rightNumber < 100n) {
-      return { [`${leftWord} og ${rightWord}`]: leftNumber + rightNumber }
+    if (precedingValue >= 100n && followingValue < 100n) {
+      return { [`${precedingWord} og ${followingWord}`]: precedingValue + followingValue }
     }
 
-    if (rightNumber > leftNumber) {
-      return { [`${leftWord} ${rightWord}`]: leftNumber * rightNumber }
+    if (followingValue > precedingValue) {
+      return { [`${precedingWord} ${followingWord}`]: precedingValue * followingValue }
     }
 
-    return { [`${leftWord}, ${rightWord}`]: leftNumber + rightNumber }
+    return { [`${precedingWord}, ${followingWord}`]: precedingValue + followingValue }
   }
 }
-
-/**
- * Converts a number to Norwegian cardinal (written) form.
- *
- * @param {number|string|bigint} value The number to convert.
- * @param {Object} [options] Conversion options (see Norwegian class options).
- * @returns {string} The number expressed in Norwegian words.
- * @throws {TypeError} If value is NaN or invalid type.
- * @throws {Error} If value is an invalid number string.
- *
- * @example
- * convertToWords(42); // 'førti-to'
- * convertToWords('1.5'); // 'en komma fem'
- */
-export default function convertToWords (value, options = {}) {
-  return new Norwegian(options).convertToWords(value)
-}

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';