n2words 5.0.0 → 5.1.1

package/src/ko-KR.d.ts

@@ -1,11 +1,12 @@
+export const cardinalMax: bigint;
+export const ordinalMax: bigint;
+export const currencyMax: bigint;
 /**
  * Converts a numeric value to Korean words.
- *
  * @param {number | string | bigint} value - The numeric value to convert
  * @returns {string} The number in Korean words
  * @throws {TypeError} If value is not a valid numeric type
  * @throws {Error} If value is not a valid number format
- *
  * @example
  * toCardinal(21)         // '이십일'
  * toCardinal(10000)      // '만'
@@ -14,12 +15,10 @@
 export function toCardinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Korean 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)    // '제일'
  * toOrdinal(2)    // '제이'
@@ -31,12 +30,10 @@ export function toOrdinal(value: number | string | bigint): string;
  *
  * Korean Won has no subunit (jeon are historical).
  * Amounts are rounded to whole won.
- *
  * @param {number | string | bigint} value - The currency amount to convert
  * @returns {string} The amount in Korean 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)     // '사십이원'
  * toCurrency(1000)   // '천원'

package/src/ko-KR.js

@@ -13,6 +13,8 @@
 import { parseCardinalValue } from './utils/parse-cardinal.js'
 import { parseCurrencyValue } from './utils/parse-currency.js'
 import { parseOrdinalValue } from './utils/parse-ordinal.js'
+import { checkMax } from './utils/check-max.js'
+import { myriad } from './utils/scale.js'
 
 // ============================================================================
 // Vocabulary (module-level constants)
@@ -32,6 +34,13 @@ const DECIMAL_SEP = '점'
 // 만 (10^4), 억 (10^8), 조 (10^12), 경 (10^16), etc.
 const SCALES = ['만', '억', '조', '경', '해', '자', '양']
 
+// Myriad (4-digit) grouping: each scale word covers a power of 10,000, so the
+// first unsupported value is 10^((SCALES.length + 1) * 4). Ordinals and currency
+// build on the cardinal speller, so they share its ceiling.
+export const cardinalMax = myriad(SCALES.length)
+export const ordinalMax = myriad(SCALES.length)
+export const currencyMax = myriad(SCALES.length)
+
 // ============================================================================
 // Ordinal Vocabulary
 // ============================================================================
@@ -51,8 +60,10 @@ const WON = '원'
 /**
  * Builds segment word for 0-9999 (4-digit myriad segment).
  * Korean omits "일" before 십, 백, 천.
+ * @param {number} n - Segment value (0-9999)
+ * @returns {string} Korean words for the segment
  */
