n2words 3.0.0 → 3.1.0

package/lib/languages/gu.js

@@ -1,7 +1,7 @@
 /**
  * Gujarati 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 (હજાર, લાખ, કરોડ)
@@ -39,26 +39,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]
 
@@ -75,25 +62,51 @@ function segmentToWords (n) {
 // Conversion Functions
 // ============================================================================
 
+/**
+ * Converts a non-negative integer to Gujarati 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} Gujarati 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
+  const segments = []
+  segments.push(Number(n % 1000n))
+  let temp = n / 1000n
+
+  while (temp > 0n) {
+    segments.push(Number(temp % 100n))
+    temp = temp / 100n
+  }
 
-  for (let i = 0; i < segmentCount; i++) {
-    const segmentValue = segments[i]
-    if (segmentValue === 0) continue
+  // 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 {
+      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])
+    if (i > 0 && SCALE_WORDS[i]) {
+      words.push(SCALE_WORDS[i])
     }
   }
 
-  return words.join(' ').trim()
+  return words.join(' ')
 }
 
 function decimalPartToWords (decimalPart) {

package/lib/languages/ha.js

@@ -1,7 +1,7 @@
 /**
  * Hausa 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:
  * - Authentic Boko orthography with ɗ (hooked d) and ' (glottal stop)
@@ -88,11 +88,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
 // ============================================================================
@@ -101,7 +96,7 @@ function integerToWords (n) {
   if (n === 0n) return ZERO
 
   if (n < 1000n) {
-    return SEGMENTS[Number(n)]
+    return buildSegment(Number(n))
   }
 
   return buildLargeNumberWords(n)
@@ -143,9 +138,9 @@ function buildLargeNumberWords (n) {
       const scaleWord = SCALE_WORDS[scaleIndex] || ''
 
       if (scaleIndex === 0) {
-        rawParts.push(SEGMENTS[segment])
+        rawParts.push(buildSegment(segment))
       } else {
-        rawParts.push(SEGMENTS[segment])
+        rawParts.push(buildSegment(segment))
         rawParts.push(scaleWord)
       }
     }

package/lib/languages/hbo.js

@@ -1,7 +1,7 @@
 /**
  * Biblical Hebrew language converter - Functional Implementation
  *
- * Self-contained converter with segment-based decomposition.
+ * Self-contained module with its own input validation, ready for subpath exports.
  *
  * Key features:
  * - Gender agreement (masculine default, feminine via option)
@@ -9,8 +9,6 @@
  * - Special 1-9 thousands construct state
  * - "ו" (ve) conjunction rules vary by position
  * - Per-digit decimal reading
- *
- * Optimization: Precomputed segment lookup tables for both genders.
  */
 
 import { parseNumericValue } from '../utils/parse-numeric.js'
@@ -44,7 +42,7 @@ const NEGATIVE = 'מינוס'
 const DECIMAL_SEP = 'נקודה'
 
 // ============================================================================
