n2words 1.24.0 → 3.0.0

package/lib/languages/hu.js

@@ -1,155 +1,216 @@
-import GreedyScaleLanguage from '../classes/greedy-scale-language.js'
-
 /**
- * Hungarian language converter.
+ * Hungarian language converter - Functional Implementation
  *
- * Converts numbers to Hungarian words following Hungarian conventions:
- * - Agglutinative structure for compound numbers
- * - No spaces between tens and units (e.g., "huszonegy" = twenty-one)
- * - Special handling for "egy" (one) - often omitted as multiplier
- * - Vowel harmony in compound words
+ * Self-contained converter with agglutinative word formation.
  *
- * Features:
- * - Compact number representations (húsz, harminc, negyven)
+ * Key features:
+ * - Agglutinative structure (no spaces between compound parts)
+ * - Special handling for "egy" (one) omission
  * - Pre-composed twenties (huszonegy through huszonkilenc)
- * - "egész" as decimal separator (meaning "whole")
- * - Support for very large numbers (up to quadrilliards)
+ * - "két" instead of "kettő" in compound forms
  */
-export class Hungarian extends GreedyScaleLanguage {
-  negativeWord = 'mínusz'
-  decimalSeparatorWord = 'egész'
-  zeroWord = 'nulla'
-  scaleWordPairs = [
-    [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']
-  ]
-
-  tensToCardinal (number) {
-    // Expecting `number` as bigint when called from convertWholePart
-    if (this.getScaleWord(number)) {
-      return this.getScaleWord(number)
-    } else {
-      const tens = number / 10n
-      const units = number % 10n
-      return this.getScaleWord(tens * 10n) + this.convertWholePart(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)
+}
 
-  hundredsToCardinal (number) {
-    const hundreds = number / 100n
-    let prefix = 'száz'
-    if (hundreds !== 1n) {
-      prefix = this.convertWholePart(hundreds, '') + prefix
-    }
-    const postfix = this.convertWholePart(number % 100n, '')
-    return prefix + postfix
+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
+}
+
+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
+}
 
-  thousandsToCardinal (number) {
-    const thousands = number / 1000n
-    let prefix = 'ezer'
-    if (thousands !== 1n) {
-      prefix = this.convertWholePart(thousands, '') + prefix
+// 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
+]
+
+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.convertWholePart(number % 1000n, '')
-    const middle = (number <= 2000n || postfix === '') ? '' : '-'
-    return prefix + middle + postfix
   }
 
-  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.convertWholePart(number / BigInt(exp), '')
-    const rest = this.convertWholePart(number % BigInt(exp), '')
-    const postfix = (rest === '') ? '' : ('-' + rest)
-    return prefix + this.getScaleWord(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)
+}
 
-  convertWholePart (number, zeroWord = this.zeroWord) {
-    let words = ''
-
-    // Normalize to BigInt for consistent comparisons
-    if (typeof number !== 'bigint') number = BigInt(number)
-
-    if (number === 0n) {
-      words = zeroWord
-    } else if (zeroWord === '' && number === 2n) {
-      words = 'két'
-    } else if (number < 30n) {
-      words = this.getScaleWord(number)
-    } else if (number < 100n) {
-      words = this.tensToCardinal(number)
-    } else if (number < 1000n) {
-      words = this.hundredsToCardinal(number)
-    } else if (number < 1_000_000n) {
-      words = this.thousandsToCardinal(number)
-    } else {
-      words = this.bigNumberToCardinal(number)
-    }
+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 number to Hungarian cardinal (written) form.
+ * Converts a numeric value to Hungarian words.
  *
- * @param {number|string|bigint} value The number to convert.
- * @param {Object} [options] Conversion options (see Hungarian class options).
- * @returns {string} The number expressed in Hungarian words.
- * @throws {TypeError} If value is NaN or invalid type.
- * @throws {Error} If value is an invalid number string.
- *
- * @example
- * convertToWords(42); // 'negyvenkettő'
- * convertToWords(21); // 'huszonegy'
+ * @param {number | string | bigint} value - The numeric value to convert
+ * @returns {string} The number in Hungarian words
  */
-export default function convertToWords (value, options = {}) {
-  return new Hungarian(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/id.d.ts

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