n2words 3.0.0 → 4.0.0

package/lib/languages/he.js

@@ -1,276 +0,0 @@
-/**
- * Modern Hebrew language converter - Functional Implementation
- *
- * Self-contained converter with segment-based decomposition.
- *
- * Key features:
- * - Feminine grammatical forms (default in Modern Hebrew)
- * - Dual forms for 2, 200, 2000
- * - Special 1-9 thousands construct state
- * - "ו" (ve) conjunction rules vary by position
- * - Per-digit decimal reading
- *
- * Optimization: Precomputed segment lookup tables for 0-999.
- */
-
-import { parseNumericValue } from '../utils/parse-numeric.js'
-import { validateOptions } from '../utils/validate-options.js'
-
-// ============================================================================
-// Vocabulary (arrays for indexed access - faster than object property lookup)
-// ============================================================================
-
-// Feminine forms (default in Modern Hebrew) - index 0 unused
-const ONES = ['', 'אחת', 'שתים', 'שלש', 'ארבע', 'חמש', 'שש', 'שבע', 'שמונה', 'תשע']
-const TEENS = ['עשר', 'אחת עשרה', 'שתים עשרה', 'שלש עשרה', 'ארבע עשרה', 'חמש עשרה', 'שש עשרה', 'שבע עשרה', 'שמונה עשרה', 'תשע עשרה']
-const TENS = ['', '', 'עשרים', 'שלשים', 'ארבעים', 'חמישים', 'ששים', 'שבעים', 'שמונים', 'תשעים']
-const HUNDREDS = ['', 'מאה', 'מאתיים', 'שלש מאות', 'ארבע מאות', 'חמש מאות', 'שש מאות', 'שבע מאות', 'שמונה מאות', 'תשע מאות']
-
-// Special forms for 1-9 thousand (index 0 unused)
-const THOUSANDS_SPECIAL = ['', 'אלף', 'אלפיים', 'שלשת אלפים', 'ארבעת אלפים', 'חמשת אלפים', 'ששת אלפים', 'שבעת אלפים', 'שמונת אלפים', 'תשעת אלפים']
-
-// Scale words (index 1 = thousands, 2 = millions, etc.)
-const SCALE = ['', 'אלף', 'מיליון', 'מיליארד', 'טריליון', 'קוודרליון', 'קווינטיליון']
-const SCALE_PLURAL = ['', 'אלפים', 'מיליונים', 'מיליארדים', 'טריליונים', 'קוודרליונים', 'קווינטיליונים']
-
-const ZERO = 'אפס'
-const NEGATIVE = 'מינוס'
-const DECIMAL_SEP = 'נקודה'
-
-// ============================================================================
-// Precomputed Lookup Tables (built once at module load)
-// ============================================================================
-
-/**
- * Builds segment word for scale segments (thousands, millions, etc.).
- * "ו" is added before tens and ones when following hundreds.
- */
-function buildScaleSegment (n, andWord) {
-  if (n === 0) return ''
-
-  const ones = n % 10
-  const tens = Math.floor(n / 10) % 10
-  const hundreds = Math.floor(n / 100)
-
-  let result = ''
-
-  // Hundreds
-  if (hundreds > 0) {
-    result = HUNDREDS[hundreds]
-  }
-
-  // Tens and ones
-  if (tens === 1) {
-    // Teens (10-19)
-    const teenWord = TEENS[ones]
-    if (result) {
-      result += ' ' + andWord + teenWord
-    } else {
-      result = teenWord
-    }
-  } else {
-    // Tens (20-90)
-    if (tens >= 2) {
-      if (result) {
-        result += ' ' + andWord + TENS[tens]
-      } else {
-        result = TENS[tens]
-      }
-    }
-
-    // Ones
-    if (ones > 0) {
-      if (result) {
-        result += ' ' + andWord + ONES[ones]
-      } else {
-        result = ONES[ones]
-      }
-    }
-  }
-
-  return result
-}
-
-/**
- * Builds segment word for units segment (no scale word).
- * "ו" is only added before the final ones digit.
- */
-function buildUnitsSegment (n, andWord) {
-  if (n === 0) return ''
-
-  const ones = n % 10
-  const tens = Math.floor(n / 10) % 10
-  const hundreds = Math.floor(n / 100)
-
-  let result = ''
-
-  // Hundreds
-  if (hundreds > 0) {
-    result = HUNDREDS[hundreds]
-  }
-
-  // Tens (no conjunction)
-  if (tens === 1) {
-    // Teens (10-19)
-    if (result) {
-      result += ' ' + TEENS[ones]
-    } else {
-      result = TEENS[ones]
-    }
-  } else {
-    if (tens >= 2) {
-      if (result) {
-        result += ' ' + TENS[tens]
-      } else {
-        result = TENS[tens]
-      }
-    }
-
-    // Ones - conjunction only here
-    if (ones > 0) {
-      if (result) {
-        result += ' ' + andWord + ONES[ones]
-      } else {
-        result = ONES[ones]
-      }
-    }
-  }
-
-  return result
-}
-
-// Precompute all 1000 segment words with default conjunction
-const SCALE_SEGMENTS = new Array(1000)
-const UNITS_SEGMENTS = new Array(1000)
-for (let i = 0; i < 1000; i++) {
-  SCALE_SEGMENTS[i] = buildScaleSegment(i, 'ו')
-  UNITS_SEGMENTS[i] = buildUnitsSegment(i, 'ו')
-}
-
-// ============================================================================
-// Conversion Functions
-// ============================================================================
-
-/**
- * Converts a non-negative integer to Hebrew words.
- *
- * @param {bigint} n - Non-negative integer to convert
- * @param {Object} options - Conversion options
- * @returns {string} Hebrew words
- */
-function integerToWords (n, options) {
-  if (n === 0n) return ZERO
-
-  const andWord = options.andWord ?? 'ו'
-  const usePrecomputed = andWord === 'ו'
-
-  // Fast path: numbers < 1000 (direct lookup)
-  if (n < 1000n) {
-    return usePrecomputed ? UNITS_SEGMENTS[Number(n)] : buildUnitsSegment(Number(n), andWord)
-  }
-
-  // Extract segments using BigInt modulo
-  const segments = []
-  let temp = n
-  while (temp > 0n) {
-    segments.push(Number(temp % 1000n))
-    temp = temp / 1000n
-  }
-
-  // Build result string directly
-  let result = ''
-
-  for (let i = segments.length - 1; i >= 0; i--) {
-    const segment = segments[i]
-    if (segment === 0) continue
-
-    if (i === 0) {
-      // Units segment (no scale word)
-      const segmentWord = usePrecomputed ? UNITS_SEGMENTS[segment] : buildUnitsSegment(segment, andWord)
-      if (result) {
-        // Add "ו" before single-digit units when following scale words
-        if (segment <= 9) {
-          result += ' ' + andWord + segmentWord
-        } else {
-          result += ' ' + segmentWord
-        }
-      } else {
-        result = segmentWord
-      }
-    } else if (i === 1) {
-      // Thousands - special handling for 1-9
-      if (segment <= 9) {
-        if (result) result += ' '
-        result += THOUSANDS_SPECIAL[segment]
-      } else {
-        const segmentWord = usePrecomputed ? SCALE_SEGMENTS[segment] : buildScaleSegment(segment, andWord)
-        if (result) result += ' '
-        result += segmentWord + ' ' + SCALE[1]
-      }
-    } else {
-      // Millions and above
-      if (segment === 1) {
-        if (result) result += ' '
-        result += SCALE[i]
-      } else {
-        const segmentWord = usePrecomputed ? SCALE_SEGMENTS[segment] : buildScaleSegment(segment, andWord)
-        if (result) result += ' '
-        result += segmentWord + ' ' + SCALE_PLURAL[i]
-      }
-    }
-  }
-
-  return result
-}
-
-/**
- * Converts decimal digits to Hebrew words (digit by digit).
- *
- * @param {string} decimalPart - Decimal digits (without the point)
- * @returns {string} Hebrew words for decimal part
- */
-function decimalPartToWords (decimalPart) {
-  let result = ''
-
-  for (let i = 0; i < decimalPart.length; i++) {
-    const d = parseInt(decimalPart[i], 10)
-    if (result) result += ' '
-    result += d === 0 ? ZERO : ONES[d]
-  }
-
-  return result
-}
-
-/**
- * Converts a numeric value to Modern Hebrew words.
- *
- * @param {number | string | bigint} value - The numeric value to convert
- * @param {Object} [options] - Optional configuration
- * @param {('masculine'|'feminine')} [options.gender='masculine'] - Grammatical gender
- * @param {string} [options.andWord] - Custom conjunction word
- * @returns {string} The number in Modern Hebrew words
- */
-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)
-  }
-
-  return result
-}
-
-// ============================================================================
-// Exports
-// ============================================================================
-
-export { toWords }