-// Precomputed Lookup Tables (built once at module load)
+// Segment Building
 // ============================================================================
 
 /**
@@ -145,19 +143,6 @@ function buildUnitsSegment (n, andWord, ONES, TEENS, HUNDREDS_ARR) {
   return result
 }
 
-// Precompute all 1000 segment words for masculine (default) with default conjunction
-const SCALE_SEGMENTS_MASC = new Array(1000)
-const UNITS_SEGMENTS_MASC = new Array(1000)
-const SCALE_SEGMENTS_FEM = new Array(1000)
-const UNITS_SEGMENTS_FEM = new Array(1000)
-
-for (let i = 0; i < 1000; i++) {
-  SCALE_SEGMENTS_MASC[i] = buildScaleSegment(i, 'ו', ONES_MASC, TEENS_MASC, HUNDREDS)
-  UNITS_SEGMENTS_MASC[i] = buildUnitsSegment(i, 'ו', ONES_MASC, TEENS_MASC, HUNDREDS)
-  SCALE_SEGMENTS_FEM[i] = buildScaleSegment(i, 'ו', ONES_FEM, TEENS_FEM, HUNDREDS_FEM)
-  UNITS_SEGMENTS_FEM[i] = buildUnitsSegment(i, 'ו', ONES_FEM, TEENS_FEM, HUNDREDS_FEM)
-}
-
 // ============================================================================
 // Conversion Functions
 // ============================================================================
@@ -175,19 +160,16 @@ function integerToWords (n, options) {
   const andWord = options.andWord ?? 'ו'
   const gender = options.gender || 'masculine'
   const isFeminine = gender === 'feminine'
-  const usePrecomputed = andWord === 'ו'
 
   // Select vocabulary based on gender
   const ONES = isFeminine ? ONES_FEM : ONES_MASC
   const TEENS = isFeminine ? TEENS_FEM : TEENS_MASC
   const THOUSANDS_SPECIAL = isFeminine ? THOUSANDS_FEM : THOUSANDS_MASC
   const HUNDREDS_ARR = isFeminine ? HUNDREDS_FEM : HUNDREDS
-  const SCALE_SEGS = isFeminine ? SCALE_SEGMENTS_FEM : SCALE_SEGMENTS_MASC
-  const UNITS_SEGS = isFeminine ? UNITS_SEGMENTS_FEM : UNITS_SEGMENTS_MASC
 
-  // Fast path: numbers < 1000 (direct lookup)
+  // Fast path: numbers < 1000
   if (n < 1000n) {
-    return usePrecomputed ? UNITS_SEGS[Number(n)] : buildUnitsSegment(Number(n), andWord, ONES, TEENS, HUNDREDS_ARR)
+    return buildUnitsSegment(Number(n), andWord, ONES, TEENS, HUNDREDS_ARR)
   }
 
   // Extract segments using BigInt modulo
@@ -207,7 +189,7 @@ function integerToWords (n, options) {
 
     if (i === 0) {
       // Units segment (no scale word)
-      const segmentWord = usePrecomputed ? UNITS_SEGS[segment] : buildUnitsSegment(segment, andWord, ONES, TEENS, HUNDREDS_ARR)
+      const segmentWord = buildUnitsSegment(segment, andWord, ONES, TEENS, HUNDREDS_ARR)
       if (result) {
         // Add "ו" before single-digit units when following scale words
         if (segment <= 9) {
@@ -224,7 +206,7 @@ function integerToWords (n, options) {
         if (result) result += ' '
         result += THOUSANDS_SPECIAL[segment]
       } else {
-        const segmentWord = usePrecomputed ? SCALE_SEGS[segment] : buildScaleSegment(segment, andWord, ONES, TEENS, HUNDREDS_ARR)
+        const segmentWord = buildScaleSegment(segment, andWord, ONES, TEENS, HUNDREDS_ARR)
         if (result) result += ' '
         result += segmentWord + ' ' + SCALE[1]
       }
@@ -234,7 +216,7 @@ function integerToWords (n, options) {
         if (result) result += ' '
         result += SCALE[i]
       } else {
-        const segmentWord = usePrecomputed ? SCALE_SEGS[segment] : buildScaleSegment(segment, andWord, ONES, TEENS, HUNDREDS_ARR)
+        const segmentWord = buildScaleSegment(segment, andWord, ONES, TEENS, HUNDREDS_ARR)
         if (result) result += ' '
         result += segmentWord + ' ' + SCALE_PLURAL[i]
       }

package/lib/languages/he.js

@@ -1,7 +1,7 @@
 /**
  * Modern Hebrew language converter - Functional Implementation
  *
- * Self-contained converter with segment-based decomposition.
+ * Self-contained module with its own input validation, ready for subpath exports.
  *
  * Key features:
  * - Feminine grammatical forms (default in Modern Hebrew)
@@ -9,8 +9,6 @@
  * - 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'
@@ -38,7 +36,7 @@ const NEGATIVE = 'מינוס'
 const DECIMAL_SEP = 'נקודה'
 
 // ============================================================================
-// Precomputed Lookup Tables (built once at module load)
+// Segment Building
 // ============================================================================
 
 /**
@@ -139,14 +137,6 @@ function buildUnitsSegment (n, andWord) {
   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
 // ============================================================================
@@ -162,11 +152,10 @@ function integerToWords (n, options) {
   if (n === 0n) return ZERO
 
   const andWord = options.andWord ?? 'ו'
-  const usePrecomputed = andWord === 'ו'
 
-  // Fast path: numbers < 1000 (direct lookup)
+  // Fast path: numbers < 1000
   if (n < 1000n) {
-    return usePrecomputed ? UNITS_SEGMENTS[Number(n)] : buildUnitsSegment(Number(n), andWord)
+    return buildUnitsSegment(Number(n), andWord)
   }
 
   // Extract segments using BigInt modulo
@@ -186,7 +175,7 @@ function integerToWords (n, options) {
 
     if (i === 0) {
       // Units segment (no scale word)
-      const segmentWord = usePrecomputed ? UNITS_SEGMENTS[segment] : buildUnitsSegment(segment, andWord)
+      const segmentWord = buildUnitsSegment(segment, andWord)
       if (result) {
         // Add "ו" before single-digit units when following scale words
         if (segment <= 9) {
@@ -203,7 +192,7 @@ function integerToWords (n, options) {
         if (result) result += ' '
         result += THOUSANDS_SPECIAL[segment]
       } else {
-        const segmentWord = usePrecomputed ? SCALE_SEGMENTS[segment] : buildScaleSegment(segment, andWord)
+        const segmentWord = buildScaleSegment(segment, andWord)
         if (result) result += ' '
         result += segmentWord + ' ' + SCALE[1]
       }
@@ -213,7 +202,7 @@ function integerToWords (n, options) {
         if (result) result += ' '
         result += SCALE[i]
       } else {
-        const segmentWord = usePrecomputed ? SCALE_SEGMENTS[segment] : buildScaleSegment(segment, andWord)
+        const segmentWord = buildScaleSegment(segment, andWord)
         if (result) result += ' '
         result += segmentWord + ' ' + SCALE_PLURAL[i]
       }

package/lib/languages/hi.js

@@ -1,13 +1,14 @@
 /**
  * Hindi 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 (हज़ार, लाख, करोड़)
  * - Devanagari script
  * - 3-2-2 grouping pattern (last 3 digits, then groups of 2)
  * - Complete word forms for 0-99
+ * - BigInt modulo for efficient segment extraction
  */
 
 import { parseNumericValue } from '../utils/parse-numeric.js'
