n2words 1.24.0 → 3.0.0

package/lib/languages/id.js

@@ -1,174 +1,201 @@
-import AbstractLanguage from '../classes/abstract-language.js'
-
 /**
- * Indonesian language converter.
- *
- * Converts numbers to Indonesian words following Indonesian conventions:
- * - Simple base-10 structure
- * - "Se-" prefix for one (e.g., "seratus" = one hundred, "seribu" = one thousand)
- * - Space-separated number components
- * - Straightforward grouping by thousands
+ * Indonesian language converter - Functional Implementation
  *
- * Key Features:
- * - Base number mapping (base) for single digits 0-9
- * - Magnitude scale (thousands) mapping powers of 10 to Indonesian words
- * - Group-based algorithm:
- *   1. Split number into groups of 3 digits
- *   2. For each group, convert ones/tens/hundreds using base and naming rules
- *   3. Apply "se-" prefix for 1 (seratus, seribu, sejuta)
- *   4. Combine with magnitude words
- *   5. Join all parts with spaces
- * - Regular patterns (puluh for tens, ratus for hundreds, ribu for thousands)
- * - Clear grouping: ribu (10³), juta (10⁶), miliar (10⁹), triliun (10¹²)
+ * Self-contained converter with precomputed lookup tables.
  *
- * Features:
- * - "Se-" prefix usage for singular units
- * - Support for very large numbers (up to decillions)
+ * Key features:
+ * - "Se-" prefix for 100 (seratus) and 1000 (seribu)
+ * - Regular patterns (puluh for tens, ratus for hundreds)
+ * - Teens with "belas" suffix
+ * - Indonesian uses "satu juta" (not "sejuta") for millions+
  */
