n2words 1.24.0 → 2.0.0

package/lib/languages/he.js

@@ -1,45 +1,22 @@
-import SlavicLanguage from '../classes/slavic-language.js'
+import { SlavicLanguage } from '../classes/slavic-language.js'
 
 /**
- * @typedef {Object} HebrewOptions
- * @property {string} [and='ו'] Conjunction character (typically 'ו' for and).
- * @property {boolean} [biblical=false] Use biblical scale words instead of modern ones.
- * @property {boolean} [feminine=false] Use feminine forms for numbers.
- */
-
-/**
- * Hebrew language converter.
- *
- * Implements Hebrew number words using the Slavic language pattern:
- * - Hebrew alphabet and right-to-left text
- * - Hebrew number words (אחת, שתים, שלוש, ארבע...)
- * - Feminine number forms (default in Hebrew)
- * - Optional "ve" (ו, "and") conjunction between number groups
+ * Modern Hebrew language converter.
  *
- * Key Features:
- * - Three-form pluralization system shared across Slavic languages
- *   * Form 1 (singular): 1 (e.g., "אלף")
- *   * Form 2 (few): 2-4, 22-24, 32-34... excluding teens (e.g., "אלפים")
- *   * Form 3 (many): all other numbers (e.g., "אלף")
- * - 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:
+ * Supports:
  * - Right-to-left text orientation
- * - Feminine grammatical gender for numbers
- * - Three-form pluralization (similar to Slavic pattern)
- * - Conjunction control via "and" option
- *
- * Inherits from SlavicLanguage for complex pluralization algorithms.
+ * - Feminine grammatical forms (default in Modern Hebrew)
+ * - Three-form pluralization (singular/few/many)
+ * - Optional "ve" (ו) conjunction via options
  */
 export class Hebrew extends SlavicLanguage {
   negativeWord = 'מינוס'
   decimalSeparatorWord = 'נקודה'
   zeroWord = 'אפס'
-  convertDecimalsPerDigit = true
+  usePerDigitDecimals = true
 
-  // Modern Hebrew (feminine forms)
-  ones = {
+  // Feminine forms (default in Modern Hebrew)
+  onesWords = {
     1: 'אחת',
     2: 'שתים',
     3: 'שלש',
@@ -51,7 +28,7 @@ export class Hebrew extends SlavicLanguage {
     9: 'תשע'
   }
 
-  tens = {
+  teensWords = {
     0: 'עשר',
     1: 'אחת עשרה',
     2: 'שתים עשרה',
@@ -64,7 +41,7 @@ export class Hebrew extends SlavicLanguage {
     9: 'תשע עשרה'
   }
 
-  twenties = {
+  twentiesWords = {
     2: 'עשרים',
     3: 'שלשים',
     4: 'ארבעים',
@@ -75,13 +52,13 @@ export class Hebrew extends SlavicLanguage {
     9: 'תשעים'
   }
 
-  hundreds = {
+  hundredsWords = {
     1: 'מאה',
     2: 'מאתיים',
     3: 'מאות'
   }
 
-  thousands = {
+  pluralForms = {
     1: 'אלף',
     2: 'אלפיים',
     3: 'שלשת אלפים',
@@ -111,116 +88,29 @@ export class Hebrew extends SlavicLanguage {
     6: 'קווינטיליונים' // quintillions
   }
 
-  // Biblical Hebrew (masculine forms)
-  biblicalOnes = {
-    1: 'אחד',
-    2: 'שניים',
-    3: 'שלשה',
-    4: 'ארבעה',
-    5: 'חמשה',
-    6: 'ששה',
-    7: 'שבעה',
-    8: 'שמונה',
-    9: 'תשעה'
-  }
+  constructor (options = {}) {
+    super(options)
 
-  biblicalTens = {
-    0: 'עשרה',
-    1: 'אחד עשר',
-    2: 'שנים עשר',
-    3: 'שלשה עשר',
-    4: 'ארבעה עשר',
-    5: 'חמשה עשר',
-    6: 'ששה עשר',
-    7: 'שבעה עשר',
-    8: 'שמונה עשר',
-    9: 'תשעה עשר'
+    this.setOptions({
+      andWord: 'ו'
+    }, options)
   }
 
-  biblicalTwenties = {
-    2: 'עשרים',
-    3: 'שלשים',
-    4: 'ארבעים',
-    5: 'חמישים',
-    6: 'ששים',
-    7: 'שבעים',
-    8: 'שמונים',
-    9: 'תשעים'
-  }
-
-  biblicalHundreds = {
-    1: 'מאה',
-    2: 'מאתיים',
-    3: 'מאות'
-  }
-
-  biblicalThousands = {
-    1: 'אלף',
-    2: 'אלפיים',
-    3: 'שלשת אלפים',
-    4: 'ארבעת אלפים',
-    5: 'חמשת אלפים',
-    6: 'ששת אלפים',
-    7: 'שבעת אלפים',
-    8: 'שמונת אלפים',
-    9: 'תשעת אלפים'
-  }
-
-  biblicalScale = {
-    1: 'אלף',
-    2: 'מיליון',
-    3: 'מיליארד',
-    4: 'טריליון',
-    5: 'קוודרליון',
-    6: 'קווינטיליון'
-  }
-
-  biblicalScalePlural = {
-    1: 'אלפים',
-    2: 'מיליונים',
-    3: 'מיליארדים',
-    4: 'טריליונים',
-    5: 'קוודרליונים',
-    6: 'קווינטיליונים'
-  }
-
-  /**
-   * Initializes the Hebrew converter with language-specific options.
-   *
-   * @param {HebrewOptions} [options={}] Configuration options.
-   */
-  constructor ({ and = 'ו', biblical = false, feminine = false } = {}) {
-    super({ feminine })
-
-    this.and = and
-    this.feminine = feminine
-
-    this.biblical = biblical
-    if (this.biblical) {
-      this.ones = this.biblicalOnes
-      this.tens = this.biblicalTens
-      this.twenties = this.biblicalTwenties
-      this.hundreds = this.biblicalHundreds
-      this.thousands = this.biblicalThousands
-      this.scale = this.biblicalScale
-      this.scalePlural = this.biblicalScalePlural
-    }
-  }
-
-  convertWholePart (number) {
-    if (number === 0n) {
+  /** Converts integer part to Hebrew words with special handling for thousands. */
+  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 (index > 0) {
         // For thousands and above, handle the full chunk value
@@ -231,35 +121,35 @@ export class Hebrew extends SlavicLanguage {
         if (n3 > 0n) {
           hasHundreds = true
           if (n3 <= 2n) {
-            chunkWords.push(this.hundreds[n3])
+            chunkWords.push(this.hundredsWords[n3])
           } else {
-            chunkWords.push(this.ones[n3] + ' ' + this.hundreds[3])
+            chunkWords.push(this.onesWords[n3] + ' ' + this.hundredsWords[3])
           }
         }
 
         // Process tens in this chunk
         if (n2 > 1n) {
           // Add conjunction if there were hundreds before
-          const tensWord = this.twenties[n2]
-          chunkWords.push(hasHundreds ? this.and + tensWord : tensWord)
+          const tensWord = this.twentiesWords[n2]
+          chunkWords.push(hasHundreds ? this.options.andWord + tensWord : tensWord)
         }
 
         // Process ones in this chunk
         if (n2 === 1n) {
           // Add conjunction if there were hundreds before
-          const onesWord = this.tens[n1]
-          chunkWords.push(hasHundreds ? this.and + onesWord : onesWord)
+          const onesWord = this.teensWords[n1]
+          chunkWords.push(hasHundreds ? this.options.andWord + onesWord : onesWord)
         } else if (n1 > 0n) {
           // For "one million", "one billion", etc., don't add the word "one"
           if (x === 1n && index > 1) {
             // Skip adding "one" for millions/billions/etc.
           } else if (x <= 9n && chunkWords.length === 0 && index === 1) {
             // Use special forms for 1-9 thousand
-            chunkWords.push(this.thousands[n1])
+            chunkWords.push(this.pluralForms[n1])
           } else {
-            const onesWord = this.ones[n1]
+            const onesWord = this.onesWords[n1]
             // Add conjunction if there were hundreds or tens before
-            chunkWords.push((hasHundreds || n2 > 0n) ? this.and + onesWord : onesWord)
+            chunkWords.push((hasHundreds || n2 > 0n) ? this.options.andWord + onesWord : onesWord)
           }
         }
 
@@ -271,7 +161,7 @@ export class Hebrew extends SlavicLanguage {
             chunkWords.push(this.scale[index])
           } else if (x === 2n && index === 1) {
             // Special dual form for "two thousand" (already in thousands[2])
-            return [this.thousands[2], ...words].join(' ')
+            return [this.pluralForms[2], ...words].join(' ')
           } else if (x === 2n) {
             // For two million, two billion, etc. - use plural form
             chunkWords.push(this.scalePlural[index])
@@ -290,40 +180,27 @@ export class Hebrew extends SlavicLanguage {
 
       if (n3 > 0n) {
         if (n3 <= 2n) {
-          words.push(this.hundreds[n3])
+          words.push(this.hundredsWords[n3])
         } else {
-          words.push(this.ones[n3] + ' ' + this.hundreds[3])
+          words.push(this.onesWords[n3] + ' ' + this.hundredsWords[3])
         }
       }
 
       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) {
-        words.push(this.ones[n1])
+        words.push(this.onesWords[n1])
       }
     }
 
     if (words.length > 1) {
-      words[words.length - 1] = this.and + words.at(-1)
+      words[words.length - 1] = this.options.andWord + words.at(-1)
     }
 
     return words.join(' ')
   }
 }
-
-/**
- * Converts a number to Hebrew cardinal (written) form.
- *
- * @param {number|string|bigint} value The number to convert.
- * @param {HebrewOptions} [options={}] Configuration options.
- * @returns {string} The number expressed in Hebrew 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 Hebrew(options).convertToWords(value)
-}

package/lib/languages/hi.d.ts

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

package/lib/languages/hi.js

@@ -1,11 +1,20 @@
-import SouthAsianLanguage from '../classes/south-asian-language.js'
+import { SouthAsianLanguage } from '../classes/south-asian-language.js'
 
-class Hindi extends SouthAsianLanguage {
+/**
+ * Hindi language converter.
+ *
+ * Supports:
+ * - Indian numbering system (हज़ार, लाख, करोड़)
+ * - Devanagari script
+ * - Complete word forms for 0-99
+ */
+export class Hindi extends SouthAsianLanguage {
   negativeWord = 'माइनस'
   decimalSeparatorWord = 'दशमलव'
   zeroWord = 'शून्य'
   hundredWord = 'सौ'
-  belowHundred = [
+
+  belowHundredWords = [
     'शून्य',
     'एक',
     'दो',
@@ -120,7 +129,3 @@ class Hindi extends SouthAsianLanguage {
     'शंख'
   ]
 }
-
-export default function convertToWords (value, options = {}) {
-  return new Hindi(options).convertToWords(value)
-}

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

@@ -1,52 +1,43 @@
-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'
 
 /**
  * Croatian language converter.
  *
- * Implements Croatian number words using the Slavic language pattern:
- * - Croatian number words (jedan/jedna, dva/dvije, tri, četiri...)
- * - Gender-aware forms (masculine/feminine)
- * - Slavic three-form pluralization (tisuća/tisuće/tisuća)
+ * Supports:
+ * - Three-form pluralization (one/few/many)
+ * - Gender agreement (jedan/jedna, dva/dvije)
  * - Croatian-specific declension endings
- *
- * Key Features:
- * - Three-form pluralization system shared across Slavic languages
- *   * Form 1 (singular): 1 (e.g., "tisuća")
- *   * Form 2 (few): 2-4, 22-24, 32-34... excluding teens (e.g., "tisuće")
- *   * Form 3 (many): all other numbers (e.g., "tisuća")
- * - 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
- * - Gender-specific number forms for 1 and 2 (masculine/feminine dual forms)
- *
- * Features:
- * - Dual gender forms for 1 and 2 (jedan/jedna, dva/dvije)
- * - Latin script orthography
- * - Similar structure to Serbian
- *
- * Inherits from SlavicLanguage for complex pluralization algorithms.
  */
 export class Croatian extends SlavicLanguage {
   negativeWord = 'minus'
   decimalSeparatorWord = 'zarez'
   zeroWord = 'nula'
-  ones = {
-    1: ['jedan', 'jedna'],
-    2: ['dva', 'dvije'],
-    3: ['tri', 'tri'],
-    4: ['četiri', 'četiri'],
-    5: ['pet', 'pet'],
-    6: ['šest', 'šest'],
-    7: ['sedam', 'sedam'],
-    8: ['osam', 'osam'],
-    9: ['devet', 'devet']
+
+  onesWords = {
+    1: 'jedan',
+    2: 'dva',
+    3: 'tri',
+    4: 'četiri',
+    5: 'pet',
+    6: 'šest',
+    7: 'sedam',
+    8: 'osam',
+    9: 'devet'
   }
 
-  tens = {
+  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',
@@ -59,7 +50,7 @@ export class Croatian extends SlavicLanguage {
     9: 'devetnaest'
   }
 
-  twenties = {
+  twentiesWords = {
     2: 'dvadeset',
     3: 'trideset',
     4: 'četrdeset',
@@ -70,7 +61,7 @@ export class Croatian extends SlavicLanguage {
     9: 'devedeset'
   }
 
-  hundreds = {
+  hundredsWords = {
     1: 'sto',
     2: 'dvjesto',
     3: 'tristo',
@@ -82,20 +73,29 @@ export class Croatian extends SlavicLanguage {
     9: 'devetsto'
   }
 
-  SCALE = {
-    0: ['', '', '', false],
-    1: ['tisuća', 'tisuće', 'tisuća', true], // 10 ^ 3
-    2: ['milijun', 'milijuna', 'milijuna', false], // 10 ^ 6
-    3: ['milijarda', 'milijarde', 'milijarda', false], // 10 ^ 9
-    4: ['bilijun', 'bilijuna', 'bilijuna', false], // 10 ^ 12
-    5: ['bilijarda', 'bilijarde', 'bilijarda', false], // 10 ^ 15
-    6: ['trilijun', 'trilijuna', 'trilijuna', false], // 10 ^ 18
-    7: ['trilijarda', 'trilijarde', 'trilijarda', false], // 10 ^ 21
-    8: ['kvadrilijun', 'kvadrilijuna', 'kvadrilijuna', false], // 10 ^ 24
-    9: ['kvadrilijarda', 'kvadrilijarde', 'kvadrilijarda', false], // 10 ^ 27
-    10: ['kvintilijun', 'kvintilijuna', 'kvintilijuna', false] // 10 ^ 30
+  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
@@ -110,48 +110,4 @@ export class Croatian extends SlavicLanguage {
 
     return forms[2]
   }
-
-  convertWholePart (number) {
-    if (number === 0n) {
-      return this.zeroWord
-    }
-    const words = []
-    const chunks = this.splitByX(number.toString(), 3)
-    let index = chunks.length
-    for (const x of chunks) {
-      index = index - 1
-      const [n1, n2, n3] = this.getDigits(x)
-      if (n3 > 0n) {
-        words.push(this.hundreds[n3])
-      }
-      if (n2 > 1n) {
-        words.push(this.twenties[n2])
-      }
-      if (n2 === 1n) {
-        words.push(this.tens[n1])
-      } else if (n1 > 0n) {
-        const isFeminine = (this.feminine || this.SCALE[index][3])
-        const genderIndex = isFeminine ? 1 : 0
-        words.push(this.ones[n1][genderIndex])
-      }
-      if ((index > 0) && (x !== 0n)) {
-        words.push(this.pluralize(x, this.SCALE[index]))
-      }
-    }
-    return words.join(' ')
-  }
-}
-
-/**
- * Converts a number to Croatian 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 Croatian 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 Croatian(options).convertToWords(value)
 }

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