n2words 2.0.0 → 3.0.0

package/lib/languages/mr.js

@@ -1,132 +1,137 @@
-import { SouthAsianLanguage } from '../classes/south-asian-language.js'
-
 /**
- * Marathi language converter.
+ * Marathi language converter - Functional Implementation
+ *
+ * Self-contained converter for South Asian numbering.
  *
- * Supports:
+ * 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
+ * - Per-digit decimal reading
  */
-export class Marathi extends SouthAsianLanguage {
-  negativeWord = 'उणे'
-  decimalSeparatorWord = 'दशांश'
-  zeroWord = 'शून्य'
-  hundredWord = 'शंभर'
-  usePerDigitDecimals = true
-
-  belowHundredWords = [
-    'शून्य',
-    'एक',
-    'दोन',
-    'तीन',
-    'चार',
-    'पाच',
-    'सहा',
-    'सात',
-    'आठ',
-    'नऊ',
-    'दहा',
-    'अकरा',
-    'बारा',
-    'तेरा',
-    'चौदा',
-    'पंधरा',
-    'सोळा',
-    'सतरा',
-    'अठरा',
-    'एकोणीस',
-    'वीस',
-    'एकवीस',
-    'बावीस',
-    'तेवीस',
-    'चोवीस',
-    'पंचवीस',
-    'सव्वीस',
-    'सत्तावीस',
-    'अठ्ठावीस',
-    'एकोणतीस',
-    'तीस',
-    'एकतीस',
-    'बत्तीस',
-    'तेहेतीस',
-    'चौतीस',
-    'पस्तीस',
-    'छत्तीस',
-    'सदतीस',
-    'अडतीस',
-    'एकोणचाळीस',
-    'चाळीस',
-    'एकेचाळीस',
-    'बेचाळीस',
-    'त्रेचाळीस',
-    'चव्वेचाळीस',
-    'पंचेचाळीस',
-    'सेहेचाळीस',
-    'सत्तेचाळीस',
-    'अठ्ठेचाळीस',
-    'एकोणपन्नास',
-    'पन्नास',
-    'एक्काव्वन',
-    'बावन्न',
-    'त्रेपन्न',
-    'चोपन्न',
-    'पंचाव्वन',
-    'छप्पन्न',
-    'सत्तावन्न',
-    'अठ्ठावन्न',
-    'एकोणसाठ',
-    'साठ',
-    'एकसष्ठ',
-    'बासष्ठ',
-    'त्रेसष्ठ',
-    'चौसष्ठ',
-    'पासष्ठ',
-    'सहासष्ठ',
-    'सदुसष्ठ',
-    'अडुसष्ठ',
-    'एकोणसत्तर',
-    'सत्तर',
-    'एकाहत्तर',
-    'बाहत्तर',
-    'त्र्याहत्तर',
-    'चौऱ्याहत्तर',
-    'पंच्याहत्तर',
-    'शहात्तर',
-    'सत्याहत्तर',
-    'अठ्ठ्याहत्तर',
-    'एकोणऐंशी',
-    'ऐंशी',
-    'एक्याऐंशी',
-    'ब्याऐंशी',
-    'त्र्याऐंशी',
-    'चौऱ्याऐंशी',
-    'पंच्याऐंशी',
-    'शहाऐंशी',
-    'सत्याऐंशी',
-    'अठ्ठ्याऐंशी',
-    'एकोणनव्वद',
-    'नव्वद',
-    'एक्याण्णव',
-    'ब्याण्णव',
-    'त्र्याण्णव',
-    'चौऱ्याण्णव',
-    'पंच्याण्णव',
-    'शहाण्णव',
-    'सत्याण्णव',
-    'अठ्ठ्याण्णव',
-    'नव्याण्णव'
-  ]
-
-  scaleWords = [
-    '',
-    'हजार',
-    'लाख',
-    'कोटी',
-    'अब्ज',
-    'खर्व',
-    'निखर्व',
-    'महापद्म',
-    'शंकू'
-  ]
+
+import { parseNumericValue } from '../utils/parse-numeric.js'
+
+// ============================================================================
+// 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 numeric value to Marathi words.
+ *
+ * @param {number | string | bigint} value - The numeric value to convert
+ * @returns {string} The number in Marathi 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/ms.d.ts

@@ -1,31 +1,7 @@
 /**
- * Malay (Bahasa Melayu) language converter.
+ * Converts a numeric value to Malay words.
  *
- * Supports:
- * - "Se-" prefix for singular units (seratus, seribu, sejuta)
- * - Regular patterns (puluh for tens, ratus for hundreds)
- * - Space-separated number components
+ * @param {number | string | bigint} value - The numeric value to convert
+ * @returns {string} The number in Malay words
  */
-export class Malay extends AbstractLanguage {
-    /**
-     * Word forms for digits 0-9.
-     * @type {Object.<number, string[]>}
-     */
-    digitWords: {
-        [x: number]: string[];
-    };
-    /**
-     * Scale magnitude words keyed by exponent (10^n).
-     * @type {Object.<number, string>}
-     */
-    scaleWords: {
-        [x: number]: string;
-    };
-    splitBy3(number: any): any[][];
-    spell(blocks: any): any[];
-    getHundreds(number: any): string[];
-    getTens(number: any): string[];
-    join(wordBlocks: any): string;
-    integerToWords(integerPart: any): string;
-}
-import { AbstractLanguage } from '../classes/abstract-language.js';
+export function toWords(value: number | string | bigint): string;

package/lib/languages/ms.js

@@ -1,150 +1,205 @@
-import { AbstractLanguage } from '../classes/abstract-language.js'
-
 /**
- * Malay (Bahasa Melayu) language converter.
+ * Malay (Bahasa Melayu) language converter - Functional Implementation
+ *
+ * Self-contained converter with precomputed lookup tables.
  *
- * Supports:
- * - "Se-" prefix for singular units (seratus, seribu, sejuta)
+ * Key features:
+ * - "Se-" prefix for ALL singular scale units (seratus, seribu, sejuta, sebilion)
  * - Regular patterns (puluh for tens, ratus for hundreds)
- * - Space-separated number components
+ * - Teens with "belas" suffix
+ * - Note: "lapan" (8) differs from Indonesian "delapan"
  */
-export class Malay extends AbstractLanguage {
-  negativeWord = 'minus'
-  decimalSeparatorWord = 'perpuluhan'
-  zeroWord = 'sifar'
-
-  /**
-   * Word forms for digits 0-9.
-   * @type {Object.<number, string[]>}
-   */
-  digitWords = {
-    0: [],
-    1: ['satu'],
-    2: ['dua'],
-    3: ['tiga'],
-    4: ['empat'],
-    5: ['lima'],
-    6: ['enam'],
-    7: ['tujuh'],
-    8: ['lapan'],
-    9: ['sembilan']
+
+import { parseNumericValue } from '../utils/parse-numeric.js'
+
+// ============================================================================
+// Vocabulary
+// ============================================================================
+
+const ONES = ['', 'satu', 'dua', 'tiga', 'empat', 'lima', 'enam', 'tujuh', 'lapan', 'sembilan']
+const TEENS = ['sepuluh', 'sebelas', 'dua belas', 'tiga belas', 'empat belas', 'lima belas', 'enam belas', 'tujuh belas', 'lapan belas', 'sembilan belas']
+const TENS = ['', '', 'dua puluh', 'tiga puluh', 'empat puluh', 'lima puluh', 'enam puluh', 'tujuh puluh', 'lapan puluh', 'sembilan puluh']
+
+const HUNDRED_WORD = 'ratus'
+const THOUSAND_WORD = 'ribu'
+const SCALE_WORDS = ['juta', 'bilion', 'trilion']
+
+const ZERO = 'sifar'
+const NEGATIVE = 'minus'
+const DECIMAL_SEP = 'perpuluhan'
+
+// ============================================================================
+// 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)
+    }
   }
 
-  /**
-   * Scale magnitude words keyed by exponent (10^n).
-   * @type {Object.<number, string>}
-   */
-  scaleWords = {
-    3: 'ribu',
-    6: 'juta',
-    9: 'bilion',
-    12: 'trilion'
+  // 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) {
-    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' ? ['sifar'] : this.digitWords[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))]
+      result = SEGMENTS[thousands] + ' ' + THOUSAND_WORD
     }
-    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]
+
+    if (remainder > 0) {
+      result += ' ' + SEGMENTS[remainder]
     }
