n2words 2.0.0 → 3.1.0

package/lib/languages/te.js

@@ -1,219 +1,156 @@
-import { AbstractLanguage } from '../classes/abstract-language.js'
-
 /**
- * Telugu language converter.
+ * Telugu language converter - Functional Implementation
+ *
+ * Self-contained module with its own input validation, ready for subpath exports.
  *
- * Supports:
- * - Telugu numbering system
+ * Key features:
+ * - Indian numbering system (వెయ్యి, లక్ష, కోటి)
  * - Telugu script
+ * - 3-2-2 grouping pattern
  * - Complete word forms for 0-99
+ * - Per-digit decimal reading
  */
-export class Telugu extends AbstractLanguage {
-  negativeWord = 'మైనస్'
-  decimalSeparatorWord = 'పాయింట్'
-  zeroWord = 'సున్నా'
-  usePerDigitDecimals = true // Enable digit-by-digit decimal conversion
-
-  belowHundredWords = [
-    'సున్నా',
-    'ఒకటి',
-    'రెండు',
-    'మూడు',
-    'నాలుగు',
-    'ఐదు',
-    'ఆరు',
-    'ఏడు',
-    'ఎనిమిది',
-    'తొమ్మిది',
-    'పది',
-    'పదకొండు',
-    'పన్నెండు',
-    'పదమూడు',
-    'పద్నాలుగు',
-    'పదిహేను',
-    'పదహారు',
-    'పదిహేడు',
-    'పద్దెనిమిది',
-    'పంతొమ్మిది',
-    'ఇరవై',
-    'ఇరవై ఒక్కటి',
-    'ఇరవై రెండు',
-    'ఇరవై మూడు',
-    'ఇరవై నాలుగు',
-    'ఇరవై ఐదు',
-    'ఇరవై ఆరు',
-    'ఇరవై ఏడు',
-    'ఇరవై ఎనిమిది',
-    'ఇరవై తొమ్మిది',
-    'ముప్పై',
-    'ముప్పై ఒకటి',
-    'ముప్పై రెండు',
-    'ముప్పై మూడు',
-    'ముప్పై నాలుగు',
-    'ముప్పై ఐదు',
-    'ముప్పై ఆరు',
-    'ముప్పై ఏడు',
-    'ముప్పై ఎనిమిది',
-    'ముప్పై తొమ్మిది',
-    'నలభై',
-    'నలభై ఒకటి',
-    'నలభై రెండు',
-    'నలభై మూడు',
-    'నలభై నాలుగు',
-    'నలభై ఐదు',
-    'నలభై ఆరు',
-    'నలభై ఏడు',
-    'నలభై ఎనిమిది',
-    'నలభై తొమ్మిది',
-    'యాభై',
-    'యాభై ఒకటి',
-    'యాభై రెండు',
-    'యాభై మూడు',
-    'యాభై నాలుగు',
-    'యాభై ఐదు',
-    'యాభై ఆరు',
-    'యాభై ఏడు',
-    'యాభై ఎనిమిది',
-    'యాభై తొమ్మిది',
-    'అరవై',
-    'అరవై ఒకటి',
-    'అరవై రెండు',
-    'అరవై మూడు',
-    'అరవై నాలుగు',
-    'అరవై ఐదు',
-    'అరవై ఆరు',
-    'అరవై ఏడు',
-    'అరవై ఎనిమిది',
-    'అరవై తొమ్మిది',
-    'డెబ్బై',
-    'డెబ్బై ఒకటి',
-    'డెబ్బై రెండు',
-    'డెబ్బై మూడు',
-    'డెబ్బై నాలుగు',
-    'డెబ్బై ఐదు',
-    'డెబ్బై ఆరు',
-    'డెబ్బై ఏడు',
-    'డెబ్బై ఎనిమిది',
-    'డెబ్బై తొమ్మిది',
-    'ఎనభై',
-    'ఎనభై ఒకటి',
-    'ఎనభై రెండు',
-    'ఎనభై మూడు',
-    'ఎనభై నాలుగు',
-    'ఎనభై ఐదు',
-    'ఎనభై ఆరు',
-    'ఎనభై ఏడు',
-    'ఎనభై ఎనిమిది',
-    'ఎనభై తొమ్మిది',
-    'తొంభై',
-    'తొంభై ఒకటి',
-    'తొంభై రెండు',
-    'తొంభై మూడు',
-    'తొంభై నాలుగు',
-    'తొంభై ఐదు',
-    'తొంభై ఆరు',
-    'తొంభై ఏడు',
-    'తొంభై ఎనిమిది',
-    'తొంభై తొమ్మిది'
-  ]
-
-  hundredsWords = [
-    '',
-    'వంద',
-    'రెండు వందలు',
-    'మూడు వందలు',
-    'నాలుగు వందలు',
-    'ఐదు వందలు',
-    'ఆరు వందలు',
-    'ఏడు వందలు',
-    'ఎనిమిది వందలు',
-    'తొమ్మిది వందలు'
-  ]
-
-  // Ones words map 1–9 for decimal reading
-  onesWords = [
-    'ఒకటి',
-    'రెండు',
-    'మూడు',
-    'నాలుగు',
-    'ఐదు',
-    'ఆరు',
-    'ఏడు',
-    'ఎనిమిది',
-    'తొమ్మిది'
-  ]
-
-  scaleWords = [
-    '',
-    'వెయ్యి',
-    'లక్ష',
-    'కోటి',
-    'అరబ్',
-    'ఖరబ్',
-    'నిల్',
-    'పడ్మ',
-    'శంకు'
-  ]
-
-  /** Convert numbers below 100 to Telugu words. */
-  convertBelowHundred (number) {
-    return this.belowHundredWords[number]
-  }
 
-  /** Convert numbers below 1000 to Telugu words. */
-  convertBelowThousand (number) {
-    if (number === 0) return ''
-    if (number < 100) return this.convertBelowHundred(number)
+import { parseNumericValue } from '../utils/parse-numeric.js'
 
-    const hundreds = Math.trunc(number / 100)
-    const remainder = number % 100
-    const parts = [this.hundredsWords[hundreds]]
+// ============================================================================
+// Vocabulary
+// ============================================================================
 
-    if (remainder > 0) {
-      parts.push(this.convertBelowHundred(remainder))
-    }
+const ZERO = 'సున్నా'
+const NEGATIVE = 'మైనస్'
+const DECIMAL_SEP = 'పాయింట్'
 
-    return parts.join(' ').trim()
-  }
+const BELOW_HUNDRED = [
+  'సున్నా', 'ఒకటి', 'రెండు', 'మూడు', 'నాలుగు', 'ఐదు', 'ఆరు', 'ఏడు', 'ఎనిమిది', 'తొమ్మిది',
+  'పది', 'పదకొండు', 'పన్నెండు', 'పదమూడు', 'పద్నాలుగు', 'పదిహేను', 'పదహారు', 'పదిహేడు', 'పద్దెనిమిది', 'పంతొమ్మిది',
+  'ఇరవై', 'ఇరవై ఒక్కటి', 'ఇరవై రెండు', 'ఇరవై మూడు', 'ఇరవై నాలుగు', 'ఇరవై ఐదు', 'ఇరవై ఆరు', 'ఇరవై ఏడు', 'ఇరవై ఎనిమిది', 'ఇరవై తొమ్మిది',
+  'ముప్పై', 'ముప్పై ఒకటి', 'ముప్పై రెండు', 'ముప్పై మూడు', 'ముప్పై నాలుగు', 'ముప్పై ఐదు', 'ముప్పై ఆరు', 'ముప్పై ఏడు', 'ముప్పై ఎనిమిది', 'ముప్పై తొమ్మిది',
+  'నలభై', 'నలభై ఒకటి', 'నలభై రెండు', 'నలభై మూడు', 'నలభై నాలుగు', 'నలభై ఐదు', 'నలభై ఆరు', 'నలభై ఏడు', 'నలభై ఎనిమిది', 'నలభై తొమ్మిది',
+  'యాభై', 'యాభై ఒకటి', 'యాభై రెండు', 'యాభై మూడు', 'యాభై నాలుగు', 'యాభై ఐదు', 'యాభై ఆరు', 'యాభై ఏడు', 'యాభై ఎనిమిది', 'యాభై తొమ్మిది',
+  'అరవై', 'అరవై ఒకటి', 'అరవై రెండు', 'అరవై మూడు', 'అరవై నాలుగు', 'అరవై ఐదు', 'అరవై ఆరు', 'అరవై ఏడు', 'అరవై ఎనిమిది', 'అరవై తొమ్మిది',
+  'డెబ్బై', 'డెబ్బై ఒకటి', 'డెబ్బై రెండు', 'డెబ్బై మూడు', 'డెబ్బై నాలుగు', 'డెబ్బై ఐదు', 'డెబ్బై ఆరు', 'డెబ్బై ఏడు', 'డెబ్బై ఎనిమిది', 'డెబ్బై తొమ్మిది',
+  'ఎనభై', 'ఎనభై ఒకటి', 'ఎనభై రెండు', 'ఎనభై మూడు', 'ఎనభై నాలుగు', 'ఎనభై ఐదు', 'ఎనభై ఆరు', 'ఎనభై ఏడు', 'ఎనభై ఎనిమిది', 'ఎనభై తొమ్మిది',
+  'తొంభై', 'తొంభై ఒకటి', 'తొంభై రెండు', 'తొంభై మూడు', 'తొంభై నాలుగు', 'తొంభై ఐదు', 'తొంభై ఆరు', 'తొంభై ఏడు', 'తొంభై ఎనిమిది', 'తొంభై తొమ్మిది'
+]
 
-  /** Split a number using Indian-style grouping (3-2-2 digits from right). */
-  splitIndian (number) {
-    const numStr = number.toString()
-    if (numStr.length <= 3) return [Number(numStr)]
+const HUNDREDS = ['', 'వంద', 'రెండు వందలు', 'మూడు వందలు', 'నాలుగు వందలు', 'ఐదు వందలు', 'ఆరు వందలు', 'ఏడు వందలు', 'ఎనిమిది వందలు', 'తొమ్మిది వందలు']
 
-    const groups = []
-    const last3 = numStr.slice(-3)
-    groups.unshift(Number(last3))
+// Ones for decimal reading
+const ONES = ['ఒకటి', 'రెండు', 'మూడు', 'నాలుగు', 'ఐదు', 'ఆరు', 'ఏడు', 'ఎనిమిది', 'తొమ్మిది']
 
-    let remaining = numStr.slice(0, -3)
-    while (remaining.length > 0) {
-      const group = remaining.slice(-2)
-      groups.unshift(Number(group))
-      remaining = remaining.slice(0, -2)
-    }
+// Scale words: index 0 = units, 1 = thousand, 2 = lakh, etc.
+const SCALE_WORDS = ['', 'వెయ్యి', 'లక్ష', 'కోటి', 'అరబ్', 'ఖరబ్', 'నిల్', 'పడ్మ', 'శంకు']
+
+// ============================================================================
+// Segment Building
+// ============================================================================
+
+/**
+ * Builds words for a 0-999 segment.
+ */
+function buildSegment (n) {
+  if (n === 0) return ''
+  if (n < 100) return BELOW_HUNDRED[n]
 
-    return groups
+  const hundreds = Math.trunc(n / 100)
+  const remainder = n % 100
+
+  if (remainder === 0) {
+    return HUNDREDS[hundreds]
   }
+  return HUNDREDS[hundreds] + ' ' + BELOW_HUNDRED[remainder]
+}
+
+// ============================================================================
+// Conversion Functions
+// ============================================================================
+
+/**
+ * Converts a non-negative integer to Telugu 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} Telugu words
+ */
+function integerToWords (n) {
+  if (n === 0n) return ZERO
 
-  integerToWords (integerPart) {
-    if (integerPart === 0n) return this.zeroWord
+  // Fast path: numbers < 1000 (direct lookup)
+  if (n < 1000n) {
+    return buildSegment(Number(n))
+  }
 
-    const groups = this.splitIndian(integerPart)
-    const groupCount = groups.length
-    const words = []
+  // 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
+  }
 
-      const scaleIndex = groupCount - i - 1
-      const groupWords = (groupValue === 1 && scaleIndex > 0) ? 'ఒక' : this.convertBelowThousand(groupValue)
+  // 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)
-      if (scaleIndex > 0 && this.scaleWords[scaleIndex]) {
-        words.push(this.scaleWords[scaleIndex])
-      }
     }
 
-    return words.join(' ').trim()
+    if (i > 0 && SCALE_WORDS[i]) {
+      words.push(SCALE_WORDS[i])
+    }
+  }
+
+  return words.join(' ')
+}
+
+function decimalPartToWords (decimalPart) {
+  // Per-digit decimal reading
+  const digits = []
+  for (const char of decimalPart) {
+    const d = parseInt(char, 10)
+    digits.push(d === 0 ? ZERO : ONES[d - 1])
   }
+  return digits.join(' ')
 }
