n2words 1.24.0 → 3.0.0

package/lib/languages/hi.js

@@ -1,126 +1,145 @@
-import SouthAsianLanguage from '../classes/south-asian-language.js'
-
-class Hindi extends SouthAsianLanguage {
-  negativeWord = 'माइनस'
-  decimalSeparatorWord = 'दशमलव'
-  zeroWord = 'शून्य'
-  hundredWord = 'सौ'
-  belowHundred = [
-    'शून्य',
-    'एक',
-    'दो',
-    'तीन',
-    'चार',
-    'पाँच',
-    'छह',
-    'सात',
-    'आठ',
-    'नौ',
-    'दस',
-    'ग्यारह',
-    'बारह',
-    'तेरह',
-    'चौदह',
-    'पंद्रह',
-    'सोलह',
-    'सत्रह',
-    'अठारह',
-    'उन्नीस',
-    'बीस',
-    'इक्कीस',
-    'बाईस',
-    'तेईस',
-    'चौबीस',
-    'पच्चीस',
-    'छब्बीस',
-    'सत्ताईस',
-    'अट्ठाईस',
-    'उनतीस',
-    'तीस',
-    'इकतीस',
-    'बत्तीस',
-    'तैंतीस',
-    'चौंतीस',
-    'पैंतीस',
-    'छत्तीस',
-    'सैंतीस',
-    'अड़तीस',
-    'उनतालीस',
-    'चालीस',
-    'इकतालीस',
-    'बयालीस',
-    'तेतालीस',
-    'चवालीस',
-    'पैंतालीस',
-    'छियालीस',
-    'सैंतालीस',
-    'अड़तालीस',
-    'उनचास',
-    'पचास',
-    'इक्यावन',
-    'बावन',
-    'तिरपन',
-    'चौवन',
-    'पचपन',
-    'छप्पन',
-    'सत्तावन',
-    'अट्ठावन',
-    'उनसठ',
-    'साठ',
-    'इकसठ',
-    'बासठ',
-    'तिरसठ',
-    'चौंसठ',
-    'पैंसठ',
-    'छियासठ',
-    'सड़सठ',
-    'अड़सठ',
-    'उनहत्तर',
-    'सत्तर',
-    'इकहत्तर',
-    'बहत्तर',
-    'तिहत्तर',
-    'चौहत्तर',
-    'पचहत्तर',
-    'छिहत्तर',
-    'सतहत्तर',
-    'अठहत्तर',
-    'उन्यासी',
-    'अस्सी',
-    'इक्यासी',
-    'बयासी',
-    'तिरासी',
-    'चौरासी',
-    'पचासी',
-    'छियासी',
-    'सत्तासी',
-    'अट्ठासी',
-    'नवासी',
-    'नब्बे',
-    'इक्यानवे',
-    'बानवे',
-    'तिरानवे',
-    'चौरानवे',
-    'पचानवे',
-    'छियानवे',
-    'सत्तानवे',
-    'अट्ठानवे',
-    'निन्यानवे'
-  ]
-
-  scaleWords = [
-    '',
-    'हज़ार',
-    'लाख',
-    'करोड़',
-    'अरब',
-    'खरब',
-    'नील',
-    'पद्म',
-    'शंख'
-  ]
+/**
+ * Hindi language converter - Functional Implementation
+ *
+ * Self-contained converter for South Asian numbering.
+ *
+ * Key features:
+ * - Indian numbering system (हज़ार, लाख, करोड़)
+ * - Devanagari script
+ * - 3-2-2 grouping pattern (last 3 digits, then groups of 2)
+ * - Complete word forms for 0-99
+ */
+
+import { parseNumericValue } from '../utils/parse-numeric.js'
+
+// ============================================================================
+// Vocabulary
+// ============================================================================
+
+const ZERO = 'शून्य'
+const NEGATIVE = 'माइनस'
+const DECIMAL_SEP = 'दशमलव'
+const HUNDRED = 'सौ'
+
+const BELOW_HUNDRED = [
+  'शून्य', 'एक', 'दो', 'तीन', 'चार', 'पाँच', 'छह', 'सात', 'आठ', 'नौ',
+  'दस', 'ग्यारह', 'बारह', 'तेरह', 'चौदह', 'पंद्रह', 'सोलह', 'सत्रह', 'अठारह', 'उन्नीस',
+  'बीस', 'इक्कीस', 'बाईस', 'तेईस', 'चौबीस', 'पच्चीस', 'छब्बीस', 'सत्ताईस', 'अट्ठाईस', 'उनतीस',
+  'तीस', 'इकतीस', 'बत्तीस', 'तैंतीस', 'चौंतीस', 'पैंतीस', 'छत्तीस', 'सैंतीस', 'अड़तीस', 'उनतालीस',
+  'चालीस', 'इकतालीस', 'बयालीस', 'तेतालीस', 'चवालीस', 'पैंतालीस', 'छियालीस', 'सैंतालीस', 'अड़तालीस', 'उनचास',
+  'पचास', 'इक्यावन', 'बावन', 'तिरपन', 'चौवन', 'पचपन', 'छप्पन', 'सत्तावन', 'अट्ठावन', 'उनसठ',
+  'साठ', 'इकसठ', 'बासठ', 'तिरसठ', 'चौंसठ', 'पैंसठ', 'छियासठ', 'सड़सठ', 'अड़सठ', 'उनहत्तर',
+  'सत्तर', 'इकहत्तर', 'बहत्तर', 'तिहत्तर', 'चौहत्तर', 'पचहत्तर', 'छिहत्तर', 'सतहत्तर', 'अठहत्तर', 'उन्यासी',
+  'अस्सी', 'इक्यासी', 'बयासी', 'तिरासी', 'चौरासी', 'पचासी', 'छियासी', 'सत्तासी', 'अट्ठासी', 'नवासी',
+  'नब्बे', 'इक्यानवे', 'बानवे', 'तिरानवे', 'चौरानवे', 'पचानवे', 'छियानवे', 'सत्तानवे', 'अट्ठानवे', 'निन्यानवे'
+]
+
+// Scale words: index 0 = units (empty), 1 = thousand, 2 = lakh, 3 = crore, etc.
+const SCALE_WORDS = ['', 'हज़ार', 'लाख', 'करोड़', 'अरब', 'खरब', 'नील', 'पद्म', 'शंख']
+
+// ============================================================================
+// Segment Splitting (inlined for performance)
+// ============================================================================
+
+function groupByThreeThenTwos (n) {
+  const numStr = n.toString()
+  if (numStr.length <= 3) return [Number(numStr)]
+
+  const segments = []
+  segments.unshift(Number(numStr.slice(-3)))
+
+  let remaining = numStr.slice(0, -3)
+  while (remaining.length > 0) {
+    segments.unshift(Number(remaining.slice(-2)))
+    remaining = remaining.slice(0, -2)
+  }
+
+  return segments
 }
 
-export default function convertToWords (value, options = {}) {
-  return new Hindi(options).convertToWords(value)
+function segmentToWords (n) {
+  if (n === 0) return ''
+  if (n < 100) return BELOW_HUNDRED[n]
+
+  const hundreds = Math.trunc(n / 100)
+  const remainder = n % 100
+
+  if (remainder === 0) {
+    return BELOW_HUNDRED[hundreds] + ' ' + HUNDRED
+  }
+  return BELOW_HUNDRED[hundreds] + ' ' + HUNDRED + ' ' + BELOW_HUNDRED[remainder]
 }
+
+// ============================================================================
+// Conversion Functions
+// ============================================================================
+
+function integerToWords (n) {
+  if (n === 0n) return ZERO
+
+  const segments = groupByThreeThenTwos(n)
+  const segmentCount = segments.length
+  const words = []
+
+  for (let i = 0; i < segmentCount; i++) {
+    const segmentValue = segments[i]
+    if (segmentValue === 0) continue
+
+    const scaleIndex = segmentCount - i - 1
+    words.push(segmentToWords(segmentValue))
+    if (scaleIndex > 0 && SCALE_WORDS[scaleIndex]) {
+      words.push(SCALE_WORDS[scaleIndex])
+    }
+  }
+
+  return words.join(' ').trim()
+}
+
+function decimalPartToWords (decimalPart) {
+  let result = ''
+  let i = 0
+
+  while (i < decimalPart.length && decimalPart[i] === '0') {
+    if (result) result += ' '
+    result += ZERO
+    i++
+  }
+
+  const remainder = decimalPart.slice(i)
+  if (remainder) {
+    if (result) result += ' '
+    result += integerToWords(BigInt(remainder))
+  }
+
+  return result
+}
+
+/**
+ * Converts a numeric value to Hindi words.
+ *
+ * @param {number | string | bigint} value - The numeric value to convert
+ * @returns {string} The number in Hindi words
+ */
+function toWords (value) {
+  const { isNegative, integerPart, decimalPart } = parseNumericValue(value)
+
+  let result = ''
+
+  if (isNegative) {
+    result = NEGATIVE + ' '
+  }
+
+  result += integerToWords(integerPart)
+
+  if (decimalPart) {
+    result += ' ' + DECIMAL_SEP + ' ' + decimalPartToWords(decimalPart)
+  }
+
+  return result
+}
+
+// ============================================================================
+// Exports
+// ============================================================================
+
+export { toWords }

package/lib/languages/hr.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Converts a numeric value to Croatian words.
+ *
+ * @param {number | string | bigint} value - The numeric value to convert
+ * @param {Object} [options] - Optional configuration
+ * @param {('masculine'|'feminine')} [options.gender='masculine'] - Grammatical gender
+ * @returns {string} The number in Croatian words
+ */
+export function toWords(value: number | string | bigint, options?: {
+    gender?: "masculine" | "feminine" | undefined;
+}): string;

package/lib/languages/hr.js

@@ -1,157 +1,218 @@
-import SlavicLanguage from '../classes/slavic-language.js'
-
-/**
- * @typedef {Object} SlavicOptions
- * @property {boolean} [feminine=false] Use feminine forms for numbers.
- */
-
 /**
- * Croatian language converter.
+ * Croatian language converter - Functional Implementation
  *
- * 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
+ * Self-contained converter using shared Slavic utilities.
  *
- * 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.
+ * Key features:
+ * - Three-form pluralization (one/few/many)
+ * - Gender: thousands are feminine, millions+ are masculine
+ * - Irregular hundreds (dvjesto, tristo, etc.)
+ * - Long scale naming with -ard forms
  */
-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']
+
+import { parseNumericValue } from '../utils/parse-numeric.js'
+import { validateOptions } from '../utils/validate-options.js'
+
+// ============================================================================
+// Slavic Utilities (inlined for performance)
+// ============================================================================
+
+function pluralize (n, forms) {
+  const num = typeof n === 'bigint' ? Number(n) : n
+  const lastDigit = num % 10
+  const lastTwoDigits = num % 100
+
+  if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {
+    return forms[2]
   }
 
-  tens = {
-    0: 'deset',
-    1: 'jedanaest',
-    2: 'dvanaest',
-    3: 'trinaest',
-    4: 'četrnaest',
-    5: 'petnaest',
-    6: 'šesnaest',
-    7: 'sedamnaest',
-    8: 'osamnaest',
-    9: 'devetnaest'
+  if (lastDigit === 1) return forms[0]
+  if (lastDigit >= 2 && lastDigit <= 4) return forms[1]
+  return forms[2]
+}
+
+function buildAllSegments (onesMasc, onesFem, teens, tens, hundreds) {
+  const masc = new Array(1000)
+  const fem = new Array(1000)
+
+  for (let i = 0; i < 1000; i++) {
+    masc[i] = buildSegment(i, onesMasc, teens, tens, hundreds)
+    fem[i] = buildSegment(i, onesFem, teens, tens, hundreds)
   }
 
-  twenties = {
-    2: 'dvadeset',
-    3: 'trideset',
-    4: 'četrdeset',
-    5: 'pedeset',
-    6: 'šezdeset',
-    7: 'sedamdeset',
-    8: 'osamdeset',
-    9: 'devedeset'
+  return { masc, fem }
+}
+
+function buildSegment (n, ones, teens, tens, hundreds) {
+  if (n === 0) return ''
+
+  const onesDigit = n % 10
+  const tensDigit = Math.floor(n / 10) % 10
+  const hundredsDigit = Math.floor(n / 100)
+
+  const parts = []
+
+  if (hundredsDigit > 0) {
+    parts.push(hundreds[hundredsDigit])
   }
 
-  hundreds = {
-    1: 'sto',
-    2: 'dvjesto',
-    3: 'tristo',
-    4: 'četiristo',
-    5: 'petsto',
-    6: 'šesto',
-    7: 'sedamsto',
-    8: 'osamsto',
-    9: 'devetsto'
+  if (tensDigit > 1) {
+    parts.push(tens[tensDigit])
   }
 
-  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
+  if (tensDigit === 1) {
+    parts.push(teens[onesDigit])
+  } else if (onesDigit > 0) {
+    parts.push(ones[onesDigit])
   }
 
-  pluralize (n, forms) {
-    const lastDigit = n % 10n
-    const lastTwoDigits = n % 100n
+  return parts.join(' ')
+}
+
+// ============================================================================
+// Vocabulary
+// ============================================================================
 
-    if ((lastTwoDigits < 10n || lastTwoDigits > 20n) && lastDigit === 1n) {
-      return forms[0]
-    }
+const ONES_MASC = ['', 'jedan', 'dva', 'tri', 'četiri', 'pet', 'šest', 'sedam', 'osam', 'devet']
+const ONES_FEM = ['', 'jedna', 'dvije', 'tri', 'četiri', 'pet', 'šest', 'sedam', 'osam', 'devet']
 
-    if ((lastTwoDigits < 10n || lastTwoDigits > 20n) && lastDigit > 1n && lastDigit < 5n) {
-      return forms[1]
-    }
+const TEENS = ['deset', 'jedanaest', 'dvanaest', 'trinaest', 'četrnaest', 'petnaest', 'šesnaest', 'sedamnaest', 'osamnaest', 'devetnaest']
+const TENS = ['', '', 'dvadeset', 'trideset', 'četrdeset', 'pedeset', 'šezdeset', 'sedamdeset', 'osamdeset', 'devedeset']
 
-    return forms[2]
+// Croatian has irregular hundreds
+const HUNDREDS = ['', 'sto', 'dvjesto', 'tristo', 'četiristo', 'petsto', 'šesto', 'sedamsto', 'osamsto', 'devetsto']
+
+const ZERO = 'nula'
+const NEGATIVE = 'minus'
+const DECIMAL_SEP = 'zarez'
+
+// Scale words: [singular, few, many]
+// Thousands (index 0) are feminine, rest are masculine
+const SCALE_FORMS = [
+  ['tisuća', 'tisuće', 'tisuća'],
+  ['milijun', 'milijuna', 'milijuna'],
+  ['milijarda', 'milijarde', 'milijarda'],
+  ['bilijun', 'bilijuna', 'bilijuna'],
+  ['bilijarda', 'bilijarde', 'bilijarda'],
+  ['trilijun', 'trilijuna', 'trilijuna'],
+  ['trilijarda', 'trilijarde', 'trilijarda'],
+  ['kvadrilijun', 'kvadrilijuna', 'kvadrilijuna'],
+  ['kvadrilijarda', 'kvadrilijarde', 'kvadrilijarda']
+]
+
+// ============================================================================
+// Precomputed Lookup Tables
+// ============================================================================
+
+const { masc: SEGMENTS_MASC, fem: SEGMENTS_FEM } = buildAllSegments(ONES_MASC, ONES_FEM, TEENS, TENS, HUNDREDS)
+
+// ============================================================================
+// Conversion Functions
+// ============================================================================
+
+function integerToWords (n, options = {}) {
+  if (n === 0n) return ZERO
+
+  if (n < 1000n) {
+    const segments = options.gender === 'feminine' ? SEGMENTS_FEM : SEGMENTS_MASC
+    return segments[Number(n)]
   }
 
-  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 buildLargeNumberWords(n, options)
+}
+
+function buildLargeNumberWords (n, options) {
+  const numStr = n.toString()
+  const len = numStr.length
+
+  const segments = []
+  const segmentSize = 3
+
+  const remainderLen = len % segmentSize
+  let pos = 0
+  if (remainderLen > 0) {
+    segments.push(Number(numStr.slice(0, remainderLen)))
+    pos = remainderLen
+  }
+  while (pos < len) {
+    segments.push(Number(numStr.slice(pos, pos + segmentSize)))
+    pos += segmentSize
+  }
+
+  const parts = []
+  let scaleIndex = segments.length - 1
+
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i]
+
+    if (segment !== 0) {
+      if (scaleIndex === 0) {
+        const segmentWords = options.gender === 'feminine' ? SEGMENTS_FEM : SEGMENTS_MASC
+        parts.push(segmentWords[segment])
+      } else {
+        const scaleForms = SCALE_FORMS[scaleIndex - 1]
+        const scaleWord = pluralize(segment, scaleForms)
+        // Thousands (scaleIndex=1) are feminine, others masculine
+        const isFeminine = scaleIndex === 1
+        const segmentWords = isFeminine ? SEGMENTS_FEM : SEGMENTS_MASC
+        parts.push(segmentWords[segment] + ' ' + scaleWord)
       }
     }
-    return words.join(' ')
+
+    scaleIndex--
   }
+
+  return parts.join(' ')
+}
+
+function decimalPartToWords (decimalPart, options) {
+  let result = ''
+  let i = 0
+
+  while (i < decimalPart.length && decimalPart[i] === '0') {
+    if (result) result += ' '
+    result += ZERO
+    i++
+  }
+
+  const remainder = decimalPart.slice(i)
+  if (remainder) {
+    if (result) result += ' '
+    result += integerToWords(BigInt(remainder), options)
+  }
+
+  return result
 }
 
 /**
- * Converts a number to Croatian cardinal (written) form.
+ * Converts a numeric value to Croatian words.
  *
- * @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.
+ * @param {number | string | bigint} value - The numeric value to convert
+ * @param {Object} [options] - Optional configuration
+ * @param {('masculine'|'feminine')} [options.gender='masculine'] - Grammatical gender
+ * @returns {string} The number in Croatian words
  */
-export default function convertToWords (value, options = {}) {
-  return new Croatian(options).convertToWords(value)
+function toWords (value, options) {
+  options = validateOptions(options)
+  const { isNegative, integerPart, decimalPart } = parseNumericValue(value)
+
+  let result = ''
+
+  if (isNegative) {
+    result = NEGATIVE + ' '
+  }
+
+  result += integerToWords(integerPart, options)
+
+  if (decimalPart) {
+    result += ' ' + DECIMAL_SEP + ' ' + decimalPartToWords(decimalPart, options)
+  }
+
+  return result
 }
+
+// ============================================================================
+// Exports
+// ============================================================================
+
+export { toWords }

package/lib/languages/hu.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Converts a numeric value to Hungarian words.
+ *
+ * @param {number | string | bigint} value - The numeric value to convert
+ * @returns {string} The number in Hungarian words
+ */
+export function toWords(value: number | string | bigint): string;