n2words 5.0.0 → 5.1.1

package/src/ar-SA.d.ts

@@ -1,46 +1,72 @@
+export const cardinalMax: bigint;
+export const ordinalMax: bigint;
+export const currencyMax: bigint;
+/**
+ * @typedef {object} CardinalOptions
+ * @property {('masculine'|'feminine')} [gender] - Grammatical gender
+ * @property {string} [negativeWord] - Custom word for negative numbers
+ */
+/** @type {Required<CardinalOptions>} */
+export const cardinalDefaults: Required<CardinalOptions>;
+/** @type {{ gender: ReadonlyArray<Required<CardinalOptions>['gender']> }} */
+export const cardinalValues: {
+    gender: ReadonlyArray<Required<CardinalOptions>["gender"]>;
+};
+/**
+ * @typedef {object} OrdinalOptions
+ * @property {('masculine'|'feminine')} [gender] - Grammatical gender
+ */
+/** @type {Required<OrdinalOptions>} */
+export const ordinalDefaults: Required<OrdinalOptions>;
+/** @type {{ gender: ReadonlyArray<Required<OrdinalOptions>['gender']> }} */
+export const ordinalValues: {
+    gender: ReadonlyArray<Required<OrdinalOptions>["gender"]>;
+};
+export type CardinalOptions = {
+    /**
+     * - Grammatical gender
+     */
+    gender?: "feminine" | "masculine" | undefined;
+    /**
+     * - Custom word for negative numbers
+     */
+    negativeWord?: string | undefined;
+};
+export type OrdinalOptions = {
+    /**
+     * - Grammatical gender
+     */
+    gender?: "feminine" | "masculine" | undefined;
+};
 /**
  * Converts a numeric value to Arabic words.
- *
  * @param {number | string | bigint} value - The numeric value to convert
- * @param {Object} [options] - Optional configuration
- * @param {('masculine'|'feminine')} [options.gender='masculine'] - Grammatical gender
- * @param {string} [options.negativeWord] - Custom word for negative numbers
+ * @param {CardinalOptions} [options] - Optional configuration
  * @returns {string} The number in Arabic words
- *
  * @example
  * toCardinal(1)                        // 'واحد'
  * toCardinal(1, {gender: 'feminine'})  // 'واحدة'
  */
-export function toCardinal(value: number | string | bigint, options?: {
-    gender?: "masculine" | "feminine" | undefined;
-    negativeWord?: string | undefined;
-}): string;
+export function toCardinal(value: number | string | bigint, options?: CardinalOptions): string;
 /**
  * Converts a numeric value to Arabic ordinal words.
- *
  * @param {number | string | bigint} value - The numeric value to convert (positive integer)
- * @param {Object} [options] - Optional configuration
- * @param {('masculine'|'feminine')} [options.gender='masculine'] - Grammatical gender
+ * @param {OrdinalOptions} [options] - Optional configuration
  * @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(1, {gender: 'feminine'})  // 'الأولى'
  * toOrdinal(3)                        // 'الثالث'
  */
