n2words 1.23.0 → 1.24.0

package/lib/languages/he.js

@@ -0,0 +1,329 @@
+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
+ *
+ * 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:
+ * - 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.
+ */
+export class Hebrew extends SlavicLanguage {
+  negativeWord = 'מינוס'
+  decimalSeparatorWord = 'נקודה'
+  zeroWord = 'אפס'
+  convertDecimalsPerDigit = true
+
+  // Modern Hebrew (feminine forms)
+  ones = {
+    1: 'אחת',
+    2: 'שתים',
+    3: 'שלש',
+    4: 'ארבע',
+    5: 'חמש',
+    6: 'שש',
+    7: 'שבע',
+    8: 'שמונה',
+    9: 'תשע'
+  }
+
+  tens = {
+    0: 'עשר',
+    1: 'אחת עשרה',
+    2: 'שתים עשרה',
+    3: 'שלש עשרה',
+    4: 'ארבע עשרה',
+    5: 'חמש עשרה',
+    6: 'שש עשרה',
+    7: 'שבע עשרה',
+    8: 'שמונה עשרה',
+    9: 'תשע עשרה'
+  }
+
+  twenties = {
+    2: 'עשרים',
+    3: 'שלשים',
+    4: 'ארבעים',
+    5: 'חמישים',
+    6: 'ששים',
+    7: 'שבעים',
+    8: 'שמונים',
+    9: 'תשעים'
+  }
+
+  hundreds = {
+    1: 'מאה',
+    2: 'מאתיים',
+    3: 'מאות'
+  }
+
+  thousands = {
+    1: 'אלף',
+    2: 'אלפיים',
+    3: 'שלשת אלפים',
+    4: 'ארבעת אלפים',
+    5: 'חמשת אלפים',
+    6: 'ששת אלפים',
+    7: 'שבעת אלפים',
+    8: 'שמונת אלפים',
+    9: 'תשעת אלפים'
+  }
+
+  scale = {
+    1: 'אלף', // thousand (singular)
+    2: 'מיליון', // million
+    3: 'מיליארד', // billion
+    4: 'טריליון', // trillion
+    5: 'קוודרליון', // quadrillion
+    6: 'קווינטיליון' // quintillion
+  }
+
+  scalePlural = {
+    1: 'אלפים', // thousands
+    2: 'מיליונים', // millions
+    3: 'מיליארדים', // billions
+    4: 'טריליונים', // trillions
+    5: 'קוודרליונים', // quadrillions
+    6: 'קווינטיליונים' // quintillions
+  }
+
+  // Biblical Hebrew (masculine forms)
+  biblicalOnes = {
+    1: 'אחד',
+    2: 'שניים',
+    3: 'שלשה',
+    4: 'ארבעה',
+    5: 'חמשה',
+    6: 'ששה',
+    7: 'שבעה',
+    8: 'שמונה',
+    9: 'תשעה'
+  }
+
+  biblicalTens = {
+    0: 'עשרה',
+    1: 'אחד עשר',
+    2: 'שנים עשר',
+    3: 'שלשה עשר',
+    4: 'ארבעה עשר',
+    5: 'חמשה עשר',
+    6: 'ששה עשר',
+    7: 'שבעה עשר',
+    8: 'שמונה עשר',
+    9: 'תשעה עשר'
+  }
+
+  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) {
+      return this.zeroWord
+    }
+    const words = []
+    const chunks = this.splitByX(number.toString(), 3)
+    let index = chunks.length
+    for (const x of chunks) {
+      index = index - 1
+      if (x === 0n) {
+        continue
+      }
+
+      const [n1, n2, n3] = this.getDigits(x)
+
+      if (index > 0) {
+        // For thousands and above, handle the full chunk value
+        const chunkWords = []
+        let hasHundreds = false
+
+        // Process hundreds in this chunk
+        if (n3 > 0n) {
+          hasHundreds = true
+          if (n3 <= 2n) {
+            chunkWords.push(this.hundreds[n3])
+          } else {
+            chunkWords.push(this.ones[n3] + ' ' + this.hundreds[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)
+        }
+
+        // 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)
+        } 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])
+          } else {
+            const onesWord = this.ones[n1]
+            // Add conjunction if there were hundreds or tens before
+            chunkWords.push((hasHundreds || n2 > 0n) ? this.and + onesWord : onesWord)
+          }
+        }
+
+        // Add scale word (thousand, million, billion, etc.)
+        if (x > 9n || index > 1) {
+          // For numbers > 9 or higher scales, use appropriate scale word
+          if (x === 1n) {
+            // Singular form (e.g., "one thousand", "one million")
+            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(' ')
+          } else if (x === 2n) {
+            // For two million, two billion, etc. - use plural form
+            chunkWords.push(this.scalePlural[index])
+          } else if (index === 1) {
+            // For thousands (10+), always use singular "אלף"
+            chunkWords.push(this.scale[index])
+          } else {
+            // For millions/billions/etc. use plural form
+            chunkWords.push(this.scalePlural[index])
+          }
+        }
+
+        words.push(chunkWords.join(' '))
+        continue
+      }
+
+      if (n3 > 0n) {
+        if (n3 <= 2n) {
+          words.push(this.hundreds[n3])
+        } else {
+          words.push(this.ones[n3] + ' ' + this.hundreds[3])
+        }
+      }
+
+      if (n2 > 1n) {
+        words.push(this.twenties[n2])
+      }
+
+      if (n2 === 1n) {
+        words.push(this.tens[n1])
+      } else if (n1 > 0n) {
+        words.push(this.ones[n1])
+      }
+    }
+
+    if (words.length > 1) {
+      words[words.length - 1] = this.and + 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.js

@@ -0,0 +1,126 @@
+import SouthAsianLanguage from '../classes/south-asian-language.js'
+
+class Hindi extends SouthAsianLanguage {
+  negativeWord = 'माइनस'
+  decimalSeparatorWord = 'दशमलव'
+  zeroWord = 'शून्य'
+  hundredWord = 'सौ'
+  belowHundred = [
+    'शून्य',
+    'एक',
+    'दो',
+    'तीन',
+    'चार',
+    'पाँच',
+    'छह',
+    'सात',
+    'आठ',
+    'नौ',
+    'दस',
+    'ग्यारह',
+    'बारह',
+    'तेरह',
+    'चौदह',
+    'पंद्रह',
+    'सोलह',
+    'सत्रह',
+    'अठारह',
+    'उन्नीस',
+    'बीस',
+    'इक्कीस',
+    'बाईस',
+    'तेईस',
+    'चौबीस',
+    'पच्चीस',
+    'छब्बीस',
+    'सत्ताईस',
+    'अट्ठाईस',
+    'उनतीस',
+    'तीस',
+    'इकतीस',
+    'बत्तीस',
+    'तैंतीस',
+    'चौंतीस',
+    'पैंतीस',
+    'छत्तीस',
+    'सैंतीस',
+    'अड़तीस',
+    'उनतालीस',
+    'चालीस',
+    'इकतालीस',
+    'बयालीस',
+    'तेतालीस',
+    'चवालीस',
+    'पैंतालीस',
+    'छियालीस',
+    'सैंतालीस',
+    'अड़तालीस',
+    'उनचास',
+    'पचास',
+    'इक्यावन',
+    'बावन',
+    'तिरपन',
+    'चौवन',
+    'पचपन',
+    'छप्पन',
+    'सत्तावन',
+    'अट्ठावन',
+    'उनसठ',
+    'साठ',
+    'इकसठ',
+    'बासठ',
+    'तिरसठ',
+    'चौंसठ',
+    'पैंसठ',
+    'छियासठ',
+    'सड़सठ',
+    'अड़सठ',
+    'उनहत्तर',
+    'सत्तर',
+    'इकहत्तर',
+    'बहत्तर',
+    'तिहत्तर',
+    'चौहत्तर',
+    'पचहत्तर',
+    'छिहत्तर',
+    'सतहत्तर',
+    'अठहत्तर',
+    'उन्यासी',
+    'अस्सी',
+    'इक्यासी',
+    'बयासी',
+    'तिरासी',
+    'चौरासी',
+    'पचासी',
+    'छियासी',
+    'सत्तासी',
+    'अट्ठासी',
+    'नवासी',
+    'नब्बे',
+    'इक्यानवे',
+    'बानवे',
+    'तिरानवे',
+    'चौरानवे',
+    'पचानवे',
+    'छियानवे',
+    'सत्तानवे',
+    'अट्ठानवे',
+    'निन्यानवे'
+  ]
+
+  scaleWords = [
+    '',
+    'हज़ार',
+    'लाख',
+    'करोड़',
+    'अरब',
+    'खरब',
+    'नील',
+    'पद्म',
+    'शंख'
+  ]
+}
+
+export default function convertToWords (value, options = {}) {
+  return new Hindi(options).convertToWords(value)
+}

package/lib/languages/hr.js

@@ -0,0 +1,157 @@
+import SlavicLanguage from '../classes/slavic-language.js'
+
+/**
+ * @typedef {Object} SlavicOptions
+ * @property {boolean} [feminine=false] Use feminine forms for numbers.
+ */
+
+/**
+ * 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)
+ * - 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']
+  }
+
+  tens = {
+    0: 'deset',
+    1: 'jedanaest',
+    2: 'dvanaest',
+    3: 'trinaest',
+    4: 'četrnaest',
+    5: 'petnaest',
+    6: 'šesnaest',
+    7: 'sedamnaest',
+    8: 'osamnaest',
+    9: 'devetnaest'
+  }
+
+  twenties = {
+    2: 'dvadeset',
+    3: 'trideset',
+    4: 'četrdeset',
+    5: 'pedeset',
+    6: 'šezdeset',
+    7: 'sedamdeset',
+    8: 'osamdeset',
+    9: 'devedeset'
+  }
+
+  hundreds = {
+    1: 'sto',
+    2: 'dvjesto',
+    3: 'tristo',
+    4: 'četiristo',
+    5: 'petsto',
+    6: 'šesto',
+    7: 'sedamsto',
+    8: 'osamsto',
+    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
+  }
+
+  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]
+  }
+
+  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)
+}