n2words 3.0.0 → 3.1.0

package/lib/languages/id.js

@@ -1,7 +1,7 @@
 /**
  * Indonesian language converter - Functional Implementation
  *
- * Self-contained converter with precomputed lookup tables.
+ * Self-contained module with its own input validation, ready for subpath exports.
  *
  * Key features:
  * - "Se-" prefix for 100 (seratus) and 1000 (seribu)
@@ -29,7 +29,7 @@ const NEGATIVE = 'min'
 const DECIMAL_SEP = 'koma'
 
 // ============================================================================
-// Precomputed Lookup Tables
+// Segment Building
 // ============================================================================
 
 function buildSegment (n) {
@@ -68,11 +68,6 @@ function buildSegment (n) {
   return parts.join(' ')
 }
 
-const SEGMENTS = new Array(1000)
-for (let i = 0; i < 1000; i++) {
-  SEGMENTS[i] = buildSegment(i)
-}
-
 // ============================================================================
 // Conversion Functions
 // ============================================================================
@@ -81,7 +76,7 @@ function integerToWords (n) {
   if (n === 0n) return ZERO
 
   if (n < 1000n) {
-    return SEGMENTS[Number(n)]
+    return buildSegment(Number(n))
   }
 
   if (n < 1_000_000n) {
@@ -92,11 +87,11 @@ function integerToWords (n) {
     if (thousands === 1) {
       result = 'se' + THOUSAND_WORD
     } else {
-      result = SEGMENTS[thousands] + ' ' + THOUSAND_WORD
+      result = buildSegment(thousands) + ' ' + THOUSAND_WORD
     }
 
     if (remainder > 0) {
-      result += ' ' + SEGMENTS[remainder]
+      result += ' ' + buildSegment(remainder)
     }
 
     return result
@@ -131,17 +126,17 @@ function buildLargeNumberWords (n) {
 
     if (segment !== 0) {
       if (scaleIndex === 0) {
-        parts.push(SEGMENTS[segment])
+        parts.push(buildSegment(segment))
       } else if (scaleIndex === 1) {
         if (segment === 1) {
           parts.push('se' + THOUSAND_WORD)
         } else {
-          parts.push(SEGMENTS[segment] + ' ' + THOUSAND_WORD)
+          parts.push(buildSegment(segment) + ' ' + THOUSAND_WORD)
         }
       } else {
         // Indonesian: "satu juta" not "sejuta"
         const scaleWord = SCALE_WORDS[scaleIndex - 2]
-        parts.push(SEGMENTS[segment] + ' ' + scaleWord)
+        parts.push(buildSegment(segment) + ' ' + scaleWord)
       }
     }
 

package/lib/languages/it.js

@@ -1,13 +1,9 @@
 /**
- * Italian language converter - Functional Implementation v2
+ * Italian language converter - Functional Implementation
  *
- * A performance-optimized number-to-words converter using precomputed lookup tables.
  * Self-contained module with its own input validation, ready for subpath exports.
  *
- * Key optimization: Precompute all 1000 segment values (0-999) at module load.
- * This eliminates all per-call string manipulation for segment conversion.
- *
- * Italian-specific rules (handled in precomputation):
+ * Italian-specific rules:
  * - Concatenation without spaces within segments ("ventotto" not "venti otto")
  * - Phonetic vowel elision: "venti" + "otto" → "ventotto"
  * - Accent on final "tre" in compounds: "ventitré"
@@ -22,12 +18,16 @@ import { parseNumericValue } from '../utils/parse-numeric.js'
 // Vocabulary (module-level constants)
 // ============================================================================
 
-// Base vocabulary for building lookup tables
+// Base vocabulary
 const ONES = ['', 'uno', 'due', 'tre', 'quattro', 'cinque', 'sei', 'sette', 'otto', 'nove']
 const TEENS = ['dieci', 'undici', 'dodici', 'tredici', 'quattordici', 'quindici', 'sedici', 'diciassette', 'diciotto', 'diciannove']
 const TENS = ['', '', 'venti', 'trenta', 'quaranta', 'cinquanta', 'sessanta', 'settanta', 'ottanta', 'novanta']
 const HUNDREDS = ['', 'cento', 'duecento', 'trecento', 'quattrocento', 'cinquecento', 'seicento', 'settecento', 'ottocento', 'novecento']
 
+// Pre-elided tens stems (drop final vowel before 'uno'/'otto')
+// vent- (from venti), trent- (from trenta), etc.
+const TENS_STEM = ['', '', 'vent', 'trent', 'quarant', 'cinquant', 'sessant', 'settant', 'ottant', 'novant']
+
 const ZERO = 'zero'
 const NEGATIVE = 'meno'
 const DECIMAL_SEP = 'virgola'
@@ -40,38 +40,19 @@ const THOUSAND_PLURAL_SUFFIX = 'mila'
 const SCALE_PREFIXES = ['m', 'b', 'tr', 'quadr', 'quint', 'sest', 'sett', 'ott', 'nov', 'dec']
 
 // ============================================================================
-// Precomputed Lookup Tables (built once at module load)
+// Segment Building
 // ============================================================================
 
-/**
- * Applies Italian phonetic vowel elision rules.
- * Only used during table construction.
- */
-function applyPhoneticRules (str) {
-  return str
-    .replace(/io/g, 'o')
-    .replace(/ao/g, 'o')
-    .replace(/oo/g, 'o')
-    .replace(/iu/g, 'u')
-    .replace(/au/g, 'u')
-}
-
-/**
- * Adds accent to final "tre" in a word.
- * Only used during table construction.
- */
-function accentuateTre (word) {
-  if (word.length > 3 && word.slice(-3) === 'tre') {
-    return word.slice(0, -3) + 'tré'
-  }
-  return word
-}
-
 /**
  * Builds the segment word for a number 0-999.
- * Only used during table construction.
+ * Handles Italian phonetic elision inline (no regex).
+ *
+ * Elision rules:
+ * - Tens ending in vowel + uno/otto → drop tens vowel: ventuno, ventotto
+ * - Hundreds cento + otto/ottanta → centotto, centottanta (drop 'o')
+ * - Final 'tre' in compounds becomes 'tré': ventitré, trentatré
  */
