n2words 3.0.0 → 4.0.0

package/{lib/languages/cs.js → src/cs-CZ.js}

@@ -1,13 +1,9 @@
 /**
- * Czech language converter - Functional Implementation
+ * Czech (Czechia) language converter
  *
- * A performance-optimized number-to-words converter using precomputed lookup tables.
- * Self-contained module with its own input validation, ready for subpath exports.
+ * CLDR: cs-CZ | Czech as used in Czechia
  *
- * Key optimization: Precompute all segment values (0-999) at module load.
- * This eliminates all per-call string manipulation for segment conversion.
- *
- * Czech-specific rules (handled in precomputation):
+ * Czech-specific rules:
  * - Three-form pluralization: 1 = singular, 2-4 = few, 5+ = many
  * - Irregular hundreds: sto, dvě stě, tři sta, čtyři sta, pět set...
  * - Gender: dva (masc) vs dvě (fem) for 2
@@ -15,7 +11,9 @@
  * - Dynamic decimal separator: celá/celé/celých based on integer
  */
 
-import { parseNumericValue } from '../utils/parse-numeric.js'
+import { parseCardinalValue } from './utils/parse-cardinal.js'
+import { parseCurrencyValue } from './utils/parse-currency.js'
+import { parseOrdinalValue } from './utils/parse-ordinal.js'
 
 // ============================================================================
 // Vocabulary (module-level constants)
@@ -50,19 +48,46 @@ const ZERO = 'nula'
 const NEGATIVE = 'mínus'
 
 // ============================================================================
-// Precomputed Lookup Tables (built once at module load)
+// Ordinal Vocabulary
+// ============================================================================
+
+// Czech ordinals (masculine nominative singular)
+const ORDINAL_ONES = ['', 'první', 'druhý', 'třetí', 'čtvrtý', 'pátý', 'šestý', 'sedmý', 'osmý', 'devátý']
+
+// Ordinal teens
+const ORDINAL_TEENS = ['desátý', 'jedenáctý', 'dvanáctý', 'třináctý', 'čtrnáctý', 'patnáctý', 'šestnáctý', 'sedmnáctý', 'osmnáctý', 'devatenáctý']
+
+// Ordinal tens (for exact tens)
+const ORDINAL_TENS = ['', '', 'dvacátý', 'třicátý', 'čtyřicátý', 'padesátý', 'šedesátý', 'sedmdesátý', 'osmdesátý', 'devadesátý']
+
+// Ordinal hundreds (for exact hundreds)
+const ORDINAL_HUNDREDS = ['', 'stý', 'dvoustý', 'třístý', 'čtyřstý', 'pětistý', 'šestistý', 'sedmistý', 'osmistý', 'devítistý']
+
+// Scale ordinals
+const ORDINAL_SCALES = ['tisící', 'miliontý', 'miliardtý', 'biliontý']
+
+// ============================================================================
+// Currency Vocabulary (Czech Koruna)
+// ============================================================================
+
+// Koruna forms: [singular, few (2-4), many (5+)]
+const KORUNA_FORMS = ['koruna', 'koruny', 'korun']
+// Haléř forms: [singular, few (2-4), many (5+)]
+const HALER_FORMS = ['haléř', 'haléře', 'haléřů']
+
+// ============================================================================
+// Segment Building
 // ============================================================================
 
 /**
  * Builds segment word for 0-999 (masculine, default form).
- * Only used during table construction.
  */
 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 tens = Math.trunc(n / 10) % 10
+  const hundreds = Math.trunc(n / 100)
 
   const parts = []
 
