n2words 4.0.0 → 5.1.0

package/src/ha-NG.js

@@ -16,6 +16,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
@@ -24,7 +26,7 @@ import { parseOrdinalValue } from './utils/parse-ordinal.js'
 const ONES = ['', 'ɗaya', 'biyu', 'uku', 'huɗu', 'biyar', 'shida', 'bakwai', 'takwas', 'tara']
 const TEENS = ['goma', 'sha ɗaya', 'sha biyu', 'sha uku', 'sha huɗu', 'sha biyar', 'sha shida', 'sha bakwai', 'sha takwas', 'sha tara']
 // Arabic loanwords for tens
-const TENS = ['', '', 'ashirin', 'talatin', "arba'in", 'hamsin', 'sittin', "saba'in", 'tamanin', "tis'in"]
+const TENS = ['', '', 'ashirin', 'talatin', 'arba\'in', 'hamsin', 'sittin', 'saba\'in', 'tamanin', 'tis\'in']
 
 const HUNDRED = 'ɗari'
 const THOUSAND = 'dubu'
@@ -36,6 +38,11 @@ const DECIMAL_SEP = 'digo'
 // Short scale
 const SCALE_WORDS = ['', THOUSAND, 'miliyan', 'biliyan']
 
+// 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)
+
 // ============================================================================
 // Ordinal Vocabulary
 // ============================================================================
@@ -60,8 +67,10 @@ const KOBO = 'kobo'
  * Build segment for 0-999 with Hausa patterns.
  * Hausa uses reversed order for hundreds: "biyu ɗari" (200)
  * And "da" connector for ones: "ashirin da ɗaya" (21)
+ * @param {number} n - Integer segment value (0-999)
+ * @returns {string} The segment in Hausa words
  */