package/lib/languages/hi.d.ts

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

package/lib/languages/hi.js

@@ -1,145 +0,0 @@
-/**
- * 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
-}
-
-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

@@ -1,11 +0,0 @@
-/**
- * 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,218 +0,0 @@
-/**
- * Croatian language converter - Functional Implementation
- *
- * Self-contained converter using shared Slavic utilities.
- *
- * 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
- */
-
-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]
-  }
-
-  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)
-  }
-
-  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])
-  }
-
-  if (tensDigit > 1) {
-    parts.push(tens[tensDigit])
-  }
-
-  if (tensDigit === 1) {
-    parts.push(teens[onesDigit])
-  } else if (onesDigit > 0) {
-    parts.push(ones[onesDigit])
-  }
-
-  return parts.join(' ')
-}
-
-// ============================================================================
-// Vocabulary
-// ============================================================================
-
-const ONES_MASC = ['', 'jedan', 'dva', 'tri', 'četiri', 'pet', 'šest', 'sedam', 'osam', 'devet']
-const ONES_FEM = ['', 'jedna', 'dvije', 'tri', 'četiri', 'pet', 'šest', 'sedam', 'osam', 'devet']
-
-const TEENS = ['deset', 'jedanaest', 'dvanaest', 'trinaest', 'četrnaest', 'petnaest', 'šesnaest', 'sedamnaest', 'osamnaest', 'devetnaest']
-const TENS = ['', '', 'dvadeset', 'trideset', 'četrdeset', 'pedeset', 'šezdeset', 'sedamdeset', 'osamdeset', 'devedeset']
-
-// 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)]
-  }
-
-  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)
-      }
-    }
-
-    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 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
- */
-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

@@ -1,7 +0,0 @@
-/**
- * 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;

package/lib/languages/id.d.ts

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

package/lib/languages/it.d.ts

@@ -1,19 +0,0 @@
-/**
- * Converts a numeric value to Italian words.
- *
- * This is the main public API. It accepts any valid numeric input
- * (number, string, or bigint) and handles parsing internally.
- *
- * @param {number | string | bigint} value - The numeric value to convert
- * @returns {string} The number in Italian words
- * @throws {TypeError} If value is not a valid numeric type
- * @throws {Error} If value is not a valid number format
- *
- * @example
- * toWords(28)           // 'ventotto'
- * toWords(23)           // 'ventitré'
- * toWords(1000)         // 'mille'
- * toWords(2000)         // 'duemila'
- * toWords(1000000)      // 'un milione'
- */
-export function toWords(value: number | string | bigint): string;