+
+/**
+ * Converts a numeric value to Telugu words.
+ *
+ * @param {number | string | bigint} value - The numeric value to convert
+ * @returns {string} The number in Telugu words
+ */
+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/th.d.ts

@@ -1,17 +1,7 @@
 /**
- * Thai language converter.
+ * Converts a numeric value to Thai words.
  *
- * Supports:
- * - Thai numerals (ศูนย์, หนึ่ง, สอง, สาม)
- * - No word separators (continuous Thai script)
- * - Digit-by-digit decimal reading
+ * @param {number | string | bigint} value - The numeric value to convert
+ * @returns {string} The number in Thai words
  */
-export class Thai extends AbstractLanguage {
-    onesWords: string[];
-    /** Converts numbers below one million to Thai words. */
-    convertBelowMillion(number: any): string;
-    /** Split a number into million-sized groups for processing. */
-    splitMillionGroups(number: any): number[];
-    integerToWords(integerPart: any): string;
-}
-import { AbstractLanguage } from '../classes/abstract-language.js';
+export function toWords(value: number | string | bigint): string;

package/lib/languages/th.js

@@ -1,117 +1,161 @@
-import { AbstractLanguage } from '../classes/abstract-language.js'
-
 /**
- * Thai language converter.
+ * Thai language converter - Functional Implementation
+ *
+ * Self-contained converter with precomputed lookup tables.
  *
- * Supports:
- * - Thai numerals (ศูนย์, หนึ่ง, สอง, สาม)
+ * Key features:
  * - No word separators (continuous Thai script)
- * - Digit-by-digit decimal reading
+ * - Million-based grouping (ล้าน)
+ * - Special handling for 1 as "เอ็ด" in compounds
+ * - 20 is "ยี่สิบ" (not "สองสิบ")
+ * - Per-digit decimal reading
  */
