n2words 2.0.0 → 3.1.0

package/lib/languages/ja.js

@@ -1,137 +1,247 @@
-import { AbstractLanguage } from '../classes/abstract-language.js'
-
 /**
- * Japanese language converter.
+ * Japanese language converter - Functional Implementation
+ *
+ * Self-contained module with its own input validation, ready for subpath exports.
  *
- * Supports:
- * - Kanji numerals (一, 二, 三, etc.)
- * - Grouping by 万 (10,000) instead of 1,000
- * - Special 一 (one) omission rules (十, 百, 千 but 一万, 一億)
+ * Japanese-specific rules:
+ * - Myriad (万-based) grouping: 4 digits per segment instead of 3
+ * - 一 omission: Omit "一" before 十, 百, 千 but NOT before 万 and higher scales
+ * - Kanji numerals: 零一二三四五六七八九
+ * - No spaces between characters
  */
-export class Japanese extends AbstractLanguage {
-  negativeWord = 'マイナス'
-  decimalSeparatorWord = '点'
-  zeroWord = '零'
-  wordSeparator = '' // Japanese doesn't use spaces between characters
-  usePerDigitDecimals = true // Enable digit-by-digit decimal conversion
-
-  // Ones words used for group conversion (1-9)
-  onesWords = ['一', '二', '三', '四', '五', '六', '七', '八', '九']
-
-  // Scale words for grouping by 10^4
-  scaleWords = [
-    '', // 10^0 (ones)
-    '万', // 10^4 (man)
-    '億', // 10^8 (oku)
-    '兆', // 10^12 (chō)
-    '京', // 10^16 (kei)
-    '垓', // 10^20 (gai)
-    '秭', // 10^24 (jo/shi)
-    '穣', // 10^28 (jō)
-    '溝', // 10^32 (kō)
-    '澗', // 10^36 (kan)
-    '正', // 10^40 (sei)
-    '載', // 10^44 (sai)
-    '極', // 10^48 (goku)
-    '恒河沙', // 10^52 (gōgasha)
-    '阿僧祇', // 10^56 (asōgi)
-    '那由他', // 10^60 (nayuta)
-    '不可思議', // 10^64 (fukashigi)
-    '無量大数' // 10^68 (muryōtaisū)
-  ]
-
-  /** Converts a segment of up to 4 digits to Japanese kanji with 一 omission rules. */
-  segmentToWords (num) {
-    if (num === 0n) return ''
-
-    const thousands = num / 1000n
-    const hundreds = (num % 1000n) / 100n
-    const tens = (num % 100n) / 10n
-    const ones = num % 10n
-
-    let result = ''
-
-    // Thousands (千)
-    if (thousands > 0n) {
-      // Always omit 一 before 千 when thousands === 1
-      if (thousands === 1n) {
-        result += '千'
-      } else {
-        result += this.onesWords[Number(thousands) - 1] + '千'
-      }
-    }
 
-    // Hundreds (百)
-    if (hundreds > 0n) {
-      // Always omit 一 before 百 when hundreds === 1
-      if (hundreds === 1n) {
-        result += '百'
-      } else {
-        result += this.onesWords[Number(hundreds) - 1] + '百'
-      }
+import { parseNumericValue } from '../utils/parse-numeric.js'
+
+// ============================================================================
+// Vocabulary (module-level constants)
+// ============================================================================
+
+// Ones words (1-9), index 0 unused
+const ONES = ['', '一', '二', '三', '四', '五', '六', '七', '八', '九']
+
+// Scale words for powers of 10,000 (万-based system)
+// Index 0 = 万 (10^4), 1 = 億 (10^8), 2 = 兆 (10^12), etc.
+const SCALES = [
+  '万', // 10^4 (man)
+  '億', // 10^8 (oku)
+  '兆', // 10^12 (chō)
+  '京', // 10^16 (kei)
+  '垓', // 10^20 (gai)
+  '秭', // 10^24 (jo/shi)
+  '穣', // 10^28 (jō)
+  '溝', // 10^32 (kō)
+  '澗', // 10^36 (kan)
+  '正', // 10^40 (sei)
+  '載', // 10^44 (sai)
+  '極', // 10^48 (goku)
+  '恒河沙', // 10^52 (gōgasha)
+  '阿僧祇', // 10^56 (asōgi)
+  '那由他', // 10^60 (nayuta)
+  '不可思議', // 10^64 (fukashigi)
+  '無量大数' // 10^68 (muryōtaisū)
+]
+
+const ZERO = '零'
+const NEGATIVE = 'マイナス'
+const DECIMAL_SEP = '点'
+
+// Internal scale words (within 4-digit segments)
+const TEN = '十'
+const HUNDRED = '百'
+const THOUSAND = '千'
+
+// ============================================================================
+// Segment Building
+// ============================================================================
+
+/**
+ * Builds segment word for 0-9999 with 一 omission rules.
+ * - Omit 一 before 十, 百, 千
+ */
+function buildSegment (n) {
+  if (n === 0) return ''
+
+  const ones = n % 10
+  const tens = Math.floor(n / 10) % 10
+  const hundreds = Math.floor(n / 100) % 10
+  const thousands = Math.floor(n / 1000)
+
+  let result = ''
+
+  // Thousands (千) - omit 一 when 1
+  if (thousands > 0) {
+    if (thousands === 1) {
+      result += THOUSAND
+    } else {
+      result += ONES[thousands] + THOUSAND
     }
+  }
 
-    // Tens (十)
-    if (tens > 0n) {
-      // Always omit 一 before 十 when tens === 1
-      if (tens === 1n) {
-        result += '十'
-      } else {
-        result += this.onesWords[Number(tens) - 1] + '十'
-      }
+  // Hundreds (百) - omit 一 when 1
+  if (hundreds > 0) {
+    if (hundreds === 1) {
+      result += HUNDRED
+    } else {
+      result += ONES[hundreds] + HUNDRED
     }
+  }
 
-    // Ones
-    if (ones > 0n) {
-      result += this.onesWords[Number(ones) - 1]
+  // Tens (十) - omit 一 when 1
+  if (tens > 0) {
+    if (tens === 1) {
+      result += TEN
+    } else {
+      result += ONES[tens] + TEN
     }
+  }
 
-    return result
+  // Ones
+  if (ones > 0) {
+    result += ONES[ones]
   }
 
-  /** Converts integer part using Japanese 万-based grouping system. */
-  integerToWords (integerPart) {
-    if (integerPart === 0n) {
-      return this.zeroWord
-    }
+  return result
+}
 
-    let temp = integerPart
-    let scaleIndex = 0
-    const groups = []
+// ============================================================================
+// Conversion Functions
+// ============================================================================
 
-    // Split into groups of 4 digits (万-based system)
-    while (temp > 0n) {
-      const group = temp % 10000n
-      if (group > 0n) {
-        groups.push({ value: group, scale: scaleIndex })
-      }
-      temp = temp / 10000n
-      scaleIndex++
+/**
+ * Converts a non-negative integer to Japanese words.
+ *
+ * @param {bigint} n - Non-negative integer to convert
+ * @returns {string} Japanese kanji words
+ */
+function integerToWords (n) {
+  if (n === 0n) return ZERO
+
+  // Fast path: numbers < 10000
+  if (n < 10000n) {
+    return buildSegment(Number(n))
+  }
+
+  // Fast path: numbers < 100,000,000 (万 range)
+  if (n < 100_000_000n) {
+    const man = Number(n / 10000n)
+    const remainder = Number(n % 10000n)
+
+    // For 万 and above, we need 一 before the scale word when segment is 1
+    let result
+    if (man === 1) {
+      result = '一' + SCALES[0] // 一万
+    } else {
+      result = buildSegment(man) + SCALES[0]
+    }
+
+    if (remainder > 0) {
+      result += buildSegment(remainder)
     }
 
-    // Reverse to process from highest to lowest
-    groups.reverse()
+    return result
+  }
+
+  // For numbers >= 100,000,000, use scale decomposition
+  return buildLargeNumberWords(n)
+}
 
-    let result = ''
+/**
+ * Builds words for numbers >= 100,000,000.
+ * Uses BigInt modulo for 4-digit (myriad) segment extraction.
+ *
+ * @param {bigint} n - Number >= 100,000,000
+ * @returns {string} Japanese kanji words
+ */
+function buildLargeNumberWords (n) {
+  // Extract segments using BigInt modulo (faster than string slicing)
+  // Segments stored least-significant first (index 0 = units, 1 = 万, etc.)
+  const segments = []
+  let temp = n
+  while (temp > 0n) {
+    segments.push(Number(temp % 10000n))
+    temp = temp / 10000n
+  }
 
-    for (let i = 0; i < groups.length; i++) {
-      const { value, scale } = groups[i]
+  // Build result string directly (process from most-significant to least)
+  let result = ''
 
-      const groupStr = this.segmentToWords(value)
+  for (let i = segments.length - 1; i >= 0; i--) {
+    const segment = segments[i]
+    if (segment === 0) continue
 
-      // For scales >= 1 (万 and above), always add the scale word
-      if (scale >= 1) {
-        // Special case: if group is 1 and scale >= 1, we need 一 before the scale
-        if (value === 1n) {
-          result += '一' + this.scaleWords[scale]
-        } else {
-          result += groupStr + this.scaleWords[scale]
-        }
+    if (i > 0) {
+      // For scales >= 万, we need 一 before scale word when segment is 1
+      if (segment === 1) {
+        result += '一' + SCALES[i - 1]
       } else {
-        result += groupStr
+        result += buildSegment(segment) + SCALES[i - 1]
       }
+    } else {
+      // Units segment (no scale word)
+      result += buildSegment(segment)
     }
+  }
 
-    return result
+  return result || ZERO
+}
+
+/**
+ * Converts decimal digits to Japanese words (digit by digit).
+ *
+ * @param {string} decimalPart - Decimal digits (without the point)
+ * @returns {string} Japanese kanji words for decimal part
+ */
+function decimalPartToWords (decimalPart) {
+  let result = ''
+
+  for (let i = 0; i < decimalPart.length; i++) {
+    const digit = parseInt(decimalPart[i], 10)
+    if (digit === 0) {
+      result += ZERO
+    } else {
+      result += ONES[digit]
+    }
+  }
+
+  return result
+}
+
+/**
+ * Converts a numeric value to Japanese 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 Japanese kanji words
+ * @throws {TypeError} If value is not a valid numeric type
+ * @throws {Error} If value is not a valid number format
+ *
+ * @example
+ * toWords(42)           // '四十二'
+ * toWords(10000)        // '一万'
+ * toWords(100000000)    // '一億'
+ */
+function toWords (value) {
+  const { isNegative, integerPart, decimalPart } = parseNumericValue(value)
+
+  let result = ''
+
+  if (isNegative) {
+    result = NEGATIVE
+  }
+
+  result += integerToWords(integerPart)
+
+  if (decimalPart) {
+    result += DECIMAL_SEP + decimalPartToWords(decimalPart)
   }
+
+  return result
 }
+
+// ============================================================================
+// Public API
+// ============================================================================
+
+export { toWords }

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;

package/lib/languages/ka.js

@@ -0,0 +1,291 @@
+/**
+ * Georgian language converter - Functional Implementation
+ *
+ * Self-contained module with its own input validation, ready for subpath exports.
+ *
+ * Georgian-specific rules:
+ * - Vigesimal (base-20) system for 20-99
+ * - 40 = ორმოცი (2×20), 60 = სამოცი (3×20), 80 = ოთხმოცი (4×20)
+ * - 30/50/70/90 use "და" + "ათი": ოცდაათი (20+10), ორმოცდაათი (40+10)
+ * - Compound numbers use "და" (da = "and") connector
+ * - Hundreds: unit prefix + ას (ორასი = 200)
+ * - Short scale for large numbers (მილიონი, მილიარდი, ტრილიონი)
+ */
+
+import { parseNumericValue } from '../utils/parse-numeric.js'
+
+// ============================================================================
+// Vocabulary (module-level constants)
+// ============================================================================
+
+// Numbers 0-9 (primitives)
+const ONES = ['ნული', 'ერთი', 'ორი', 'სამი', 'ოთხი', 'ხუთი', 'ექვსი', 'შვიდი', 'რვა', 'ცხრა']
+
+// Numbers 10-19
+const TEENS = ['ათი', 'თერთმეტი', 'თორმეტი', 'ცამეტი', 'თოთხმეტი', 'თხუთმეტი', 'თექვსმეტი', 'ჩვიდმეტი', 'თვრამეტი', 'ცხრამეტი']
+
+// Vigesimal bases: 20, 40, 60, 80 (with და connector forms)
+const VIGESIMAL = ['', 'ოცი', 'ორმოცი', 'სამოცი', 'ოთხმოცი']
+const VIGESIMAL_DA = ['', 'ოცდა', 'ორმოცდა', 'სამოცდა', 'ოთხმოცდა']
+
+// Prefixes for hundreds (unit forms without final vowel)
+const HUNDRED_PREFIXES = ['', '', 'ორ', 'სამ', 'ოთხ', 'ხუთ', 'ექვს', 'შვიდ', 'რვა', 'ცხრა']
+
+const HUNDRED = 'ასი'
+const HUNDRED_STEM = 'ას' // Without final vowel
+const THOUSAND = 'ათასი'
+const THOUSAND_STEM = 'ათას' // Without final vowel
+
+// Scale words (short scale) - indexed by segment position
+const SCALES = ['', '', 'მილიონი', 'მილიარდი', 'ტრილიონი', 'კვადრილიონი', 'კვინტილიონი', 'სექსტილიონი']
+
+const ZERO = 'ნული'
+const NEGATIVE = 'მინუს'
+const DECIMAL_SEP = 'მთელი'
+
+// ============================================================================
+// Segment Building
+// ============================================================================
+
+/**
+ * Builds segment word for 0-99 using vigesimal system.
+ * @param {number} n - Number 0-99
+ * @returns {string} Georgian word
+ */
+function buildTens (n) {
+  if (n < 10) return ONES[n]
+  if (n < 20) return TEENS[n - 10]
+
+  const vigesimalGroup = Math.floor(n / 20)
+  const remainder = n % 20
+
+  if (remainder === 0) {
+    return VIGESIMAL[vigesimalGroup]
+  }
+
+  // Use და connector: ოცდა + remainder
+  const base = VIGESIMAL_DA[vigesimalGroup]
+  if (remainder < 10) {
+    return base + ONES[remainder]
+  }
+  return base + TEENS[remainder - 10]
+}
+
+/**
+ * Builds segment word for 0-999.
+ * Returns object with full form and stem form (without final vowel).
+ * @param {number} n - Number 0-999
+ * @returns {{full: string, stem: string}} Georgian words
+ */
+function buildSegment (n) {
+  if (n === 0) return { full: '', stem: '' }
+  if (n < 100) {
+    const word = buildTens(n)
+    // Remove final vowel for stem
+    const lastChar = word.slice(-1)
+    const stem = (lastChar === 'ი' || lastChar === 'ა') ? word.slice(0, -1) : word
+    return { full: word, stem }
+  }
+
+  const hundreds = Math.floor(n / 100)
+  const remainder = n % 100
+
+  // Build hundreds: ასი (100), ორასი (200), etc.
+  let hundredWord
+  if (hundreds === 1) {
+    hundredWord = remainder > 0 ? HUNDRED_STEM : HUNDRED
+  } else {
+    hundredWord = HUNDRED_PREFIXES[hundreds] + (remainder > 0 ? HUNDRED_STEM : HUNDRED)
+  }
+
+  if (remainder > 0) {
+    const remainderWord = buildTens(remainder)
+    const full = hundredWord + ' ' + remainderWord
+    // Stem removes final vowel from remainder
+    const lastChar = remainderWord.slice(-1)
+    const remainderStem = (lastChar === 'ი' || lastChar === 'ა') ? remainderWord.slice(0, -1) : remainderWord
+    return { full, stem: hundredWord + ' ' + remainderStem }
+  }
+
+  // Hundreds only - stem removes final ი
+  return { full: hundredWord, stem: hundredWord.slice(0, -1) }
+}
+
+// ============================================================================
+// Conversion Functions
+// ============================================================================
+
+/**
+ * Converts a non-negative integer to Georgian words.
+ *
+ * @param {bigint} n - Non-negative integer to convert
+ * @returns {string} Georgian words
+ */
+function integerToWords (n) {
+  if (n === 0n) return ZERO
+
+  // Fast path: numbers < 1000
+  if (n < 1000n) {
+    const { full } = buildSegment(Number(n))
+    return full
+  }
+
+  // Fast path: numbers < 1,000,000 (thousands)
+  if (n < 1_000_000n) {
+    const thousands = Number(n / 1000n)
+    const remainder = Number(n % 1000n)
+
+    let result
+    if (thousands === 1) {
+      // "ათასი" not "ერთი ათასი"
+      result = remainder > 0 ? THOUSAND_STEM : THOUSAND
+    } else {
+      // Use stem form before ათასი
+      const { stem: thousandsPart } = buildSegment(thousands)
+      result = thousandsPart + ' ' + (remainder > 0 ? THOUSAND_STEM : THOUSAND)
+    }
+
+    if (remainder > 0) {
+      const { full: remainderWord } = buildSegment(remainder)
+      result += ' ' + remainderWord
+    }
+
+    return result
+  }
+
+  // For numbers >= 1,000,000, use scale decomposition
+  return buildLargeNumberWords(n)
+}
+
+/**
+ * Builds words for numbers >= 1,000,000.
+ *
+ * @param {bigint} n - Number >= 1,000,000
+ * @returns {string} Georgian words
+ */
+function buildLargeNumberWords (n) {
+  const numStr = n.toString()
+  const len = numStr.length
+
+  // Build segments of 3 digits from left to right
+  const segments = []
+  const segmentSize = 3
+
+  const remainderLen = len % segmentSize
+  let pos = 0
+  if (remainderLen > 0) {
+    segments.push(Number(numStr.slice(0, remainderLen)))
+    pos = remainderLen
+  }
+  while (pos < len) {
+    segments.push(Number(numStr.slice(pos, pos + segmentSize)))
+    pos += segmentSize
+  }
+
+  // Convert segments to words
+  const parts = []
+  let scaleIndex = segments.length - 1
+
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i]
+
+    if (segment !== 0) {
+      if (scaleIndex === 0) {
+        // Units (no scale)
+        const { full } = buildSegment(segment)
+        parts.push(full)
+      } else if (scaleIndex === 1) {
+        // Thousands - check if there's a remainder
+        const hasRemainder = segments.slice(i + 1).some(s => s !== 0)
+        const thousandWord = hasRemainder ? THOUSAND_STEM : THOUSAND
+
+        if (segment === 1) {
+          parts.push(thousandWord)
+        } else {
+          const { stem } = buildSegment(segment)
+          parts.push(stem + ' ' + thousandWord)
+        }
+      } else {
+        // Million and above
+        const scaleWord = SCALES[scaleIndex] || SCALES[SCALES.length - 1]
+        if (segment === 1) {
+          parts.push('ერთი ' + scaleWord)
+        } else {
+          const { full } = buildSegment(segment)
+          parts.push(full + ' ' + scaleWord)
+        }
+      }
+    }
+
+    scaleIndex--
+  }
+
+  return parts.join(' ')
+}
+
+/**
+ * Converts decimal digits to Georgian words.
+ *
+ * @param {string} decimalPart - Decimal digits (without the point)
+ * @returns {string} Georgian words for decimal part
+ */
+function decimalPartToWords (decimalPart) {
+  let result = ''
+
+  // Handle leading zeros
+  let i = 0
+  while (i < decimalPart.length && decimalPart[i] === '0') {
+    if (result) result += ' '
+    result += ZERO
+    i++
+  }
+
+  // Convert remainder as a single number
+  const remainder = decimalPart.slice(i)
+  if (remainder) {
+    if (result) result += ' '
+    result += integerToWords(BigInt(remainder))
+  }
+
+  return result
+}
+
+/**
+ * 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)         // 'ათასი'
+ */
+function toWords (value) {
+  const { isNegative, integerPart, decimalPart } = parseNumericValue(value)
+
+  let result = ''
+
+  if (isNegative) {
+    result = NEGATIVE + ' '
+  }
+
+  result += integerToWords(integerPart)
+
+  if (decimalPart) {
+    result += ' ' + DECIMAL_SEP + ' ' + decimalPartToWords(decimalPart)
+  }
+
+  return result
+}
+
+// ============================================================================
+// Public API
+// ============================================================================
+
+export { toWords }

package/lib/languages/kn.d.ts

@@ -1,11 +1,7 @@
 /**
- * Kannada language converter.
+ * Converts a numeric value to Kannada words.
  *
- * Supports:
- * - Indian numbering system (ಸಾವಿರ, ಲಕ್ಷ, ಕೋಟಿ)
- * - Kannada script
- * - Complete word forms for 0-99
+ * @param {number | string | bigint} value - The numeric value to convert
+ * @returns {string} The number in Kannada words
  */
-export class Kannada extends SouthAsianLanguage {
-}
-import { SouthAsianLanguage } from '../classes/south-asian-language.js';
+export function toWords(value: number | string | bigint): string;