n2words 1.24.0 → 3.0.0

package/lib/languages/ja.js

@@ -1,190 +1,259 @@
-import AbstractLanguage from '../classes/abstract-language.js'
-
 /**
- * Japanese language converter.
- *
- * Converts numbers to Japanese kanji numerals using the Sino-Japanese system:
- * - Uses kanji characters (一, 二, 三, etc.)
- * - Grouping by 万 (man, 10,000) and 億 (oku, 100,000,000)
- * - Unique scale units: 兆 (chō, trillion), 京 (kei, 10^16)
- * - Special rules for 1: omitted before 十 (10), 百 (100), 千 (1000), but kept for 万 and above
+ * Japanese language converter - Functional Implementation
  *
- * Key Features:
- * - Sino-Japanese number system (standard for general counting)
- * - Grouping by powers of 10,000 (万-based system, not 1,000)
- * - Scale units: 万 (10^4), 億 (10^8), 兆 (10^12), 京 (10^16)
- * - Special handling of 一 (one) prefix
- * - Support for very large numbers up to 無量大数 (10^68)
+ * A performance-optimized number-to-words converter using precomputed lookup tables.
+ * Self-contained module with its own input validation, ready for subpath exports.
  *
- * Algorithm:
- * 1. Split number into groups of 4 digits (万-based, not 3-digit thousand-based)
- * 2. Convert each group to kanji using special rules
- * 3. Append appropriate scale word (万, 億, 兆, etc.)
- * 4. Join all groups
+ * Key optimization: Precompute all segment values (0-9999) at module load.
+ * This eliminates all per-call string manipulation for segment conversion.
  *
- * Special Rules:
- * - 10, 100, 1000: Don't use 一 prefix (十, 百, 千 not 一十, 一百, 一千)
- * - 10,000+: Keep 一 prefix (一万, 一億, 一兆)
- * - Zero: 零 or 〇 (both acceptable, 零 is more formal)
+ * Japanese-specific rules (handled in precomputation):
+ * - 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
-  convertDecimalsPerDigit = true // Enable digit-by-digit decimal conversion
-
-  // Digits used for group conversion (1-9)
-  digits = ['一', '二', '三', '四', '五', '六', '七', '八', '九']
-
-  // Scale words for grouping by 10^4
-  scales = [
-    '', // 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 group of up to 4 digits to Japanese kanji.
-   * Handles special rules for omitting 一 before 十, 百, 千.
-   *
-   * Rule: Within a group, omit 一 before 十/百/千 EXCEPT when:
-   * - It's a lower group (not isTopGroup) AND
-   * - It would be the only character in that position
-   *
-   * @param {bigint} num - Number from 0 to 9999
-   * @param {boolean} isTopGroup - Whether this is the highest non-zero group
-   * @returns {string} Japanese kanji representation
-   */
-  convertGroup (num, isTopGroup = false) {
-    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.digits[Number(thousands) - 1] + '千'
-      }
-    }
 