-export class Indonesian extends AbstractLanguage {
-  negativeWord = 'min'
-  decimalSeparatorWord = 'koma'
-  zeroWord = 'nol'
-  base = {
-    0: [],
-    1: ['satu'],
-    2: ['dua'],
-    3: ['tiga'],
-    4: ['empat'],
-    5: ['lima'],
-    6: ['enam'],
-    7: ['tujuh'],
-    8: ['delapan'],
-    9: ['sembilan']
+
+import { parseNumericValue } from '../utils/parse-numeric.js'
+
+// ============================================================================
+// Vocabulary
+// ============================================================================
+
+const ONES = ['', 'satu', 'dua', 'tiga', 'empat', 'lima', 'enam', 'tujuh', 'delapan', 'sembilan']
+const TEENS = ['sepuluh', 'sebelas', 'dua belas', 'tiga belas', 'empat belas', 'lima belas', 'enam belas', 'tujuh belas', 'delapan belas', 'sembilan belas']
+const TENS = ['', '', 'dua puluh', 'tiga puluh', 'empat puluh', 'lima puluh', 'enam puluh', 'tujuh puluh', 'delapan puluh', 'sembilan puluh']
+
+const HUNDRED_WORD = 'ratus'
+const THOUSAND_WORD = 'ribu'
+const SCALE_WORDS = ['juta', 'miliar', 'triliun', 'kuadriliun', 'kuantiliun', 'sekstiliun', 'septiliun', 'oktiliun', 'noniliun', 'desiliun']
+
+const ZERO = 'nol'
+const NEGATIVE = 'min'
+const DECIMAL_SEP = 'koma'
+
+// ============================================================================
+// Precomputed Lookup Tables
+// ============================================================================
+
+function buildSegment (n) {
+  if (n === 0) return ''
+
+  const onesDigit = n % 10
+  const tensDigit = Math.floor(n / 10) % 10
+  const hundredsDigit = Math.floor(n / 100)
+
+  const parts = []
+
+  // Hundreds: seratus (100) or N ratus (200-900)
+  if (hundredsDigit > 0) {
+    if (hundredsDigit === 1) {
+      parts.push('se' + HUNDRED_WORD)
+    } else {
+      parts.push(ONES[hundredsDigit] + ' ' + HUNDRED_WORD)
+    }
   }
 
-  thousands = {
-    3: 'ribu', // 10^3
-    6: 'juta', // 10^6
-    9: 'miliar', // 10^9
-    12: 'triliun',
-    15: 'kuadriliun',
-    18: 'kuantiliun',
-    21: 'sekstiliun',
-    24: 'septiliun',
-    27: 'oktiliun',
-    30: 'noniliun',
-    33: 'desiliun'
+  // Tens and ones
+  const tensOnes = n % 100
+
+  if (tensOnes === 0) {
+    // Just hundreds
+  } else if (tensOnes < 10) {
+    parts.push(ONES[tensOnes])
+  } else if (tensOnes < 20) {
+    parts.push(TEENS[tensOnes - 10])
+  } else if (onesDigit === 0) {
+    parts.push(TENS[tensDigit])
+  } else {
+    parts.push(TENS[tensDigit] + ' ' + ONES[onesDigit])
   }
 
-  splitBy3 (number) {
-    // Split to groups of 3 numbers: 1234567 -> [['1'], ['234'], ['567']]
-    const blocks = []
-    const stringNumber = number.toString()
-    const length = stringNumber.length
-    let firstBlock
+  return parts.join(' ')
+}
 
-    if (length < 3) {
-      blocks.push([stringNumber])
-    } else {
-      const firstBlockLength = length % 3
+const SEGMENTS = new Array(1000)
+for (let i = 0; i < 1000; i++) {
+  SEGMENTS[i] = buildSegment(i)
+}
 
-      if (firstBlockLength > 0) {
-        firstBlock = [stringNumber.slice(0, firstBlockLength)]
-        blocks.push(firstBlock)
-      }
+// ============================================================================
+// Conversion Functions
+// ============================================================================
 
-      for (let index = firstBlockLength; index < length; index += 3) {
-        const nextBlock = [stringNumber.slice(index, index + 3)]
-        blocks.push(nextBlock)
-      }
-    }
-    return blocks
+function integerToWords (n) {
+  if (n === 0n) return ZERO
+
+  if (n < 1000n) {
+    return SEGMENTS[Number(n)]
   }
 
-  spell (blocks) {
-    let wordBlocks = []
-    let spelling
-    const firstBlock = blocks[0]
-    if (firstBlock[0].length === 1) {
-      spelling = firstBlock[0] === '0' ? ['nol'] : this.base[Math.trunc(firstBlock[0])]
-    } else if (firstBlock[0].length === 2) {
-      spelling = this.getTens(firstBlock[0])
+  if (n < 1_000_000n) {
+    const thousands = Number(n / 1000n)
+    const remainder = Number(n % 1000n)
+
+    let result
+    if (thousands === 1) {
+      result = 'se' + THOUSAND_WORD
     } else {
-      spelling = [...this.getHundreds(firstBlock[0][0]), ...this.getTens(firstBlock[0].slice(1, 3))]
-    }
-    wordBlocks = [...wordBlocks, [firstBlock[0], spelling]]
-    for (let index = 1; index < blocks.length; index++) {
-      let block = blocks[index]
-      spelling = [...this.getHundreds(block[0][0]), ...this.getTens(block[0].slice(1, 3))]
-      block = [...block, spelling]
-      wordBlocks = [...wordBlocks, block]
+      result = SEGMENTS[thousands] + ' ' + THOUSAND_WORD
     }
-    return wordBlocks
-  }
 
-  getHundreds (number) {
-    if (number === '1') {
-      return ['seratus']
-    } else if (number === '0') {
-      return []
-    } else {
-      return [...this.base[Math.trunc(number)], 'ratus']
+    if (remainder > 0) {
+      result += ' ' + SEGMENTS[remainder]
     }
+
+    return result
   }
 
-  getTens (number) {
-    if (number[0] === '1') {
-      if (number[1] === '0') {
-        return ['sepuluh']
-      } else if (number[1] === '1') {
-        return ['sebelas']
-      }
-      return [...this.base[Math.trunc(number[1])], 'belas']
-    }
+  return buildLargeNumberWords(n)
+}
 
-    if (number[0] === '0') {
-      return this.base[Math.trunc(number[1])]
-    }
+function buildLargeNumberWords (n) {
+  const numStr = n.toString()
+  const len = numStr.length
 
-    return [...this.base[Math.trunc(number[0])], 'puluh', ...this.base[Math.trunc(number[1])]]
+  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
   }
 
-  join (wordBlocks) {
-    let wordList = []
-    const length = wordBlocks.length - 1
-    const firstBlock = [wordBlocks[0]]
-    let start = 0
-    if (length === 1 && firstBlock[0][0] === '1') {
-      wordList.push('seribu')
-      start = 1
-    }
-    for (let index = start; index < length + 1; index++) {
-      wordList = [...wordList, ...wordBlocks[index][1]]
-      if (wordBlocks[index][1].length === 0) {
-        continue
-      }
-      if (index === length) {
-        break
+  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) {
+        parts.push(SEGMENTS[segment])
+      } else if (scaleIndex === 1) {
+        if (segment === 1) {
+          parts.push('se' + THOUSAND_WORD)
+        } else {
+          parts.push(SEGMENTS[segment] + ' ' + THOUSAND_WORD)
+        }
+      } else {
+        // Indonesian: "satu juta" not "sejuta"
+        const scaleWord = SCALE_WORDS[scaleIndex - 2]
+        parts.push(SEGMENTS[segment] + ' ' + scaleWord)
       }
-      wordList = [...wordList, this.thousands[(length - index) * 3]]
     }
-    return wordList.join(' ')
+
+    scaleIndex--
+  }
+
+  return parts.join(' ')
+}
+
+function decimalPartToWords (decimalPart) {
+  let result = ''
+
+  let i = 0
+  while (i < decimalPart.length && decimalPart[i] === '0') {
+    if (result) result += ' '
+    result += ZERO
+    i++
   }
 
-  convertWholePart (number) {
-    return this.join(
-      this.spell(
-        this.splitBy3(number)
-      )
-    ).trim()
+  const remainder = decimalPart.slice(i)
+  if (remainder) {
+    if (result) result += ' '
+    result += integerToWords(BigInt(remainder))
   }
+
+  return result
 }
 
 /**
- * Converts a number to Indonesian cardinal (written) form.
+ * Converts a numeric value to Indonesian words.
  *
- * @param {number|string|bigint} value The number to convert.
- * @param {Object} [options={}] Configuration options.
- * @returns {string} The number expressed in Indonesian words.
- * @throws {TypeError} If value is NaN or invalid type.
- * @throws {Error} If value is an invalid number string.
+ * @param {number | string | bigint} value - The numeric value to convert
+ * @returns {string} The number in Indonesian words
  */
-export default function convertToWords (value, options = {}) {
-  return new Indonesian(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/it.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Converts a numeric value to Italian 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 Italian words
+ * @throws {TypeError} If value is not a valid numeric type
+ * @throws {Error} If value is not a valid number format
+ *
+ * @example
+ * toWords(28)           // 'ventotto'
+ * toWords(23)           // 'ventitré'
+ * toWords(1000)         // 'mille'
+ * toWords(2000)         // 'duemila'
+ * toWords(1000000)      // 'un milione'
+ */
+export function toWords(value: number | string | bigint): string;