n2words 4.0.0 → 5.1.0

package/src/ja-JP.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)
@@ -40,9 +42,16 @@ const SCALES = [
   '阿僧祇', // 10^56 (asōgi)
   '那由他', // 10^60 (nayuta)
   '不可思議', // 10^64 (fukashigi)
-  '無量大数' // 10^68 (muryōtaisū)
+  '無量大数', // 10^68 (muryōtaisū)
 ]
 
+// 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 (prefix) 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)
+
 const ZERO = '零'
 const NEGATIVE = 'マイナス'
 const DECIMAL_SEP = '点'
@@ -76,8 +85,10 @@ const THOUSAND = '千'
 /**
  * Builds segment word for 0-9999 with 一 omission rules.
  * - Omit 一 before 十, 百, 千
+ * @param {number} n - Segment value (0-9999)
+ * @returns {string} Japanese kanji words for the segment
  */
-function buildSegment (n) {
+function buildSegment(n) {
   if (n === 0) return ''
 
   const ones = n % 10
@@ -91,7 +102,8 @@ function buildSegment (n) {
   if (thousands > 0) {
     if (thousands === 1) {
       result += THOUSAND
-    } else {
+    }
+    else {
       result += ONES[thousands] + THOUSAND
     }
   }
@@ -100,7 +112,8 @@ function buildSegment (n) {
   if (hundreds > 0) {
     if (hundreds === 1) {
       result += HUNDRED
-    } else {
+    }
+    else {
       result += ONES[hundreds] + HUNDRED
     }
   }
@@ -109,7 +122,8 @@ function buildSegment (n) {
   if (tens > 0) {
     if (tens === 1) {
       result += TEN
-    } else {
+    }
+    else {
       result += ONES[tens] + TEN
     }
   }
@@ -128,11 +142,10 @@ function buildSegment (n) {
 
 /**
  * Converts a non-negative integer to Japanese words.
- *
  * @param {bigint} n - Non-negative integer to convert
  * @returns {string} Japanese kanji words
  */
-function integerToWords (n) {
+function integerToWords(n) {
   if (n === 0n) return ZERO
 
   // Fast path: numbers < 10000
@@ -149,7 +162,8 @@ function integerToWords (n) {
     let result
     if (man === 1) {
       result = '一' + SCALES[0] // 一万
-    } else {
+    }
+    else {
       result = buildSegment(man) + SCALES[0]
     }
 
@@ -167,11 +181,10 @@ function integerToWords (n) {
 /**
  * Builds words for numbers >= 100,000,000.
  * Uses BigInt modulo for 4-digit (myriad) segment extraction.
- *
  * @param {bigint} n - Number >= 100,000,000
  * @returns {string} Japanese kanji words
  */
-function buildLargeNumberWords (n) {
+function buildLargeNumberWords(n) {
   // Extract segments using BigInt modulo (faster than string slicing)
   // Segments stored least-significant first (index 0 = units, 1 = 万, etc.)
   const segments = []
@@ -192,10 +205,12 @@ function buildLargeNumberWords (n) {
       // For scales >= 万, we need 一 before scale word when segment is 1
       if (segment === 1) {
         result += '一' + SCALES[i - 1]
-      } else {
+      }
+      else {
         result += buildSegment(segment) + SCALES[i - 1]
       }
-    } else {
+    }
+    else {
       // Units segment (no scale word)
       result += buildSegment(segment)
     }
@@ -206,18 +221,18 @@ function buildLargeNumberWords (n) {
 
 /**
  * Converts decimal digits to Japanese words (digit by digit).
- *
  * @param {string} decimalPart - Decimal digits (without the point)
  * @returns {string} Japanese kanji words for decimal part
  */
-function decimalPartToWords (decimalPart) {
+function decimalPartToWords(decimalPart) {
   let result = ''
 
   for (let i = 0; i < decimalPart.length; i++) {
     const digit = parseInt(decimalPart[i], 10)
     if (digit === 0) {
       result += ZERO
-    } else {
+    }
+    else {
       result += ONES[digit]
     }
   }
@@ -230,19 +245,19 @@ function decimalPartToWords (decimalPart) {
  *
  * 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 Japanese kanji words
  * @throws {TypeError} If value is not a valid numeric type
  * @throws {Error} If value is not a valid number format
- *
  * @example
  * toCardinal(42)           // '四十二'
  * toCardinal(10000)        // '一万'
  * toCardinal(100000000)    // '一億'
  */
-function toCardinal (value) {
+function toCardinal(value) {
   const { isNegative, integerPart, decimalPart } = parseCardinalValue(value)
+  // The fraction is spelled digit by digit, so only the integer part has a ceiling.
+  checkMax(integerPart, cardinalMax)
 
   let result = ''
 
@@ -267,29 +282,28 @@ function toCardinal (value) {
  * Converts a positive integer to Japanese ordinal words.
  *
  * Japanese ordinals: 第 prefix + cardinal number.
- *
  * @param {bigint} n - Positive integer to convert
  * @returns {string} Japanese ordinal words
  */
-function integerToOrdinal (n) {
+function integerToOrdinal(n) {
   return ORDINAL_PREFIX + integerToWords(n)
 }
 
 /**
  * Converts a numeric value to Japanese 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(10)   // '第十'
  * toOrdinal(100)  // '第百'
  */
-function toOrdinal (value) {
+function toOrdinal(value) {
   const integerPart = parseOrdinalValue(value)
+  // Ordinals prefix the cardinal speller, so they share its ceiling.
+  checkMax(integerPart, ordinalMax)
   return integerToOrdinal(integerPart)
 }
 
@@ -302,20 +316,19 @@ function toOrdinal (value) {
  *
  * Note: Sen (銭, 1/100 yen) is included for completeness but is rarely used
  * in modern Japan. Most transactions are in whole yen.
- *
  * @param {number | string | bigint} value - The currency amount to convert
  * @returns {string} The amount in Japanese 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(1)      // '一円'
  * toCurrency(0.50)   // '五十銭'
  * toCurrency(42.50)  // '四十二円五十銭'
  */
-function toCurrency (value) {
+function toCurrency(value) {
   const { isNegative, dollars: yen, cents: sen } = parseCurrencyValue(value)
+  checkMax(yen, currencyMax)
 
   // Build result
   let result = ''

package/src/ka-GE.d.ts

@@ -1,14 +1,15 @@
+export const cardinalMax: bigint;
+export const ordinalMax: bigint;
+export const currencyMax: bigint;
 /**
  * Converts a numeric value to Georgian 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 Georgian 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(100)          // 'ასი'
@@ -17,12 +18,10 @@
 export function toCardinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Georgian ordinal words.
- *
  * @param {number | string | bigint} value - The numeric value to convert
  * @returns {string} The ordinal in Georgian words
  * @throws {TypeError} If value is not a valid numeric type
  * @throws {Error} If value is not a positive integer
- *
  * @example
  * toOrdinal(1)   // 'პირველი'
  * toOrdinal(10)  // 'მეათე'
@@ -31,12 +30,10 @@ export function toCardinal(value: number | string | bigint): string;
 export function toOrdinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Georgian Lari currency words.
- *
  * @param {number | string | bigint} value - The numeric value to convert
  * @returns {string} The currency in Georgian words
  * @throws {TypeError} If value is not a valid numeric type
  * @throws {Error} If value is not a valid number format
- *
  * @example
  * toCurrency(1)     // 'ერთი ლარი'
  * toCurrency(2.50)  // 'ორი ლარი ორმოცდაათი თეთრი'

package/src/ka-GE.js

@@ -15,6 +15,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 { western } from './utils/scale.js'
 
 // ============================================================================
 // Vocabulary (module-level constants)
@@ -41,6 +43,13 @@ const THOUSAND_STEM = 'ათას' // Without final vowel
 // Scale words (short scale) - indexed by segment position
 const SCALES = ['', '', 'მილიონი', 'მილიარდი', 'ტრილიონი', 'კვადრილიონი', 'კვინტილიონი', 'სექსტილიონი']
 
+// 3-digit grouping; the table tops out at sextillion. Past it the builder clamps
+// to the last scale word (`SCALES[scaleIndex] || SCALES[SCALES.length - 1]`),
+// silently collapsing the magnitude — so cap there.
+export const cardinalMax = western(SCALES.length - 1)
+export const ordinalMax = western(SCALES.length - 1)
+export const currencyMax = western(SCALES.length - 1)
+
 const ZERO = 'ნული'
 const NEGATIVE = 'მინუს'
 const DECIMAL_SEP = 'მთელი'
@@ -64,7 +73,7 @@ const TETRI = 'თეთრი'
  * @param {number} n - Number 0-99
  * @returns {string} Georgian word
  */
-function buildTens (n) {
+function buildTens(n) {
   if (n < 10) return ONES[n]
   if (n < 20) return TEENS[n - 10]
 
@@ -89,7 +98,7 @@ function buildTens (n) {
  * @param {number} n - Number 0-999
  * @returns {{full: string, stem: string}} Georgian words
  */
-function buildSegment (n) {
+function buildSegment(n) {
   if (n === 0) return { full: '', stem: '' }
   if (n < 100) {
     const word = buildTens(n)
@@ -106,7 +115,8 @@ function buildSegment (n) {
   let hundredWord
   if (hundreds === 1) {
     hundredWord = remainder > 0 ? HUNDRED_STEM : HUNDRED
-  } else {
+  }
+  else {
     hundredWord = HUNDRED_PREFIXES[hundreds] + (remainder > 0 ? HUNDRED_STEM : HUNDRED)
   }
 
@@ -129,11 +139,10 @@ function buildSegment (n) {
 
 /**
  * Converts a non-negative integer to Georgian words.
- *
  * @param {bigint} n - Non-negative integer to convert
  * @returns {string} Georgian words
  */
-function integerToWords (n) {
+function integerToWords(n) {
   if (n === 0n) return ZERO
 
   // Fast path: numbers < 1000
@@ -151,7 +160,8 @@ function integerToWords (n) {
     if (thousands === 1) {
       // "ათასი" not "ერთი ათასი"
       result = remainder > 0 ? THOUSAND_STEM : THOUSAND
-    } else {
+    }
+    else {
       // Use stem form before ათასი
       const { stem: thousandsPart } = buildSegment(thousands)
       result = thousandsPart + ' ' + (remainder > 0 ? THOUSAND_STEM : THOUSAND)
@@ -171,11 +181,10 @@ function integerToWords (n) {
 
 /**
  * Builds words for numbers >= 1,000,000.
- *
  * @param {bigint} n - Number >= 1,000,000
  * @returns {string} Georgian words
  */
-function buildLargeNumberWords (n) {
+function buildLargeNumberWords(n) {
   const numStr = n.toString()
   const len = numStr.length
 
@@ -206,23 +215,27 @@ function buildLargeNumberWords (n) {
         // Units (no scale)
         const { full } = buildSegment(segment)
         parts.push(full)
-      } else if (scaleIndex === 1) {
+      }
+      else if (scaleIndex === 1) {
         // Thousands - check if there's a remainder
         const hasRemainder = segments.slice(i + 1).some(s => s !== 0)
         const thousandWord = hasRemainder ? THOUSAND_STEM : THOUSAND
 
         if (segment === 1) {
           parts.push(thousandWord)
-        } else {
+        }
+        else {
           const { stem } = buildSegment(segment)
           parts.push(stem + ' ' + thousandWord)
         }
-      } else {
+      }
+      else {
         // Million and above
         const scaleWord = SCALES[scaleIndex] || SCALES[SCALES.length - 1]
         if (segment === 1) {
           parts.push('ერთი ' + scaleWord)
-        } else {
+        }
+        else {
           const { full } = buildSegment(segment)
           parts.push(full + ' ' + scaleWord)
         }
@@ -237,11 +250,10 @@ function buildLargeNumberWords (n) {
 
 /**
  * Converts decimal digits to Georgian words.
- *
  * @param {string} decimalPart - Decimal digits (without the point)
  * @returns {string} Georgian words for decimal part
  */
-function decimalPartToWords (decimalPart) {
+function decimalPartToWords(decimalPart) {
   let result = ''
 
   // Handle leading zeros
@@ -267,19 +279,20 @@ function decimalPartToWords (decimalPart) {
  *
  * 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 Georgian 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(100)          // 'ასი'
  * toCardinal(1000)         // 'ათასი'
  */
-function toCardinal (value) {
+function toCardinal(value) {
   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)
 
   let result = ''
 
@@ -305,11 +318,10 @@ function toCardinal (value) {
  * Georgian ordinals are formed by:
  * - 1-9: special forms (პირველი, მეორე, მესამე, etc.)
  * - 10+: მე- prefix + cardinal + -ე suffix
- *
  * @param {bigint} n - Non-negative integer to convert
  * @returns {string} Georgian ordinal words
  */
-function integerToOrdinal (n) {
+function integerToOrdinal(n) {
   if (n === 0n) return ''
   if (n <= 9n) return ORDINAL_ONES[Number(n)]
 
@@ -321,7 +333,8 @@ function integerToOrdinal (n) {
   let stem
   if (lastChar === 'ი' || lastChar === 'ა') {
     stem = cardinal.slice(0, -1)
-  } else {
+  }
+  else {
     stem = cardinal
   }
 
@@ -330,19 +343,19 @@ function integerToOrdinal (n) {
 
 /**
  * Converts a numeric value to Georgian ordinal words.
- *
  * @param {number | string | bigint} value - The numeric value to convert
  * @returns {string} The ordinal in Georgian words
  * @throws {TypeError} If value is not a valid numeric type
  * @throws {Error} If value is not a positive integer
- *
  * @example
  * toOrdinal(1)   // 'პირველი'
  * toOrdinal(10)  // 'მეათე'
  * toOrdinal(21)  // 'მეოცდაერთე'
  */
-function toOrdinal (value) {
+function toOrdinal(value) {
   const n = parseOrdinalValue(value)
+  // Ordinals build on the cardinal speller, so they share its ceiling.
+  checkMax(n, ordinalMax)
   return integerToOrdinal(n)
 }
 
@@ -352,18 +365,17 @@ function toOrdinal (value) {
 
 /**
  * Converts a numeric value to Georgian Lari currency words.
- *
  * @param {number | string | bigint} value - The numeric value to convert
  * @returns {string} The currency in Georgian words
  * @throws {TypeError} If value is not a valid numeric type
  * @throws {Error} If value is not a valid number format
- *
  * @example
  * toCurrency(1)     // 'ერთი ლარი'
  * toCurrency(2.50)  // 'ორი ლარი ორმოცდაათი თეთრი'
  */
-function toCurrency (value) {
+function toCurrency(value) {
   const { isNegative, dollars, cents } = parseCurrencyValue(value)
+  checkMax(dollars, currencyMax)
 
   const parts = []
 

package/src/kn-IN.d.ts

@@ -1,18 +1,18 @@
+export const cardinalMax: bigint;
+export const ordinalMax: bigint;
+export const currencyMax: bigint;
 /**
  * Converts a numeric value to Kannada words.
- *
  * @param {number | string | bigint} value - The numeric value to convert
  * @returns {string} The number in Kannada words
  */
 export function toCardinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Kannada 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)    // 'ಎರಡನೇ'
@@ -21,12 +21,10 @@ export function toCardinal(value: number | string | bigint): string;
 export function toOrdinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Kannada currency words (Indian Rupee).
- *
  * @param {number | string | bigint} value - The currency amount to convert
  * @returns {string} The amount in Kannada 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.50)  // 'ನಲವತ್ತೆರಡು ರೂಪಾಯಿಗಳು ಐವತ್ತು ಪೈಸೆಗಳು'
  * toCurrency(1)      // 'ಒಂದು ರೂಪಾಯಿ'

package/src/kn-IN.js

@@ -14,6 +14,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 { indian } from './utils/scale.js'
 
 // ============================================================================
 // Vocabulary
@@ -56,20 +58,29 @@ const BELOW_HUNDRED = [
   'ಅರವತ್ತು', 'ಅರವತ್ತೊಂದು', 'ಅರವತ್ತೆರಡು', 'ಅರವತ್ತಮೂರು', 'ಅರವತ್ತನಾಲ್ಕು', 'ಅರವತ್ತೈದು', 'ಅರವತ್ತಾರು', 'ಅರವತ್ತೇಳು', 'ಅರವತ್ತೆಂಟು', 'ಅರವತ್ತೊಂಬತ್ತು',
   'ಎಪ್ಪತ್ತು', 'ಎಪ್ಪತ್ತೊಂದು', 'ಎಪ್ಪತ್ತೆರಡು', 'ಎಪ್ಪತ್ತಮೂರು', 'ಎಪ್ಪತ್ತನಾಲ್ಕು', 'ಎಪ್ಪತ್ತೈದು', 'ಎಪ್ಪತ್ತಾರು', 'ಎಪ್ಪತ್ತೇಳು', 'ಎಪ್ಪತ್ತೆಂಟು', 'ಎಪ್ಪತ್ತೊಂಬತ್ತು',
   'ಎಂಬತ್ತು', 'ಎಂಬತ್ತೊಂದು', 'ಎಂಬತ್ತೆರಡು', 'ಎಂಬತ್ತಮೂರು', 'ಎಂಬತ್ತನಾಲ್ಕು', 'ಎಂಬತ್ತೈದು', 'ಎಂಬತ್ತಾರು', 'ಎಂಬತ್ತೇಳು', 'ಎಂಬತ್ತೆಂಟು', 'ಎಂಬತ್ತೊಂಬತ್ತು',
-  'ತೊಂಬತ್ತು', 'ತೊಂಬತ್ತೊಂದು', 'ತೊಂಬತ್ತೆರಡು', 'ತೊಂಬತ್ತಮೂರು', 'ತೊಂಬತ್ತನಾಲ್ಕು', 'ತೊಂಬತ್ತೈದು', 'ತೊಂಬತ್ತಾರು', 'ತೊಂಬತ್ತೇಳು', 'ತೊಂಬತ್ತೆಂಟು', 'ತೊಂಬತ್ತೊಂಬತ್ತು'
+  'ತೊಂಬತ್ತು', 'ತೊಂಬತ್ತೊಂದು', 'ತೊಂಬತ್ತೆರಡು', 'ತೊಂಬತ್ತಮೂರು', 'ತೊಂಬತ್ತನಾಲ್ಕು', 'ತೊಂಬತ್ತೈದು', 'ತೊಂಬತ್ತಾರು', 'ತೊಂಬತ್ತೇಳು', 'ತೊಂಬತ್ತೆಂಟು', 'ತೊಂಬತ್ತೊಂಬತ್ತು',
 ]
 
 // Scale words: index 0 = units (empty), 1 = thousand, 2 = lakh, 3 = crore, etc.
 const SCALE_WORDS = ['', 'ಸಾವಿರ', 'ಲಕ್ಷ', 'ಕೋಟಿ', 'ಅಬ್ಜ', 'ಖರ್ವ', 'ನೀಲ', 'ಪದ್ಮ', 'ಶಂಖ']
 
+// 3-2-2 Indian grouping: a 3-digit base segment, then 2 digits per scale word
+// (SCALE_WORDS[0] = '' is the units slot). Past the table the scale word is
+// dropped, which collapses the magnitude — so cap there.
+export const cardinalMax = indian(SCALE_WORDS.length)
+export const ordinalMax = indian(SCALE_WORDS.length)
+export const currencyMax = indian(SCALE_WORDS.length)
+
 // ============================================================================
 // Segment Building
 // ============================================================================
 
 /**
  * Builds words for a 0-999 segment.
+ * @param {number} n - Segment value (0-999)
+ * @returns {string} Kannada words for the segment
  */
-function buildSegment (n) {
+function buildSegment(n) {
   if (n === 0) return ''
   if (n < 100) return BELOW_HUNDRED[n]
 
@@ -91,11 +102,10 @@ function buildSegment (n) {
  *
  * Uses BigInt modulo for segment extraction (faster than string slicing).
  * South Asian 3-2-2 grouping: first 3 digits, then groups of 2.
- *
  * @param {bigint} n - Non-negative integer to convert
  * @returns {string} Kannada words
  */
-function integerToWords (n) {
+function integerToWords(n) {
   if (n === 0n) return ZERO
 
   // Fast path: numbers < 1000 (direct lookup)
@@ -121,7 +131,8 @@ function integerToWords (n) {
 
     if (i === 0) {
       words.push(buildSegment(segment))
-    } else {
+    }
+    else {
       words.push(BELOW_HUNDRED[segment])
     }
 
@@ -133,7 +144,12 @@ function integerToWords (n) {
   return words.join(' ')
 }
 
-function decimalPartToWords (decimalPart) {
+/**
+ * Reads a decimal-fraction digit string per-digit in Kannada.
+ * @param {string} decimalPart - Digits after the decimal separator
+ * @returns {string} Per-digit Kannada words
+ */
+function decimalPartToWords(decimalPart) {
   // Per-digit decimal reading
   const digits = []
   for (const char of decimalPart) {
@@ -145,12 +161,13 @@ function decimalPartToWords (decimalPart) {
 
 /**
  * Converts a numeric value to Kannada words.
- *
  * @param {number | string | bigint} value - The numeric value to convert
  * @returns {string} The number in Kannada words
  */
-function toCardinal (value) {
+function toCardinal(value) {
   const { isNegative, integerPart, decimalPart } = parseCardinalValue(value)
+  // The fraction is spelled digit by digit, so only the integer part has a ceiling.
+  checkMax(integerPart, cardinalMax)
 
   let result = ''
 
@@ -175,11 +192,10 @@ function toCardinal (value) {
  * Converts a positive integer to Kannada ordinal words.
  *
  * Kannada ordinals: First 6 are special, then add -ನೇ suffix.
- *
  * @param {bigint} n - Positive integer to convert
  * @returns {string} Kannada ordinal words
  */
-function integerToOrdinal (n) {
+function integerToOrdinal(n) {
   // Special ordinals for 1-6
   if (n >= 1n && n <= 6n) {
     return ORDINAL_SPECIAL[Number(n)]
@@ -192,19 +208,19 @@ function integerToOrdinal (n) {
 
 /**
  * Converts a numeric value to Kannada 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)
+  // Ordinals build on the cardinal speller, so they share its ceiling.
+  checkMax(integerPart, ordinalMax)
   return integerToOrdinal(integerPart)
 }
 
@@ -214,19 +230,18 @@ function toOrdinal (value) {
 
 /**
  * Converts a numeric value to Kannada currency words (Indian Rupee).
- *
  * @param {number | string | bigint} value - The currency amount to convert
  * @returns {string} The amount in Kannada 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.50)  // 'ನಲವತ್ತೆರಡು ರೂಪಾಯಿಗಳು ಐವತ್ತು ಪೈಸೆಗಳು'
  * toCurrency(1)      // 'ಒಂದು ರೂಪಾಯಿ'
  * toCurrency(0.01)   // 'ಒಂದು ಪೈಸೆ'
  */
-function toCurrency (value) {
+function toCurrency(value) {
   const { isNegative, dollars: rupees, cents: paise } = parseCurrencyValue(value)
+  checkMax(rupees, currencyMax)
 
   // Build result
   let result = ''