-function buildSegment (n) {
+function buildSegment(n) {
   if (n === 0) return ''
 
   const ones = n % 10
@@ -74,7 +83,8 @@ function buildSegment (n) {
   if (hundredsDigit > 0) {
     if (hundredsDigit === 1) {
       parts.push(HUNDRED)
-    } else {
+    }
+    else {
       // Reversed: multiplier + hundredWord
       parts.push(ONES[hundredsDigit] + ' ' + HUNDRED)
     }
@@ -85,20 +95,25 @@ function buildSegment (n) {
 
   if (tensOnes === 0) {
     // Just hundreds
-  } else if (tensOnes < 10) {
+  }
+  else if (tensOnes < 10) {
     // Single digit - with "da" connector if after hundreds
     if (hundredsDigit > 0) {
       parts.push('da ' + ONES[ones])
-    } else {
+    }
+    else {
       parts.push(ONES[ones])
     }
-  } else if (tensOnes < 20) {
+  }
+  else if (tensOnes < 20) {
     // Teens (10-19): "sha X"
     parts.push(TEENS[ones])
-  } else if (ones === 0) {
+  }
+  else if (ones === 0) {
     // Even tens (20, 30, 40, etc.)
     parts.push(TENS[tensDigit])
-  } else {
+  }
+  else {
     // Tens + ones with "da" connector
     parts.push(TENS[tensDigit] + ' da ' + ONES[ones])
   }
@@ -110,7 +125,11 @@ function buildSegment (n) {
 // Conversion Functions
 // ============================================================================
 
-function integerToWords (n) {
+/**
+ * @param {bigint} n - Non-negative integer value
+ * @returns {string} The integer in Hausa words
+ */
+function integerToWords(n) {
   if (n === 0n) return ZERO
 
   if (n < 1000n) {
@@ -122,12 +141,18 @@ function integerToWords (n) {
 
 /**
  * Checks if a word is a single digit (1-9).
+ * @param {string} word - Word to test
+ * @returns {boolean} True if the word is a single digit (1-9)
  */
-function isSingleDigit (word) {
+function isSingleDigit(word) {
   return ONES.slice(1).includes(word)
 }
 
-function buildLargeNumberWords (n) {
+/**
+ * @param {bigint} n - Integer value of 1000 or greater
+ * @returns {string} The number in Hausa words
+ */
+function buildLargeNumberWords(n) {
   const numStr = n.toString()
   const len = numStr.length
 
@@ -157,7 +182,8 @@ function buildLargeNumberWords (n) {
 
       if (scaleIndex === 0) {
         rawParts.push(buildSegment(segment))
-      } else {
+      }
+      else {
         rawParts.push(buildSegment(segment))
         rawParts.push(scaleWord)
       }
@@ -188,11 +214,12 @@ function buildLargeNumberWords (n) {
 
     // Determine if we need "da" connector
     // Use "da" when current is a single digit following a scale word
-    if (prevPart && isSingleDigit(part) &&
-        (prevPart === THOUSAND || prevPart === HUNDRED ||
-         SCALE_WORDS.includes(prevPart))) {
+    if (prevPart && isSingleDigit(part)
+      && (prevPart === THOUSAND || prevPart === HUNDRED
+        || SCALE_WORDS.includes(prevPart))) {
       result.push(' da ')
-    } else if (i > 0) {
+    }
+    else if (i > 0) {
       result.push(' ')
     }
 
@@ -202,7 +229,11 @@ function buildLargeNumberWords (n) {
   return result.join('')
 }
 
-function decimalPartToWords (decimalPart) {
+/**
+ * @param {string} decimalPart - Digit string of the fractional part
+ * @returns {string} The fractional digits in Hausa words
+ */
+function decimalPartToWords(decimalPart) {
   // Per-digit decimal reading
   const digits = []
   for (const char of decimalPart) {
@@ -214,12 +245,12 @@ function decimalPartToWords (decimalPart) {
 
 /**
  * Converts a numeric value to Hausa words.
- *
  * @param {number | string | bigint} value - The numeric value to convert
  * @returns {string} The number in Hausa words
  */
-function toCardinal (value) {
+function toCardinal(value) {
   const { isNegative, integerPart, decimalPart } = parseCardinalValue(value)
+  checkMax(integerPart, cardinalMax)
 
   let result = ''
 
@@ -244,11 +275,10 @@ function toCardinal (value) {
  * Converts a non-negative integer to Hausa ordinal words.
  *
  * Hausa ordinals: na farko (1st), na biyu (2nd), na uku (3rd), etc.
- *
  * @param {bigint} n - Positive integer to convert
  * @returns {string} Hausa ordinal words
  */
-function integerToOrdinal (n) {
+function integerToOrdinal(n) {
   // Special form for first
   if (n === 1n) return ORDINAL_FIRST
 
@@ -258,19 +288,18 @@ function integerToOrdinal (n) {
 
 /**
  * Converts a numeric value to Hausa 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)    // 'na farko'
  * toOrdinal(2)    // 'na biyu'
  * toOrdinal(10)   // 'na goma'
  */
-function toOrdinal (value) {
+function toOrdinal(value) {
   const integerPart = parseOrdinalValue(value)
+  checkMax(integerPart, ordinalMax)
   return integerToOrdinal(integerPart)
 }
 
@@ -282,19 +311,18 @@ function toOrdinal (value) {
  * Converts a numeric value to Hausa currency words (Nigerian Naira).
  *
  * Uses naira and kobo (100 kobo = 1 naira).
- *
  * @param {number | string | bigint} value - The currency amount to convert
  * @returns {string} The amount in Hausa 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)     // 'arba'in da biyu naira'
  * toCurrency(1.50)   // 'ɗaya naira da hamsin kobo'
  * toCurrency(-5)     // 'babu biyar naira'
  */
-function toCurrency (value) {
+function toCurrency(value) {
   const { isNegative, dollars: naira, cents: kobo } = parseCurrencyValue(value)
+  checkMax(naira, currencyMax)
 
   let result = ''
   if (isNegative) {

package/src/hbo-IL.d.ts

@@ -1,24 +1,40 @@
+export const cardinalMax: bigint;
+export const ordinalMax: bigint;
+export const currencyMax: bigint;
+/**
+ * @typedef {object} CardinalOptions
+ * @property {('masculine'|'feminine')} [gender] - Grammatical gender
+ * @property {string} [andWord] - Custom conjunction word
+ */
+/** @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 = {
+    /**
+     * - Grammatical gender
+     */
+    gender?: "feminine" | "masculine" | undefined;
+    /**
+     * - Custom conjunction word
+     */
+    andWord?: string | undefined;
+};
 /**
  * Converts a numeric value to Biblical Hebrew 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.andWord='ו'] - Custom conjunction word
+ * @param {CardinalOptions} [options] - Optional configuration
  * @returns {string} The number in Biblical Hebrew words
  */
-export function toCardinal(value: number | string | bigint, options?: {
-    gender?: "masculine" | "feminine" | undefined;
-    andWord?: string | undefined;
-}): string;
+export function toCardinal(value: number | string | bigint, options?: CardinalOptions): string;
 /**
  * Converts a numeric value to Biblical Hebrew ordinal words.
- *
  * @param {number | string | bigint} value - The numeric value to convert
  * @returns {string} The ordinal in Biblical Hebrew words
  * @throws {TypeError} If value is not a valid numeric type
  * @throws {Error} If value is not a positive integer
- *
  * @example
  * toOrdinal(1)   // 'ראשון'
  * toOrdinal(21)  // 'עשרים וראשון'
@@ -26,12 +42,10 @@ export function toCardinal(value: number | string | bigint, options?: {
 export function toOrdinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Biblical Hebrew Shekel currency words.
- *
  * @param {number | string | bigint} value - The numeric value to convert
  * @returns {string} The currency in Biblical Hebrew 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/hbo-IL.js

@@ -14,7 +14,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 { bounded, western } from './utils/scale.js'
+import { resolveOptions } from './utils/resolve-options.js'
 
 // ============================================================================
 // Vocabulary (arrays for indexed access - faster than object property lookup)
@@ -39,6 +41,15 @@ const HUNDREDS_FEM = ['', 'מאה', 'מאתיים', 'שלש מאות', 'ארבע
 const SCALE = ['', 'אלף', 'מיליון', 'מיליארד', 'טריליון', 'קוודרליון', 'קווינטיליון']
 const SCALE_PLURAL = ['', 'אלפים', 'מיליונים', 'מיליארדים', 'טריליונים', 'קוודרליונים', 'קווינטיליונים']
 
+// Supported magnitude ceilings (checked at the public entry points). Cardinal
+// SCALE reaches index SCALE.length-1 (10^18), so cardinals/currency must stay
+// below 10^(SCALE.length * 3) = 10^21. Ordinals are bounded lower: past 10^6
+// the millions multiplier is built with buildScaleSegment (0-999), so n must
+// stay below 10^9. Decimals are read digit-by-digit (no ceiling).
+export const cardinalMax = western(SCALE.length - 1)
+export const ordinalMax = bounded(9)
+export const currencyMax = western(SCALE.length - 1)
+
 const ZERO = 'אפס'
 const NEGATIVE = 'מינוס'
 const DECIMAL_SEP = 'נקודה'
@@ -62,8 +73,14 @@ const GERAH_PLURAL = 'גרות'
 /**
  * Builds segment word for scale segments (thousands, millions, etc.).
  * "ו" is added before tens and ones when following hundreds.
+ * @param {number} n - Segment value (0-999)
+ * @param {string} andWord - Conjunction word
+ * @param {string[]} ONES - Ones vocabulary
+ * @param {string[]} TEENS - Teens vocabulary
+ * @param {string[]} HUNDREDS_ARR - Hundreds vocabulary
+ * @returns {string} Segment word
  */
-function buildScaleSegment (n, andWord, ONES, TEENS, HUNDREDS_ARR) {
+function buildScaleSegment(n, andWord, ONES, TEENS, HUNDREDS_ARR) {
   if (n === 0) return ''
 
   const ones = n % 10
@@ -83,15 +100,18 @@ function buildScaleSegment (n, andWord, ONES, TEENS, HUNDREDS_ARR) {
     const teenWord = TEENS[ones]
     if (result) {
       result += ' ' + andWord + teenWord
-    } else {
+    }
+    else {
       result = teenWord
     }
-  } else {
+  }
+  else {
     // Tens (20-90)
     if (tens >= 2) {
       if (result) {
         result += ' ' + andWord + TENS[tens]
-      } else {
+      }
+      else {
         result = TENS[tens]
       }
     }
@@ -100,7 +120,8 @@ function buildScaleSegment (n, andWord, ONES, TEENS, HUNDREDS_ARR) {
     if (ones > 0) {
       if (result) {
         result += ' ' + andWord + ONES[ones]
-      } else {
+      }
+      else {
         result = ONES[ones]
       }
     }
@@ -112,8 +133,14 @@ function buildScaleSegment (n, andWord, ONES, TEENS, HUNDREDS_ARR) {
 /**
  * Builds segment word for units segment (no scale word).
  * "ו" is only added before the final ones digit.
+ * @param {number} n - Segment value (0-999)
+ * @param {string} andWord - Conjunction word
+ * @param {string[]} ONES - Ones vocabulary
+ * @param {string[]} TEENS - Teens vocabulary
+ * @param {string[]} HUNDREDS_ARR - Hundreds vocabulary
+ * @returns {string} Segment word
  */
-function buildUnitsSegment (n, andWord, ONES, TEENS, HUNDREDS_ARR) {
+function buildUnitsSegment(n, andWord, ONES, TEENS, HUNDREDS_ARR) {
   if (n === 0) return ''
 
   const ones = n % 10
@@ -132,14 +159,17 @@ function buildUnitsSegment (n, andWord, ONES, TEENS, HUNDREDS_ARR) {
     // Teens (10-19)
     if (result) {
       result += ' ' + TEENS[ones]
-    } else {
+    }
+    else {
       result = TEENS[ones]
     }
-  } else {
+  }
+  else {
     if (tens >= 2) {
       if (result) {
         result += ' ' + TENS[tens]
-      } else {
+      }
+      else {
         result = TENS[tens]
       }
     }
@@ -148,7 +178,8 @@ function buildUnitsSegment (n, andWord, ONES, TEENS, HUNDREDS_ARR) {
     if (ones > 0) {
       if (result) {
         result += ' ' + andWord + ONES[ones]
-      } else {
+      }
+      else {
         result = ONES[ones]
       }
     }
@@ -163,12 +194,12 @@ function buildUnitsSegment (n, andWord, ONES, TEENS, HUNDREDS_ARR) {
 
 /**
  * Converts a non-negative integer to Biblical Hebrew words.
- *
  * @param {bigint} n - Non-negative integer to convert
- * @param {Object} options - Conversion options
+ * @param {('masculine'|'feminine')} gender - Grammatical gender
+ * @param {string} andWord - Conjunction word
  * @returns {string} Biblical Hebrew words
  */
-function integerToWords (n, gender, andWord) {
+function integerToWords(n, gender, andWord) {
   if (n === 0n) return ZERO
 
   const isFeminine = gender === 'feminine'
@@ -206,28 +237,34 @@ function integerToWords (n, gender, andWord) {
         // Add "ו" before single-digit units when following scale words
         if (segment <= 9) {
           result += ' ' + andWord + segmentWord
-        } else {
+        }
+        else {
           result += ' ' + segmentWord
         }
-      } else {
+      }
+      else {
         result = segmentWord
       }
-    } else if (i === 1) {
+    }
+    else if (i === 1) {
       // Thousands - special handling for 1-9
       if (segment <= 9) {
         if (result) result += ' '
         result += THOUSANDS_SPECIAL[segment]
-      } else {
+      }
+      else {
         const segmentWord = buildScaleSegment(segment, andWord, ONES, TEENS, HUNDREDS_ARR)
         if (result) result += ' '
         result += segmentWord + ' ' + SCALE[1]
       }
-    } else {
+    }
+    else {
       // Millions and above
       if (segment === 1) {
         if (result) result += ' '
         result += SCALE[i]
-      } else {
+      }
+      else {
         const segmentWord = buildScaleSegment(segment, andWord, ONES, TEENS, HUNDREDS_ARR)
         if (result) result += ' '
         result += segmentWord + ' ' + SCALE_PLURAL[i]
@@ -240,12 +277,11 @@ function integerToWords (n, gender, andWord) {
 
 /**
  * Converts decimal digits to Biblical Hebrew words (digit by digit).
- *
  * @param {string} decimalPart - Decimal digits (without the point)
- * @param {Object} options - Conversion options
+ * @param {('masculine'|'feminine')} gender - Grammatical gender
  * @returns {string} Biblical Hebrew words for decimal part
  */
-function decimalPartToWords (decimalPart, gender, andWord) {
+function decimalPartToWords(decimalPart, gender) {
   const ONES = gender === 'feminine' ? ONES_FEM : ONES_MASC
 
   let result = ''
@@ -258,24 +294,28 @@ function decimalPartToWords (decimalPart, gender, andWord) {
   return result
 }
 
+/**
+ * @typedef {object} CardinalOptions
+ * @property {('masculine'|'feminine')} [gender] - Grammatical gender
+ * @property {string} [andWord] - Custom conjunction word
+ */
+
+/** @type {Required<CardinalOptions>} */
+export const cardinalDefaults = { gender: 'masculine', andWord: 'ו' }
+
+/** @type {{ gender: ReadonlyArray<Required<CardinalOptions>['gender']> }} */
+export const cardinalValues = { gender: ['masculine', 'feminine'] }
+
 /**
  * Converts a numeric value to Biblical Hebrew 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.andWord='ו'] - Custom conjunction word
+ * @param {CardinalOptions} [options] - Optional configuration
  * @returns {string} The number in Biblical Hebrew words
  */
-function toCardinal (value, options) {
-  options = validateOptions(options)
+function toCardinal(value, options) {
   const { isNegative, integerPart, decimalPart } = parseCardinalValue(value)
-
-  // Apply option defaults
-  const {
-    gender = 'masculine',
-    andWord = 'ו'
-  } = options
+  checkMax(integerPart, cardinalMax)
+  const { gender, andWord } = resolveOptions(options, cardinalDefaults, cardinalValues)
 
   let result = ''
 
@@ -286,7 +326,7 @@ function toCardinal (value, options) {
   result += integerToWords(integerPart, gender, andWord)
 
   if (decimalPart) {
-    result += ' ' + DECIMAL_SEP + ' ' + decimalPartToWords(decimalPart, gender, andWord)
+    result += ' ' + DECIMAL_SEP + ' ' + decimalPartToWords(decimalPart, gender)
   }
 
   return result
@@ -298,11 +338,10 @@ function toCardinal (value, options) {
 
 /**
  * Builds ordinal for tens and ones (0-99).
- *
  * @param {number} n - Number 0-99
  * @returns {string} Ordinal word
  */
-function buildOrdinalTensOnes (n) {
+function buildOrdinalTensOnes(n) {
   if (n === 0) return ''
   if (n < 10) return ORDINAL_ONES[n]
   if (n < 20) return ORDINAL_TEENS[n - 10]
@@ -320,11 +359,10 @@ function buildOrdinalTensOnes (n) {
 
 /**
  * Converts a non-negative integer to Biblical Hebrew ordinal words.
- *
  * @param {bigint} n - Non-negative integer to convert
  * @returns {string} Biblical Hebrew ordinal words
  */
-function integerToOrdinal (n) {
+function integerToOrdinal(n) {
   if (n === 0n) return ''
   if (n === 1n) return ORDINAL_ONES[1]
 
@@ -360,7 +398,8 @@ function integerToOrdinal (n) {
     let result
     if (thousands <= 9) {
       result = THOUSANDS_MASC[thousands]
-    } else {
+    }
+    else {
       result = buildScaleSegment(thousands, 'ו', ONES_MASC, TEENS_MASC, HUNDREDS) + ' ' + SCALE[1]
     }
 
@@ -392,7 +431,8 @@ function integerToOrdinal (n) {
   let result
   if (millions === 1) {
     result = SCALE[2]
-  } else {
+  }
+  else {
     result = buildScaleSegment(millions, 'ו', ONES_MASC, TEENS_MASC, HUNDREDS) + ' ' + SCALE_PLURAL[2]
   }
 
@@ -401,18 +441,17 @@ function integerToOrdinal (n) {
 
 /**
  * Converts a numeric value to Biblical Hebrew ordinal words.
- *
  * @param {number | string | bigint} value - The numeric value to convert
  * @returns {string} The ordinal in Biblical Hebrew words
  * @throws {TypeError} If value is not a valid numeric type
  * @throws {Error} If value is not a positive integer
- *
  * @example
  * toOrdinal(1)   // 'ראשון'
  * toOrdinal(21)  // 'עשרים וראשון'
  */
-function toOrdinal (value) {
+function toOrdinal(value) {
   const n = parseOrdinalValue(value)
+  checkMax(n, ordinalMax)
   return integerToOrdinal(n)
 }
 
@@ -422,18 +461,17 @@ function toOrdinal (value) {
 
 /**
  * Converts a numeric value to Biblical Hebrew Shekel currency words.
- *
  * @param {number | string | bigint} value - The numeric value to convert
  * @returns {string} The currency in Biblical Hebrew 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 = []
 
@@ -445,9 +483,11 @@ function toCurrency (value) {
   if (dollars > 0n || cents === 0n) {
     if (dollars === 1n) {
       parts.push(SHEKEL + ' ' + ONES_MASC[1])
-    } else if (dollars === 2n) {
+    }
+    else if (dollars === 2n) {
       parts.push(ONES_MASC[2] + ' ' + SHEKEL_PLURAL)
-    } else {
+    }
+    else {
       const shekelWord = integerToWords(dollars, 'masculine', 'ו')
       parts.push(shekelWord + ' ' + SHEKEL_PLURAL)
     }
@@ -458,7 +498,8 @@ function toCurrency (value) {
     const centNum = Number(cents)
     if (centNum === 1) {
       parts.push(GERAH + ' ' + ONES_FEM[1])
-    } else {
+    }
+    else {
       const gerahWord = integerToWords(cents, 'feminine', 'ו')
       parts.push(gerahWord + ' ' + GERAH_PLURAL)
     }

package/src/he-IL.d.ts

@@ -1,22 +1,31 @@
+export const cardinalMax: bigint;
+export const ordinalMax: bigint;
+export const currencyMax: bigint;
+/**
+ * @typedef {object} CardinalOptions
+ * @property {string} [andWord] - Custom conjunction word
+ */
+/** @type {Required<CardinalOptions>} */
+export const cardinalDefaults: Required<CardinalOptions>;
+export type CardinalOptions = {
+    /**
+     * - Custom conjunction word
+     */
+    andWord?: string | undefined;
+};
 /**
  * Converts a numeric value to Modern Hebrew words.
- *
  * @param {number | string | bigint} value - The numeric value to convert
- * @param {Object} [options] - Optional configuration
- * @param {string} [options.andWord='ו'] - Custom conjunction word
+ * @param {CardinalOptions} [options] - Optional configuration
  * @returns {string} The number in Modern Hebrew words
  */
-export function toCardinal(value: number | string | bigint, options?: {
-    andWord?: string | undefined;
-}): string;
+export function toCardinal(value: number | string | bigint, options?: CardinalOptions): string;
 /**
  * Converts a numeric value to Hebrew ordinal words.
- *
  * @param {number | string | bigint} value - The numeric value to convert
  * @returns {string} The ordinal in Hebrew words
  * @throws {TypeError} If value is not a valid numeric type
  * @throws {Error} If value is not a positive integer
- *
  * @example
  * toOrdinal(1)   // 'ראשון'
  * toOrdinal(21)  // 'עשרים וראשון'
@@ -24,12 +33,10 @@ export function toCardinal(value: number | string | bigint, options?: {
 export function toOrdinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Hebrew New Israeli Shekel currency words.
- *
  * @param {number | string | bigint} value - The numeric value to convert
  * @returns {string} The currency in Hebrew 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)  // 'שניים שקלים חמישים אגורות'