@@ -95,8 +120,8 @@ function buildSegmentWithHundreds (n) {
   if (n === 0) return ''
 
   const ones = n % 10
-  const tens = Math.floor(n / 10) % 10
-  const hundreds = Math.floor(n / 100)
+  const tens = Math.trunc(n / 10) % 10
+  const hundreds = Math.trunc(n / 100)
 
   const parts = []
 
@@ -120,18 +145,6 @@ function buildSegmentWithHundreds (n) {
   return parts.join(' ')
 }
 
-// Precompute all 1000 segment words (0-999) - masculine form
-const SEGMENTS = new Array(1000)
-for (let i = 0; i < 1000; i++) {
-  SEGMENTS[i] = buildSegment(i)
-}
-
-// Precompute all 1000 segment words with hundreds (irregular hundreds forms)
-const SEGMENTS_WITH_HUNDREDS = new Array(1000)
-for (let i = 0; i < 1000; i++) {
-  SEGMENTS_WITH_HUNDREDS[i] = buildSegmentWithHundreds(i)
-}
-
 // ============================================================================
 // Helper Functions
 // ============================================================================
@@ -185,9 +198,9 @@ function getDecimalSeparator (integerPart) {
 function integerToWords (n) {
   if (n === 0n) return ZERO
 
-  // Fast path: numbers < 1000 (direct lookup)
+  // Fast path: numbers < 1000
   if (n < 1000n) {
-    return SEGMENTS[Number(n)]
+    return buildSegment(Number(n))
   }
 
   // Fast path: numbers < 1,000,000 (thousands)
@@ -202,12 +215,12 @@ function integerToWords (n) {
       // Omit "one" before tisíc
       result = scaleWord
     } else {
-      result = SEGMENTS[Number(thousands)] + ' ' + scaleWord
+      result = buildSegment(Number(thousands)) + ' ' + scaleWord
     }
 
     if (remainder > 0) {
       // Use form with irregular hundreds (for "dvě stě" etc.)
-      result += ' ' + SEGMENTS_WITH_HUNDREDS[remainder]
+      result += ' ' + buildSegmentWithHundreds(remainder)
     }
 
     return result
@@ -245,7 +258,7 @@ function buildLargeNumberWords (n) {
 
     if (i === 0) {
       // Units segment (no scale word) - use form with irregular hundreds
-      result += SEGMENTS_WITH_HUNDREDS[Number(segment)]
+      result += buildSegmentWithHundreds(Number(segment))
     } else {
       // Scale word needed
       const forms = PLURAL_FORMS[i]
@@ -257,11 +270,11 @@ function buildLargeNumberWords (n) {
           result += scaleWord
         } else {
           // Use masculine form for multiplier before scale words
-          result += SEGMENTS[Number(segment)] + ' ' + scaleWord
+          result += buildSegment(Number(segment)) + ' ' + scaleWord
         }
       } else {
         // Fallback for very large scales without defined forms
-        result += SEGMENTS[Number(segment)]
+        result += buildSegment(Number(segment))
       }
     }
   }
@@ -308,13 +321,13 @@ function decimalPartToWords (decimalPart) {
  * @throws {Error} If value is not a valid number format
  *
  * @example
- * toWords(21)           // 'dvacet jedna'
- * toWords(1000)         // 'tisíc'
- * toWords(2000)         // 'dva tisíce'
- * toWords(5000)         // 'pět tisíc'
+ * toCardinal(21)           // 'dvacet jedna'
+ * toCardinal(1000)         // 'tisíc'
+ * toCardinal(2000)         // 'dva tisíce'
+ * toCardinal(5000)         // 'pět tisíc'
  */
-function toWords (value) {
-  const { isNegative, integerPart, decimalPart } = parseNumericValue(value)
+function toCardinal (value) {
+  const { isNegative, integerPart, decimalPart } = parseCardinalValue(value)
 
   let result = ''
 
@@ -332,8 +345,204 @@ function toWords (value) {
   return result
 }
 
+// ============================================================================
+// ORDINAL: toOrdinal(value)
+// ============================================================================
+
+/**
+ * Builds ordinal for a 0-99 segment when it's the final (ordinal) part.
+ *
+ * @param {number} n - Number 0-99
+ * @returns {string} Ordinal words
+ */
+function buildOrdinalTensOnes (n) {
+  if (n === 0) return ''
+
+  const onesDigit = n % 10
+  const tensDigit = Math.trunc(n / 10)
+
+  if (tensDigit === 0) {
+    return ORDINAL_ONES[onesDigit]
+  }
+
+  if (tensDigit === 1) {
+    return ORDINAL_TEENS[onesDigit]
+  }
+
+  if (onesDigit === 0) {
+    return ORDINAL_TENS[tensDigit]
+  }
+
+  return TENS[tensDigit] + ' ' + ORDINAL_ONES[onesDigit]
+}
+
+/**
+ * Converts a positive integer to Czech ordinal words (masculine nominative).
+ *
+ * @param {bigint} n - Positive integer to convert
+ * @returns {string} Ordinal Czech words
+ */
+function integerToOrdinal (n) {
+  if (n < 100n) {
+    return buildOrdinalTensOnes(Number(n))
+  }
+
+  if (n < 1000n) {
+    const num = Number(n)
+    const hundredsDigit = Math.trunc(num / 100)
+    const remainder = num % 100
+
+    if (remainder === 0) {
+      return ORDINAL_HUNDREDS[hundredsDigit]
+    }
+
+    return HUNDREDS[hundredsDigit] + ' ' + buildOrdinalTensOnes(remainder)
+  }
+
+  if (n < 1_000_000n) {
+    const thousands = Number(n / 1000n)
+    const remainder = Number(n % 1000n)
+
+    if (remainder === 0) {
+      if (thousands === 1) {
+        return ORDINAL_SCALES[0]
+      }
+      return buildSegment(thousands) + ' ' + ORDINAL_SCALES[0]
+    }
+
+    const scaleWord = pluralize(BigInt(thousands), PLURAL_FORMS[1])
+    const thousandsWord = thousands === 1 ? '' : buildSegment(thousands) + ' '
+    return (thousands === 1 ? 'tisíc' : thousandsWord + scaleWord) + ' ' + integerToOrdinal(BigInt(remainder))
+  }
+
+  return buildLargeOrdinal(n)
+}
+
+/**
+ * Builds ordinal words for numbers >= 1,000,000.
+ *
+ * @param {bigint} n - Number >= 1,000,000
+ * @returns {string} Ordinal Czech words
+ */
+function buildLargeOrdinal (n) {
+  const segmentValues = []
+  let temp = n
+  while (temp > 0n) {
+    segmentValues.push(temp % 1000n)
+    temp = temp / 1000n
+  }
+
+  let lastNonZeroIdx = 0
+  for (let i = 0; i < segmentValues.length; i++) {
+    if (segmentValues[i] !== 0n) {
+      lastNonZeroIdx = i
+    }
+  }
+
+  const parts = []
+
+  for (let i = segmentValues.length - 1; i >= 0; i--) {
+    const segment = segmentValues[i]
+    if (segment === 0n) continue
+
+    const isLastNonZero = (i === lastNonZeroIdx)
+
+    if (i === 0) {
+      if (isLastNonZero) {
+        parts.push(integerToOrdinal(segment))
+      } else {
+        parts.push(buildSegmentWithHundreds(Number(segment)))
+      }
+    } else {
+      if (isLastNonZero) {
+        if (segment === 1n) {
+          parts.push(ORDINAL_SCALES[i - 1] || PLURAL_FORMS[i][0])
+        } else {
+          parts.push(buildSegment(Number(segment)) + ' ' + (ORDINAL_SCALES[i - 1] || PLURAL_FORMS[i][0]))
+        }
+      } else {
+        const forms = PLURAL_FORMS[i]
+        if (forms) {
+          const scaleWord = pluralize(segment, forms)
+          if (segment === 1n) {
+            parts.push(scaleWord)
+          } else {
+            parts.push(buildSegment(Number(segment)) + ' ' + scaleWord)
+          }
+        }
+      }
+    }
+  }
+
+  return parts.join(' ')
+}
+
+/**
+ * Converts a numeric value to Czech ordinal words (masculine nominative).
+ *
+ * @param {number | string | bigint} value - The numeric value to convert (must be a positive integer)
+ * @returns {string} The number as ordinal words
+ * @throws {TypeError} If value is not a valid numeric type
+ * @throws {RangeError} If value is negative, zero, or has a decimal part
+ *
+ * @example
+ * toOrdinal(1)    // 'první'
+ * toOrdinal(2)    // 'druhý'
+ * toOrdinal(21)   // 'dvacet první'
+ * toOrdinal(100)  // 'stý'
+ * toOrdinal(1000) // 'tisící'
+ */
+function toOrdinal (value) {
+  const integerPart = parseOrdinalValue(value)
+  return integerToOrdinal(integerPart)
+}
+
+// ============================================================================
+// CURRENCY: toCurrency(value)
+// ============================================================================
+
+/**
+ * Converts a numeric value to Czech currency words (Koruna).
+ *
+ * @param {number | string | bigint} value - The currency amount to convert
+ * @returns {string} The amount in Czech currency words
+ * @throws {TypeError} If value is not a valid numeric type
+ * @throws {Error} If value is not a valid number format
+ *
+ * @example
+ * toCurrency(42)     // 'čtyřicet dva koruny'
+ * toCurrency(1)      // 'jedna koruna'
+ * toCurrency(1.50)   // 'jedna koruna padesát haléřů'
+ * toCurrency(-5)     // 'mínus pět korun'
+ */
+function toCurrency (value) {
+  const { isNegative, dollars: koruny, cents: halere } = parseCurrencyValue(value)
+
+  let result = ''
+  if (isNegative) {
+    result = NEGATIVE + ' '
+  }
+
+  // Koruna part
+  if (koruny > 0n || halere === 0n) {
+    result += integerToWords(koruny)
+    result += ' ' + pluralize(koruny, KORUNA_FORMS)
+  }
+
+  // Haléř part
+  if (halere > 0n) {
+    if (koruny > 0n) {
+      result += ' '
+    }
+    result += integerToWords(halere)
+    result += ' ' + pluralize(halere, HALER_FORMS)
+  }
+
+  return result
+}
+
 // ============================================================================
 // Public API
 // ============================================================================
 
-export { toWords }
+export { toCardinal, toOrdinal, toCurrency }

package/src/da-DK.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Converts a numeric value to Danish words.
+ *
+ * @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
+ * toCardinal(21)       // 'enogtyve'
+ * toCardinal(1000)     // 'ettusind'
+ * toCardinal(1000000)  // 'en millioner'
+ */
+export function toCardinal(value: number | string | bigint): string;
+/**
+ * Converts a numeric value to Danish ordinal words.
+ *
+ * @param {number | string | bigint} value - The numeric value to convert (positive integer)
+ * @returns {string} The number as ordinal words
+ * @throws {TypeError} If value is not a valid numeric type
+ * @throws {RangeError} If value is negative, zero, or has a decimal part
+ *
+ * @example
+ * toOrdinal(1)    // 'første'
+ * toOrdinal(2)    // 'anden'
+ * toOrdinal(21)   // 'enogtyvede'
+ */
+export function toOrdinal(value: number | string | bigint): string;
+/**
+ * Converts a numeric value to Danish currency words (Danish Krone).
+ *
+ * Uses krone/kroner and øre (100 øre = 1 krone).
+ *
+ * @param {number | string | bigint} value - The currency amount to convert
+ * @returns {string} The amount in Danish currency words
+ * @throws {TypeError} If value is not a valid numeric type
+ * @throws {Error} If value is not a valid number format
+ *
+ * @example
+ * toCurrency(1)      // 'en krone'
+ * toCurrency(42)     // 'toogfyrre kroner'
+ * toCurrency(1.50)   // 'en krone og halvtreds øre'
+ */
+export function toCurrency(value: number | string | bigint): string;

package/{lib/languages/da.js → src/da-DK.js}

@@ -1,7 +1,7 @@
 /**
- * Danish language converter - Functional Implementation
+ * Danish (Denmark) language converter
  *
- * A performance-optimized number-to-words converter using precomputed lookup tables.
+ * CLDR: da-DK | Danish as used in Denmark
  *
  * Key features:
  * - Vigesimal (base-20) tens naming: halvtreds (50), treds (60), etc.
@@ -11,7 +11,9 @@
  * - Long scale for millions+
  */
 
-import { parseNumericValue } from '../utils/parse-numeric.js'
+import { parseCardinalValue } from './utils/parse-cardinal.js'
+import { parseCurrencyValue } from './utils/parse-currency.js'
+import { parseOrdinalValue } from './utils/parse-ordinal.js'
 
 // ============================================================================
 // Vocabulary (module-level constants)
@@ -37,7 +39,36 @@ const DECIMAL_SEP = 'komma'
 const SCALES = ['millioner', 'millarder', 'billioner', 'billarder', 'trillioner', 'trillarder', 'quadrillioner', 'quadrillarder']
 
 // ============================================================================
-// Precomputed Lookup Tables (built once at module load)
+// Ordinal Vocabulary
+// ============================================================================
+
+// Danish ordinals: 1st-2nd special, others use -te/-nde suffix
+// "anden/andet" for 2nd (common/neuter), we use common form
+const ORDINAL_SPECIAL = {
+  1: 'første',
+  2: 'anden',
+  3: 'tredje',
+  4: 'fjerde',
+  5: 'femte',
+  6: 'sjette',
+  7: 'syvende',
+  8: 'ottende',
+  9: 'niende',
+  10: 'tiende',
+  11: 'ellevte',
+  12: 'tolvte'
+}
+
+// ============================================================================
+// Currency Vocabulary (Danish Krone)
+// ============================================================================
+
+const KRONE = 'krone'
+const KRONER = 'kroner' // plural
+const ORE = 'øre' // same singular and plural
+
+// ============================================================================
+// Segment Building
 // ============================================================================
 
 /**
@@ -47,8 +78,8 @@ 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 tens = Math.trunc(n / 10) % 10
+  const hundreds = Math.trunc(n / 100)
 
   const parts = []
 
@@ -83,13 +114,6 @@ function buildSegment (n) {
   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
 // ============================================================================
@@ -105,7 +129,7 @@ function integerToWords (n) {
 
   // Fast path: numbers < 1000 (direct lookup)
   if (n < 1000n) {
-    return SEGMENTS[Number(n)]
+    return buildSegment(Number(n))
   }
 
   // Fast path: numbers < 1,000,000 (thousands)
@@ -114,11 +138,11 @@ function integerToWords (n) {
     const remainder = Number(n % 1000n)
 
     // Compound thousands: "ettusind", "firetusind"
-    let result = SEGMENTS[thousands] + THOUSAND
+    let result = buildSegment(thousands) + THOUSAND
 
     if (remainder > 0) {
       // Add 'e' suffix and " og " for remainder: "firetusinde og ..."
-      result += 'e og ' + SEGMENTS[remainder]
+      result += 'e og ' + buildSegment(remainder)
     }
 
     return result
@@ -162,7 +186,7 @@ function buildLargeNumberWords (n) {
     const segment = segments[i]
 
     if (segment !== 0) {
-      const segmentWord = SEGMENTS[segment]
+      const segmentWord = buildSegment(segment)
 
       if (scaleIndex === 0) {
         // Units segment
@@ -266,12 +290,12 @@ function decimalPartToWords (decimalPart) {
  * @throws {Error} If value is not a valid number format
  *
  * @example
- * toWords(21)       // 'enogtyve'
- * toWords(1000)     // 'ettusind'
- * toWords(1000000)  // 'en millioner'
+ * toCardinal(21)       // 'enogtyve'
+ * toCardinal(1000)     // 'ettusind'
+ * toCardinal(1000000)  // 'en millioner'
  */
-function toWords (value) {
-  const { isNegative, integerPart, decimalPart } = parseNumericValue(value)
+function toCardinal (value) {
+  const { isNegative, integerPart, decimalPart } = parseCardinalValue(value)
 
   let result = ''
 
@@ -288,8 +312,97 @@ function toWords (value) {
   return result
 }
 
+// ============================================================================
+// ORDINAL: toOrdinal(value)
+// ============================================================================
+
+/**
+ * Converts a non-negative integer to Danish ordinal words.
+ *
+ * Danish ordinals: første (1st), anden (2nd), tredje (3rd), etc.
+ * 1-12 have special forms, others use cardinal + -de/-nde suffix.
+ *
+ * @param {bigint} n - Positive integer to convert
+ * @returns {string} Danish ordinal words
+ */
+function integerToOrdinal (n) {
+  // Special forms for 1-12
+  if (n >= 1n && n <= 12n) {
+    return ORDINAL_SPECIAL[Number(n)]
+  }
+
+  // For numbers > 12, add -de suffix to cardinal
+  const cardinal = integerToWords(n)
+  return cardinal + 'de'
+}
+
+/**
+ * Converts a numeric value to Danish ordinal words.
+ *
+ * @param {number | string | bigint} value - The numeric value to convert (positive integer)
+ * @returns {string} The number as ordinal words
+ * @throws {TypeError} If value is not a valid numeric type
+ * @throws {RangeError} If value is negative, zero, or has a decimal part
+ *
+ * @example
+ * toOrdinal(1)    // 'første'
+ * toOrdinal(2)    // 'anden'
+ * toOrdinal(21)   // 'enogtyvede'
+ */
+function toOrdinal (value) {
+  const integerPart = parseOrdinalValue(value)
+  return integerToOrdinal(integerPart)
+}
+
+// ============================================================================
+// CURRENCY: toCurrency(value)
+// ============================================================================
+
+/**
+ * Converts a numeric value to Danish currency words (Danish Krone).
+ *
+ * Uses krone/kroner and øre (100 øre = 1 krone).
+ *
+ * @param {number | string | bigint} value - The currency amount to convert
+ * @returns {string} The amount in Danish currency words
+ * @throws {TypeError} If value is not a valid numeric type
+ * @throws {Error} If value is not a valid number format
+ *
+ * @example
+ * toCurrency(1)      // 'en krone'
+ * toCurrency(42)     // 'toogfyrre kroner'
+ * toCurrency(1.50)   // 'en krone og halvtreds øre'
+ */
+function toCurrency (value) {
+  const { isNegative, dollars: kroner, cents: ore } = parseCurrencyValue(value)
+
+  let result = ''
+  if (isNegative) {
+    result = NEGATIVE + ' '
+  }
+
+  // Kroner part - use "en" for 1 krone
+  if (kroner > 0n || ore === 0n) {
+    if (kroner === 1n) {
+      result += 'en ' + KRONE
+    } else {
+      result += integerToWords(kroner) + ' ' + KRONER
+    }
+  }
+
+  // Øre part
+  if (ore > 0n) {
+    if (kroner > 0n) {
+      result += ' og '
+    }
+    result += integerToWords(ore) + ' ' + ORE
+  }
+
+  return result
+}
+
 // ============================================================================
 // Public API
 // ============================================================================
 
-export { toWords }
+export { toCardinal, toOrdinal, toCurrency }