-    // Hundreds (百)
-    if (hundreds > 0n) {
-      // Always omit 一 before 百 when hundreds === 1
-      if (hundreds === 1n) {
-        result += '百'
-      } else {
-        result += this.digits[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 = '千'
+
+// ============================================================================
+// Precomputed Lookup Tables (built once at module load)
+// ============================================================================
+
+/**
+ * Builds segment word for 0-9999 with 一 omission rules.
+ * - Omit 一 before 十, 百, 千
+ * Only used during table construction.
+ */
+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.digits[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.digits[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 a BigInt number to Japanese cardinal form.
-   *
-   * @param {bigint} number - The number to convert
-   * @returns {string} Japanese kanji representation
-   */
-  convertWholePart (number) {
-    if (number === 0n) {
-      return this.zeroWord
-    }
+  return result
+}
+
+// Precompute all 10000 segment words (0-9999)
+// SEGMENTS[n] gives the Japanese word for n within a segment
+const SEGMENTS = new Array(10000)
+for (let i = 0; i < 10000; i++) {
+  SEGMENTS[i] = buildSegment(i)
+}
 
-    let temp = number
-    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 (direct lookup)
+  if (n < 10000n) {
+    return SEGMENTS[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 = SEGMENTS[man] + SCALES[0]
     }
 
-    // Reverse to process from highest to lowest
-    groups.reverse()
+    if (remainder > 0) {
+      result += SEGMENTS[remainder]
+    }
 
-    let result = ''
+    return result
+  }
 
-    for (let i = 0; i < groups.length; i++) {
-      const { value, scale } = groups[i]
-      const isTopGroup = (i === 0)
+  // For numbers >= 100,000,000, use scale decomposition
+  return buildLargeNumberWords(n)
+}
 
-      const groupStr = this.convertGroup(value, isTopGroup)
+/**
+ * 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
+  }
+
+  // Build result string directly (process from most-significant to least)
+  let result = ''
+
+  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.scales[scale]
-        } else {
-          result += groupStr + this.scales[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 += SEGMENTS[segment] + SCALES[i - 1]
       }
+    } else {
+      // Units segment (no scale word)
+      result += SEGMENTS[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 value to cardinal (written) form in Japanese.
+ * Converts a numeric value to Japanese words.
  *
- * @param {number|string|bigint} value - Number to convert.
- * @param {Object} [options] - Options for the converter.
- * @returns {string} Value in Japanese kanji numerals.
- * @throws {Error} If value is invalid.
+ * 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
- * convertToWords(42, { lang: 'ja' }); // '四十二'
- * convertToWords(1000, { lang: 'ja' }); // '千'
- * convertToWords(10000, { lang: 'ja' }); // '一万'
+ * toWords(42)           // '四十二'
+ * toWords(10000)        // '一万'
+ * toWords(100000000)    // '一億'
  */
-export default function convertToWords (value, options = {}) {
-  return new Japanese(options).convertToWords(value)
+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

@@ -0,0 +1,7 @@
+/**
+ * Converts a numeric value to Kannada words.
+ *
+ * @param {number | string | bigint} value - The numeric value to convert
+ * @returns {string} The number in Kannada words
+ */
+export function toWords(value: number | string | bigint): string;

package/lib/languages/kn.js

@@ -1,71 +1,137 @@
 /**
- * Converts numbers to their word representation in Kannada (ಕನ್ನಡ).
- * @module languages/kn
+ * Kannada language converter - Functional Implementation
+ *
+ * Self-contained converter for South Asian numbering.
+ *
+ * Key features:
+ * - Indian numbering system (ಸಾವಿರ, ಲಕ್ಷ, ಕೋಟಿ)
+ * - Kannada script
+ * - 3-2-2 grouping pattern (last 3 digits, then groups of 2)
+ * - Complete word forms for 0-99
+ * - Per-digit decimal reading
  */
 
-import SouthAsianLanguage from '../classes/south-asian-language.js'
+import { parseNumericValue } from '../utils/parse-numeric.js'
 
-/**
- * Kannada language implementation using Indian-style number grouping.
- * @extends SouthAsianLanguage
- */
-class KannadaLanguage extends SouthAsianLanguage {
-  negativeWord = 'ಋಣಾತ್ಮಕ'
-  decimalSeparatorWord = 'ದಶಮಾಂಶ'
-  zeroWord = 'ಸೊನ್ನೆ'
-  hundredWord = 'ನೂರು'
-  convertDecimalsPerDigit = true
-
-  /**
-   * Array of number words from 0 to 99.
-   * Index matches the number value.
-   * @type {string[]}
-   */
-  belowHundred = [
-    'ಸೊನ್ನೆ', 'ಒಂದು', 'ಎರಡು', 'ಮೂರು', 'ನಾಲ್ಕು', 'ಐದು', 'ಆರು', 'ಏಳು', 'ಎಂಟು', 'ಒಂಬತ್ತು',
-    'ಹತ್ತು', 'ಹನ್ನೊಂದು', 'ಹನ್ನೆರಡು', 'ಹದಿಮೂರು', 'ಹದಿನಾಲ್ಕು', 'ಹದಿನೈದು', 'ಹದಿನಾರು', 'ಹದಿನೇಳು', 'ಹದಿನೆಂಟು', 'ಹತ್ತೊಂಬತ್ತು',
-    'ಇಪ್ಪತ್ತು', 'ಇಪ್ಪತ್ತೊಂದು', 'ಇಪ್ಪತ್ತೆರಡು', 'ಇಪ್ಪತ್ತಮೂರು', 'ಇಪ್ಪತ್ತನಾಲ್ಕು', 'ಇಪ್ಪತ್ತೈದು', 'ಇಪ್ಪತ್ತಾರು', 'ಇಪ್ಪತ್ತೇಳು', 'ಇಪ್ಪತ್ತೆಂಟು', 'ಇಪ್ಪತ್ತೊಂಬತ್ತು',
-    'ಮೂವತ್ತು', 'ಮೂವತ್ತೊಂದು', 'ಮೂವತ್ತೆರಡು', 'ಮೂವತ್ತಮೂರು', 'ಮೂವತ್ತನಾಲ್ಕು', 'ಮೂವತ್ತೈದು', 'ಮೂವತ್ತಾರು', 'ಮೂವತ್ತೇಳು', 'ಮೂವತ್ತೆಂಟು', 'ಮೂವತ್ತೊಂಬತ್ತು',
-    'ನಲವತ್ತು', 'ನಲವತ್ತೊಂದು', 'ನಲವತ್ತೆರಡು', 'ನಲವತ್ತಮೂರು', 'ನಲವತ್ತನಾಲ್ಕು', 'ನಲವತ್ತೈದು', 'ನಲವತ್ತಾರು', 'ನಲವತ್ತೇಳು', 'ನಲವತ್ತೆಂಟು', 'ನಲವತ್ತೊಂಬತ್ತು',
-    'ಐವತ್ತು', 'ಐವತ್ತೊಂದು', 'ಐವತ್ತೆರಡು', 'ಐವತ್ತಮೂರು', 'ಐವತ್ತನಾಲ್ಕು', 'ಐವತ್ತೈದು', 'ಐವತ್ತಾರು', 'ಐವತ್ತೇಳು', 'ಐವತ್ತೆಂಟು', 'ಐವತ್ತೊಂಬತ್ತು',
-    'ಅರವತ್ತು', 'ಅರವತ್ತೊಂದು', 'ಅರವತ್ತೆರಡು', 'ಅರವತ್ತಮೂರು', 'ಅರವತ್ತನಾಲ್ಕು', 'ಅರವತ್ತೈದು', 'ಅರವತ್ತಾರು', 'ಅರವತ್ತೇಳು', 'ಅರವತ್ತೆಂಟು', 'ಅರವತ್ತೊಂಬತ್ತು',
-    'ಎಪ್ಪತ್ತು', 'ಎಪ್ಪತ್ತೊಂದು', 'ಎಪ್ಪತ್ತೆರಡು', 'ಎಪ್ಪತ್ತಮೂರು', 'ಎಪ್ಪತ್ತನಾಲ್ಕು', 'ಎಪ್ಪತ್ತೈದು', 'ಎಪ್ಪತ್ತಾರು', 'ಎಪ್ಪತ್ತೇಳು', 'ಎಪ್ಪತ್ತೆಂಟು', 'ಎಪ್ಪತ್ತೊಂಬತ್ತು',
-    'ಎಂಬತ್ತು', 'ಎಂಬತ್ತೊಂದು', 'ಎಂಬತ್ತೆರಡು', 'ಎಂಬತ್ತಮೂರು', 'ಎಂಬತ್ತನಾಲ್ಕು', 'ಎಂಬತ್ತೈದು', 'ಎಂಬತ್ತಾರು', 'ಎಂಬತ್ತೇಳು', 'ಎಂಬತ್ತೆಂಟು', 'ಎಂಬತ್ತೊಂಬತ್ತು',
-    'ತೊಂಬತ್ತು', 'ತೊಂಬತ್ತೊಂದು', 'ತೊಂಬತ್ತೆರಡು', 'ತೊಂಬತ್ತಮೂರು', 'ತೊಂಬತ್ತನಾಲ್ಕು', 'ತೊಂಬತ್ತೈದು', 'ತೊಂಬತ್ತಾರು', 'ತೊಂಬತ್ತೇಳು', 'ತೊಂಬತ್ತೆಂಟು', 'ತೊಂಬತ್ತೊಂಬತ್ತು'
-  ]
-
-  /**
-   * Scale words for powers of ten in Indian numbering system.
-   * Index 0 = units, 1 = thousand, 2 = lakh, 3 = crore, etc.
-   * @type {string[]}
-   */
-  scaleWords = [
-    '', // units
-    'ಸಾವಿರ', // thousand (1,000)
-    'ಲಕ್ಷ', // lakh (100,000)
-    'ಕೋಟಿ', // crore (10,000,000)
-    'ಅಬ್ಜ', // arab (1,000,000,000)
-    'ಖರ್ವ', // kharab (100,000,000,000)
-    'ನೀಲ', // neel (10,000,000,000,000)
-    'ಪದ್ಮ', // padma (1,000,000,000,000,000)
-    'ಶಂಖ' // shankh (100,000,000,000,000,000)
-  ]
-
-  /**
-   * Converts numbers using the belowHundred array directly.
-   */
+// ============================================================================
+// Vocabulary
+// ============================================================================
+
+const ZERO = 'ಸೊನ್ನೆ'
+const NEGATIVE = 'ಋಣಾತ್ಮಕ'
+const DECIMAL_SEP = 'ದಶಮಾಂಶ'
+const HUNDRED = 'ನೂರು'
+
+const BELOW_HUNDRED = [
+  'ಸೊನ್ನೆ', 'ಒಂದು', 'ಎರಡು', 'ಮೂರು', 'ನಾಲ್ಕು', 'ಐದು', 'ಆರು', 'ಏಳು', 'ಎಂಟು', 'ಒಂಬತ್ತು',
+  'ಹತ್ತು', 'ಹನ್ನೊಂದು', 'ಹನ್ನೆರಡು', 'ಹದಿಮೂರು', 'ಹದಿನಾಲ್ಕು', 'ಹದಿನೈದು', 'ಹದಿನಾರು', 'ಹದಿನೇಳು', 'ಹದಿನೆಂಟು', 'ಹತ್ತೊಂಬತ್ತು',
+  'ಇಪ್ಪತ್ತು', 'ಇಪ್ಪತ್ತೊಂದು', 'ಇಪ್ಪತ್ತೆರಡು', 'ಇಪ್ಪತ್ತಮೂರು', 'ಇಪ್ಪತ್ತನಾಲ್ಕು', 'ಇಪ್ಪತ್ತೈದು', 'ಇಪ್ಪತ್ತಾರು', 'ಇಪ್ಪತ್ತೇಳು', 'ಇಪ್ಪತ್ತೆಂಟು', 'ಇಪ್ಪತ್ತೊಂಬತ್ತು',
+  'ಮೂವತ್ತು', 'ಮೂವತ್ತೊಂದು', 'ಮೂವತ್ತೆರಡು', 'ಮೂವತ್ತಮೂರು', 'ಮೂವತ್ತನಾಲ್ಕು', 'ಮೂವತ್ತೈದು', 'ಮೂವತ್ತಾರು', 'ಮೂವತ್ತೇಳು', 'ಮೂವತ್ತೆಂಟು', 'ಮೂವತ್ತೊಂಬತ್ತು',
+  'ನಲವತ್ತು', 'ನಲವತ್ತೊಂದು', 'ನಲವತ್ತೆರಡು', 'ನಲವತ್ತಮೂರು', 'ನಲವತ್ತನಾಲ್ಕು', 'ನಲವತ್ತೈದು', 'ನಲವತ್ತಾರು', 'ನಲವತ್ತೇಳು', 'ನಲವತ್ತೆಂಟು', 'ನಲವತ್ತೊಂಬತ್ತು',
+  'ಐವತ್ತು', 'ಐವತ್ತೊಂದು', 'ಐವತ್ತೆರಡು', 'ಐವತ್ತಮೂರು', 'ಐವತ್ತನಾಲ್ಕು', 'ಐವತ್ತೈದು', 'ಐವತ್ತಾರು', 'ಐವತ್ತೇಳು', 'ಐವತ್ತೆಂಟು', 'ಐವತ್ತೊಂಬತ್ತು',
+  'ಅರವತ್ತು', 'ಅರವತ್ತೊಂದು', 'ಅರವತ್ತೆರಡು', 'ಅರವತ್ತಮೂರು', 'ಅರವತ್ತನಾಲ್ಕು', 'ಅರವತ್ತೈದು', 'ಅರವತ್ತಾರು', 'ಅರವತ್ತೇಳು', 'ಅರವತ್ತೆಂಟು', 'ಅರವತ್ತೊಂಬತ್ತು',
+  'ಎಪ್ಪತ್ತು', 'ಎಪ್ಪತ್ತೊಂದು', 'ಎಪ್ಪತ್ತೆರಡು', 'ಎಪ್ಪತ್ತಮೂರು', 'ಎಪ್ಪತ್ತನಾಲ್ಕು', 'ಎಪ್ಪತ್ತೈದು', 'ಎಪ್ಪತ್ತಾರು', 'ಎಪ್ಪತ್ತೇಳು', 'ಎಪ್ಪತ್ತೆಂಟು', 'ಎಪ್ಪತ್ತೊಂಬತ್ತು',
+  'ಎಂಬತ್ತು', 'ಎಂಬತ್ತೊಂದು', 'ಎಂಬತ್ತೆರಡು', 'ಎಂಬತ್ತಮೂರು', 'ಎಂಬತ್ತನಾಲ್ಕು', 'ಎಂಬತ್ತೈದು', 'ಎಂಬತ್ತಾರು', 'ಎಂಬತ್ತೇಳು', 'ಎಂಬತ್ತೆಂಟು', 'ಎಂಬತ್ತೊಂಬತ್ತು',
+  'ತೊಂಬತ್ತು', 'ತೊಂಬತ್ತೊಂದು', 'ತೊಂಬತ್ತೆರಡು', 'ತೊಂಬತ್ತಮೂರು', 'ತೊಂಬತ್ತನಾಲ್ಕು', 'ತೊಂಬತ್ತೈದು', 'ತೊಂಬತ್ತಾರು', 'ತೊಂಬತ್ತೇಳು', 'ತೊಂಬತ್ತೆಂಟು', 'ತೊಂಬತ್ತೊಂಬತ್ತು'
+]
+
+// Scale words: index 0 = units (empty), 1 = thousand, 2 = lakh, 3 = crore, etc.
+const SCALE_WORDS = ['', 'ಸಾವಿರ', 'ಲಕ್ಷ', 'ಕೋಟಿ', 'ಅಬ್ಜ', 'ಖರ್ವ', 'ನೀಲ', 'ಪದ್ಮ', 'ಶಂಖ']
+
+// ============================================================================
+// Segment Splitting (inlined for performance)
+// ============================================================================
+
+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) {
+  if (n === 0) return ''
+  if (n < 100) return BELOW_HUNDRED[n]
+
+  const hundreds = Math.trunc(n / 100)
+  const remainder = n % 100
+
+  if (remainder === 0) {
+    return BELOW_HUNDRED[hundreds] + ' ' + HUNDRED
+  }
+  return BELOW_HUNDRED[hundreds] + ' ' + HUNDRED + ' ' + BELOW_HUNDRED[remainder]
+}
+
+// ============================================================================
+// Conversion Functions
+// ============================================================================
+
+function integerToWords (n) {
+  if (n === 0n) return ZERO
+
+  const segments = groupByThreeThenTwos(n)
+  const segmentCount = segments.length
+  const words = []
+
+  for (let i = 0; i < segmentCount; i++) {
+    const segmentValue = segments[i]
+    if (segmentValue === 0) continue
+
+    const scaleIndex = segmentCount - i - 1
+    words.push(segmentToWords(segmentValue))
+    if (scaleIndex > 0 && SCALE_WORDS[scaleIndex]) {
+      words.push(SCALE_WORDS[scaleIndex])
+    }
+  }
+
+  return words.join(' ').trim()
+}
+
+function decimalPartToWords (decimalPart) {
+  // Per-digit decimal reading
+  const digits = []
+  for (const char of decimalPart) {
+    const d = parseInt(char, 10)
+    digits.push(d === 0 ? ZERO : BELOW_HUNDRED[d])
+  }
+  return digits.join(' ')
 }
 
 /**
- * Converts a number to its word representation in Kannada.
- * @param {number|string|bigint} value - The number to convert
- * @param {Object} [options={}] - Conversion options
- * @returns {string} The word representation of the number
- * @example
- * convertToWords(42) // 'ನಲವತ್ತೆರಡು'
- * convertToWords(1000) // 'ಒಂದು ಸಾವಿರ'
- * convertToWords(100000) // 'ಒಂದು ಲಕ್ಷ'
+ * Converts a numeric value to Kannada words.
+ *
+ * @param {number | string | bigint} value - The numeric value to convert
+ * @returns {string} The number in Kannada words
  */
-export default function convertToWords (value, options = {}) {
-  return new KannadaLanguage(options).convertToWords(value)
+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
 }
+
+// ============================================================================
+// Exports
+// ============================================================================
+
+export { toWords }

package/lib/languages/ko.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Converts a numeric value to Korean words.
+ *
+ * @param {number | string | bigint} value - The numeric value to convert
+ * @returns {string} The number in Korean 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(10000)      // '만'
+ * toWords(1000000)    // '백만'
+ */
+export function toWords(value: number | string | bigint): string;