n2words 3.0.0 → 3.1.0

package/lib/languages/am-Latn.js

@@ -1,7 +1,7 @@
 /**
  * Amharic Latin language converter - Functional Implementation
  *
- * Self-contained converter with precomputed lookup tables.
+ * Self-contained module with its own input validation, ready for subpath exports.
  * Latin/ASCII romanization of Amharic numerals.
  *
  * Key features:
@@ -64,11 +64,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
 // ============================================================================
@@ -77,7 +72,7 @@ function integerToWords (n) {
   if (n === 0n) return ZERO
 
   if (n < 1000n) {
-    return SEGMENTS[Number(n)]
+    return buildSegment(Number(n))
   }
 
   return buildLargeNumberWords(n)
@@ -111,9 +106,9 @@ function buildLargeNumberWords (n) {
       const scaleWord = SCALE_WORDS[scaleIndex] || ''
 
       if (scaleIndex === 0) {
-        parts.push(SEGMENTS[segment])
+        parts.push(buildSegment(segment))
       } else {
-        parts.push(SEGMENTS[segment] + ' ' + scaleWord)
+        parts.push(buildSegment(segment) + ' ' + scaleWord)
       }
     }
 

package/lib/languages/am.js

@@ -1,7 +1,7 @@
 /**
  * Amharic language converter - Functional Implementation
  *
- * Self-contained converter with precomputed lookup tables.
+ * Self-contained module with its own input validation, ready for subpath exports.
  * Native Ge'ez script (ግዕዝ) output.
  *
  * Key features:
@@ -64,11 +64,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
 // ============================================================================
@@ -77,7 +72,7 @@ function integerToWords (n) {
   if (n === 0n) return ZERO
 
   if (n < 1000n) {
-    return SEGMENTS[Number(n)]
+    return buildSegment(Number(n))
   }
 
   return buildLargeNumberWords(n)
@@ -111,9 +106,9 @@ function buildLargeNumberWords (n) {
       const scaleWord = SCALE_WORDS[scaleIndex] || ''
 
       if (scaleIndex === 0) {
-        parts.push(SEGMENTS[segment])
+        parts.push(buildSegment(segment))
       } else {
-        parts.push(SEGMENTS[segment] + ' ' + scaleWord)
+        parts.push(buildSegment(segment) + ' ' + scaleWord)
       }
     }
 

package/lib/languages/az.js

@@ -1,7 +1,7 @@
 /**
  * Azerbaijani 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:
  * - Turkic language patterns
@@ -64,11 +64,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
 // ============================================================================
@@ -77,7 +72,7 @@ function integerToWords (n) {
   if (n === 0n) return ZERO
 
   if (n < 1000n) {
-    return SEGMENTS[Number(n)]
+    return buildSegment(Number(n))
   }
 
   return buildLargeNumberWords(n)
@@ -111,12 +106,12 @@ function buildLargeNumberWords (n) {
       const scaleWord = SCALE_WORDS[scaleIndex] || ''
 
       if (scaleIndex === 0) {
-        parts.push(SEGMENTS[segment])
+        parts.push(buildSegment(segment))
       } else if (scaleIndex === 1 && segment === 1) {
         // Omit "bir" before thousand
         parts.push(scaleWord)
       } else {
-        parts.push(SEGMENTS[segment] + ' ' + scaleWord)
+        parts.push(buildSegment(segment) + ' ' + scaleWord)
       }
     }
 

package/lib/languages/bn.js

@@ -1,7 +1,7 @@
 /**
  * Bangla language converter - Functional Implementation
  *
- * Self-contained converter for South Asian numbering.
+ * Self-contained module with its own input validation, ready for subpath exports.
  *
  * Key features:
  * - Indian numbering system (হাজার, লাখ, কোটি)
@@ -38,26 +38,13 @@ const BELOW_HUNDRED = [
 const SCALE_WORDS = ['', 'হাজার', 'লাখ', 'কোটি', 'আরব', 'খরব', 'নীল', 'পদ্ম', 'শঙ্খ']
 
 // ============================================================================
-// Segment Splitting (inlined for performance)
+// Segment Building
 // ============================================================================
 
-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) {
+/**
+ * Builds words for a 0-999 segment.
+ */
+function buildSegment (n) {
   if (n === 0) return ''
   if (n < 100) return BELOW_HUNDRED[n]
 
@@ -74,25 +61,59 @@ function segmentToWords (n) {
 // Conversion Functions
 // ============================================================================
 
+/**
+ * Converts a non-negative integer to Bengali words.
+ *
+ * Uses BigInt modulo for segment extraction (faster than string slicing).
+ * South Asian 3-2-2 grouping: first 3 digits, then groups of 2.
+ *
+ * @param {bigint} n - Non-negative integer to convert
+ * @returns {string} Bengali words
+ */
 function integerToWords (n) {
   if (n === 0n) return ZERO
 
-  const segments = groupByThreeThenTwos(n)
-  const segmentCount = segments.length
-  const words = []
+  // Fast path: numbers < 1000 (direct lookup)
+  if (n < 1000n) {
+    return buildSegment(Number(n))
+  }
+
+  // Extract segments using BigInt modulo
+  // First segment is 3 digits (thousands), rest are 2 digits (lakhs, crores, etc.)
+  // Segments stored least-significant first
+  const segments = []
 
-  for (let i = 0; i < segmentCount; i++) {
-    const segmentValue = segments[i]
-    if (segmentValue === 0) continue
+  // First segment: last 3 digits
+  segments.push(Number(n % 1000n))
+  let temp = n / 1000n
+
+  // Remaining segments: 2 digits each (lakh = 100k, crore = 10M, etc.)
+  while (temp > 0n) {
+    segments.push(Number(temp % 100n))
+    temp = temp / 100n
+  }
+
+  // Build result string (process from most-significant to least)
+  const words = []
+  for (let i = segments.length - 1; i >= 0; i--) {
+    const segment = segments[i]
+    if (segment === 0) continue
+
+    if (i === 0) {
+      // First segment (units place) can be 0-999
+      words.push(buildSegment(segment))
+    } else {
+      // Other segments are 0-99
+      words.push(BELOW_HUNDRED[segment])
+    }
 
-    const scaleIndex = segmentCount - i - 1
-    words.push(segmentToWords(segmentValue))
-    if (scaleIndex > 0 && SCALE_WORDS[scaleIndex]) {
-      words.push(SCALE_WORDS[scaleIndex])
+    // Add scale word if not the units segment
+    if (i > 0 && SCALE_WORDS[i]) {
+      words.push(SCALE_WORDS[i])
     }
   }
 
-  return words.join(' ').trim()
+  return words.join(' ')
 }
 
 function decimalPartToWords (decimalPart) {

package/lib/languages/cs.js

@@ -1,13 +1,9 @@
 /**
  * Czech 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-999) at module load.
- * This eliminates all per-call string manipulation for segment conversion.
- *
- * Czech-specific rules (handled in precomputation):
+ * Czech-specific rules:
  * - Three-form pluralization: 1 = singular, 2-4 = few, 5+ = many
  * - Irregular hundreds: sto, dvě stě, tři sta, čtyři sta, pět set...
  * - Gender: dva (masc) vs dvě (fem) for 2
@@ -50,12 +46,11 @@ const ZERO = 'nula'
 const NEGATIVE = 'mínus'
 
 // ============================================================================
-// Precomputed Lookup Tables (built once at module load)
+// Segment Building
 // ============================================================================
 
 /**
  * Builds segment word for 0-999 (masculine, default form).
- * Only used during table construction.
  */
 function buildSegment (n) {
   if (n === 0) return ''
@@ -120,18 +115,6 @@ function buildSegmentWithHundreds (n) {
   return parts.join(' ')
 }
 
-// Precompute all 1000 segment words (0-999) - masculine form
-const SEGMENTS = new Array(1000)
-for (let i = 0; i < 1000; i++) {
-  SEGMENTS[i] = buildSegment(i)
-}
-
-// Precompute all 1000 segment words with hundreds (irregular hundreds forms)
-const SEGMENTS_WITH_HUNDREDS = new Array(1000)
-for (let i = 0; i < 1000; i++) {
-  SEGMENTS_WITH_HUNDREDS[i] = buildSegmentWithHundreds(i)
-}
-
 // ============================================================================
 // Helper Functions
 // ============================================================================
@@ -185,9 +168,9 @@ function getDecimalSeparator (integerPart) {
 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)
@@ -202,12 +185,12 @@ function integerToWords (n) {
       // Omit "one" before tisíc
       result = scaleWord
     } else {
-      result = SEGMENTS[Number(thousands)] + ' ' + scaleWord
+      result = buildSegment(Number(thousands)) + ' ' + scaleWord
     }
 
     if (remainder > 0) {
       // Use form with irregular hundreds (for "dvě stě" etc.)
-      result += ' ' + SEGMENTS_WITH_HUNDREDS[remainder]
+      result += ' ' + buildSegmentWithHundreds(remainder)
     }
 
     return result
@@ -245,7 +228,7 @@ function buildLargeNumberWords (n) {
 
     if (i === 0) {
       // Units segment (no scale word) - use form with irregular hundreds
-      result += SEGMENTS_WITH_HUNDREDS[Number(segment)]
+      result += buildSegmentWithHundreds(Number(segment))
     } else {
       // Scale word needed
       const forms = PLURAL_FORMS[i]
@@ -257,11 +240,11 @@ function buildLargeNumberWords (n) {
           result += scaleWord
         } else {
           // Use masculine form for multiplier before scale words
-          result += SEGMENTS[Number(segment)] + ' ' + scaleWord
+          result += buildSegment(Number(segment)) + ' ' + scaleWord
         }
       } else {
         // Fallback for very large scales without defined forms
-        result += SEGMENTS[Number(segment)]
+        result += buildSegment(Number(segment))
       }
     }
   }

package/lib/languages/da.js

@@ -1,7 +1,7 @@
 /**
  * Danish 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 features:
  * - Vigesimal (base-20) tens naming: halvtreds (50), treds (60), etc.
@@ -37,7 +37,7 @@ const DECIMAL_SEP = 'komma'
 const SCALES = ['millioner', 'millarder', 'billioner', 'billarder', 'trillioner', 'trillarder', 'quadrillioner', 'quadrillarder']
 
 // ============================================================================
-// Precomputed Lookup Tables (built once at module load)
+// Segment Building
 // ============================================================================
 
 /**
@@ -83,13 +83,6 @@ function buildSegment (n) {
   return parts[0] || ''
 }
 
-// Precompute all 1000 segment words (0-999)
-const SEGMENTS = new Array(1000)
-
-for (let i = 0; i < 1000; i++) {
-  SEGMENTS[i] = buildSegment(i)
-}
-
 // ============================================================================
 // Conversion Functions
 // ============================================================================
@@ -105,7 +98,7 @@ function integerToWords (n) {
 
   // Fast path: numbers < 1000 (direct lookup)
   if (n < 1000n) {
-    return SEGMENTS[Number(n)]
+    return buildSegment(Number(n))
   }
 
   // Fast path: numbers < 1,000,000 (thousands)
@@ -114,11 +107,11 @@ function integerToWords (n) {
     const remainder = Number(n % 1000n)
 
     // Compound thousands: "ettusind", "firetusind"
-    let result = SEGMENTS[thousands] + THOUSAND
+    let result = buildSegment(thousands) + THOUSAND
 
     if (remainder > 0) {
       // Add 'e' suffix and " og " for remainder: "firetusinde og ..."
-      result += 'e og ' + SEGMENTS[remainder]
+      result += 'e og ' + buildSegment(remainder)
     }
 
     return result
@@ -162,7 +155,7 @@ function buildLargeNumberWords (n) {
     const segment = segments[i]
 
     if (segment !== 0) {
-      const segmentWord = SEGMENTS[segment]
+      const segmentWord = buildSegment(segment)
 
       if (scaleIndex === 0) {
         // Units segment

package/lib/languages/de.js

@@ -1,18 +1,15 @@
 /**
  * German 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-999) at module load.
- * This eliminates all per-call string manipulation for segment conversion.
- *
- * German-specific rules (handled in precomputation):
+ * Key features:
  * - Inverted tens-ones order: "einundzwanzig" (one-and-twenty) for 21-99
  * - Compound words without spaces below million level
  * - Three forms of 1: "eins" (standalone), "ein" (before hundert/tausend), "eine" (before Million+)
  * - Scale pluralization: Million → Millionen, Milliarde → Milliarden
  * - Spaces only around million+ scale words
+ * - BigInt modulo for efficient segment extraction
  */
 
 import { parseNumericValue } from '../utils/parse-numeric.js'
@@ -45,20 +42,22 @@ const NEGATIVE = 'minus'
 const DECIMAL_SEP = 'komma'
 
 // ============================================================================
-// Precomputed Lookup Tables (built once at module load)
+// Segment Building
 // ============================================================================
 
 /**
  * Builds segment word for 0-999 (standalone form, uses "eins").
  * German inverts ones and tens: "einundzwanzig" = one-and-twenty
- * Only used during table construction.
+ *
+ * @param {number} n - Number 0-999
+ * @returns {string} German words for the segment
  */
 function buildSegment (n) {
   if (n === 0) return ''
 
   const ones = n % 10
-  const tens = Math.floor(n / 10) % 10
-  const hundreds = Math.floor(n / 100)
+  const tens = Math.trunc(n / 10) % 10
+  const hundreds = Math.trunc(n / 100)
 
   let result = ''
 
@@ -90,14 +89,17 @@ function buildSegment (n) {
 /**
  * Builds segment word for use before "tausend".
  * Uses "ein" instead of "eins" for 1.
+ *
+ * @param {number} n - Number 0-999
+ * @returns {string} German words for thousand context
  */
 function buildSegmentForThousand (n) {
   if (n === 0) return ''
   if (n === 1) return EIN // "eintausend"
 
   const ones = n % 10
-  const tens = Math.floor(n / 10) % 10
-  const hundreds = Math.floor(n / 100)
+  const tens = Math.trunc(n / 10) % 10
+  const hundreds = Math.trunc(n / 100)
 
   let result = ''
 
@@ -112,8 +114,6 @@ function buildSegmentForThousand (n) {
   } else if (tens >= 2) {
     result += TENS[tens]
   } else if (ones > 0 && hundreds > 0) {
-    // After hundreds, ones 1 stays "eins" when not followed by scale
-    // But we're going to tausend, so this path won't hit for n=1
     result += ONES[ones]
   } else if (ones > 0) {
     result += ONES[ones]
@@ -122,18 +122,6 @@ function buildSegmentForThousand (n) {
   return result
 }
 
-// Precompute all 1000 segment words (0-999) - standalone form
-const SEGMENTS = new Array(1000)
-for (let i = 0; i < 1000; i++) {
-  SEGMENTS[i] = buildSegment(i)
-}
-
-// Precompute all 1000 segment words for thousand context
-const SEGMENTS_THOUSAND = new Array(1000)
-for (let i = 0; i < 1000; i++) {
-  SEGMENTS_THOUSAND[i] = buildSegmentForThousand(i)
-}
-
 // ============================================================================
 // Conversion Functions
 // ============================================================================
@@ -147,21 +135,21 @@ for (let i = 0; i < 1000; i++) {
 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)
+  // Fast path: numbers < 1,000,000
   if (n < 1_000_000n) {
     const thousands = Number(n / 1000n)
     const remainder = Number(n % 1000n)
 
     // Compound: "eintausendzweihundert" (no spaces)
-    let result = SEGMENTS_THOUSAND[thousands] + SCALES[0]
+    let result = buildSegmentForThousand(thousands) + SCALES[0]
 
     if (remainder > 0) {
-      result += SEGMENTS[remainder]
+      result += buildSegment(remainder)
     }
 
     return result
@@ -206,10 +194,10 @@ function buildLargeNumberWords (n) {
     if (segment !== 0) {
       if (scaleIndex === 0) {
         // Units segment (no scale word)
-        parts.push({ words: SEGMENTS[segment], isScale: false, scaleLevel: 0 })
+        parts.push({ words: buildSegment(segment), isScale: false, scaleLevel: 0 })
       } else if (scaleIndex === 1) {
         // Thousands: compound without space
-        const segWords = SEGMENTS_THOUSAND[segment]
+        const segWords = buildSegmentForThousand(segment)
         parts.push({ words: segWords + SCALES[0], isScale: false, scaleLevel: 1 })
       } else {
         // Million+ : space around scale word
@@ -217,7 +205,7 @@ function buildLargeNumberWords (n) {
         if (segment === 1) {
           segWords = 'eine' // "eine Million"
         } else {
-          segWords = SEGMENTS[segment]
+          segWords = buildSegment(segment)
         }
         const scaleWord = segment === 1 ? SCALES[scaleIndex - 1] : SCALES_PLURAL[scaleIndex - 1]
         parts.push({ words: segWords, isScale: false, scaleLevel: scaleIndex })

package/lib/languages/el.js

@@ -1,7 +1,7 @@
 /**
  * Greek 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 features:
  * - Space-separated number composition
@@ -35,7 +35,7 @@ const DECIMAL_SEP = 'κόμμα'
 const SCALES = ['εκατομμύριο', 'δισεκατομμύριο', 'τρισεκατομμύριο']
 
 // ============================================================================
-// Precomputed Lookup Tables (built once at module load)
+// Segment Building
 // ============================================================================
 
 /**
@@ -73,13 +73,6 @@ function buildSegment (n) {
   return parts.join(' ')
 }
 
-// Precompute all 1000 segment words (0-999)
-const SEGMENTS = new Array(1000)
-
-for (let i = 0; i < 1000; i++) {
-  SEGMENTS[i] = buildSegment(i)
-}
-
 // ============================================================================
 // Conversion Functions
 // ============================================================================
@@ -95,7 +88,7 @@ function integerToWords (n) {
 
   // Fast path: numbers < 1000 (direct lookup)
   if (n < 1000n) {
-    return SEGMENTS[Number(n)]
+    return buildSegment(Number(n))
   }
 
   // Fast path: numbers < 1,000,000 (thousands)
@@ -108,11 +101,11 @@ function integerToWords (n) {
     if (thousands === 1) {
       result = THOUSAND
     } else {
-      result = SEGMENTS[thousands] + ' ' + THOUSAND
+      result = buildSegment(thousands) + ' ' + THOUSAND
     }
 
     if (remainder > 0) {
-      result += ' ' + SEGMENTS[remainder]
+      result += ' ' + buildSegment(remainder)
     }
 
     return result
@@ -155,7 +148,7 @@ function buildLargeNumberWords (n) {
     const segment = segments[i]
 
     if (segment !== 0) {
-      const segmentWord = SEGMENTS[segment]
+      const segmentWord = buildSegment(segment)
 
       if (scaleIndex === 0) {
         // Units segment