n2words 3.0.0 → 4.0.0

package/{lib/languages/nb.js → src/nb-NO.js}

@@ -1,7 +1,7 @@
 /**
- * Norwegian Bokmål language converter - Functional Implementation
+ * Norwegian Bokmål (Norway) language converter
  *
- * A performance-optimized number-to-words converter using precomputed lookup tables.
+ * CLDR: nb-NO | Norwegian Bokmål as used in Norway
  *
  * Key features:
  * - Hyphenated tens+ones: "tjue-en" (21)
@@ -10,7 +10,9 @@
  * - Short scale: million, milliard, billion, etc.
  */
 
-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)
@@ -32,7 +34,35 @@ const DECIMAL_SEP = 'komma'
 const SCALES = ['million', 'milliard', 'billion', 'billiard', 'kvintillion', 'sekstillion', 'septillion', 'oktillion']
 
 // ============================================================================
-// Precomputed Lookup Tables (built once at module load)
+// Ordinal Vocabulary
+// ============================================================================
+
+// Norwegian ordinals: 1st-12th special forms, then cardinal + -de/-te
+const ORDINAL_SPECIAL = {
+  1: 'første',
+  2: 'andre',
+  3: 'tredje',
+  4: 'fjerde',
+  5: 'femte',
+  6: 'sjette',
+  7: 'sjuende',
+  8: 'åttende',
+  9: 'niende',
+  10: 'tiende',
+  11: 'ellevte',
+  12: 'tolvte'
+}
+
+// ============================================================================
+// Currency Vocabulary (Norwegian Krone)
+// ============================================================================
+
+const KRONE = 'krone'
+const KRONER = 'kroner' // plural
+const ORE = 'øre' // same singular and plural
+
+// ============================================================================
+// Segment Building
 // ============================================================================
 
 /**
@@ -43,8 +73,8 @@ function buildSegment (n) {
   if (n === 0) return { word: '', hasHundred: false }
 
   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 = []
   let hasHundred = false
@@ -81,16 +111,6 @@ function buildSegment (n) {
   return { word: parts[0] || '', hasHundred }
 }
 
-// Precompute all 1000 segment words (0-999)
-const SEGMENTS = new Array(1000)
-const SEGMENTS_HAS_HUNDRED = new Array(1000)
-
-for (let i = 0; i < 1000; i++) {
-  const result = buildSegment(i)
-  SEGMENTS[i] = result.word
-  SEGMENTS_HAS_HUNDRED[i] = result.hasHundred
-}
-
 // ============================================================================
 // Conversion Functions
 // ============================================================================
@@ -104,9 +124,9 @@ for (let i = 0; i < 1000; i++) {
 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)).word
   }
 
   // Fast path: numbers < 1,000,000 (thousands)
@@ -114,14 +134,15 @@ function integerToWords (n) {
     const thousands = Number(n / 1000n)
     const remainder = Number(n % 1000n)
 
-    let result = SEGMENTS[thousands] + ' ' + THOUSAND
+    let result = buildSegment(thousands).word + ' ' + THOUSAND
 
     if (remainder > 0) {
+      const remainderResult = buildSegment(remainder)
       // Comma before hundreds, " og " before small numbers
-      if (SEGMENTS_HAS_HUNDRED[remainder]) {
-        result += ', ' + SEGMENTS[remainder]
+      if (remainderResult.hasHundred) {
+        result += ', ' + remainderResult.word
       } else {
-        result += ' og ' + SEGMENTS[remainder]
+        result += ' og ' + remainderResult.word
       }
     }
 
@@ -165,19 +186,18 @@ function buildLargeNumberWords (n) {
     const segment = segments[i]
 
     if (segment !== 0) {
-      const segmentWord = SEGMENTS[segment]
-      const hasHundred = SEGMENTS_HAS_HUNDRED[segment]
+      const segmentResult = buildSegment(segment)
 
       if (scaleIndex === 0) {
         // Units segment
-        parts.push({ word: segmentWord, hasHundred, type: 'units' })
+        parts.push({ word: segmentResult.word, hasHundred: segmentResult.hasHundred, type: 'units' })
       } else if (scaleIndex === 1) {
         // Thousands
-        parts.push({ word: segmentWord + ' ' + THOUSAND, hasHundred: false, type: 'thousand' })
+        parts.push({ word: segmentResult.word + ' ' + THOUSAND, hasHundred: false, type: 'thousand' })
       } else {
         // Millions+
         const scaleWord = SCALES[scaleIndex - 2]
-        parts.push({ word: segmentWord + ' ' + scaleWord, hasHundred: false, type: 'million' })
+        parts.push({ word: segmentResult.word + ' ' + scaleWord, hasHundred: false, type: 'million' })
       }
     }
 
@@ -266,12 +286,12 @@ function decimalPartToWords (decimalPart) {
  * @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'
+ * toCardinal(21)       // 'tjue-en'
+ * toCardinal(101)      // 'en hundre og en'
+ * toCardinal(1000000)  // 'en million'
  */
