n2words 2.0.0 → 3.0.0

package/lib/languages/hu.d.ts

@@ -1,22 +1,7 @@
 /**
- * Hungarian language converter.
+ * Converts a numeric value to Hungarian words.
  *
- * Supports:
- * - Agglutinative structure (no spaces between compound parts)
- * - Special handling for "egy" (one) omission
- * - Pre-composed twenties (huszonegy through huszonkilenc)
+ * @param {number | string | bigint} value - The numeric value to convert
+ * @returns {string} The number in Hungarian words
  */
-export class Hungarian extends GreedyScaleLanguage {
-    scaleWords: (string | bigint)[][];
-    /** Converts tens (30-99) with agglutinative composition. */
-    tensToCardinal(number: any): string | undefined;
-    /** Converts hundreds (100-999) with "száz" composition. */
-    hundredsToCardinal(number: any): string;
-    /** Converts thousands (1000-999999) with "ezer" composition. */
-    thousandsToCardinal(number: any): string;
-    /** Converts large numbers (millions and above) with scale words. */
-    bigNumberToCardinal(number: any): string;
-    /** Converts integer part using Hungarian agglutinative rules. */
-    integerToWords(integerPart: any, zeroWord?: string): string;
-}
-import { GreedyScaleLanguage } from '../classes/greedy-scale-language.js';
+export function toWords(value: number | string | bigint): string;

package/lib/languages/hu.js

@@ -1,137 +1,216 @@
-import { GreedyScaleLanguage } from '../classes/greedy-scale-language.js'
-
 /**
- * Hungarian language converter.
+ * Hungarian language converter - Functional Implementation
+ *
+ * Self-contained converter with agglutinative word formation.
  *
- * Supports:
+ * Key features:
  * - Agglutinative structure (no spaces between compound parts)
  * - Special handling for "egy" (one) omission
  * - Pre-composed twenties (huszonegy through huszonkilenc)
+ * - "két" instead of "kettő" in compound forms
  */
