n2words 1.24.0 → 3.0.0

package/lib/languages/da.js

@@ -1,167 +1,295 @@
-import GreedyScaleLanguage from '../classes/greedy-scale-language.js'
+/**
+ * Danish language converter - Functional Implementation
+ *
+ * A performance-optimized number-to-words converter using precomputed lookup tables.
+ *
+ * Key features:
+ * - Vigesimal (base-20) tens naming: halvtreds (50), treds (60), etc.
+ * - Units-before-tens: "enogtyve" (21) = one-and-twenty
+ * - Compound thousands: "ettusind", "firetusinde"
+ * - "og" conjunction after hundreds and thousands
+ * - Long scale for millions+
+ */
+
+import { parseNumericValue } from '../utils/parse-numeric.js'
+
+// ============================================================================
+// Vocabulary (module-level constants)
+// ============================================================================
+
+const ONES = ['', 'et', 'to', 'tre', 'fire', 'fem', 'seks', 'syv', 'otte', 'ni']
+// "en" form used in vigesimal pattern (X og Y) and before millions
+const ONES_VIGESIMAL = ['', 'en', 'to', 'tre', 'fire', 'fem', 'seks', 'syv', 'otte', 'ni']
+
+const TEENS = ['ti', 'elleve', 'tolv', 'tretten', 'fjorten', 'femten', 'seksten', 'sytten', 'atten', 'nitten']
+
+// Danish vigesimal tens (base-20 derived names)
+const TENS = ['', '', 'tyve', 'tredive', 'fyrre', 'halvtreds', 'treds', 'halvfjerds', 'firs', 'halvfems']
+
+const HUNDRED = 'hundrede'
+const THOUSAND = 'tusind'
+
+const ZERO = 'nul'
+const NEGATIVE = 'minus'
+const DECIMAL_SEP = 'komma'
+
+// Long scale: millioner, millarder, billioner, etc.
+const SCALES = ['millioner', 'millarder', 'billioner', 'billarder', 'trillioner', 'trillarder', 'quadrillioner', 'quadrillarder']
+
+// ============================================================================
+// Precomputed Lookup Tables (built once at module load)
+// ============================================================================
 
 /**
- * @typedef {Object} DanishOptions
- * @property {boolean} [ordFlag=false] Enable ordinal number conversion.
+ * Builds segment word for 0-999.
  */
+function buildSegment (n) {
+  if (n === 0) return ''
+
+  const ones = n % 10
+  const tens = Math.floor(n / 10) % 10
+  const hundreds = Math.floor(n / 100)
+
+  const parts = []
+
+  // Hundreds: "ethundrede", "tohundrede" (compound, no space)
+  if (hundreds > 0) {
+    parts.push(ONES[hundreds] + HUNDRED)
+  }
+
+  // Tens and ones
+  const tensOnes = n % 100
+
+  if (tensOnes === 0) {
+    // Just hundreds
+  } else if (tensOnes < 10) {
+    // Single digit
+    parts.push(ONES[ones])
+  } else if (tensOnes < 20) {
+    // Teens
+    parts.push(TEENS[ones])
+  } else if (ones === 0) {
+    // Even tens
+    parts.push(TENS[tens])
+  } else {
+    // Units-before-tens: "enogtyve", "treogfyrre"
+    parts.push(ONES_VIGESIMAL[ones] + 'og' + TENS[tens])
+  }
+
+  // Combine with " og " between hundreds and remainder
+  if (parts.length === 2) {
+    return parts[0] + ' og ' + parts[1]
+  }
+  return parts[0] || ''
+}
+
+// Precompute all 1000 segment words (0-999)
+const SEGMENTS = new Array(1000)
+
+for (let i = 0; i < 1000; i++) {
+  SEGMENTS[i] = buildSegment(i)
+}
+
+// ============================================================================
+// Conversion Functions
+// ============================================================================
 
 /**
- * Danish language converter.
- *
- * GreedyScaleLanguage with Danish-specific extensions:
- * - Unique vigesimal (base-20) number system for 50-90
- * - Special composition rules ("og" for "and" between units and tens)
- * - Reverse digit order (e.g., "fem-og-tyve" = five-and-twenty = 25)
- * - Support for ordinal numbers via ordFlag option
+ * Converts a non-negative integer to Danish words.
  *
- * Key Features:
- * - Vigesimal tens: halvtreds (50), treds (60), halvfjerds (70), firs (80), halvfems (90)
- * - Units-before-tens pattern (e.g., "tre-og-tyve" = 23)
- * - "et" prefix for hundreds/thousands (not "en")
- * - Optional ordinal number conversion via ordFlag option
- * - Inline merge logic tailored for Danish ordering
+ * @param {bigint} n - Non-negative integer to convert
+ * @returns {string} Danish words
  */