-function buildSegmentWord (n) {
+function buildSegment (n) {
   if (n === 0) return ''
 
   const ones = n % 10
@@ -82,86 +63,70 @@ function buildSegmentWord (n) {
 
   // Hundreds
   if (hundreds > 0) {
-    result = HUNDREDS[hundreds]
+    // Elision: *cento + otto/ottanta → *centotto/centottanta (drop final 'o')
+    // Only applies when tens = 8 (ottanta) or tens = 0 and ones = 8 (otto)
+    if (tens === 8 || (tens === 0 && ones === 8)) {
+      // Remove final 'o' from hundreds: cento→cent, duecento→duecent, etc.
+      result = HUNDREDS[hundreds].slice(0, -1)
+    } else {
+      result = HUNDREDS[hundreds]
+    }
   }
 
   // Tens and ones
   if (tens === 0 && ones === 0) {
-    // Nothing more
+    // Nothing more (just hundreds)
   } else if (tens === 1) {
     // Teens: 10-19
     result += TEENS[ones]
   } else if (tens >= 2) {
-    // 20-99
-    result += TENS[tens]
-    if (ones > 0) {
-      result += ONES[ones]
+    // 20-99: handle elision for uno (1) and otto (8)
+    if (ones === 1 || ones === 8) {
+      // Use stem form: vent + uno = ventuno, vent + otto = ventotto
+      result += TENS_STEM[tens] + ONES[ones]
+    } else if (ones === 3) {
+      // Final tre becomes tré
+      result += TENS[tens] + 'tré'
+    } else if (ones > 0) {
+      result += TENS[tens] + ONES[ones]
+    } else {
+      result += TENS[tens]
     }
   } else if (ones > 0) {
     // 1-9 (tens === 0)
-    result += ONES[ones]
+    if (ones === 3 && hundreds > 0) {
+      // centotré, duecentotré, etc.
+      result += 'tré'
+    } else {
+      result += ONES[ones]
+    }
   }
 
-  // Apply phonetic rules and accent
-  return accentuateTre(applyPhoneticRules(result))
+  return result
 }
 
 /**
  * Builds segment word with "un" for scale context (millions, billions).
- * Only used during table construction.
+ * Same as buildSegment but returns "un" for 1 instead of "uno".
  */
-function buildSegmentWordForScale (n) {
+function buildSegmentForScale (n) {
   if (n === 0) return ''
   if (n === 1) return 'un' // "un milione" not "uno milione"
-
-  const ones = n % 10
-  const tens = Math.floor(n / 10) % 10
-  const hundreds = Math.floor(n / 100)
-
-  let result = ''
-
-  if (hundreds > 0) {
-    result = HUNDREDS[hundreds]
-  }
-
-  if (tens === 0 && ones === 0) {
-    // Nothing more
-  } else if (tens === 1) {
-    result += TEENS[ones]
-  } else if (tens >= 2) {
-    result += TENS[tens]
-    if (ones > 0) {
-      result += ONES[ones]
-    }
-  } else if (ones > 0) {
-    // 1-9 with tens === 0
-    // "un" only for exactly 1, others normal
-    result += ONES[ones]
-  }
-
-  return accentuateTre(applyPhoneticRules(result))
+  return buildSegment(n)
 }
 
-// Precompute all 1000 segment words (0-999)
-// SEGMENTS[n] gives the Italian word for n within a segment
-const SEGMENTS = new Array(1000)
-for (let i = 0; i < 1000; i++) {
-  SEGMENTS[i] = buildSegmentWord(i)
-}
-
-// Precompute segment words for scale context (uses "un" for 1)
-const SEGMENTS_SCALE = new Array(1000)
-for (let i = 0; i < 1000; i++) {
-  SEGMENTS_SCALE[i] = buildSegmentWordForScale(i)
-}
+/**
+ * Builds thousands word for 1-999 thousand.
+ * Handles elision: tre + mila = tremila (no accent), otto + mila = ottomila
+ */
+function buildThousands (n) {
+  if (n === 0) return ''
+  if (n === 1) return THOUSAND_SINGULAR // "mille"
 
-// Precompute thousands words (1-999) + "mila" suffix
-// THOUSANDS[n] gives the word for n thousand (e.g., THOUSANDS[2] = "duemila")
-const THOUSANDS = new Array(1000)
-THOUSANDS[0] = ''
-THOUSANDS[1] = THOUSAND_SINGULAR // "mille"
-for (let i = 2; i < 1000; i++) {
-  THOUSANDS[i] = applyPhoneticRules(SEGMENTS[i] + THOUSAND_PLURAL_SUFFIX)
+  // Build segment and append "mila"
+  // Note: elision of segment ending vowel + 'mila' not needed (mila starts with 'm')
+  // But we need to handle cases like "ottomila" (no double-o issue since we build directly)
+  return buildSegment(n) + THOUSAND_PLURAL_SUFFIX
 }
 
 // ============================================================================
@@ -207,9 +172,9 @@ function getScaleWordPlural (scaleIndex) {
 function integerToWords (n) {
   if (n === 0n) return ZERO
 
-  // Fast path: numbers < 1000 (direct lookup)
+  // Fast path: numbers < 1000
   if (n < 1000n) {
-    return SEGMENTS[Number(n)]
+    return buildSegment(Number(n))
   }
 
   // Fast path: numbers < 1,000,000 (thousands)
@@ -218,11 +183,11 @@ function integerToWords (n) {
     const remainder = Number(n % 1000n)
 
     if (remainder === 0) {
-      return THOUSANDS[thousands]
+      return buildThousands(thousands)
     }
 
     // Concatenate thousands + remainder
-    return THOUSANDS[thousands] + SEGMENTS[remainder]
+    return buildThousands(thousands) + buildSegment(remainder)
   }
 
   // For numbers >= 1,000,000, use scale decomposition
@@ -259,17 +224,17 @@ function buildLargeNumberWords (n) {
 
     if (scaleIndex >= 2) {
       // Millions and above: "segment scaleWord"
-      const segmentWords = SEGMENTS_SCALE[segNum]
+      const segmentWords = buildSegmentForScale(segNum)
       const scaleWord = segment === 1n
         ? getScaleWordSingular(scaleIndex)
         : getScaleWordPlural(scaleIndex)
       parts.push(segmentWords + ' ' + scaleWord)
     } else if (scaleIndex === 1) {
-      // Thousands: use precomputed table
-      parts.push(THOUSANDS[segNum])
+      // Thousands
+      parts.push(buildThousands(segNum))
     } else {
       // Units (scaleIndex === 0): just the segment
-      parts.push(SEGMENTS[segNum])
+      parts.push(buildSegment(segNum))
     }
   }
 

package/lib/languages/ja.js

@@ -1,13 +1,9 @@
 /**
  * Japanese language converter - Functional Implementation
  *
- * A performance-optimized number-to-words converter using precomputed lookup tables.
  * Self-contained module with its own input validation, ready for subpath exports.
  *
- * Key optimization: Precompute all segment values (0-9999) at module load.
- * This eliminates all per-call string manipulation for segment conversion.
- *
- * Japanese-specific rules (handled in precomputation):
+ * Japanese-specific rules:
  * - Myriad (万-based) grouping: 4 digits per segment instead of 3
  * - 一 omission: Omit "一" before 十, 百, 千 but NOT before 万 and higher scales
  * - Kanji numerals: 零一二三四五六七八九
@@ -55,13 +51,12 @@ const HUNDRED = '百'
 const THOUSAND = '千'
 
 // ============================================================================
-// Precomputed Lookup Tables (built once at module load)
+// Segment Building
 // ============================================================================
 
 /**
  * Builds segment word for 0-9999 with 一 omission rules.
  * - Omit 一 before 十, 百, 千
- * Only used during table construction.
  */
 function buildSegment (n) {
   if (n === 0) return ''
@@ -108,13 +103,6 @@ function buildSegment (n) {
   return result
 }
 
-// Precompute all 10000 segment words (0-9999)
-// SEGMENTS[n] gives the Japanese word for n within a segment
-const SEGMENTS = new Array(10000)
-for (let i = 0; i < 10000; i++) {
-  SEGMENTS[i] = buildSegment(i)
-}
-
 // ============================================================================
 // Conversion Functions
 // ============================================================================
@@ -128,9 +116,9 @@ for (let i = 0; i < 10000; i++) {
 function integerToWords (n) {
   if (n === 0n) return ZERO
 
-  // Fast path: numbers < 10000 (direct lookup)
+  // Fast path: numbers < 10000
   if (n < 10000n) {
-    return SEGMENTS[Number(n)]
+    return buildSegment(Number(n))
   }
 
   // Fast path: numbers < 100,000,000 (万 range)
@@ -143,11 +131,11 @@ function integerToWords (n) {
     if (man === 1) {
       result = '一' + SCALES[0] // 一万
     } else {
-      result = SEGMENTS[man] + SCALES[0]
+      result = buildSegment(man) + SCALES[0]
     }
 
     if (remainder > 0) {
-      result += SEGMENTS[remainder]
+      result += buildSegment(remainder)
     }
 
     return result
@@ -186,11 +174,11 @@ function buildLargeNumberWords (n) {
       if (segment === 1) {
         result += '一' + SCALES[i - 1]
       } else {
-        result += SEGMENTS[segment] + SCALES[i - 1]
+        result += buildSegment(segment) + SCALES[i - 1]
       }
     } else {
       // Units segment (no scale word)
-      result += SEGMENTS[segment]
+      result += buildSegment(segment)
     }
   }
 

package/lib/languages/ka.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Converts a numeric value to Georgian 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 Georgian words
+ * @throws {TypeError} If value is not a valid numeric type
+ * @throws {Error} If value is not a valid number format
+ *
+ * @example
+ * toWords(21)           // 'ოცდაერთი'
+ * toWords(100)          // 'ასი'
+ * toWords(1000)         // 'ათასი'
+ */
+export function toWords(value: number | string | bigint): string;