n2words 3.0.0 → 3.1.0

package/lib/languages/ta.js

@@ -1,15 +1,16 @@
 /**
  * Tamil 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 (ஆயிரம், லட்சம், கோடி)
  * - Tamil script
  * - 3-2-2 grouping pattern
  * - Complete word forms for 0-99
- * - Special hundred word transformations
+ * - Special hundred word transformations (connected vs standalone)
  * - Per-digit decimal reading
+ * - BigInt modulo for efficient segment extraction
  */
 
 import { parseNumericValue } from '../utils/parse-numeric.js'
@@ -48,35 +49,16 @@ const ONES = ['ஒன்று', 'இரண்டு', 'மூன்று', '
 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 = []
-  const last3 = numStr.slice(-3)
-  segments.unshift(Number(last3))
-
-  let remaining = numStr.slice(0, -3)
-  while (remaining.length > 0) {
-    const segment = remaining.slice(-2)
-    segments.unshift(Number(segment))
-    remaining = remaining.slice(0, -2)
-  }
-
-  return segments
-}
-
-// ============================================================================
-// Conversion Functions
-// ============================================================================
-
-function convertBelowThousand (n) {
+/**
+ * Builds words for a 0-999 segment.
+ *
+ * @param {number} n - Number 0-999
+ * @returns {string} Tamil words for the segment
+ */
+function buildSegment (n) {
   if (n === 0) return ''
   if (n < 100) return BELOW_HUNDRED[n]
 
@@ -87,30 +69,61 @@ function convertBelowThousand (n) {
     return HUNDREDS[hundreds]
   }
 
-  // Use precomputed connected form
+  // Use connected form when followed by remainder
   return HUNDREDS_CONNECTED[hundreds] + ' ' + BELOW_HUNDRED[remainder]
 }
 
+// ============================================================================
+// Conversion Functions
+// ============================================================================
+
+/**
+ * Converts a non-negative integer to Tamil 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} Tamil words
+ */
 function integerToWords (n) {
   if (n === 0n) return ZERO
 
-  const groups = groupByThreeThenTwos(n)
-  const groupCount = groups.length
-  const words = []
+  // Fast path: numbers < 1000
+  if (n < 1000n) {
+    return buildSegment(Number(n))
+  }
+
+  // Extract segments using BigInt modulo
+  const segments = []
+  segments.push(Number(n % 1000n))
+  let temp = n / 1000n
 
-  for (let i = 0; i < groupCount; i++) {
-    const groupValue = groups[i]
-    if (groupValue === 0) continue
+  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) {
+      words.push(buildSegment(segment))
+    } else {
+      // Use 'ஒரு' for 1 at scale positions
+      const groupWords = (segment === 1) ? 'ஒரு' : BELOW_HUNDRED[segment]
+      words.push(groupWords)
+    }
 
-    const scaleIndex = groupCount - i - 1
-    const groupWords = (groupValue === 1 && scaleIndex > 0) ? 'ஒரு' : convertBelowThousand(groupValue)
-    words.push(groupWords)
-    if (scaleIndex > 0 && SCALE_WORDS[scaleIndex]) {
-      words.push(SCALE_WORDS[scaleIndex])
+    if (i > 0 && SCALE_WORDS[i]) {
+      words.push(SCALE_WORDS[i])
     }
   }
 
-  return words.join(' ').trim()
+  return words.join(' ')
 }
 
 function decimalPartToWords (decimalPart) {

package/lib/languages/te.js

@@ -1,7 +1,7 @@
 /**
  * Telugu 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 (వెయ్యి, లక్ష, కోటి)
@@ -34,10 +34,6 @@ const BELOW_HUNDRED = [
   'తొంభై', 'తొంభై ఒకటి', 'తొంభై రెండు', 'తొంభై మూడు', 'తొంభై నాలుగు', 'తొంభై ఐదు', 'తొంభై ఆరు', 'తొంభై ఏడు', 'తొంభై ఎనిమిది', 'తొంభై తొమ్మిది'
 ]
 
-// ============================================================================
-// Vocabulary (continued)
-// ============================================================================
-
 const HUNDREDS = ['', 'వంద', 'రెండు వందలు', 'మూడు వందలు', 'నాలుగు వందలు', 'ఐదు వందలు', 'ఆరు వందలు', 'ఏడు వందలు', 'ఎనిమిది వందలు', 'తొమ్మిది వందలు']
 
 // Ones for decimal reading
@@ -47,13 +43,13 @@ const ONES = ['ఒకటి', 'రెండు', 'మూడు', 'నాలు
 const SCALE_WORDS = ['', 'వెయ్యి', 'లక్ష', 'కోటి', 'అరబ్', 'ఖరబ్', 'నిల్', 'పడ్మ', 'శంకు']
 
 // ============================================================================
-// Conversion Functions
+// Segment Building
 // ============================================================================
 
 /**
- * Converts 0-999 to Telugu words.
+ * Builds words for a 0-999 segment.
  */
-function convertBelowThousand (n) {
+function buildSegment (n) {
   if (n === 0) return ''
   if (n < 100) return BELOW_HUNDRED[n]
 
@@ -66,9 +62,15 @@ function convertBelowThousand (n) {
   return HUNDREDS[hundreds] + ' ' + BELOW_HUNDRED[remainder]
 }
 
+// ============================================================================
+// Conversion Functions
+// ============================================================================
+
 /**
  * Converts a non-negative integer to Telugu 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} Telugu words
@@ -78,49 +80,39 @@ function integerToWords (n) {
 
   // Fast path: numbers < 1000 (direct lookup)
   if (n < 1000n) {
-    return convertBelowThousand(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} Telugu 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 += convertBelowThousand(segment)
+    if (i === 0) {
+      words.push(buildSegment(segment))
     } else {
-      // Scale segments (0-99)
+      // Use 'ఒక' for 1 at scale positions
       const groupWords = (segment === 1) ? 'ఒక' : BELOW_HUNDRED[segment]
-      result += groupWords + ' ' + SCALE_WORDS[scale]
+      words.push(groupWords)
+    }
+
+    if (i > 0 && SCALE_WORDS[i]) {
+      words.push(SCALE_WORDS[i])
     }
   }
 
-  return result
+  return words.join(' ')
 }
 
 function decimalPartToWords (decimalPart) {

package/lib/languages/tr.js

@@ -1,7 +1,7 @@
 /**
  * Turkish 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:
  * - Omits 'bir' (one) before hundreds and thousands
@@ -32,7 +32,7 @@ const DECIMAL_SEP = 'virgül'
 const SCALES = ['milyon', 'milyar', 'trilyon', 'katrilyon', 'kentilyon']
 
 // ============================================================================
-// Precomputed Lookup Tables (built once at module load)
+// Segment Building
 // ============================================================================
 
 /**
@@ -75,15 +75,6 @@ function buildSegment (n, separator = ' ') {
   return parts.join(separator)
 }
 
-// Precompute all 1000 segment words (0-999) with space separator
-const SEGMENTS = new Array(1000)
-const SEGMENTS_NO_SPACE = new Array(1000)
-
-for (let i = 0; i < 1000; i++) {
-  SEGMENTS[i] = buildSegment(i, ' ')
-  SEGMENTS_NO_SPACE[i] = buildSegment(i, '')
-}
-
 // ============================================================================
 // Conversion Functions
 // ============================================================================
@@ -99,11 +90,10 @@ function integerToWords (n, options = {}) {
   if (n === 0n) return ZERO
 
   const sep = options.dropSpaces ? '' : ' '
-  const segments = options.dropSpaces ? SEGMENTS_NO_SPACE : SEGMENTS
 
-  // Fast path: numbers < 1000 (direct lookup)
+  // Fast path: numbers < 1000
   if (n < 1000n) {
-    return segments[Number(n)]
+    return buildSegment(Number(n), sep)
   }
 
   // Fast path: numbers < 1,000,000 (thousands)
@@ -116,11 +106,11 @@ function integerToWords (n, options = {}) {
     if (thousands === 1) {
       result = THOUSAND
     } else {
-      result = segments[thousands] + sep + THOUSAND
+      result = buildSegment(thousands, sep) + sep + THOUSAND
     }
 
     if (remainder > 0) {
-      result += sep + segments[remainder]
+      result += sep + buildSegment(remainder, sep)
     }
 
     return result
@@ -139,7 +129,6 @@ function integerToWords (n, options = {}) {
  */
 function buildLargeNumberWords (n, options) {
   const sep = options.dropSpaces ? '' : ' '
-  const segmentsArr = options.dropSpaces ? SEGMENTS_NO_SPACE : SEGMENTS
 
   const numStr = n.toString()
   const len = numStr.length
@@ -167,7 +156,7 @@ function buildLargeNumberWords (n, options) {
     const segment = segments[i]
 
     if (segment !== 0) {
-      const segmentWord = segmentsArr[segment]
+      const segmentWord = buildSegment(segment, sep)
 
       if (scaleIndex === 0) {
         // Units segment

package/lib/languages/uk.js

@@ -1,7 +1,7 @@
 /**
  * Ukrainian language converter - Functional Implementation
  *
- * Self-contained converter using shared Slavic utilities.
+ * Self-contained module with its own input validation, ready for subpath exports.
  *
  * Key features:
  * - Three-form pluralization (one/few/many)
@@ -14,7 +14,38 @@ import { parseNumericValue } from '../utils/parse-numeric.js'
 import { validateOptions } from '../utils/validate-options.js'
 
 // ============================================================================
-// Slavic Utilities (inlined for performance)
+// Vocabulary
+// ============================================================================
+
+const ONES_MASC = ['', 'один', 'два', 'три', 'чотири', 'п\'ять', 'шiсть', 'сiм', 'вiсiм', 'дев\'ять']
+const ONES_FEM = ['', 'одна', 'двi', 'три', 'чотири', 'п\'ять', 'шiсть', 'сiм', 'вiсiм', 'дев\'ять']
+
+const TEENS = ['десять', 'одинадцять', 'дванадцять', 'тринадцять', 'чотирнадцять', 'п\'ятнадцять', 'шiстнадцять', 'сiмнадцять', 'вiсiмнадцять', 'дев\'ятнадцять']
+const TENS = ['', '', 'двадцять', 'тридцять', 'сорок', 'п\'ятдесят', 'шiстдесят', 'сiмдесят', 'вiсiмдесят', 'дев\'яносто']
+
+// Irregular hundreds
+const HUNDREDS = ['', 'сто', 'двiстi', 'триста', 'чотириста', 'п\'ятсот', 'шiстсот', 'сiмсот', 'вiсiмсот', 'дев\'ятсот']
+
+const ZERO = 'нуль'
+const NEGATIVE = 'мiнус'
+const DECIMAL_SEP = 'кома'
+
+// Scale words: [singular, few, many]
+// Thousands (index 0) are feminine, rest are masculine
+const SCALE_FORMS = [
+  ['тисяча', 'тисячi', 'тисяч'],
+  ['мiльйон', 'мiльйони', 'мiльйонiв'],
+  ['мiльярд', 'мiльярди', 'мiльярдiв'],
+  ['трильйон', 'трильйони', 'трильйонiв'],
+  ['квадрильйон', 'квадрильйони', 'квадрильйонiв'],
+  ['квiнтильйон', 'квiнтильйони', 'квiнтильйонiв'],
+  ['секстильйон', 'секстильйони', 'секстильйонiв'],
+  ['септильйон', 'септильйони', 'септильйонiв'],
+  ['октильйон', 'октильйони', 'октильйонiв']
+]
+
+// ============================================================================
+// Segment Building
 // ============================================================================
 
 function pluralize (n, forms) {
@@ -31,19 +62,7 @@ function pluralize (n, forms) {
   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) {
+function buildSegmentMasc (n) {
   if (n === 0) return ''
 
   const onesDigit = n % 10
@@ -53,58 +72,47 @@ function buildSegment (n, ones, teens, tens, hundreds) {
   const parts = []
 
   if (hundredsDigit > 0) {
-    parts.push(hundreds[hundredsDigit])
+    parts.push(HUNDREDS[hundredsDigit])
   }
 
   if (tensDigit > 1) {
-    parts.push(tens[tensDigit])
+    parts.push(TENS[tensDigit])
   }
 
   if (tensDigit === 1) {
-    parts.push(teens[onesDigit])
+    parts.push(TEENS[onesDigit])
   } else if (onesDigit > 0) {
-    parts.push(ones[onesDigit])
+    parts.push(ONES_MASC[onesDigit])
   }
 
   return parts.join(' ')
 }
 
-// ============================================================================
-// Vocabulary
-// ============================================================================
-
-const ONES_MASC = ['', 'один', 'два', 'три', 'чотири', 'п\'ять', 'шiсть', 'сiм', 'вiсiм', 'дев\'ять']
-const ONES_FEM = ['', 'одна', 'двi', 'три', 'чотири', 'п\'ять', 'шiсть', 'сiм', 'вiсiм', 'дев\'ять']
+function buildSegmentFem (n) {
+  if (n === 0) return ''
 
-const TEENS = ['десять', 'одинадцять', 'дванадцять', 'тринадцять', 'чотирнадцять', 'п\'ятнадцять', 'шiстнадцять', 'сiмнадцять', 'вiсiмнадцять', 'дев\'ятнадцять']
-const TENS = ['', '', 'двадцять', 'тридцять', 'сорок', 'п\'ятдесят', 'шiстдесят', 'сiмдесят', 'вiсiмдесят', 'дев\'яносто']
+  const onesDigit = n % 10
+  const tensDigit = Math.floor(n / 10) % 10
+  const hundredsDigit = Math.floor(n / 100)
 
-// Irregular hundreds
-const HUNDREDS = ['', 'сто', 'двiстi', 'триста', 'чотириста', 'п\'ятсот', 'шiстсот', 'сiмсот', 'вiсiмсот', 'дев\'ятсот']
+  const parts = []
 
-const ZERO = 'нуль'
-const NEGATIVE = 'мiнус'
-const DECIMAL_SEP = 'кома'
+  if (hundredsDigit > 0) {
+    parts.push(HUNDREDS[hundredsDigit])
+  }
 
-// Scale words: [singular, few, many]
-// Thousands (index 0) are feminine, rest are masculine
-const SCALE_FORMS = [
-  ['тисяча', 'тисячi', 'тисяч'],
-  ['мiльйон', 'мiльйони', 'мiльйонiв'],
-  ['мiльярд', 'мiльярди', 'мiльярдiв'],
-  ['трильйон', 'трильйони', 'трильйонiв'],
-  ['квадрильйон', 'квадрильйони', 'квадрильйонiв'],
-  ['квiнтильйон', 'квiнтильйони', 'квiнтильйонiв'],
-  ['секстильйон', 'секстильйони', 'секстильйонiв'],
-  ['септильйон', 'септильйони', 'септильйонiв'],
-  ['октильйон', 'октильйони', 'октильйонiв']
-]
+  if (tensDigit > 1) {
+    parts.push(TENS[tensDigit])
+  }
 
-// ============================================================================
-// Precomputed Lookup Tables
-// ============================================================================
+  if (tensDigit === 1) {
+    parts.push(TEENS[onesDigit])
+  } else if (onesDigit > 0) {
+    parts.push(ONES_FEM[onesDigit])
+  }
 
-const { masc: SEGMENTS_MASC, fem: SEGMENTS_FEM } = buildAllSegments(ONES_MASC, ONES_FEM, TEENS, TENS, HUNDREDS)
+  return parts.join(' ')
+}
 
 // ============================================================================
 // Conversion Functions
@@ -114,8 +122,7 @@ 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 options.gender === 'feminine' ? buildSegmentFem(Number(n)) : buildSegmentMasc(Number(n))
   }
 
   return buildLargeNumberWords(n, options)
@@ -147,15 +154,14 @@ function buildLargeNumberWords (n, options) {
 
     if (segment !== 0) {
       if (scaleIndex === 0) {
-        const segmentWords = options.gender === 'feminine' ? SEGMENTS_FEM : SEGMENTS_MASC
-        parts.push(segmentWords[segment])
+        parts.push(options.gender === 'feminine' ? buildSegmentFem(segment) : buildSegmentMasc(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)
+        const segmentWord = isFeminine ? buildSegmentFem(segment) : buildSegmentMasc(segment)
+        parts.push(segmentWord + ' ' + scaleWord)
       }
     }
 

package/lib/languages/ur.js

@@ -1,7 +1,7 @@
 /**
  * Urdu 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 Urdu 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 Urdu 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} Urdu 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} Urdu 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) {