-export class Hungarian extends GreedyScaleLanguage {
-  negativeWord = 'mínusz'
-  decimalSeparatorWord = 'egész'
-  zeroWord = 'nulla'
-
-  scaleWords = [
-    [1_000_000_000_000_000_000_000_000_000n, 'quadrilliárd'],
-    [1_000_000_000_000_000_000_000_000n, 'quadrillió'],
-    [1_000_000_000_000_000_000_000n, 'trilliárd'],
-    [1_000_000_000_000_000_000n, 'trillió'],
-    [1_000_000_000_000_000n, 'billiárd'],
-    [1_000_000_000_000n, 'billió'],
-    [1_000_000_000n, 'milliárd'],
-    [1_000_000n, 'millió'],
-    [1000n, 'ezer'],
-    [100n, 'száz'],
-    [90n, 'kilencven'],
-    [80n, 'nyolcvan'],
-    [70n, 'hetven'],
-    [60n, 'hatvan'],
-    [50n, 'ötven'],
-    [40n, 'negyven'],
-    [30n, 'harminc'],
-    [29n, 'huszonkilenc'],
-    [28n, 'huszonnyolc'],
-    [27n, 'huszonhét'],
-    [26n, 'huszonhat'],
-    [25n, 'huszonöt'],
-    [24n, 'huszonnégy'],
-    [23n, 'huszonhárom'],
-    [22n, 'huszonkettő'],
-    [21n, 'huszonegy'],
-    [20n, 'húsz'],
-    [19n, 'tizenkilenc'],
-    [18n, 'tizennyolc'],
-    [17n, 'tizenhét'],
-    [16n, 'tizenhat'],
-    [15n, 'tizenöt'],
-    [14n, 'tizennégy'],
-    [13n, 'tizenhárom'],
-    [12n, 'tizenkettő'],
-    [11n, 'tizenegy'],
-    [10n, 'tíz'],
-    [9n, 'kilenc'],
-    [8n, 'nyolc'],
-    [7n, 'hét'],
-    [6n, 'hat'],
-    [5n, 'öt'],
-    [4n, 'négy'],
-    [3n, 'három'],
-    [2n, 'kettő'],
-    [1n, 'egy'],
-    [0n, 'nulla']
-  ]
-
-  /** Converts tens (30-99) with agglutinative composition. */
-  tensToCardinal (number) {
-    // Expecting `number` as bigint when called from integerToWords
-    if (this.wordForScale(number)) {
-      return this.wordForScale(number)
-    } else {
-      const tens = number / 10n
-      const units = number % 10n
-      return this.wordForScale(tens * 10n) + this.integerToWords(units)
-    }
+
+import { parseNumericValue } from '../utils/parse-numeric.js'
+
+// ============================================================================
+// Vocabulary
+// ============================================================================
+
+// Word map using BigInt keys for scale values
+const WORDS = new Map([
+  [1_000_000_000_000_000_000_000_000_000n, 'quadrilliárd'],
+  [1_000_000_000_000_000_000_000_000n, 'quadrillió'],
+  [1_000_000_000_000_000_000_000n, 'trilliárd'],
+  [1_000_000_000_000_000_000n, 'trillió'],
+  [1_000_000_000_000_000n, 'billiárd'],
+  [1_000_000_000_000n, 'billió'],
+  [1_000_000_000n, 'milliárd'],
+  [1_000_000n, 'millió'],
+  [1000n, 'ezer'],
+  [100n, 'száz'],
+  [90n, 'kilencven'],
+  [80n, 'nyolcvan'],
+  [70n, 'hetven'],
+  [60n, 'hatvan'],
+  [50n, 'ötven'],
+  [40n, 'negyven'],
+  [30n, 'harminc'],
+  [29n, 'huszonkilenc'],
+  [28n, 'huszonnyolc'],
+  [27n, 'huszonhét'],
+  [26n, 'huszonhat'],
+  [25n, 'huszonöt'],
+  [24n, 'huszonnégy'],
+  [23n, 'huszonhárom'],
+  [22n, 'huszonkettő'],
+  [21n, 'huszonegy'],
+  [20n, 'húsz'],
+  [19n, 'tizenkilenc'],
+  [18n, 'tizennyolc'],
+  [17n, 'tizenhét'],
+  [16n, 'tizenhat'],
+  [15n, 'tizenöt'],
+  [14n, 'tizennégy'],
+  [13n, 'tizenhárom'],
+  [12n, 'tizenkettő'],
+  [11n, 'tizenegy'],
+  [10n, 'tíz'],
+  [9n, 'kilenc'],
+  [8n, 'nyolc'],
+  [7n, 'hét'],
+  [6n, 'hat'],
+  [5n, 'öt'],
+  [4n, 'négy'],
+  [3n, 'három'],
+  [2n, 'kettő'],
+  [1n, 'egy'],
+  [0n, 'nulla']
+])
+
+const ZERO = 'nulla'
+const NEGATIVE = 'mínusz'
+const DECIMAL_SEP = 'egész'
+
+// ============================================================================
+// Conversion Functions
+// ============================================================================
+
+function wordForScale (value) {
+  return WORDS.get(value)
+}
+
+function tensToCardinal (n) {
+  if (WORDS.has(n)) {
+    return WORDS.get(n)
+  }
+  const tens = n / 10n
+  const units = n % 10n
+  return wordForScale(tens * 10n) + integerToWordsInner(units)
+}
+
+function hundredsToCardinal (n) {
+  const hundreds = n / 100n
+  let prefix = 'száz'
+  if (hundreds !== 1n) {
+    prefix = integerToWordsInner(hundreds, '') + prefix
   }
+  const postfix = integerToWordsInner(n % 100n, '')
+  return prefix + postfix
+}
 
-  /** Converts hundreds (100-999) with "száz" composition. */
-  hundredsToCardinal (number) {
-    const hundreds = number / 100n
-    let prefix = 'száz'
-    if (hundreds !== 1n) {
-      prefix = this.integerToWords(hundreds, '') + prefix
-    }
-    const postfix = this.integerToWords(number % 100n, '')
-    return prefix + postfix
+function thousandsToCardinal (n) {
+  const thousands = n / 1000n
+  let prefix = 'ezer'
+  if (thousands !== 1n) {
+    prefix = integerToWordsInner(thousands, '') + prefix
   }
+  const postfix = integerToWordsInner(n % 1000n, '')
+  const middle = (n <= 2000n || postfix === '') ? '' : '-'
+  return prefix + middle + postfix
+}
+
+// Scale values for finding appropriate scale (avoids toString)
+const SCALES = [
+  1_000_000_000_000_000_000_000_000_000n,
+  1_000_000_000_000_000_000_000_000n,
+  1_000_000_000_000_000_000_000n,
+  1_000_000_000_000_000_000n,
+  1_000_000_000_000_000n,
+  1_000_000_000_000n,
+  1_000_000_000n,
+  1_000_000n
+]
 
-  /** Converts thousands (1000-999999) with "ezer" composition. */
-  thousandsToCardinal (number) {
-    const thousands = number / 1000n
-    let prefix = 'ezer'
-    if (thousands !== 1n) {
-      prefix = this.integerToWords(thousands, '') + prefix
+function bigNumberToCardinal (n) {
+  // Find appropriate scale using BigInt comparison (avoids toString)
+  let exp = 1_000_000n
+  for (const scale of SCALES) {
+    if (n >= scale) {
+      exp = scale
+      break
     }
-    const postfix = this.integerToWords(number % 1000n, '')
-    const middle = (number <= 2000n || postfix === '') ? '' : '-'
-    return prefix + middle + postfix
   }
 
-  /** Converts large numbers (millions and above) with scale words. */
-  bigNumberToCardinal (number) {
-    const numberLength = number.toString().length
-    const digits = (numberLength % 3 === 0) ? numberLength - 2 : numberLength
-    const exp = 10 ** (Math.floor(digits / 3) * 3)
-    const prefix = this.integerToWords(number / BigInt(exp), '')
-    const rest = this.integerToWords(number % BigInt(exp), '')
-    const postfix = (rest === '') ? '' : ('-' + rest)
-    return prefix + this.wordForScale(BigInt(exp)) + postfix
+  const prefix = integerToWordsInner(n / exp, '')
+  const rest = integerToWordsInner(n % exp, '')
+  const postfix = (rest === '') ? '' : ('-' + rest)
+  return prefix + wordForScale(exp) + postfix
+}
+
+function integerToWordsInner (n, zeroWord = ZERO) {
+  // Normalize to BigInt for consistent comparisons
+  if (typeof n !== 'bigint') n = BigInt(n)
+
+  if (n === 0n) {
+    return zeroWord
+  }
+  if (zeroWord === '' && n === 2n) {
+    return 'két'
+  }
+  if (n < 30n) {
+    return wordForScale(n)
+  }
+  if (n < 100n) {
+    return tensToCardinal(n)
   }
+  if (n < 1000n) {
+    return hundredsToCardinal(n)
+  }
+  if (n < 1_000_000n) {
+    return thousandsToCardinal(n)
+  }
+  return bigNumberToCardinal(n)
+}
 
-  /** Converts integer part using Hungarian agglutinative rules. */
-  integerToWords (integerPart, zeroWord = this.zeroWord) {
-    let words = ''
-
-    // Normalize to BigInt for consistent comparisons
-    if (typeof integerPart !== 'bigint') integerPart = BigInt(integerPart)
-
-    if (integerPart === 0n) {
-      words = zeroWord
-    } else if (zeroWord === '' && integerPart === 2n) {
-      words = 'két'
-    } else if (integerPart < 30n) {
-      words = this.wordForScale(integerPart)
-    } else if (integerPart < 100n) {
-      words = this.tensToCardinal(integerPart)
-    } else if (integerPart < 1000n) {
-      words = this.hundredsToCardinal(integerPart)
-    } else if (integerPart < 1_000_000n) {
-      words = this.thousandsToCardinal(integerPart)
-    } else {
-      words = this.bigNumberToCardinal(integerPart)
-    }
+function integerToWords (n) {
+  return integerToWordsInner(n, ZERO)
+}
+
+function decimalPartToWords (decimalPart) {
+  let result = ''
+  let i = 0
 
-    return words
+  while (i < decimalPart.length && decimalPart[i] === '0') {
+    if (result) result += ' '
+    result += ZERO
+    i++
   }
+
+  const remainder = decimalPart.slice(i)
+  if (remainder) {
+    if (result) result += ' '
+    result += integerToWords(BigInt(remainder))
+  }
+
+  return result
 }
+
+/**
+ * Converts a numeric value to Hungarian words.
+ *
+ * @param {number | string | bigint} value - The numeric value to convert
+ * @returns {string} The number in Hungarian 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/id.d.ts

@@ -1,37 +1,7 @@
 /**
- * Indonesian language converter.
+ * Converts a numeric value to Indonesian words.
  *
- * Supports:
- * - "Se-" prefix for one (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 Indonesian words
  */
-export class Indonesian 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;
-    };
-    /** Splits number into groups of 3 digits. */
-    splitBy3(number: any): any[][];
-    /** Converts digit blocks to Indonesian words. */
-    spell(blocks: any): any[];
-    /** Converts hundreds digit with "seratus" or "ratus" suffix. */
-    getHundreds(number: any): string[];
-    /** Converts tens and units digits with "puluh" or "belas" suffix. */
-    getTens(number: any): string[];
-    /** Joins word blocks with magnitude scale words. */
-    join(wordBlocks: any): string;
-    /** Converts integer part using Indonesian group-based conversion. */
-    integerToWords(integerPart: any): string;
-}
-import { AbstractLanguage } from '../classes/abstract-language.js';
+export function toWords(value: number | string | bigint): string;