n2words 5.0.0 → 5.1.0

package/src/id-ID.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 { western } from './utils/scale.js'
 
 // ============================================================================
 // Vocabulary
@@ -26,6 +28,11 @@ const HUNDRED_WORD = 'ratus'
 const THOUSAND_WORD = 'ribu'
 const SCALE_WORDS = ['juta', 'miliar', 'triliun', 'kuadriliun', 'kuantiliun', 'sekstiliun', 'septiliun', 'oktiliun', 'noniliun', 'desiliun']
 
+// 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 ZERO = 'nol'
 const NEGATIVE = 'min'
 const DECIMAL_SEP = 'koma'
@@ -48,7 +55,12 @@ const RUPIAH = 'rupiah'
 // Segment Building
 // ============================================================================
 
-function buildSegment (n) {
+/**
+ * Builds the Indonesian words for a 1-3 digit segment (0-999).
+ * @param {number} n - The segment value (0-999)
+ * @returns {string} The segment in Indonesian words
+ */
+function buildSegment(n) {
   if (n === 0) return ''
 
   const onesDigit = n % 10
@@ -61,7 +73,8 @@ function buildSegment (n) {
   if (hundredsDigit > 0) {
     if (hundredsDigit === 1) {
       parts.push('se' + HUNDRED_WORD)
-    } else {
+    }
+    else {
       parts.push(ONES[hundredsDigit] + ' ' + HUNDRED_WORD)
     }
   }
@@ -71,13 +84,17 @@ function buildSegment (n) {
 
   if (tensOnes === 0) {
     // Just hundreds
-  } else if (tensOnes < 10) {
+  }
+  else if (tensOnes < 10) {
     parts.push(ONES[tensOnes])
-  } else if (tensOnes < 20) {
+  }
+  else if (tensOnes < 20) {
     parts.push(TEENS[tensOnes - 10])
-  } else if (onesDigit === 0) {
+  }
+  else if (onesDigit === 0) {
     parts.push(TENS[tensDigit])
-  } else {
+  }
+  else {
     parts.push(TENS[tensDigit] + ' ' + ONES[onesDigit])
   }
 
@@ -88,7 +105,12 @@ function buildSegment (n) {
 // Conversion Functions
 // ============================================================================
 
-function integerToWords (n) {
+/**
+ * Converts a non-negative integer to Indonesian words.
+ * @param {bigint} n - The integer value to convert
+ * @returns {string} The integer in Indonesian words
+ */
+function integerToWords(n) {
   if (n === 0n) return ZERO
 
   if (n < 1000n) {
@@ -102,7 +124,8 @@ function integerToWords (n) {
     let result
     if (thousands === 1) {
       result = 'se' + THOUSAND_WORD
-    } else {
+    }
+    else {
       result = buildSegment(thousands) + ' ' + THOUSAND_WORD
     }
 
@@ -116,7 +139,12 @@ function integerToWords (n) {
   return buildLargeNumberWords(n)
 }
 
-function buildLargeNumberWords (n) {
+/**
+ * Builds Indonesian words for large numbers (1,000,000 and above).
+ * @param {bigint} n - The integer value to convert
+ * @returns {string} The number in Indonesian words
+ */
+function buildLargeNumberWords(n) {
   const numStr = n.toString()
   const len = numStr.length
 
@@ -143,13 +171,16 @@ function buildLargeNumberWords (n) {
     if (segment !== 0) {
       if (scaleIndex === 0) {
         parts.push(buildSegment(segment))
-      } else if (scaleIndex === 1) {
+      }
+      else if (scaleIndex === 1) {
         if (segment === 1) {
           parts.push('se' + THOUSAND_WORD)
-        } else {
+        }
+        else {
           parts.push(buildSegment(segment) + ' ' + THOUSAND_WORD)
         }
-      } else {
+      }
+      else {
         // Indonesian: "satu juta" not "sejuta"
         const scaleWord = SCALE_WORDS[scaleIndex - 2]
         parts.push(buildSegment(segment) + ' ' + scaleWord)
@@ -162,7 +193,12 @@ function buildLargeNumberWords (n) {
   return parts.join(' ')
 }
 
-function decimalPartToWords (decimalPart) {
+/**
+ * Converts the decimal-part digit string to Indonesian words.
+ * @param {string} decimalPart - The decimal digits as a string
+ * @returns {string} The decimal part in Indonesian words
+ */
+function decimalPartToWords(decimalPart) {
   let result = ''
 
   let i = 0
@@ -183,12 +219,12 @@ function decimalPartToWords (decimalPart) {
 
 /**
  * Converts a numeric value to Indonesian words.
- *
  * @param {number | string | bigint} value - The numeric value to convert
  * @returns {string} The number in Indonesian words
  */
-function toCardinal (value) {
+function toCardinal(value) {
   const { isNegative, integerPart, decimalPart } = parseCardinalValue(value)
+  checkMax(integerPart, cardinalMax, decimalPart)
 
   let result = ''
 
@@ -214,11 +250,10 @@ function toCardinal (value) {
  *
  * Indonesian ordinals use "ke-" prefix + cardinal number.
  * Special case: "pertama" for 1st (not "kesatu").
- *
  * @param {bigint} n - Positive integer to convert
  * @returns {string} Indonesian ordinal words
  */
-function integerToOrdinal (n) {
+function integerToOrdinal(n) {
   // Special case: 1st is "pertama"
   if (n === 1n) {
     return ORDINAL_FIRST
@@ -230,19 +265,18 @@ function integerToOrdinal (n) {
 
 /**
  * Converts a numeric value to Indonesian 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)    // 'pertama'
  * toOrdinal(2)    // 'kedua'
  * toOrdinal(10)   // 'kesepuluh'
  */
-function toOrdinal (value) {
+function toOrdinal(value) {
   const integerPart = parseOrdinalValue(value)
+  checkMax(integerPart, ordinalMax)
   return integerToOrdinal(integerPart)
 }
 
@@ -255,19 +289,18 @@ function toOrdinal (value) {
  *
  * Indonesian Rupiah has no subunit in modern usage (sen are historical).
  * Amounts are rounded to whole rupiah.
- *
  * @param {number | string | bigint} value - The currency amount to convert
  * @returns {string} The amount in Indonesian 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)     // 'empat puluh dua rupiah'
  * toCurrency(1000)   // 'seribu rupiah'
  * toCurrency(-5)     // 'min lima rupiah'
  */
-function toCurrency (value) {
+function toCurrency(value) {
   const { isNegative, dollars: rupiah } = parseCurrencyValue(value)
+  checkMax(rupiah, currencyMax)
 
   let result = ''
   if (isNegative) {

package/src/it-IT.d.ts

@@ -1,14 +1,27 @@
+export const cardinalMax: bigint;
+export const ordinalMax: bigint;
+export const currencyMax: bigint;
+/**
+ * @typedef {object} CurrencyOptions
+ * @property {boolean} [and] - Use "e" between euros and centesimi
+ */
+/** @type {Required<CurrencyOptions>} */
+export const currencyDefaults: Required<CurrencyOptions>;
+export type CurrencyOptions = {
+    /**
+     * - Use "e" between euros and centesimi
+     */
+    and?: boolean | undefined;
+};
 /**
  * Converts a numeric value to Italian 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 Italian words
  * @throws {TypeError} If value is not a valid numeric type
  * @throws {Error} If value is not a valid number format
- *
  * @example
  * toCardinal(28)           // 'ventotto'
  * toCardinal(23)           // 'ventitré'
@@ -22,12 +35,10 @@ export function toCardinal(value: number | string | bigint): string;
  *
  * Italian ordinals: primo, secondo, terzo... (1-10 irregular)
  * For 11+: cardinal word (drop final vowel) + -esimo
- *
  * @param {number | string | bigint} value - The numeric value to convert (positive integer)
  * @returns {string} The number as ordinal words (masculine form)
  * @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)    // 'primo'
  * toOrdinal(2)    // 'secondo'
@@ -39,14 +50,11 @@ export function toCardinal(value: number | string | bigint): string;
 export function toOrdinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Italian currency words (Euro).
- *
  * @param {number | string | bigint} value - The currency amount to convert
- * @param {Object} [options] - Optional configuration
- * @param {boolean} [options.and=true] - Use "e" between euros and centesimi
+ * @param {CurrencyOptions} [options] - Optional configuration
  * @returns {string} The amount in Italian 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)                 // 'quarantadue euro e cinquanta centesimi'
  * toCurrency(1)                     // 'un euro'
@@ -54,6 +62,4 @@ export function toOrdinal(value: number | string | bigint): string;
  * toCurrency(0.01)                  // 'un centesimo'
  * toCurrency(42.50, { and: false }) // 'quarantadue euro cinquanta centesimi'
  */
-export function toCurrency(value: number | string | bigint, options?: {
-    and?: boolean | undefined;
-}): string;
+export function toCurrency(value: number | string | bigint, options?: CurrencyOptions): string;

package/src/it-IT.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 { longScale } from './utils/scale.js'
+import { resolveOptions } from './utils/resolve-options.js'
 
 // ============================================================================
 // Vocabulary (module-level constants)
@@ -42,6 +44,15 @@ const THOUSAND_PLURAL_SUFFIX = 'mila'
 // Scale word generation
 const SCALE_PREFIXES = ['m', 'b', 'tr', 'quadr', 'quint', 'sest', 'sett', 'ott', 'nov', 'dec']
 
+// Long scale: each prefix yields an -ilione (10^6k) and an -iliardo (10^6k+3),
+// so the table spans 6 powers of ten per prefix; past it the scale word is empty.
+// Each form's maximum supported value (a bigint), derived from the prefix table
+// so it can't drift. Exported per form so they split cleanly and the gate/docs
+// read each as a fact. it-IT shares one ceiling across all three forms.
+export const cardinalMax = longScale(SCALE_PREFIXES.length)
+export const ordinalMax = longScale(SCALE_PREFIXES.length)
+export const currencyMax = longScale(SCALE_PREFIXES.length)
+
 // ============================================================================
 // Ordinal Vocabulary
 // ============================================================================
@@ -72,8 +83,10 @@ const CENTESIMI = 'centesimi'
  * - Tens ending in vowel + uno/otto → drop tens vowel: ventuno, ventotto
  * - Hundreds cento + otto/ottanta → centotto, centottanta (drop 'o')
  * - Final 'tre' in compounds becomes 'tré': ventitré, trentatré
+ * @param {number} n - Number 0-999 to convert
+ * @returns {string} Segment word
  */
-function buildSegment (n) {
+function buildSegment(n) {
   if (n === 0) return ''
 
   const ones = n % 10
@@ -89,7 +102,8 @@ function buildSegment (n) {
     if (tens === 8 || (tens === 0 && ones === 8)) {
       // Remove final 'o' from hundreds: cento→cent, duecento→duecent, etc.
       result = HUNDREDS[hundreds].slice(0, -1)
-    } else {
+    }
+    else {
       result = HUNDREDS[hundreds]
     }
   }
@@ -97,28 +111,35 @@ function buildSegment (n) {
   // Tens and ones
   if (tens === 0 && ones === 0) {
     // Nothing more (just hundreds)
-  } else if (tens === 1) {
+  }
+  else if (tens === 1) {
     // Teens: 10-19
     result += TEENS[ones]
-  } else if (tens >= 2) {
+  }
+  else if (tens >= 2) {
     // 20-99: handle elision for uno (1) and otto (8)
     if (ones === 1 || ones === 8) {
       // Use stem form: vent + uno = ventuno, vent + otto = ventotto
       result += TENS_STEM[tens] + ONES[ones]
-    } else if (ones === 3) {
+    }
+    else if (ones === 3) {
       // Final tre becomes tré
       result += TENS[tens] + 'tré'
-    } else if (ones > 0) {
+    }
+    else if (ones > 0) {
       result += TENS[tens] + ONES[ones]
-    } else {
+    }
+    else {
       result += TENS[tens]
     }
-  } else if (ones > 0) {
+  }
+  else if (ones > 0) {
     // 1-9 (tens === 0)
     if (ones === 3 && hundreds > 0) {
       // centotré, duecentotré, etc.
       result += 'tré'
-    } else {
+    }
+    else {
       result += ONES[ones]
     }
   }
@@ -129,8 +150,10 @@ function buildSegment (n) {
 /**
  * Builds segment word with "un" for scale context (millions, billions).
  * Same as buildSegment but returns "un" for 1 instead of "uno".
+ * @param {number} n - Number 0-999 to convert
+ * @returns {string} Segment word
  */
-function buildSegmentForScale (n) {
+function buildSegmentForScale(n) {
   if (n === 0) return ''
   if (n === 1) return 'un' // "un milione" not "uno milione"
   return buildSegment(n)
@@ -139,8 +162,10 @@ function buildSegmentForScale (n) {
 /**
  * Builds thousands word for 1-999 thousand.
  * Handles elision: tre + mila = tremila (no accent), otto + mila = ottomila
+ * @param {number} n - Number of thousands 1-999
+ * @returns {string} Thousands word
  */
-function buildThousands (n) {
+function buildThousands(n) {
   if (n === 0) return ''
   if (n === 1) return THOUSAND_SINGULAR // "mille"
 
@@ -157,8 +182,9 @@ function buildThousands (n) {
 /**
  * Gets singular scale word for index.
  * @param {number} scaleIndex - 2=million, 3=billion, etc.
+ * @returns {string} Singular scale word
  */
-function getScaleWordSingular (scaleIndex) {
+function getScaleWordSingular(scaleIndex) {
   if (scaleIndex < 2) return ''
   const prefixIndex = Math.trunc((scaleIndex - 2) / 2)
   const isIardo = (scaleIndex - 2) % 2 === 1
@@ -170,8 +196,9 @@ function getScaleWordSingular (scaleIndex) {
 /**
  * Gets plural scale word for index.
  * @param {number} scaleIndex - 2=million, 3=billion, etc.
+ * @returns {string} Plural scale word
  */
-function getScaleWordPlural (scaleIndex) {
+function getScaleWordPlural(scaleIndex) {
   if (scaleIndex < 2) return ''
   const prefixIndex = Math.trunc((scaleIndex - 2) / 2)
   const isIardo = (scaleIndex - 2) % 2 === 1
@@ -186,11 +213,10 @@ function getScaleWordPlural (scaleIndex) {
 
 /**
  * Converts a non-negative integer to Italian words.
- *
  * @param {bigint} n - Non-negative integer to convert
  * @returns {string} Italian words
  */
-function integerToWords (n) {
+function integerToWords(n) {
   if (n === 0n) return ZERO
 
   // Fast path: numbers < 1000
@@ -217,11 +243,10 @@ function integerToWords (n) {
 
 /**
  * Builds words for numbers >= 1,000,000.
- *
  * @param {bigint} n - Number >= 1,000,000
  * @returns {string} Italian words
  */
-function buildLargeNumberWords (n) {
+function buildLargeNumberWords(n) {
   const parts = []
   let remaining = n
 
@@ -250,10 +275,12 @@ function buildLargeNumberWords (n) {
         ? getScaleWordSingular(scaleIndex)
         : getScaleWordPlural(scaleIndex)
       parts.push(segmentWords + ' ' + scaleWord)
-    } else if (scaleIndex === 1) {
+    }
+    else if (scaleIndex === 1) {
       // Thousands
       parts.push(buildThousands(segNum))
-    } else {
+    }
+    else {
       // Units (scaleIndex === 0): just the segment
       parts.push(buildSegment(segNum))
     }
@@ -265,11 +292,10 @@ function buildLargeNumberWords (n) {
 /**
  * Joins parts with Italian connector rules.
  * Uses "e" before simple (non-compound) final segment.
- *
  * @param {string[]} parts - Parts to join
  * @returns {string} Joined string
  */
-function joinPartsWithConnector (parts) {
+function joinPartsWithConnector(parts) {
   const len = parts.length
   if (len === 0) return ''
   if (len === 1) return parts[0]
@@ -295,11 +321,10 @@ function joinPartsWithConnector (parts) {
 
 /**
  * Converts decimal digits to Italian words.
- *
  * @param {string} decimalPart - Decimal digits (without the point)
  * @returns {string} Italian words for decimal part
  */
-function decimalPartToWords (decimalPart) {
+function decimalPartToWords(decimalPart) {
   let result = ''
 
   // Handle leading zeros
@@ -325,12 +350,10 @@ 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 Italian words
  * @throws {TypeError} If value is not a valid numeric type
  * @throws {Error} If value is not a valid number format
- *
  * @example
  * toCardinal(28)           // 'ventotto'
  * toCardinal(23)           // 'ventitré'
@@ -338,8 +361,11 @@ function decimalPartToWords (decimalPart) {
  * toCardinal(2000)         // 'duemila'
  * toCardinal(1000000)      // 'un milione'
  */
-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 = ''
 
@@ -362,11 +388,10 @@ function toCardinal (value) {
 
 /**
  * Converts a cardinal word to ordinal form by dropping final vowel and adding -esimo.
- *
  * @param {string} cardinalWord - Cardinal word to convert
  * @returns {string} Ordinal form
  */
-function cardinalToOrdinal (cardinalWord) {
+function cardinalToOrdinal(cardinalWord) {
   // Handle accented 'é' at end (tré → tre + esimo = treesimo)
   if (cardinalWord.endsWith('é')) {
     return cardinalWord.slice(0, -1) + 'e' + ORDINAL_SUFFIX
@@ -401,11 +426,10 @@ function cardinalToOrdinal (cardinalWord) {
 
 /**
  * Converts a positive integer to Italian ordinal words.
- *
  * @param {bigint} n - Positive integer
  * @returns {string} Italian ordinal words (masculine form)
  */
-function integerToOrdinal (n) {
+function integerToOrdinal(n) {
   // Special cases: 1-10 have irregular forms
   if (n <= 10n) {
     return ORDINAL_ONES[Number(n)]
@@ -421,12 +445,10 @@ function integerToOrdinal (n) {
  *
  * Italian ordinals: primo, secondo, terzo... (1-10 irregular)
  * For 11+: cardinal word (drop final vowel) + -esimo
- *
  * @param {number | string | bigint} value - The numeric value to convert (positive integer)
  * @returns {string} The number as ordinal words (masculine form)
  * @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)    // 'primo'
  * toOrdinal(2)    // 'secondo'
@@ -435,8 +457,10 @@ function integerToOrdinal (n) {
  * toOrdinal(100)  // 'centesimo'
  * toOrdinal(1000) // 'millesimo'
  */
-function toOrdinal (value) {
+function toOrdinal(value) {
   const integerPart = parseOrdinalValue(value)
+  // Ordinals are derived from the cardinal speller, so they share its ceiling.
+  checkMax(integerPart, ordinalMax)
   return integerToOrdinal(integerPart)
 }
 
@@ -444,16 +468,21 @@ function toOrdinal (value) {
 // CURRENCY: toCurrency(value, options?)
 // ============================================================================
 
+/**
+ * @typedef {object} CurrencyOptions
+ * @property {boolean} [and] - Use "e" between euros and centesimi
+ */
+
+/** @type {Required<CurrencyOptions>} */
+export const currencyDefaults = { and: true }
+
 /**
  * Converts a numeric value to Italian currency words (Euro).
- *
  * @param {number | string | bigint} value - The currency amount to convert
- * @param {Object} [options] - Optional configuration
- * @param {boolean} [options.and=true] - Use "e" between euros and centesimi
+ * @param {CurrencyOptions} [options] - Optional configuration
  * @returns {string} The amount in Italian 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)                 // 'quarantadue euro e cinquanta centesimi'
  * toCurrency(1)                     // 'un euro'
@@ -461,10 +490,10 @@ function toOrdinal (value) {
  * toCurrency(0.01)                  // 'un centesimo'
  * toCurrency(42.50, { and: false }) // 'quarantadue euro cinquanta centesimi'
  */
-function toCurrency (value, options) {
-  options = validateOptions(options)
+function toCurrency(value, options) {
   const { isNegative, dollars: euros, cents: centesimi } = parseCurrencyValue(value)
-  const { and: useAnd = true } = options
+  checkMax(euros, currencyMax)
+  const { and: useAnd } = resolveOptions(options, currencyDefaults)
 
   // Build result
   let result = ''
@@ -475,7 +504,8 @@ function toCurrency (value, options) {
     // Use "un" for 1 euro instead of "uno"
     if (euros === 1n) {
       result += 'un'
-    } else {
+    }
+    else {
       result += integerToWords(euros)
     }
     // Euro is invariable (doesn't change for plural in Italian)
@@ -490,7 +520,8 @@ function toCurrency (value, options) {
     // Use "un" for 1 centesimo instead of "uno"
     if (centesimi === 1n) {
       result += 'un'
-    } else {
+    }
+    else {
       result += integerToWords(centesimi)
     }
     result += ' ' + (centesimi === 1n ? CENTESIMO : CENTESIMI)

package/src/ja-JP.d.ts

@@ -1,14 +1,15 @@
+export const cardinalMax: bigint;
+export const ordinalMax: bigint;
+export const currencyMax: bigint;
 /**
  * Converts a numeric value to Japanese 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 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)        // '一万'
@@ -17,12 +18,10 @@
 export function toCardinal(value: number | string | bigint): string;
 /**
  * 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)   // '第十'
@@ -34,12 +33,10 @@ export function toOrdinal(value: number | string | bigint): string;
  *
  * 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)      // '一円'