n2words 3.0.0 → 3.1.0

package/lib/languages/ms.js

@@ -1,7 +1,7 @@
 /**
  * Malay (Bahasa Melayu) 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 ALL singular scale units (seratus, seribu, sejuta, sebilion)
@@ -29,7 +29,7 @@ const NEGATIVE = 'minus'
 const DECIMAL_SEP = 'perpuluhan'
 
 // ============================================================================
-// 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,12 +126,12 @@ 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 {
         // Malay: "se-" prefix for ALL scale words when segment is 1
@@ -144,7 +139,7 @@ function buildLargeNumberWords (n) {
         if (segment === 1) {
           parts.push('se' + scaleWord)
         } else {
-          parts.push(SEGMENTS[segment] + ' ' + scaleWord)
+          parts.push(buildSegment(segment) + ' ' + scaleWord)
         }
       }
     }

package/lib/languages/nb.js

@@ -1,7 +1,7 @@
 /**
  * Norwegian Bokmål 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:
  * - Hyphenated tens+ones: "tjue-en" (21)
@@ -32,7 +32,7 @@ const DECIMAL_SEP = 'komma'
 const SCALES = ['million', 'milliard', 'billion', 'billiard', 'kvintillion', 'sekstillion', 'septillion', 'oktillion']
 
 // ============================================================================
-// Precomputed Lookup Tables (built once at module load)
+// Segment Building
 // ============================================================================
 
 /**
@@ -81,16 +81,6 @@ function buildSegment (n) {
   return { word: parts[0] || '', hasHundred }
 }
 
-// Precompute all 1000 segment words (0-999)
-const SEGMENTS = new Array(1000)
-const SEGMENTS_HAS_HUNDRED = new Array(1000)
-
-for (let i = 0; i < 1000; i++) {
-  const result = buildSegment(i)
-  SEGMENTS[i] = result.word
-  SEGMENTS_HAS_HUNDRED[i] = result.hasHundred
-}
-
 // ============================================================================
 // Conversion Functions
 // ============================================================================
@@ -104,9 +94,9 @@ 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)).word
   }
 
   // Fast path: numbers < 1,000,000 (thousands)
@@ -114,14 +104,15 @@ function integerToWords (n) {
     const thousands = Number(n / 1000n)
     const remainder = Number(n % 1000n)
 
-    let result = SEGMENTS[thousands] + ' ' + THOUSAND
+    let result = buildSegment(thousands).word + ' ' + THOUSAND
 
     if (remainder > 0) {
+      const remainderResult = buildSegment(remainder)
       // Comma before hundreds, " og " before small numbers
-      if (SEGMENTS_HAS_HUNDRED[remainder]) {
-        result += ', ' + SEGMENTS[remainder]
+      if (remainderResult.hasHundred) {
+        result += ', ' + remainderResult.word
       } else {
-        result += ' og ' + SEGMENTS[remainder]
+        result += ' og ' + remainderResult.word
       }
     }
 
@@ -165,19 +156,18 @@ function buildLargeNumberWords (n) {
     const segment = segments[i]
 
     if (segment !== 0) {
-      const segmentWord = SEGMENTS[segment]
-      const hasHundred = SEGMENTS_HAS_HUNDRED[segment]
+      const segmentResult = buildSegment(segment)
 
       if (scaleIndex === 0) {
         // Units segment
-        parts.push({ word: segmentWord, hasHundred, type: 'units' })
+        parts.push({ word: segmentResult.word, hasHundred: segmentResult.hasHundred, type: 'units' })
       } else if (scaleIndex === 1) {
         // Thousands
-        parts.push({ word: segmentWord + ' ' + THOUSAND, hasHundred: false, type: 'thousand' })
+        parts.push({ word: segmentResult.word + ' ' + THOUSAND, hasHundred: false, type: 'thousand' })
       } else {
         // Millions+
         const scaleWord = SCALES[scaleIndex - 2]
-        parts.push({ word: segmentWord + ' ' + scaleWord, hasHundred: false, type: 'million' })
+        parts.push({ word: segmentResult.word + ' ' + scaleWord, hasHundred: false, type: 'million' })
       }
     }
 

package/lib/languages/nl.js

@@ -1,13 +1,9 @@
 /**
  * Dutch 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.
- *
- * Dutch-specific rules (handled in precomputation):
+ * Dutch-specific rules:
  * - Inverted tens-ones: eenentwintig (one-and-twenty)
  * - "ën" connector when ones ends in 'e' (twee, drie)
  * - Compound words without spaces
@@ -38,7 +34,7 @@ const NEGATIVE = 'min'
 const DECIMAL_SEP = 'komma'
 
 // ============================================================================
-// Precomputed Lookup Tables (built once at module load)
+// Segment Building
 // ============================================================================
 
 /**
@@ -98,18 +94,6 @@ function buildSegment (n, withAnd) {
   return result
 }
 
-// Precompute all 1000 segment words (0-999) - standard form
-const SEGMENTS = new Array(1000)
-for (let i = 0; i < 1000; i++) {
-  SEGMENTS[i] = buildSegment(i, false)
-}
-
-// Precompute all 1000 segment words (0-999) - with optional "en"
-const SEGMENTS_WITH_AND = new Array(1000)
-for (let i = 0; i < 1000; i++) {
-  SEGMENTS_WITH_AND[i] = buildSegment(i, true)
-}
-
 // ============================================================================
 // Conversion Functions
 // ============================================================================
@@ -125,7 +109,6 @@ function integerToWords (n, options) {
   if (n === 0n) return ZERO
 
   const { accentOne, includeOptionalAnd, noHundredPairing } = options
-  const segments = includeOptionalAnd ? SEGMENTS_WITH_AND : SEGMENTS
 
   // Apply één/een replacement
   const applyAccent = (word) => {
@@ -135,9 +118,9 @@ function integerToWords (n, options) {
     return word
   }
 
-  // Fast path: numbers < 1000 (direct lookup)
+  // Fast path: numbers < 1000
   if (n < 1000n) {
-    return applyAccent(segments[Number(n)])
+    return applyAccent(buildSegment(Number(n), includeOptionalAnd))
   }
 
   // Hundred pairing for 1100-9999
@@ -147,9 +130,9 @@ function integerToWords (n, options) {
 
     // Only use pairing when high is not a multiple of 10
     if (high % 10 !== 0) {
-      let result = segments[high] + HUNDRED
+      let result = buildSegment(high, includeOptionalAnd) + HUNDRED
       if (low > 0) {
-        const lowWord = segments[low]
+        const lowWord = buildSegment(low, includeOptionalAnd)
         if (includeOptionalAnd && low < 13) {
           result += ' en ' + lowWord
         } else {
@@ -171,11 +154,11 @@ function integerToWords (n, options) {
       result = SCALES[0]
     } else {
       // Compound: "vijfduizend"
-      result = segments[thousands] + SCALES[0]
+      result = buildSegment(thousands, includeOptionalAnd) + SCALES[0]
     }
 
     if (remainder > 0) {
-      const remainderWord = segments[remainder]
+      const remainderWord = buildSegment(remainder, includeOptionalAnd)
       if (includeOptionalAnd && remainder < 13) {
         result += ' en ' + remainderWord
       } else {
@@ -200,7 +183,6 @@ function integerToWords (n, options) {
  */
 function buildLargeNumberWords (n, options) {
   const { includeOptionalAnd } = options
-  const segmentLookup = includeOptionalAnd ? SEGMENTS_WITH_AND : SEGMENTS
 
   // Extract segments using BigInt division (faster than string slicing)
   // Segments stored least-significant first (index 0 = ones, 1 = thousands, etc.)
@@ -221,7 +203,7 @@ function buildLargeNumberWords (n, options) {
 
     if (i === 0) {
       // Units segment
-      const word = segmentLookup[segment]
+      const word = buildSegment(segment, includeOptionalAnd)
       if (result) {
         if (prevWasScale && includeOptionalAnd && segment < 13) {
           result += ' en ' + word
@@ -238,7 +220,7 @@ function buildLargeNumberWords (n, options) {
       if (segment === 1) {
         result += SCALES[0]
       } else {
-        result += segmentLookup[segment] + SCALES[0]
+        result += buildSegment(segment, includeOptionalAnd) + SCALES[0]
       }
       prevWasScale = true
     } else {
@@ -248,7 +230,7 @@ function buildLargeNumberWords (n, options) {
       if (segment === 1) {
         result += 'een ' + scaleWord
       } else {
-        result += segmentLookup[segment] + ' ' + scaleWord
+        result += buildSegment(segment, includeOptionalAnd) + ' ' + scaleWord
       }
       prevWasScale = true
     }

package/lib/languages/pa.js

@@ -1,7 +1,7 @@
 /**
  * Punjabi 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,13 +38,13 @@ const BELOW_HUNDRED = [
 const SCALE_WORDS = ['', 'ਹਜ਼ਾਰ', 'ਲੱਖ', 'ਕਰੋੜ', 'ਅਰਬ', 'ਖਰਬ', 'ਨੀਲ', 'ਪਦਮ', 'ਸ਼ੰਖ']
 
 // ============================================================================
-// Conversion Functions
+// Segment Building
 // ============================================================================
 
 /**
- * Converts 0-999 to Punjabi words.
+ * Builds words for a 0-999 segment.
  */
-function segmentToWords (n) {
+function buildSegment (n) {
   if (n === 0) return ''
   if (n < 100) return BELOW_HUNDRED[n]
 
@@ -57,9 +57,15 @@ function segmentToWords (n) {
   return BELOW_HUNDRED[hundreds] + ' ' + HUNDRED + ' ' + BELOW_HUNDRED[remainder]
 }
 
+// ============================================================================
+// Conversion Functions
+// ============================================================================
+
 /**
  * Converts a non-negative integer to Punjabi words.
- * Uses recursive approach for Indian 3-2-2 grouping pattern.
+ *
+ * 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} Punjabi words
@@ -69,48 +75,37 @@ function integerToWords (n) {
 
   // Fast path: numbers < 1000 (direct lookup)
   if (n < 1000n) {
-    return segmentToWords(Number(n))
+    return buildSegment(Number(n))
   }
 
-  return buildLargeNumberWords(n, 0)
-}
-
-/**
- * Recursively builds words for numbers >= 1000.
- * Indian grouping: first 3 digits, then 2-digit groups.
- *
- * @param {bigint} n - Number to convert
- * @param {number} scale - Current scale index (0=units, 1=thousands, etc.)
- * @returns {string} Punjabi words
- */
-function buildLargeNumberWords (n, scale) {
-  if (n === 0n) return ''
-
-  // Determine divisor: 1000 for first split, 100 for rest
-  const divisor = scale === 0 ? 1000n : 100n
-  const segment = Number(n % divisor)
-  const rest = n / divisor
+  // Extract segments using BigInt modulo
+  const segments = []
+  segments.push(Number(n % 1000n))
+  let temp = n / 1000n
 
-  // Build higher segments first (recursive)
-  let result = ''
-  if (rest > 0n) {
-    result = buildLargeNumberWords(rest, scale + 1)
+  while (temp > 0n) {
+    segments.push(Number(temp % 100n))
+    temp = temp / 100n
   }
 
-  // Add current segment
-  if (segment > 0) {
-    if (result) result += ' '
+  // 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 (scale === 0) {
-      // Units segment (0-999)
-      result += segmentToWords(segment)
+    if (i === 0) {
+      words.push(buildSegment(segment))
     } else {
-      // Scale segments (0-99)
-      result += BELOW_HUNDRED[segment] + ' ' + SCALE_WORDS[scale]
+      words.push(BELOW_HUNDRED[segment])
+    }
+
+    if (i > 0 && SCALE_WORDS[i]) {
+      words.push(SCALE_WORDS[i])
     }
   }
 
-  return result
+  return words.join(' ')
 }
 
 function decimalPartToWords (decimalPart) {

package/lib/languages/pl.js

@@ -1,13 +1,9 @@
 /**
  * Polish 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.
- *
- * Polish-specific rules (handled in precomputation):
+ * Polish-specific rules:
  * - Three-form pluralization: 1 = singular, 2-4 = few, 5+ = many
  * - Gender agreement (masculine/feminine for numbers < 1000)
  * - Omit "jeden" before scale words (tysiąc, milion, etc.)
@@ -51,7 +47,7 @@ const NEGATIVE = 'minus'
 const DECIMAL_SEP = 'przecinek'
 
 // ============================================================================
-// Precomputed Lookup Tables (built once at module load)
+// Segment Building
 // ============================================================================
 
 /**
@@ -123,14 +119,6 @@ function buildSegmentFeminine (n) {
   return parts.join(' ')
 }
 
-// Precompute all 1000 segment words (0-999)
-const SEGMENTS_MASC = new Array(1000)
-const SEGMENTS_FEM = new Array(1000)
-for (let i = 0; i < 1000; i++) {
-  SEGMENTS_MASC[i] = buildSegment(i)
-  SEGMENTS_FEM[i] = buildSegmentFeminine(i)
-}
-
 // ============================================================================
 // Helper Functions
 // ============================================================================
@@ -174,10 +162,9 @@ function pluralize (n, forms) {
 function integerToWords (n, options = {}) {
   if (n === 0n) return ZERO
 
-  // Fast path: numbers < 1000 (direct lookup)
+  // Fast path: numbers < 1000
   if (n < 1000n) {
-    const segments = options.gender === 'feminine' ? SEGMENTS_FEM : SEGMENTS_MASC
-    return segments[Number(n)]
+    return options.gender === 'feminine' ? buildSegmentFeminine(Number(n)) : buildSegment(Number(n))
   }
 
   // Fast path: numbers < 1,000,000 (thousands)
@@ -192,11 +179,11 @@ function integerToWords (n, options = {}) {
       // Omit "jeden" before tysiąc
       result = scaleWord
     } else {
-      result = SEGMENTS_MASC[thousands] + ' ' + scaleWord
+      result = buildSegment(thousands) + ' ' + scaleWord
     }
 
     if (remainder > 0) {
-      result += ' ' + SEGMENTS_MASC[remainder]
+      result += ' ' + buildSegment(remainder)
     }
 
     return result
@@ -231,7 +218,7 @@ function buildLargeNumberWords (n, options) {
     const segment = segmentValues[i]
     if (segment === 0n) continue
 
-    const segmentWord = SEGMENTS_MASC[Number(segment)]
+    const segmentWord = buildSegment(Number(segment))
 
     if (result) result += ' '
 

package/lib/languages/pt.js

@@ -1,13 +1,9 @@
 /**
  * Portuguese 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.
- *
- * Portuguese-specific rules (handled in precomputation):
+ * Portuguese-specific rules:
  * - "e" conjunction everywhere: vinte e um, cento e um, mil e um
  * - "cem" for exact 100, "cento" for 100+ remainder
  * - Irregular hundreds: duzentos, trezentos, quatrocentos, etc.
@@ -34,7 +30,7 @@ const NEGATIVE = 'menos'
 const DECIMAL_SEP = 'vírgula'
 
 // ============================================================================
-// Precomputed Lookup Tables (built once at module load)
+// Segment Building
 // ============================================================================
 
 /**
@@ -76,22 +72,11 @@ function buildSegment (n) {
   // Join hundreds with "e": "cento e um", "duzentos e trinta e um"
   const word = parts.join(' e ')
 
-  return { word, isExactHundred: hundreds > 0 && tens === 0 && ones === 0 }
-}
-
-// Precompute all 1000 segment words (0-999)
-const SEGMENTS = new Array(1000)
-const SEGMENTS_STARTS_WITH_HUNDREDS = new Array(1000)
-
-for (let i = 0; i < 1000; i++) {
-  const result = buildSegment(i)
-  SEGMENTS[i] = result.word
-  // Precompute whether segment starts with hundreds (100-999)
-  SEGMENTS_STARTS_WITH_HUNDREDS[i] = i >= 100
+  return { word, isExactHundred: hundreds > 0 && tens === 0 && ones === 0, startsWithHundreds: n >= 100 }
 }
 
 // ============================================================================
-// Scale Word Lookup (precomputed for common scales)
+// Scale Word Lookup
 // ============================================================================
 
 // Precompute scale words for singular and plural forms
@@ -133,9 +118,9 @@ const SCALE_WORDS_PLURAL = [
 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)).word
   }
 
   // Fast path: numbers < 1,000,000 (thousands)
@@ -148,15 +133,16 @@ function integerToWords (n) {
       // "mil" not "um mil"
       result = THOUSAND
     } else {
-      result = SEGMENTS[thousands] + ' ' + THOUSAND
+      result = buildSegment(thousands).word + ' ' + THOUSAND
     }
 
     if (remainder > 0) {
+      const remainderResult = buildSegment(remainder)
       // Insert "e" before remainder if it doesn't start with hundreds (< 100)
-      if (!SEGMENTS_STARTS_WITH_HUNDREDS[remainder]) {
-        result += ' e ' + SEGMENTS[remainder]
+      if (!remainderResult.startsWithHundreds) {
+        result += ' e ' + remainderResult.word
       } else {
-        result += ' ' + SEGMENTS[remainder]
+        result += ' ' + remainderResult.word
       }
     }
 
@@ -201,11 +187,11 @@ function buildLargeNumberWords (n) {
     const segment = segments[i]
     if (segment === 0) continue
 
-    const segmentWord = SEGMENTS[segment]
+    const segmentResult = buildSegment(segment)
     const isLastSegment = (i === firstNonZeroIdx)
 
     // Add "e" before final segment if previous was scale and this doesn't start with hundreds
-    if (result && isLastSegment && prevWasScale && !SEGMENTS_STARTS_WITH_HUNDREDS[segment]) {
+    if (result && isLastSegment && prevWasScale && !segmentResult.startsWithHundreds) {
       result += ' e'
     }
 
@@ -213,23 +199,23 @@ function buildLargeNumberWords (n) {
 
     if (i === 0) {
       // Units segment
-      result += segmentWord
+      result += segmentResult.word
       prevWasScale = false
     } else if (i === 1) {
       // Thousands
       if (segment === 1) {
         result += THOUSAND
       } else {
-        result += segmentWord + ' ' + THOUSAND
+        result += segmentResult.word + ' ' + THOUSAND
       }
       prevWasScale = true
     } else {
-      // Million and above - use precomputed scale arrays
+      // Million and above - use scale arrays
       const scaleWord = segment === 1 ? SCALE_WORDS_SINGULAR[i] : SCALE_WORDS_PLURAL[i]
       if (segment === 1) {
         result += 'um ' + scaleWord
       } else {
-        result += segmentWord + ' ' + scaleWord
+        result += segmentResult.word + ' ' + scaleWord
       }
       prevWasScale = true
     }