-export class Danish extends GreedyScaleLanguage {
-  negativeWord = 'minus'
-  decimalSeparatorWord = 'komma'
-  zeroWord = 'nul'
-  scaleWordPairs = [
-    [1_000_000_000_000_000_000_000_000_000n, 'quadrillarder'],
-    [1_000_000_000_000_000_000_000_000n, 'quadrillioner'],
-    [1_000_000_000_000_000_000_000n, 'trillarder'],
-    [1_000_000_000_000_000_000n, 'trillioner'],
-    [1_000_000_000_000_000n, 'billarder'],
-    [1_000_000_000_000n, 'billioner'],
-    [1_000_000_000n, 'millarder'],
-    [1_000_000n, 'millioner'],
-    [1000n, 'tusind'],
-    [100n, 'hundrede'],
-    [90n, 'halvfems'],
-    [80n, 'firs'],
-    [70n, 'halvfjerds'],
-    [60n, 'treds'],
-    [50n, 'halvtreds'],
-    [40n, 'fyrre'],
-    [30n, 'tredive'],
-    [20n, 'tyve'],
-    [19n, 'nitten'],
-    [18n, 'atten'],
-    [17n, 'sytten'],
-    [16n, 'seksten'],
-    [15n, 'femten'],
-    [14n, 'fjorten'],
-    [13n, 'tretten'],
-    [12n, 'tolv'],
-    [11n, 'elleve'],
-    [10n, 'ti'],
-    [9n, 'ni'],
-    [8n, 'otte'],
-    [7n, 'syv'],
-    [6n, 'seks'],
-    [5n, 'fem'],
-    [4n, 'fire'],
-    [3n, 'tre'],
-    [2n, 'to'],
-    [1n, 'et'],
-    [0n, 'nul']
-  ]
-
-  /**
-   * Initializes the Danish converter with language-specific options.
-   *
-   * @param {DanishOptions} [options={}] Configuration options.
-   */
-  constructor ({ ordFlag = false } = {}) {
-    super()
-
-    this.ordFlag = ordFlag
+function integerToWords (n) {
+  if (n === 0n) return ZERO
+
+  // Fast path: numbers < 1000 (direct lookup)
+  if (n < 1000n) {
+    return SEGMENTS[Number(n)]
   }
 
-  /**
-   * Merges two adjacent word-number pairs according to Danish grammar rules.
-   * Danish uses complex vigesimal (base-20) patterns and reverse digit ordering.
-   *
-   * Key Danish patterns:
-   * - Vigesimal tens: halvtreds(50), treds(60), halvfjerds(70), firs(80), halvfems(90)
-   * - Units-before-tens order with "og" (and): "tre-og-tyve" (3 and 20 = 25)
-   * - "et" prefix for hundreds/thousands (not "en")
-   * - Space separators for large magnitudes (≥ millions)
-   * - Ordinal support via this.ordFlag
-   *
-   * @param {Object} current The left operand as `{ word: bigint }`.
-   * @param {Object} next The right operand as `{ word: bigint }`.
-   * @returns {Object} Merged pair with combined word and resulting number (bigint).
-   */
-  mergeScales (current, next) {
-    let cText = Object.keys(current)[0]
-    let nText = Object.keys(next)[0]
-    const cNumber = Object.values(current)[0] // BigInt (e.g., 1n, 100n, 1000n)
-    const nNumber = Object.values(next)[0] // BigInt (e.g., magnitude level like 100n, 1000n)
-
-    // Prepend "et" to hundreds and thousands (not "en") for proper Danish form
-    if (nNumber === 100n || nNumber === 1000n) {
-      next = { [`et${nText}`]: nNumber }
-    }
+  // Fast path: numbers < 1,000,000 (thousands)
+  if (n < 1_000_000n) {
+    const thousands = Number(n / 1000n)
+    const remainder = Number(n % 1000n)
 
-    // Implicit '1' handling: omit '1' before most magnitudes (except millions/ordinals)
-    if (cNumber === 1n) {
-      if (nNumber < 1_000_000n || this.ordFlag) {
-        return next // Just the magnitude word (e.g., "hundrede" not "en hundrede")
-      }
-      cText = 'en' // Explicit "en" (one) for millions and above
+    // Compound thousands: "ettusind", "firetusind"
+    let result = SEGMENTS[thousands] + THOUSAND
+
+    if (remainder > 0) {
+      // Add 'e' suffix and " og " for remainder: "firetusinde og ..."
+      result += 'e og ' + SEGMENTS[remainder]
     }
 
-    // Multiplication across magnitude boundaries
-    if (nNumber > cNumber) {
-      // Space for million+ (e.g., "en million", "to millioner")
-      if (nNumber >= 1_000_000n) {
-        cText += ' '
+    return result
+  }
+
+  // For numbers >= 1,000,000, use scale decomposition
+  return buildLargeNumberWords(n)
+}
+
+/**
+ * Builds words for numbers >= 1,000,000.
+ *
+ * @param {bigint} n - Number >= 1,000,000
+ * @returns {string} Danish words
+ */
+function buildLargeNumberWords (n) {
+  const numStr = n.toString()
+  const len = numStr.length
+
+  // Build segments of 3 digits from right to left
+  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
+  }
+
+  // Convert segments to words with scale tracking
+  // scaleIndex: 0 = units, 1 = thousands, 2 = millions, etc.
+  const parts = []
+  let scaleIndex = segments.length - 1
+
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i]
+
+    if (segment !== 0) {
+      const segmentWord = SEGMENTS[segment]
+
+      if (scaleIndex === 0) {
+        // Units segment
+        parts.push({ word: segmentWord, type: 'units' })
+      } else if (scaleIndex === 1) {
+        // Thousands - compound form
+        parts.push({ word: segmentWord + THOUSAND, type: 'thousand' })
+      } else {
+        // Millions+ - space-separated, use "en" for 1
+        const scaleWord = SCALES[scaleIndex - 2]
+        let numWord = segmentWord
+        // "et" → "en" before millions+
+        if (segment === 1) {
+          numWord = 'en'
+        }
+        parts.push({ word: numWord + ' ' + scaleWord, type: 'million' })
       }
-      return { [`${cText}${nText}`]: cNumber * nNumber }
     }
 
-    // Addition with separator rules:
-    // "og" (and) for hundreds + smaller numbers
-    if (cNumber >= 100n && cNumber < 1000n) {
-      cText += ' og '
-    } else if (cNumber >= 1000n && cNumber <= 100_000n) {
-      // Special "e og" for thousands (e.g., "tusinde og tyve")
-      cText += 'e og '
-    }
+    scaleIndex--
+  }
 
-    // Units-before-tens reversal (Danish vigesimal pattern):
-    // For small units (< 10) with tens (10-99), swap order: "tre og tyve" (25)
-    if (nNumber < 10n && cNumber > 10n && cNumber < 100n) {
-      if (nNumber === 1n) {
-        nText = 'en' // Convert 1 to "en" for vigesimal context
+  // Join parts with Danish rules
+  return joinDanishParts(parts)
+}
+
+/**
+ * Joins parts with Danish spacing rules.
+ * - After thousands with remainder: "tusinde og"
+ * - Millions are space-separated
+ *
+ * @param {Array} parts - Parts with type metadata
+ * @returns {string} Joined string
+ */
+function joinDanishParts (parts) {
+  if (parts.length === 0) return ZERO
+  if (parts.length === 1) return parts[0].word
+
+  const result = []
+
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i]
+    const nextPart = parts[i + 1]
+
+    if (part.type === 'thousand' && nextPart && nextPart.type === 'units') {
+      // Thousands followed by units: add "e og"
+      result.push(part.word + 'e og ' + nextPart.word)
+      i++ // Skip the units part
+    } else if (part.type === 'million') {
+      if (result.length > 0) {
+        result.push(' ')
+      }
+      result.push(part.word)
+      if (nextPart) {
+        result.push(' ')
+      }
+    } else {
+      if (result.length > 0 && !result[result.length - 1].endsWith(' ')) {
+        result.push(' ')
       }
-      // Swap positions: units go after "og", tens go before
-      const temporary = nText
-      nText = cText
-      cText = temporary + 'og'
-    } else if (cNumber >= 1_000_000n) {
-      // Space for large magnitudes (millions+)
-      cText += ' '
+      result.push(part.word)
     }
+  }
+
+  return result.join('')
+}
+
+/**
+ * Converts decimal digits to Danish words.
+ *
+ * @param {string} decimalPart - Decimal digits (without the point)
+ * @returns {string} Danish words for decimal part
+ */
+function decimalPartToWords (decimalPart) {
+  let result = ''
 
-    return { [`${cText}${nText}`]: cNumber + nNumber }
+  // Handle leading zeros
+  let i = 0
+  while (i < decimalPart.length && decimalPart[i] === '0') {
+    if (result) result += ' '
+    result += ZERO
+    i++
   }
+
+  // Convert remainder as a single number
+  const remainder = decimalPart.slice(i)
+  if (remainder) {
+    if (result) result += ' '
+    result += integerToWords(BigInt(remainder))
+  }
+
+  return result
 }
 
 /**
- * Converts a number to Danish cardinal (written) form.
+ * Converts a numeric value to Danish words.
  *
- * @param {number|string|bigint} value The number to convert.
- * @param {Object} [options] Conversion options (see Danish class options).
- * @param {boolean} [options.ordFlag=false] Enable ordinal number conversion.
- * @returns {string} The number expressed in Danish 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 Danish words
+ * @throws {TypeError} If value is not a valid numeric type
+ * @throws {Error} If value is not a valid number format
  *
  * @example
- * convertToWords(25); // 'femogtyve' (five-and-twenty)
- * convertToWords(50); // 'halvtreds' (half-third-times-twenty)
+ * toWords(21)       // 'enogtyve'
+ * toWords(1000)     // 'ettusind'
+ * toWords(1000000)  // 'en millioner'
  */
-export default function convertToWords (value, options = {}) {
-  return new Danish(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
 }
+
+// ============================================================================
+// Public API
+// ============================================================================
+
+export { toWords }

package/lib/languages/de.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Converts a numeric value to German 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 German words
+ * @throws {TypeError} If value is not a valid numeric type
+ * @throws {Error} If value is not a valid number format
+ *
+ * @example
+ * toWords(21)           // 'einundzwanzig'
+ * toWords(1000)         // 'eintausend'
+ * toWords(1000000)      // 'eine Million'
+ */
+export function toWords(value: number | string | bigint): string;