-export function toOrdinal(value: number | string | bigint, options?: {
-    gender?: "masculine" | "feminine" | undefined;
-}): string;
+export function toOrdinal(value: number | string | bigint, options?: OrdinalOptions): string;
 /**
  * Converts a numeric value to Arabic currency words (Saudi Riyal).
- *
  * @param {number | string | bigint} value - The currency amount to convert
  * @returns {string} The amount in Arabic 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/ar-SA.js

@@ -15,7 +15,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
@@ -26,6 +28,11 @@ const HUNDREDS = ['', 'مائة', 'مئتان', 'ثلاثمائة', 'أربعم
 
 // Magnitude words with three forms: singular, appended (tanween), plural
 const SCALE_WORDS = ['مائة', 'ألف', 'مليون', 'مليار', 'تريليون', 'كوادريليون', 'كوينتليون', 'سكستيليون']
+
+// Supported magnitude ceiling (checked at the public entry points), derived from the scale table.
+export const cardinalMax = western(SCALE_WORDS.length - 1)
+export const ordinalMax = western(SCALE_WORDS.length - 1)
+export const currencyMax = western(SCALE_WORDS.length - 1)
 const SCALE_APPENDED = ['', 'ألفاً', 'مليوناً', 'ملياراً', 'تريليوناً', 'كوادريليوناً', 'كوينتليوناً', 'سكستيليوناً']
 const SCALE_PLURAL = ['', 'آلاف', 'ملايين', 'مليارات', 'تريليونات', 'كوادريليونات', 'كوينتليونات', 'سكستيليونات']
 
@@ -76,8 +83,13 @@ const HALALA_PLURAL_11 = 'هللة'
  * Convert a 3-digit group to words.
  * Returns a clean string with no leading/trailing spaces.
  * Arabic "و" (and) is attached to following word: "مائة وخمسة" not "مائة و خمسة"
+ * @param {number} groupNumber - The 3-digit group value (0-999)
+ * @param {number} groupLevel - The scale level of this group (0 = units, 1 = thousands, ...)
+ * @param {bigint} fullNumber - The full number being converted
+ * @param {string[]} ones - Gender-specific ones words (1-19)
+ * @returns {string} The group rendered as words
  */