-function buildSegment (n) {
+function buildSegment(n) {
   if (n === 0) return ''
 
   const ones = n % 10
@@ -66,7 +77,8 @@ function buildSegment (n) {
   if (thousands > 0) {
     if (thousands === 1) {
       result += THOUSAND
-    } else {
+    }
+    else {
       result += ONES[thousands] + THOUSAND
     }
   }
@@ -75,7 +87,8 @@ function buildSegment (n) {
   if (hundreds > 0) {
     if (hundreds === 1) {
       result += HUNDRED
-    } else {
+    }
+    else {
       result += ONES[hundreds] + HUNDRED
     }
   }
@@ -84,7 +97,8 @@ function buildSegment (n) {
   if (tens > 0) {
     if (tens === 1) {
       result += TEN
-    } else {
+    }
+    else {
       result += ONES[tens] + TEN
     }
   }
@@ -103,11 +117,10 @@ function buildSegment (n) {
 
 /**
  * Converts a non-negative integer to Korean words.
- *
  * @param {bigint} n - Non-negative integer to convert
  * @returns {string} Korean words
  */
-function integerToWords (n) {
+function integerToWords(n) {
   if (n === 0n) return ZERO
 
   // Fast path: numbers < 10000
@@ -122,11 +135,10 @@ function integerToWords (n) {
 /**
  * Builds words for numbers >= 10000.
  * Uses myriad (만) grouping - 4 digits per segment.
- *
  * @param {bigint} n - Number >= 10000
  * @returns {string} Korean words
  */
-function buildLargeNumberWords (n) {
+function buildLargeNumberWords(n) {
   const numStr = n.toString()
   const len = numStr.length
 
@@ -156,14 +168,16 @@ function buildLargeNumberWords (n) {
       if (scaleIndex === 0) {
         // Units segment (no scale word)
         parts.push({ word: buildSegment(segment), isScale: false })
-      } else {
+      }
+      else {
         // Segment with scale word
         const scaleWord = SCALES[scaleIndex - 1]
 
         // Korean omits segment when it's 1 before scale words
         if (segment === 1) {
           parts.push({ word: scaleWord, isScale: true })
-        } else {
+        }
+        else {
           parts.push({ word: buildSegment(segment), isScale: false })
           parts.push({ word: scaleWord, isScale: true })
         }
@@ -181,11 +195,10 @@ function buildLargeNumberWords (n) {
  * Joins parts with Korean spacing rules.
  * - Concatenate without spaces within segments
  * - Space after scale words before next number
- *
- * @param {Array} parts - Parts with isScale metadata
+ * @param {Array<{word: string, isScale: boolean}>} parts - Parts with isScale metadata
  * @returns {string} Joined string
  */
-function joinKoreanParts (parts) {
+function joinKoreanParts(parts) {
   if (parts.length === 0) return ZERO
   if (parts.length === 1) return parts[0].word
 
@@ -208,11 +221,10 @@ function joinKoreanParts (parts) {
 
 /**
  * Converts decimal digits to Korean words.
- *
  * @param {string} decimalPart - Decimal digits (without the point)
  * @returns {string} Korean words for decimal part (space-separated)
  */
-function decimalPartToWords (decimalPart) {
+function decimalPartToWords(decimalPart) {
   const parts = []
 
   // Handle leading zeros
@@ -233,19 +245,18 @@ function decimalPartToWords (decimalPart) {
 
 /**
  * Converts a numeric value to Korean words.
- *
  * @param {number | string | bigint} value - The numeric value to convert
  * @returns {string} The number in Korean words
  * @throws {TypeError} If value is not a valid numeric type
  * @throws {Error} If value is not a valid number format
- *
  * @example
  * toCardinal(21)         // '이십일'
  * toCardinal(10000)      // '만'
  * toCardinal(1000000)    // '백만'
  */
-function toCardinal (value) {
+function toCardinal(value) {
   const { isNegative, integerPart, decimalPart } = parseCardinalValue(value)
+  checkMax(integerPart, cardinalMax, decimalPart)
 
   const parts = []
 
@@ -271,29 +282,27 @@ function toCardinal (value) {
  * Converts a non-negative integer to Korean ordinal words.
  *
  * Korean ordinals use "제" prefix + Sino-Korean numeral.
- *
  * @param {bigint} n - Positive integer to convert
  * @returns {string} Korean ordinal words
  */
-function integerToOrdinal (n) {
+function integerToOrdinal(n) {
   return ORDINAL_PREFIX + integerToWords(n)
 }
 
 /**
  * Converts a numeric value to Korean 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)    // '제일'
  * toOrdinal(2)    // '제이'
  * toOrdinal(10)   // '제십'
  */
-function toOrdinal (value) {
+function toOrdinal(value) {
   const integerPart = parseOrdinalValue(value)
+  checkMax(integerPart, ordinalMax)
   return integerToOrdinal(integerPart)
 }
 
@@ -306,19 +315,18 @@ function toOrdinal (value) {
  *
  * Korean Won has no subunit (jeon are historical).
  * Amounts are rounded to whole won.
- *
  * @param {number | string | bigint} value - The currency amount to convert
  * @returns {string} The amount in Korean 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)     // '사십이원'
  * toCurrency(1000)   // '천원'
  * toCurrency(-5)     // '마이너스 오원'
  */
-function toCurrency (value) {
+function toCurrency(value) {
   const { isNegative, dollars: won } = parseCurrencyValue(value)
+  checkMax(won, currencyMax)
 
   let result = ''
   if (isNegative) {

package/src/lt-LT.d.ts

@@ -1,29 +1,41 @@
+export const cardinalMax: bigint;
+export const ordinalMax: bigint;
+export const currencyMax: bigint;
+/**
+ * @typedef {object} CardinalOptions
+ * @property {('masculine'|'feminine')} [gender] - Gender for numbers < 1000
+ */
+/** @type {Required<CardinalOptions>} */
+export const cardinalDefaults: Required<CardinalOptions>;
+/** @type {{ gender: ReadonlyArray<Required<CardinalOptions>['gender']> }} */
+export const cardinalValues: {
+    gender: ReadonlyArray<Required<CardinalOptions>["gender"]>;
+};
+export type CardinalOptions = {
+    /**
+     * - Gender for numbers < 1000
+     */
+    gender?: "feminine" | "masculine" | undefined;
+};
 /**
  * Converts a numeric value to Lithuanian words.
- *
  * @param {number | string | bigint} value - The numeric value to convert
- * @param {Object} [options] - Conversion options
- * @param {string} [options.gender='masculine'] - Gender for numbers < 1000
+ * @param {CardinalOptions} [options] - Conversion options
  * @returns {string} The number in Lithuanian words
  * @throws {TypeError} If value is not a valid numeric type
  * @throws {Error} If value is not a valid number format
- *
  * @example
  * toCardinal(42)                          // 'keturiasdešimt du'
  * toCardinal(1, { gender: 'feminine' })   // 'viena'
  * toCardinal(1000000)                     // 'vienas milijonas'
  */
-export function toCardinal(value: number | string | bigint, options?: {
-    gender?: string | undefined;
-}): string;
+export function toCardinal(value: number | string | bigint, options?: CardinalOptions): string;
 /**
  * Converts a numeric value to Lithuanian 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)    // 'pirmas'
  * toOrdinal(2)    // 'antras'
@@ -34,12 +46,10 @@ export function toCardinal(value: number | string | bigint, options?: {
 export function toOrdinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Lithuanian currency words (Euro).
- *
  * @param {number | string | bigint} value - The currency amount to convert
  * @returns {string} The amount in Lithuanian 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)     // 'keturiasdešimt du eurai'
  * toCurrency(1)      // 'vienas euras'

package/src/lt-LT.js

@@ -13,7 +13,9 @@
 import { parseCardinalValue } from './utils/parse-cardinal.js'
 import { parseCurrencyValue } from './utils/parse-currency.js'
 import { parseOrdinalValue } from './utils/parse-ordinal.js'
-import { validateOptions } from './utils/validate-options.js'
+import { checkMax } from './utils/check-max.js'
+import { western } from './utils/scale.js'
+import { resolveOptions } from './utils/resolve-options.js'
 
 // ============================================================================
 // Vocabulary (module-level constants)
@@ -71,17 +73,28 @@ const SCALE_FORMS = [
   ['kvintilijonas', 'kvintilijonai', 'kvintilijonų'],
   ['sikstilijonas', 'sikstilijonai', 'sikstilijonų'],
   ['septilijonas', 'septilijonai', 'septilijonų'],
-  ['oktilijonas', 'oktilijonai', 'oktilijonų']
+  ['oktilijonas', 'oktilijonai', 'oktilijonų'],
 ]
 
+// Supported magnitude ceilings (checked at the public entry points). Both
+// tables are indexed [scaleIndex - 1] (units separate), so the cardinal/
+// currency ceiling is 10^((SCALE_FORMS.length + 1) * 3) = 10^30, and the
+// shorter ORDINAL_SCALES bounds ordinals at 10^((ORDINAL_SCALES.length + 1) *
+// 3) = 10^15.
+export const cardinalMax = western(SCALE_FORMS.length)
+export const ordinalMax = western(ORDINAL_SCALES.length)
+export const currencyMax = western(SCALE_FORMS.length)
+
 // ============================================================================
 // Segment Building
 // ============================================================================
 
 /**
  * Builds segment word for 0-999 (masculine form).
+ * @param {number} n - Segment value (0-999)
+ * @returns {string} Segment words
  */
-function buildSegment (n) {
+function buildSegment(n) {
   if (n === 0) return ''
 
   const ones = n % 10
@@ -104,7 +117,8 @@ function buildSegment (n) {
   // Teens or ones
   if (tens === 1) {
     parts.push(TEENS[ones])
-  } else if (ones > 0) {
+  }
+  else if (ones > 0) {
     parts.push(ONES_MASC[ones])
   }
 
@@ -113,8 +127,10 @@ function buildSegment (n) {
 
 /**
  * Builds segment word for 0-999 (feminine form - only differs in ones).
+ * @param {number} n - Segment value (0-999)
+ * @returns {string} Segment words
  */
-function buildSegmentFeminine (n) {
+function buildSegmentFeminine(n) {
   if (n === 0) return ''
 
   const ones = n % 10
@@ -137,7 +153,8 @@ function buildSegmentFeminine (n) {
   // Teens or ones - feminine for ones only
   if (tens === 1) {
     parts.push(TEENS[ones])
-  } else if (ones > 0) {
+  }
+  else if (ones > 0) {
     parts.push(ONES_FEM[ones])
   }
 
@@ -153,12 +170,11 @@ function buildSegmentFeminine (n) {
  * - Singular: ends in 1 (except 11)
  * - Plural: ends in 2-9 (except 12-19)
  * - Genitive: 0, 10-19, or ends in 0
- *
  * @param {number} n - The segment value
  * @param {string[]} forms - [singular, plural, genitive]
  * @returns {string} The appropriate form
  */
-function pluralize (n, forms) {
+function pluralize(n, forms) {
   if (n === 0) return forms[2]
 
   const lastDigit = n % 10
@@ -189,12 +205,11 @@ function pluralize (n, forms) {
 
 /**
  * Converts a non-negative integer to Lithuanian words.
- *
  * @param {bigint} n - Non-negative integer to convert
- * @param {Object} options - Conversion options
+ * @param {string} gender - Gender for numbers < 1000 ('masculine' or 'feminine')
  * @returns {string} Lithuanian words
  */
-function integerToWords (n, gender) {
+function integerToWords(n, gender) {
   if (n === 0n) return ZERO
 
   // Fast path: numbers < 1000
@@ -206,17 +221,15 @@ function integerToWords (n, gender) {
   // For numbers >= 1000, feminine only applies to final segment if < 1000
   // But the fixture shows feminine NOT applying for n >= 1000
   // So we use masculine for all segments when n >= 1000
-  return buildLargeNumberWords(n, gender)
+  return buildLargeNumberWords(n)
 }
 
 /**
  * Builds words for numbers >= 1000.
- *
  * @param {bigint} n - Number >= 1000
- * @param {Object} options - Conversion options
  * @returns {string} Lithuanian words
  */
-function buildLargeNumberWords (n, gender) {
+function buildLargeNumberWords(n) {
   const numStr = n.toString()
   const len = numStr.length
 
@@ -248,7 +261,8 @@ function buildLargeNumberWords (n, gender) {
       if (scaleIndex === 0) {
         // Units segment - use masculine (feminine doesn't apply when n >= 1000)
         parts.push(segmentWord)
-      } else {
+      }
+      else {
         // Segment with scale word
         const scaleForms = SCALE_FORMS[scaleIndex - 1]
         const scaleWord = pluralize(segment, scaleForms)
@@ -264,12 +278,11 @@ function buildLargeNumberWords (n, gender) {
 
 /**
  * Converts decimal digits to Lithuanian words.
- *
  * @param {string} decimalPart - Decimal digits (without the point)
- * @param {Object} options - Conversion options
+ * @param {string} gender - Gender for numbers < 1000 ('masculine' or 'feminine')
  * @returns {string} Lithuanian words for decimal part
  */
-function decimalPartToWords (decimalPart, gender) {
+function decimalPartToWords(decimalPart, gender) {
   let result = ''
 
   // Handle leading zeros
@@ -290,27 +303,37 @@ function decimalPartToWords (decimalPart, gender) {
   return result
 }
 
+/**
+ * @typedef {object} CardinalOptions
+ * @property {('masculine'|'feminine')} [gender] - Gender for numbers < 1000
+ */
+
+/** @type {Required<CardinalOptions>} */
+export const cardinalDefaults = { gender: 'masculine' }
+
+/** @type {{ gender: ReadonlyArray<Required<CardinalOptions>['gender']> }} */
+export const cardinalValues = { gender: ['masculine', 'feminine'] }
+
 /**
  * Converts a numeric value to Lithuanian words.
- *
  * @param {number | string | bigint} value - The numeric value to convert
- * @param {Object} [options] - Conversion options
- * @param {string} [options.gender='masculine'] - Gender for numbers < 1000
+ * @param {CardinalOptions} [options] - Conversion options
  * @returns {string} The number in Lithuanian words
  * @throws {TypeError} If value is not a valid numeric type
  * @throws {Error} If value is not a valid number format
- *
  * @example
  * toCardinal(42)                          // 'keturiasdešimt du'
  * toCardinal(1, { gender: 'feminine' })   // 'viena'
  * toCardinal(1000000)                     // 'vienas milijonas'
  */
-function toCardinal (value, options) {
-  options = validateOptions(options)
+function toCardinal(value, options) {
   const { isNegative, integerPart, decimalPart } = parseCardinalValue(value)
+  // Both the integer part and the decimal's significant digits are spelled via
+  // the scale builder, so both must clear the ceiling.
+  checkMax(integerPart, cardinalMax, decimalPart)
 
   // Apply option defaults
-  const { gender = 'masculine' } = options
+  const { gender } = resolveOptions(options, cardinalDefaults, cardinalValues)
 
   let result = ''
 
@@ -333,11 +356,10 @@ function toCardinal (value, options) {
 
 /**
  * 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) {
+function buildOrdinalTensOnes(n) {
   if (n === 0) return ''
 
   const onesDigit = n % 10
@@ -360,11 +382,10 @@ function buildOrdinalTensOnes (n) {
 
 /**
  * Converts a positive integer to Lithuanian ordinal words (masculine nominative).
- *
  * @param {bigint} n - Positive integer to convert
  * @returns {string} Ordinal Lithuanian words
  */
-function integerToOrdinal (n) {
+function integerToOrdinal(n) {
   if (n < 100n) {
     return buildOrdinalTensOnes(Number(n))
   }
@@ -406,11 +427,10 @@ function integerToOrdinal (n) {
 
 /**
  * Builds ordinal words for numbers >= 1,000,000.
- *
  * @param {bigint} n - Number >= 1,000,000
  * @returns {string} Ordinal Lithuanian words
  */
-function buildLargeOrdinal (n) {
+function buildLargeOrdinal(n) {
   const numStr = n.toString()
   const len = numStr.length
 
@@ -445,20 +465,24 @@ function buildLargeOrdinal (n) {
       if (scaleIndex === 0) {
         if (isLastNonZero) {
           parts.push(integerToOrdinal(BigInt(segment)))
-        } else {
+        }
+        else {
           parts.push(buildSegment(segment))
         }
-      } else {
+      }
+      else {
         if (isLastNonZero) {
           if (segment === 1) {
             parts.push(ORDINAL_SCALES[scaleIndex - 1])
-          } else {
+          }
+          else {
             // For 2+, include cardinal scale word before ordinal
             const scaleForms = SCALE_FORMS[scaleIndex - 1]
             const cardinalScaleWord = pluralize(segment, scaleForms)
             parts.push(buildSegment(segment) + ' ' + cardinalScaleWord + ' ' + ORDINAL_SCALES[scaleIndex - 1])
           }
-        } else {
+        }
+        else {
           const scaleForms = SCALE_FORMS[scaleIndex - 1]
           const scaleWord = pluralize(segment, scaleForms)
           parts.push(buildSegment(segment) + ' ' + scaleWord)
@@ -474,12 +498,10 @@ function buildLargeOrdinal (n) {
 
 /**
  * Converts a numeric value to Lithuanian 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)    // 'pirmas'
  * toOrdinal(2)    // 'antras'
@@ -487,8 +509,9 @@ function buildLargeOrdinal (n) {
  * toOrdinal(100)  // 'šimtasis'
  * toOrdinal(1000) // 'tūkstantasis'
  */
-function toOrdinal (value) {
+function toOrdinal(value) {
   const integerPart = parseOrdinalValue(value)
+  checkMax(integerPart, ordinalMax)
   return integerToOrdinal(integerPart)
 }
 
@@ -498,20 +521,19 @@ function toOrdinal (value) {
 
 /**
  * Converts a numeric value to Lithuanian currency words (Euro).
- *
  * @param {number | string | bigint} value - The currency amount to convert
  * @returns {string} The amount in Lithuanian 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)     // 'keturiasdešimt du eurai'
  * toCurrency(1)      // 'vienas euras'
  * toCurrency(1.50)   // 'vienas euras penkiasdešimt centų'
  * toCurrency(-5)     // 'minus penki eurai'
  */
-function toCurrency (value) {
+function toCurrency(value) {
   const { isNegative, dollars: euros, cents } = parseCurrencyValue(value)
+  checkMax(euros, currencyMax)
 
   let result = ''
   if (isNegative) {

package/src/lv-LV.d.ts

@@ -1,29 +1,41 @@
+export const cardinalMax: bigint;
+export const ordinalMax: bigint;
+export const currencyMax: bigint;
+/**
+ * @typedef {object} CardinalOptions
+ * @property {('masculine'|'feminine')} [gender] - Gender for numbers < 1000
+ */
+/** @type {Required<CardinalOptions>} */
+export const cardinalDefaults: Required<CardinalOptions>;
+/** @type {{ gender: ReadonlyArray<Required<CardinalOptions>['gender']> }} */
+export const cardinalValues: {
+    gender: ReadonlyArray<Required<CardinalOptions>["gender"]>;
+};
+export type CardinalOptions = {
+    /**
+     * - Gender for numbers < 1000
+     */
+    gender?: "feminine" | "masculine" | undefined;
+};
 /**
  * Converts a numeric value to Latvian words.
- *
  * @param {number | string | bigint} value - The numeric value to convert
- * @param {Object} [options] - Conversion options
- * @param {string} [options.gender='masculine'] - Gender for numbers < 1000
+ * @param {CardinalOptions} [options] - Conversion options
  * @returns {string} The number in Latvian words
  * @throws {TypeError} If value is not a valid numeric type
  * @throws {Error} If value is not a valid number format
- *
  * @example
  * toCardinal(42)                          // 'četrdesmit divi'
  * toCardinal(1, { gender: 'feminine' })   // 'viena'
  * toCardinal(1000)                        // 'tūkstotis'
  */
-export function toCardinal(value: number | string | bigint, options?: {
-    gender?: string | undefined;
-}): string;
+export function toCardinal(value: number | string | bigint, options?: CardinalOptions): string;
 /**
  * Converts a numeric value to Latvian 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)    // 'pirmais'
  * toOrdinal(2)    // 'otrais'
@@ -34,12 +46,10 @@ export function toCardinal(value: number | string | bigint, options?: {
 export function toOrdinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Latvian currency words (Euro).
- *
  * @param {number | string | bigint} value - The currency amount to convert
  * @returns {string} The amount in Latvian 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)     // 'četrdesmit divi eiro'
  * toCurrency(1)      // 'viens eiro'