-function toWords (value) {
-  const { isNegative, integerPart, decimalPart } = parseNumericValue(value)
+function toCardinal (value) {
+  const { isNegative, integerPart, decimalPart } = parseCardinalValue(value)
 
   let result = ''
 
@@ -288,8 +308,120 @@ function toWords (value) {
   return result
 }
 
+// ============================================================================
+// ORDINAL: toOrdinal(value)
+// ============================================================================
+
+/**
+ * Converts a non-negative integer to Norwegian Bokmål ordinal words.
+ *
+ * Norwegian ordinals: første (1st), andre (2nd), tredje (3rd), etc.
+ * 1-12 have special forms, others use cardinal + de/te suffix.
+ * Teens (13-19): drop -en and add -ende (tretten → trettende)
+ * Numbers ending in 'en' (one): replace with 'ende' (tjue-en → tjue-ende)
+ * Numbers ending in 9 (ni): add 'ede' (nitti-ni → nitti-niede)
+ *
+ * @param {bigint} n - Positive integer to convert
+ * @returns {string} Norwegian ordinal words
+ */
+function integerToOrdinal (n) {
+  // Special forms for 1-12
+  if (n >= 1n && n <= 12n) {
+    return ORDINAL_SPECIAL[Number(n)]
+  }
+
+  const num = Number(n)
+  const cardinal = integerToWords(n)
+
+  // Teens 13-19: drop -en and add -ende
+  if (num >= 13 && num <= 19) {
+    // tretten → trettende, nitten → nittende
+    return cardinal.slice(0, -2) + 'ende'
+  }
+
+  // For other numbers, check if cardinal ends with 'en' (one)
+  // tjue-en → tjue-ende, en hundre og en → en hundre og ende
+  if (cardinal.endsWith('en')) {
+    return cardinal.slice(0, -2) + 'ende'
+  }
+
+  // Numbers ending in 'ni' (9): add 'ede'
+  // nitti-ni → nitti-niede
+  if (cardinal.endsWith('ni')) {
+    return cardinal + 'ede'
+  }
+
+  // Others use -de suffix
+  return cardinal + 'de'
+}
+
+/**
+ * Converts a numeric value to Norwegian Bokmål 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)    // 'andre'
+ * toOrdinal(21)   // 'tjue-ende'
+ */
+function toOrdinal (value) {
+  const integerPart = parseOrdinalValue(value)
+  return integerToOrdinal(integerPart)
+}
+
+// ============================================================================
+// CURRENCY: toCurrency(value)
+// ============================================================================
+
+/**
+ * Converts a numeric value to Norwegian currency words (Norwegian 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 Norwegian 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)     // 'førti-to kroner'
+ * toCurrency(1.50)   // 'en krone og femti øre'
+ */
+function toCurrency (value) {
+  const { isNegative, dollars: kroner, cents: ore } = parseCurrencyValue(value)
+
+  let result = ''
+  if (isNegative) {
+    result = NEGATIVE + ' '
+  }
+
+  // Kroner part
+  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 }

package/src/nl-NL.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Converts a numeric value to Dutch 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
+ * @param {Object} [options] - Optional configuration
+ * @param {boolean} [options.accentOne=true] - Use "één" instead of "een"
+ * @param {boolean} [options.includeOptionalAnd=false] - Include "en" before small numbers
+ * @param {boolean} [options.noHundredPairing=false] - Disable hundred pairing (1104→duizend honderdvier)
+ * @returns {string} The number in Dutch words
+ * @throws {TypeError} If value is not a valid numeric type
+ * @throws {Error} If value is not a valid number format
+ *
+ * @example
+ * toCardinal(21)                        // 'eenentwintig'
+ * toCardinal(1)                         // 'één'
+ * toCardinal(1, {accentOne: false})     // 'een'
+ * toCardinal(1104)                      // 'elfhonderd vier'
+ */
+export function toCardinal(value: number | string | bigint, options?: {
+    accentOne?: boolean | undefined;
+    includeOptionalAnd?: boolean | undefined;
+    noHundredPairing?: boolean | undefined;
+}): string;
+/**
+ * Converts a number to Dutch ordinal words.
+ *
+ * @param {number | string | bigint} value - The number to convert
+ * @returns {string} Dutch ordinal words
+ *
+ * @example
+ * toOrdinal(1)     // 'eerste'
+ * toOrdinal(21)    // 'eenentwintigste'
+ * toOrdinal(100)   // 'honderdste'
+ */
+export function toOrdinal(value: number | string | bigint): string;
+/**
+ * Converts a number to Dutch currency words (Euro).
+ *
+ * @param {number | string | bigint} value - The amount to convert
+ * @param {Object} [options]
+ * @param {boolean} [options.and=true] - Include "en" between euros and cents
+ * @returns {string} Dutch currency words
+ *
+ * @example
+ * toCurrency(42.50)  // 'tweeënveertig euro en vijftig cent'
+ * toCurrency(1)      // 'één euro'
+ * toCurrency(0.01)   // 'één cent'
+ */
+export function toCurrency(value: number | string | bigint, options?: {
+    and?: boolean | undefined;
+}): string;