-function segmentToWords (groupNumber, groupLevel, fullNumber, ones) {
+function segmentToWords(groupNumber, groupLevel, fullNumber, ones) {
   const tensValue = groupNumber % 100
   const hundredsDigit = Math.trunc(groupNumber / 100)
   let result = ''
@@ -86,7 +98,8 @@ function segmentToWords (groupNumber, groupLevel, fullNumber, ones) {
   if (hundredsDigit > 0) {
     if (tensValue === 0 && hundredsDigit === 2) {
       result = DUAL[0]
-    } else {
+    }
+    else {
       const hundredsWord = HUNDREDS[hundredsDigit]
       if (hundredsWord) {
         result = hundredsWord
@@ -105,15 +118,19 @@ function segmentToWords (groupNumber, groupLevel, fullNumber, ones) {
         const pow = Math.trunc(Math.log10(numValue))
         if (pow % 3 === 0 && fullNumber === BigInt(2 * Math.pow(10, pow))) {
           result += (groupNumber === 2 ? DUAL[groupLevel] : DUAL_APPENDED[groupLevel])
-        } else {
+        }
+        else {
           result += DUAL[groupLevel]
         }
-      } else if (tensValue === 1 && groupLevel > 0) {
+      }
+      else if (tensValue === 1 && groupLevel > 0) {
         result += SCALE_WORDS[groupLevel]
-      } else {
+      }
+      else {
         result += ones[tensValue - 1]
       }
-    } else {
+    }
+    else {
       const onesDigit = tensValue % 10
       const tensIndex = Math.trunc(tensValue / 10) - 2
 
@@ -127,7 +144,13 @@ function segmentToWords (groupNumber, groupLevel, fullNumber, ones) {
   return result
 }
 
-function integerToWords (n, gender) {
+/**
+ * Convert a non-negative integer to Arabic words.
+ * @param {bigint} n - The non-negative integer to convert
+ * @param {string} gender - 'masculine' or 'feminine'
+ * @returns {string} The number rendered as words
+ */
+function integerToWords(n, gender) {
   if (n === 0n) return ZERO
 
   const ones = gender === 'feminine' ? ONES_FEM : ONES_MASC
@@ -151,9 +174,11 @@ function integerToWords (n, gender) {
           const remainder = numberToProcess % 100
           if (remainder === 1) {
             groupText += ' ' + SCALE_WORDS[group]
-          } else if (numberToProcess >= 3 && numberToProcess <= 10) {
+          }
+          else if (numberToProcess >= 3 && numberToProcess <= 10) {
             groupText += ' ' + SCALE_PLURAL[group]
-          } else {
+          }
+          else {
             groupText += ' ' + (groups.length > 0 ? SCALE_APPENDED[group] : SCALE_WORDS[group])
           }
         }
@@ -177,7 +202,13 @@ function integerToWords (n, gender) {
   return result
 }
 
-function decimalPartToWords (decimalPart, gender) {
+/**
+ * Convert the fractional digits of a number to Arabic words.
+ * @param {string} decimalPart - The decimal digits (after the separator)
+ * @param {string} gender - 'masculine' or 'feminine'
+ * @returns {string} The decimal part rendered as words
+ */
+function decimalPartToWords(decimalPart, gender) {
   const parts = []
   let i = 0
 
@@ -194,28 +225,33 @@ function decimalPartToWords (decimalPart, gender) {
   return parts.join(' ')
 }
 
+/**
+ * @typedef {object} CardinalOptions
+ * @property {('masculine'|'feminine')} [gender] - Grammatical gender
+ * @property {string} [negativeWord] - Custom word for negative numbers
+ */
+
+/** @type {Required<CardinalOptions>} */
+export const cardinalDefaults = { gender: 'masculine', negativeWord: NEGATIVE }
+
+/** @type {{ gender: ReadonlyArray<Required<CardinalOptions>['gender']> }} */
+export const cardinalValues = { gender: ['masculine', 'feminine'] }
+
 /**
  * Converts a numeric value to Arabic words.
- *
  * @param {number | string | bigint} value - The numeric value to convert
- * @param {Object} [options] - Optional configuration
- * @param {('masculine'|'feminine')} [options.gender='masculine'] - Grammatical gender
- * @param {string} [options.negativeWord] - Custom word for negative numbers
+ * @param {CardinalOptions} [options] - Optional configuration
  * @returns {string} The number in Arabic words
- *
  * @example
  * toCardinal(1)                        // 'واحد'
  * toCardinal(1, {gender: 'feminine'})  // 'واحدة'
  */
-function toCardinal (value, options) {
-  options = validateOptions(options)
+function toCardinal(value, options) {
   const { isNegative, integerPart, decimalPart } = parseCardinalValue(value)
+  checkMax(integerPart, cardinalMax, decimalPart)
 
   // Apply option defaults
-  const {
-    gender = 'masculine',
-    negativeWord = NEGATIVE
-  } = options
+  const { gender, negativeWord } = resolveOptions(options, cardinalDefaults, cardinalValues)
 
   const parts = []
 
@@ -241,12 +277,11 @@ function toCardinal (value, options) {
  * Gets the Arabic ordinal form for a number.
  *
  * Arabic ordinals 1-10 have special forms, beyond 10 use cardinal + position.
- *
  * @param {bigint} n - Positive integer to convert
  * @param {string} gender - 'masculine' or 'feminine'
  * @returns {string} Arabic ordinal words
  */
-function integerToOrdinal (n, gender) {
+function integerToOrdinal(n, gender) {
   const ordinals = gender === 'feminine' ? ORDINAL_FEM : ORDINAL_MASC
 
   // Special ordinals for 1-10
@@ -259,25 +294,33 @@ function integerToOrdinal (n, gender) {
   return 'ال' + cardinal
 }
 
+/**
+ * @typedef {object} OrdinalOptions
+ * @property {('masculine'|'feminine')} [gender] - Grammatical gender
+ */
+
+/** @type {Required<OrdinalOptions>} */
+export const ordinalDefaults = { gender: 'masculine' }
+
+/** @type {{ gender: ReadonlyArray<Required<OrdinalOptions>['gender']> }} */
+export const ordinalValues = { gender: ['masculine', 'feminine'] }
+
 /**
  * Converts a numeric value to Arabic ordinal words.
- *
  * @param {number | string | bigint} value - The numeric value to convert (positive integer)
- * @param {Object} [options] - Optional configuration
- * @param {('masculine'|'feminine')} [options.gender='masculine'] - Grammatical gender
+ * @param {OrdinalOptions} [options] - Optional configuration
  * @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(1, {gender: 'feminine'})  // 'الأولى'
  * toOrdinal(3)                        // 'الثالث'
  */
-function toOrdinal (value, options) {
-  options = validateOptions(options)
+function toOrdinal(value, options) {
   const integerPart = parseOrdinalValue(value)
-  const { gender = 'masculine' } = options
+  checkMax(integerPart, ordinalMax)
+  const { gender } = resolveOptions(options, ordinalDefaults, ordinalValues)
   return integerToOrdinal(integerPart, gender)
 }
 
@@ -293,15 +336,22 @@ function toOrdinal (value, options) {
  * - 2: dual
  * - 3-10: plural form 1
  * - 11+: plural form 2 (different ending)
+ * @param {bigint} n - The riyal count
+ * @returns {string} The appropriate riyal word form
  */
-function getRiyalForm (n) {
+function getRiyalForm(n) {
   if (n === 1n) return RIYAL_SINGULAR
   if (n === 2n) return RIYAL_DUAL
   if (n >= 3n && n <= 10n) return RIYAL_PLURAL_3_10
   return RIYAL_PLURAL_11
 }
 
-function getHalalaForm (n) {
+/**
+ * Gets the appropriate halala word form based on number.
+ * @param {bigint} n - The halala count
+ * @returns {string} The appropriate halala word form
+ */
+function getHalalaForm(n) {
   if (n === 1n) return HALALA_SINGULAR
   if (n === 2n) return HALALA_DUAL
   if (n >= 3n && n <= 10n) return HALALA_PLURAL_3_10
@@ -310,19 +360,18 @@ function getHalalaForm (n) {
 
 /**
  * Converts a numeric value to Arabic currency words (Saudi Riyal).
- *
  * @param {number | string | bigint} value - The currency amount to convert
  * @returns {string} The amount in Arabic 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: riyals, cents: halalas } = parseCurrencyValue(value)
+  checkMax(riyals, currencyMax)
 
   // Build result
   let result = ''
@@ -333,9 +382,11 @@ function toCurrency (value) {
     // Special case for 1 and 2: currency word comes first
     if (riyals === 1n) {
       result += RIYAL_SINGULAR + ' ' + ONES_MASC[0]
-    } else if (riyals === 2n) {
+    }
+    else if (riyals === 2n) {
       result += RIYAL_DUAL
-    } else {
+    }
+    else {
       const riyalWord = integerToWords(riyals, 'masculine')
       result += riyalWord + ' ' + getRiyalForm(riyals)
     }
@@ -349,9 +400,11 @@ function toCurrency (value) {
     // Special case for 1 and 2: currency word comes first
     if (halalas === 1n) {
       result += HALALA_SINGULAR + ' ' + ONES_FEM[0]
-    } else if (halalas === 2n) {
+    }
+    else if (halalas === 2n) {
       result += HALALA_DUAL
-    } else {
+    }
+    else {
       const halalaWord = integerToWords(halalas, 'feminine')
       result += halalaWord + ' ' + getHalalaForm(halalas)
     }

package/src/az-AZ.d.ts

@@ -1,18 +1,18 @@
+export const cardinalMax: bigint;
+export const ordinalMax: bigint;
+export const currencyMax: bigint;
 /**
  * Converts a numeric value to Azerbaijani words.
- *
  * @param {number | string | bigint} value - The numeric value to convert
  * @returns {string} The number in Azerbaijani words
  */
 export function toCardinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Azerbaijani 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)    // 'birinci'
  * toOrdinal(2)    // 'ikinci'
@@ -23,12 +23,10 @@ export function toOrdinal(value: number | string | bigint): string;
  * Converts a numeric value to Azerbaijani currency words (Manat).
  *
  * Uses manat and qəpik (100 qəpik = 1 manat).
- *
  * @param {number | string | bigint} value - The currency amount to convert
  * @returns {string} The amount in Azerbaijani 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)     // 'qırx iki manat'
  * toCurrency(1.50)   // 'bir manat əlli qəpik'

package/src/az-AZ.js

@@ -12,6 +12,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
@@ -31,12 +33,22 @@ const DECIMAL_SEP = 'nöqtə'
 // Short scale
 const SCALE_WORDS = ['', THOUSAND, 'milyon', 'milyar', 'trilyon', 'katrilyon', 'kentilyon']
 
+// Supported magnitude ceiling (checked at the public entry points). SCALE_WORDS
+// reaches index SCALE_WORDS.length-1 (kentilyon, 10^18), so values must stay
+// below 10^(SCALE_WORDS.length * 3) = 10^21. Ordinal builds on the cardinal
+// (integerToWords + suffix) and currency too, so all three share the ceiling —
+// and the decimal is also spelled via integerToWords, so it's guarded as well.
+export const cardinalMax = western(SCALE_WORDS.length - 1)
+export const ordinalMax = western(SCALE_WORDS.length - 1)
+export const currencyMax = western(SCALE_WORDS.length - 1)
+
 // ============================================================================
 // Ordinal Vocabulary
 // ============================================================================
 
 // Azerbaijani ordinals use -(i/ı/u/ü)nci/ncı/ncu/ncü suffix with vowel harmony
 // Special forms for 1-10
+/** @type {Record<number, string>} */
 const ORDINAL_SPECIAL = {
   1: 'birinci',
   2: 'ikinci',
@@ -47,7 +59,7 @@ const ORDINAL_SPECIAL = {
   7: 'yeddinci',
   8: 'səkkizinci',
   9: 'doqquzuncu',
-  10: 'onuncu'
+  10: 'onuncu',
 }
 
 // ============================================================================
@@ -61,7 +73,12 @@ const QEPIK = 'qəpik' // subunit (100 qəpik = 1 manat)
 // Precomputed Lookup Table
 // ============================================================================
 
-function buildSegment (n) {
+/**
+ * Builds the Azerbaijani words for a 3-digit segment (0-999).
+ * @param {number} n - The segment value
+ * @returns {string} The segment in words
+ */
+function buildSegment(n) {
   if (n === 0) return ''
 
   const ones = n % 10
@@ -73,14 +90,16 @@ function buildSegment (n) {
   if (hundredsDigit > 0) {
     if (hundredsDigit === 1) {
       parts.push(HUNDRED)
-    } else {
+    }
+    else {
       parts.push(ONES[hundredsDigit] + ' ' + HUNDRED)
     }
   }
 
   if (tensDigit === 1) {
     parts.push(TEENS[ones])
-  } else {
+  }
+  else {
     if (tensDigit > 1) {
       parts.push(TENS[tensDigit])
     }
@@ -96,7 +115,12 @@ function buildSegment (n) {
 // Conversion Functions
 // ============================================================================
 
-function integerToWords (n) {
+/**
+ * Converts a non-negative integer to Azerbaijani words.
+ * @param {bigint} n - The integer value
+ * @returns {string} The integer in words
+ */
+function integerToWords(n) {
   if (n === 0n) return ZERO
 
   if (n < 1000n) {
@@ -106,7 +130,12 @@ function integerToWords (n) {
   return buildLargeNumberWords(n)
 }
 
-function buildLargeNumberWords (n) {
+/**
+ * Builds Azerbaijani words for numbers >= 1000 using scale words.
+ * @param {bigint} n - The integer value
+ * @returns {string} The number in words
+ */
+function buildLargeNumberWords(n) {
   const numStr = n.toString()
   const len = numStr.length
 
@@ -135,10 +164,12 @@ function buildLargeNumberWords (n) {
 
       if (scaleIndex === 0) {
         parts.push(buildSegment(segment))
-      } else if (scaleIndex === 1 && segment === 1) {
+      }
+      else if (scaleIndex === 1 && segment === 1) {
         // Omit "bir" before thousand
         parts.push(scaleWord)
-      } else {
+      }
+      else {
         parts.push(buildSegment(segment) + ' ' + scaleWord)
       }
     }
@@ -149,7 +180,12 @@ function buildLargeNumberWords (n) {
   return parts.join(' ')
 }
 
-function decimalPartToWords (decimalPart) {
+/**
+ * Converts the decimal-part digit string to Azerbaijani words.
+ * @param {string} decimalPart - The decimal digits as a string
+ * @returns {string} The decimal part in words
+ */
+function decimalPartToWords(decimalPart) {
   let result = ''
   let i = 0
 
@@ -170,12 +206,14 @@ function decimalPartToWords (decimalPart) {
 
 /**
  * Converts a numeric value to Azerbaijani words.
- *
  * @param {number | string | bigint} value - The numeric value to convert
  * @returns {string} The number in Azerbaijani words
  */
-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 = ''
 
@@ -201,7 +239,7 @@ function toCardinal (value) {
  * @param {string} word - The cardinal word
  * @returns {string} The appropriate suffix
  */
-function getOrdinalSuffix (word) {
+function getOrdinalSuffix(word) {
   // Azerbaijani vowel harmony: back vowels (a,ı,o,u) vs front vowels (ə,e,i,ö,ü)
   const backVowels = 'aıou'
   const frontVowels = 'əeiöü'
@@ -228,11 +266,10 @@ function getOrdinalSuffix (word) {
  *
  * Azerbaijani ordinals: birinci (1st), ikinci (2nd), üçüncü (3rd), etc.
  * Uses vowel harmony for suffix selection.
- *
  * @param {bigint} n - Positive integer to convert
  * @returns {string} Azerbaijani ordinal words
  */
-function integerToOrdinal (n) {
+function integerToOrdinal(n) {
   // Special forms for 1-10
   if (n >= 1n && n <= 10n) {
     return ORDINAL_SPECIAL[Number(n)]
@@ -246,19 +283,21 @@ function integerToOrdinal (n) {
 
 /**
  * Converts a numeric value to Azerbaijani 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)    // 'birinci'
  * toOrdinal(2)    // 'ikinci'
  * toOrdinal(21)   // 'iyirmibirinci'
  */
-function toOrdinal (value) {
+function toOrdinal(value) {
   const integerPart = parseOrdinalValue(value)
+  // Ordinal builds on the cardinal (integerToWords + suffix), so it shares the
+  // ceiling — past it the cardinal's trailing-space artifact would be hidden by
+  // the space-stripping and emit a silently-wrong ordinal.
+  checkMax(integerPart, ordinalMax)
   return integerToOrdinal(integerPart)
 }
 
@@ -270,19 +309,18 @@ function toOrdinal (value) {
  * Converts a numeric value to Azerbaijani currency words (Manat).
  *
  * Uses manat and qəpik (100 qəpik = 1 manat).
- *
  * @param {number | string | bigint} value - The currency amount to convert
  * @returns {string} The amount in Azerbaijani 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)     // 'qırx iki manat'
  * toCurrency(1.50)   // 'bir manat əlli qəpik'
  * toCurrency(-5)     // 'mənfi beş manat'
  */
-function toCurrency (value) {
+function toCurrency(value) {
   const { isNegative, dollars: manat, cents: qepik } = parseCurrencyValue(value)
+  checkMax(manat, currencyMax)
 
   let result = ''
   if (isNegative) {

package/src/bn-BD.d.ts

@@ -1,18 +1,18 @@
+export const cardinalMax: bigint;
+export const ordinalMax: bigint;
+export const currencyMax: bigint;
 /**
  * Converts a numeric value to Bengali words.
- *
  * @param {number | string | bigint} value - The numeric value to convert
  * @returns {string} The number in Bengali words
  */
 export function toCardinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Bengali 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)    // 'দ্বিতীয়'
@@ -22,12 +22,10 @@ export function toCardinal(value: number | string | bigint): string;
 export function toOrdinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Bengali currency words (Bangladeshi Taka).
- *
  * @param {number | string | bigint} value - The currency amount to convert
  * @returns {string} The amount in Bengali 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)      // 'এক টাকা'