-export class Thai extends AbstractLanguage {
-  negativeWord = 'ลบ'
-  decimalSeparatorWord = 'จุด'
-  zeroWord = 'ศูนย์'
-  wordSeparator = ''
-  usePerDigitDecimals = true // Enable digit-by-digit decimal conversion
-
-  // Ones words map 1–9
-  onesWords = ['หนึ่ง', 'สอง', 'สาม', 'สี่', 'ห้า', 'หก', 'เจ็ด', 'แปด', 'เก้า']
-
-  /** Converts numbers below one million to Thai words. */
-  convertBelowMillion (number) {
-    if (number === 0) return ''
-
-    let value = number
-    const parts = []
-
-    const hundredThousands = Math.trunc(value / 100000)
-    value %= 100000
-    const tenThousands = Math.trunc(value / 10000)
-    value %= 10000
-    const thousands = Math.trunc(value / 1000)
-    value %= 1000
-    const hundreds = Math.trunc(value / 100)
-    value %= 100
-    const tens = Math.trunc(value / 10)
-    const ones = value % 10
-
-    if (hundredThousands > 0) {
-      parts.push(this.onesWords[hundredThousands - 1] + 'แสน')
-    }
 
-    if (tenThousands > 0) {
-      if (tenThousands === 1) {
-        parts.push('หนึ่งหมื่น')
-      } else {
-        parts.push(this.onesWords[tenThousands - 1] + 'หมื่น')
-      }
-    }
+import { parseNumericValue } from '../utils/parse-numeric.js'
 
-    if (thousands > 0) {
-      parts.push(this.onesWords[thousands - 1] + 'พัน')
-    }
+// ============================================================================
+// Vocabulary
+// ============================================================================
+
+const ONES = ['หนึ่ง', 'สอง', 'สาม', 'สี่', 'ห้า', 'หก', 'เจ็ด', 'แปด', 'เก้า']
+
+const ZERO = 'ศูนย์'
+const NEGATIVE = 'ลบ'
+const DECIMAL_SEP = 'จุด'
+
+// ============================================================================
+// Conversion Functions
+// ============================================================================
+
+function convertBelowMillion (n) {
+  if (n === 0) return ''
+
+  let value = n
+  const parts = []
 
-    if (hundreds > 0) {
-      parts.push(this.onesWords[hundreds - 1] + 'ร้อย')
+  const hundredThousands = Math.trunc(value / 100000)
+  value %= 100000
+  const tenThousands = Math.trunc(value / 10000)
+  value %= 10000
+  const thousands = Math.trunc(value / 1000)
+  value %= 1000
+  const hundreds = Math.trunc(value / 100)
+  value %= 100
+  const tens = Math.trunc(value / 10)
+  const ones = value % 10
+
+  if (hundredThousands > 0) {
+    parts.push(ONES[hundredThousands - 1] + 'แสน')
+  }
+
+  if (tenThousands > 0) {
+    if (tenThousands === 1) {
+      parts.push('หนึ่งหมื่น')
+    } else {
+      parts.push(ONES[tenThousands - 1] + 'หมื่น')
     }
+  }
+
+  if (thousands > 0) {
+    parts.push(ONES[thousands - 1] + 'พัน')
+  }
+
+  if (hundreds > 0) {
+    parts.push(ONES[hundreds - 1] + 'ร้อย')
+  }
 
-    if (tens > 0) {
-      if (tens === 1) {
-        parts.push('สิบ')
-      } else if (tens === 2) {
-        parts.push('ยี่สิบ')
-      } else {
-        parts.push(this.onesWords[tens - 1] + 'สิบ')
-      }
+  if (tens > 0) {
+    if (tens === 1) {
+      parts.push('สิบ')
+    } else if (tens === 2) {
+      parts.push('ยี่สิบ')
+    } else {
+      parts.push(ONES[tens - 1] + 'สิบ')
     }
+  }
 
-    if (ones > 0) {
-      const hasHigher = hundredThousands > 0 || tenThousands > 0 || thousands > 0 || hundreds > 0 || tens > 0
-      if (ones === 1 && (tens > 0 || hasHigher)) {
-        parts.push('เอ็ด')
-      } else {
-        parts.push(this.onesWords[ones - 1])
-      }
+  if (ones > 0) {
+    const hasHigher = hundredThousands > 0 || tenThousands > 0 || thousands > 0 || hundreds > 0 || tens > 0
+    if (ones === 1 && (tens > 0 || hasHigher)) {
+      parts.push('เอ็ด')
+    } else {
+      parts.push(ONES[ones - 1])
     }
+  }
 
-    return parts.join('')
+  return parts.join('')
+}
+
+function splitMillionGroups (n) {
+  const groups = []
+  let remaining = n
+
+  const million = 1_000_000n
+  while (remaining > 0n) {
+    const chunk = Number(remaining % million)
+    groups.unshift(chunk)
+    remaining = remaining / million
   }
 
-  /** Split a number into million-sized groups for processing. */
-  splitMillionGroups (number) {
-    const groups = []
-    let remaining = number
+  return groups
+}
+
+function integerToWords (n) {
+  if (n === 0n) return ZERO
 
-    const million = 1_000_000n
-    while (remaining > 0n) {
-      const chunk = Number(remaining % million)
-      groups.unshift(chunk)
-      remaining = remaining / million
+  const groups = splitMillionGroups(n)
+  const parts = []
+
+  for (let i = 0; i < groups.length; i++) {
+    const groupValue = groups[i]
+    if (groupValue === 0) continue
+
+    parts.push(convertBelowMillion(groupValue))
+    const remaining = groups.length - i - 1
+    if (remaining > 0) {
+      parts.push('ล้าน'.repeat(remaining))
     }
+  }
+
+  return parts.join('')
+}
 
-    return groups
+function decimalPartToWords (decimalPart) {
+  // Per-digit decimal reading
+  const digits = []
+  for (const char of decimalPart) {
+    const d = parseInt(char, 10)
+    digits.push(d === 0 ? ZERO : ONES[d - 1])
   }
+  return digits.join('')
+}
 
-  integerToWords (integerPart) {
-    if (integerPart === 0n) {
-      return this.zeroWord
-    }
+/**
+ * Converts a numeric value to Thai words.
+ *
+ * @param {number | string | bigint} value - The numeric value to convert
+ * @returns {string} The number in Thai words
+ */
+function toWords (value) {
+  const { isNegative, integerPart, decimalPart } = parseNumericValue(value)
 
-    const groups = this.splitMillionGroups(integerPart)
-    const parts = []
+  let result = ''
 
-    for (let i = 0; i < groups.length; i++) {
-      const groupValue = groups[i]
-      if (groupValue === 0) continue
+  if (isNegative) {
+    result = NEGATIVE
+  }
 
-      parts.push(this.convertBelowMillion(groupValue))
-      const remaining = groups.length - i - 1
-      if (remaining > 0) {
-        parts.push('ล้าน'.repeat(remaining))
-      }
-    }
+  result += integerToWords(integerPart)
 
-    return parts.join('')
+  if (decimalPart) {
+    result += DECIMAL_SEP + decimalPartToWords(decimalPart)
   }
+
+  return result
 }
+
+// ============================================================================
+// Exports
+// ============================================================================
+
+export { toWords }

package/lib/languages/tr.d.ts

@@ -1,12 +1,18 @@
 /**
- * Turkish language converter.
+ * Converts a numeric value to Turkish words.
  *
- * Supports:
- * - Omits 'bir' (one) before hundreds and thousands
- * - Optional space removal via dropSpaces option
+ * @param {number | string | bigint} value - The numeric value to convert
+ * @param {Object} [options] - Conversion options
+ * @param {boolean} [options.dropSpaces=false] - Remove spaces for compound form
+ * @returns {string} The number in Turkish words
+ * @throws {TypeError} If value is not a valid numeric type
+ * @throws {Error} If value is not a valid number format
+ *
+ * @example
+ * toWords(21)                        // 'yirmi bir'
+ * toWords(21, { dropSpaces: true })  // 'yirmibir'
+ * toWords(1000)                      // 'bin'
  */
-export class Turkish extends TurkicLanguage {
-    constructor(options?: {});
-    scaleWords: (string | bigint)[][];
-}
-import { TurkicLanguage } from '../classes/turkic-language.js';
+export function toWords(value: number | string | bigint, options?: {
+    dropSpaces?: boolean | undefined;
+}): string;