-    return wordBlocks
+
+    return result
   }
 
-  getHundreds (number) { // 'ratus'
-    if (number === '1') {
-      return ['seratus']
-    } else if (number === '0') {
-      return []
-    } else {
-      return [...this.digitWords[Math.trunc(number)], 'ratus']
-    }
+  return buildLargeNumberWords(n)
+}
+
+function buildLargeNumberWords (n) {
+  const numStr = n.toString()
+  const len = numStr.length
+
+  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
   }
 
-  getTens (number) { // 'puluh' and 'belas'
-    if (number[0] === '1') {
-      if (number[1] === '0') {
-        return ['sepuluh']
-      } else if (number[1] === '1') {
-        return ['sebelas']
+  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 {
+        // Malay: "se-" prefix for ALL scale words when segment is 1
+        const scaleWord = SCALE_WORDS[scaleIndex - 2]
+        if (segment === 1) {
+          parts.push('se' + scaleWord)
+        } else {
+          parts.push(SEGMENTS[segment] + ' ' + scaleWord)
+        }
       }
-      return [...this.digitWords[Math.trunc(number[1])], 'belas']
     }
 
-    if (number[0] === '0') {
-      return this.digitWords[Math.trunc(number[1])]
-    }
-
-    return [...this.digitWords[Math.trunc(number[0])], 'puluh', ...this.digitWords[Math.trunc(number[1])]]
+    scaleIndex--
   }
 
-  join (wordBlocks) {
-    const wordList = []
-    const length = wordBlocks.length - 1
+  return parts.join(' ')
+}
+
+function decimalPartToWords (decimalPart) {
+  let result = ''
 
-    for (let index = 0; index <= length; index++) {
-      const words = wordBlocks[index][1]
-      const isLast = index === length
-      const scaleWord = isLast ? null : this.scaleWords[(length - index) * 3]
+  let i = 0
+  while (i < decimalPart.length && decimalPart[i] === '0') {
+    if (result) result += ' '
+    result += ZERO
+    i++
+  }
 
-      if (!isLast && words.length === 1 && words[0] === 'satu') {
-        // Use se- prefix for singular scale units: seribu, sejuta, sebilion, setrilion
-        wordList.push('se' + scaleWord)
-        continue
-      }
+  const remainder = decimalPart.slice(i)
+  if (remainder) {
+    if (result) result += ' '
+    result += integerToWords(BigInt(remainder))
+  }
 
-      // Add current block words
-      for (const w of words) wordList.push(w)
+  return result
+}
 
-      // Append scale word if applicable and current block contributed words
-      if (!isLast && words.length > 0) {
-        wordList.push(scaleWord)
-      }
-    }
+/**
+ * Converts a numeric value to Malay words.
+ *
+ * @param {number | string | bigint} value - The numeric value to convert
+ * @returns {string} The number in Malay words
+ */
+function toWords (value) {
+  const { isNegative, integerPart, decimalPart } = parseNumericValue(value)
+
+  let result = ''
 
-    return wordList.join(' ')
+  if (isNegative) {
+    result = NEGATIVE + ' '
   }
 
-  integerToWords (integerPart) {
-    return this.join(
-      this.spell(
-        this.splitBy3(integerPart)
-      )
-    ).trim()
+  result += integerToWords(integerPart)
+
+  if (decimalPart) {
+    result += ' ' + DECIMAL_SEP + ' ' + decimalPartToWords(decimalPart)
   }
+
+  return result
 }
+
+// ============================================================================
+// Exports
+// ============================================================================
+
+export { toWords }

package/lib/languages/nb.d.ts

@@ -1,12 +1,14 @@
 /**
- * Norwegian Bokmål language converter.
+ * Converts a numeric value to Norwegian Bokmål words.
  *
- * Supports:
- * - Hyphenation for compound numbers (tjue-en)
- * - "og" (and) for hundreds combinations
- * - Implicit '1' omission before tens and magnitudes
+ * @param {number | string | bigint} value - The numeric value to convert
+ * @returns {string} The number in Norwegian words
+ * @throws {TypeError} If value is not a valid numeric type
+ * @throws {Error} If value is not a valid number format
+ *
+ * @example
+ * toWords(21)       // 'tjue-en'
+ * toWords(101)      // 'en hundre og en'
+ * toWords(1000000)  // 'en million'
  */
-export class NorwegianBokmal extends GreedyScaleLanguage {
-    scaleWords: (string | bigint)[][];
-}
-import { GreedyScaleLanguage } from '../classes/greedy-scale-language.js';
+export function toWords(value: number | string | bigint): string;