@@ -38,26 +39,16 @@ 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.
+ *
+ * @param {number} n - Number 0-999
+ * @returns {string} Hindi words for the segment
+ */
+function buildSegment (n) {
   if (n === 0) return ''
   if (n < 100) return BELOW_HUNDRED[n]
 
@@ -74,25 +65,59 @@ function segmentToWords (n) {
 // Conversion Functions
 // ============================================================================
 
+/**
+ * Converts a non-negative integer to Hindi 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} Hindi words
+ */
 function integerToWords (n) {
   if (n === 0n) return ZERO
 
-  const segments = groupByThreeThenTwos(n)
-  const segmentCount = segments.length
-  const words = []
+  // Fast path: numbers < 1000
+  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/hr.js

@@ -1,7 +1,7 @@
 /**
  * Croatian 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 = ['', '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']
+]
+
+// ============================================================================
+// 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 = ['', 'jedan', 'dva', 'tri', 'četiri', 'pet', 'šest', 'sedam', 'osam', 'devet']
-const ONES_FEM = ['', 'jedna', 'dvije', 'tri', 'četiri', 'pet', 'šest', 'sedam', 'osam', 'devet']
+function buildSegmentFem (n) {
+  if (n === 0) return ''
 
-const TEENS = ['deset', 'jedanaest', 'dvanaest', 'trinaest', 'četrnaest', 'petnaest', 'šesnaest', 'sedamnaest', 'osamnaest', 'devetnaest']
-const TENS = ['', '', 'dvadeset', 'trideset', 'četrdeset', 'pedeset', 'šezdeset', 'sedamdeset', 'osamdeset', 'devedeset']
+  const onesDigit = n % 10
+  const tensDigit = Math.floor(n / 10) % 10
+  const hundredsDigit = Math.floor(n / 100)
 
-// Croatian has irregular hundreds
-const HUNDREDS = ['', 'sto', 'dvjesto', 'tristo', 'četiristo', 'petsto', 'šesto', 'sedamsto', 'osamsto', 'devetsto']
+  const parts = []
 
-const ZERO = 'nula'
-const NEGATIVE = 'minus'
-const DECIMAL_SEP = 'zarez'
+  if (hundredsDigit > 0) {
+    parts.push(HUNDREDS[hundredsDigit])
+  }
 
-// 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']
-]
+  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)
       }
     }