n2words 5.0.0 → 5.1.1

package/src/fr-FR.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 { longScale } from './utils/scale.js'
+import { resolveOptions } from './utils/resolve-options.js'
 
 // ============================================================================
 // Vocabulary (module-level constants)
@@ -28,6 +30,15 @@ const TENS = ['', '', 'vingt', 'trente', 'quarante', 'cinquante', 'soixante']
 const SCALES = ['million', 'billion', 'trillion', 'quadrillion']
 const SCALES_ARD = ['milliard', 'billiard', 'trilliard', 'quadrilliard']
 
+// Supported magnitude ceiling (checked at the public entry points). Long scale:
+// each SCALES entry has a base and an "-ard" form spanning two segment groups,
+// so with the units group that's 2 * SCALES.length + 2 groups of 3 digits.
+// Cardinals must stay below 10^30; ordinals and currency build on the cardinal,
+// so they share the same ceiling.
+export const cardinalMax = longScale(SCALES.length)
+export const ordinalMax = longScale(SCALES.length)
+export const currencyMax = longScale(SCALES.length)
+
 const THOUSAND = 'mille'
 const HUNDRED = 'cent'
 const ZERO = 'zéro'
@@ -60,8 +71,10 @@ const CENTIMES = 'centimes'
 /**
  * Builds segment word for 0-999.
  * Returns object with { word, endsWithCents, endsWithVingts } for pluralization handling.
+ * @param {number} n - Segment value (0-999)
+ * @returns {{ word: string, endsWithCents: boolean, endsWithVingts: boolean }} Segment words and pluralization flags
  */
-function buildSegment (n) {
+function buildSegment(n) {
   if (n === 0) return { word: '', endsWithCents: false, endsWithVingts: false }
 
   const tensOnes = n % 100
@@ -76,15 +89,18 @@ function buildSegment (n) {
     if (hundreds === 1) {
       if (tensOnes === 0) {
         parts.push(HUNDRED)
-      } else {
+      }
+      else {
         parts.push(HUNDRED)
       }
-    } else {
+    }
+    else {
       if (tensOnes === 0) {
         // "deux cents", "trois cents" (with 's')
         parts.push(ONES[hundreds] + ' ' + HUNDRED + 's')
         endsWithCents = true
-      } else {
+      }
+      else {
         // "deux cent", "trois cent" (no 's' when followed by more)
         parts.push(ONES[hundreds] + ' ' + HUNDRED)
       }
@@ -94,48 +110,59 @@ function buildSegment (n) {
   // Tens and ones - vigesimal pattern
   if (tensOnes === 0) {
     // Just hundreds, nothing more
-  } else if (tensOnes < 10) {
+  }
+  else if (tensOnes < 10) {
     // Single digit
     parts.push(ONES[tensOnes])
-  } else if (tensOnes < 17) {
+  }
+  else if (tensOnes < 17) {
     // 10-16: regular teens
     parts.push(TEENS[tensOnes - 10])
-  } else if (tensOnes < 20) {
+  }
+  else if (tensOnes < 20) {
     // 17-19: dix-sept, dix-huit, dix-neuf
     parts.push(TEENS[tensOnes - 10])
-  } else if (tensOnes < 70) {
+  }
+  else if (tensOnes < 70) {
     // 20-69: standard tens + ones
     const t = Math.trunc(tensOnes / 10)
     const o = tensOnes % 10
     if (o === 0) {
       parts.push(TENS[t])
-    } else if (o === 1) {
+    }
+    else if (o === 1) {
       // "et un" for 21, 31, 41, 51, 61
       parts.push(TENS[t] + ' et ' + ONES[1])
-    } else {
+    }
+    else {
       parts.push(TENS[t] + '-' + ONES[o])
     }
-  } else if (tensOnes < 80) {
+  }
+  else if (tensOnes < 80) {
     // 70-79: soixante-dix, soixante et onze, soixante-douze...
     const remainder = tensOnes - 60
     if (remainder === 11) {
       // 71: soixante et onze
       parts.push('soixante et onze')
-    } else {
+    }
+    else {
       // 70, 72-79: soixante-dix, soixante-douze...
       parts.push('soixante-' + TEENS[remainder - 10])
     }
-  } else if (tensOnes === 80) {
+  }
+  else if (tensOnes === 80) {
     // 80: quatre-vingts (with 's')
     parts.push('quatre-vingts')
     endsWithVingts = true
-  } else if (tensOnes < 100) {
+  }
+  else if (tensOnes < 100) {
     // 81-99: quatre-vingt-un, quatre-vingt-dix...
     const remainder = tensOnes - 80
     if (remainder < 10) {
       // 81-89
       parts.push('quatre-vingt-' + ONES[remainder])
-    } else {
+    }
+    else {
       // 90-99
       parts.push('quatre-vingt-' + TEENS[remainder - 10])
     }
@@ -151,12 +178,11 @@ function buildSegment (n) {
 
 /**
  * Gets scale word for French long scale with -ard pattern.
- *
  * @param {number} scaleIndex - Scale level (1 = thousand, 2 = million, etc.)
  * @param {bigint} segment - Segment value for pluralization
  * @returns {string} Scale word
  */
-function getScaleWord (scaleIndex, segment) {
+function getScaleWord(scaleIndex, segment) {
   if (scaleIndex === 1) return THOUSAND
 
   // Even indices (2, 4, 6, 8): million, billion, trillion, quadrillion
@@ -166,7 +192,8 @@ function getScaleWord (scaleIndex, segment) {
     const baseWord = SCALES[arrayIndex]
     if (!baseWord) return ''
     return segment > 1n ? baseWord + 's' : baseWord
-  } else {
+  }
+  else {
     const arrayIndex = ((scaleIndex - 1) / 2) - 1
     const ardWord = SCALES_ARD[arrayIndex]
     if (!ardWord) return THOUSAND
@@ -180,12 +207,11 @@ function getScaleWord (scaleIndex, segment) {
 
 /**
  * Converts a non-negative integer to French words.
- *
  * @param {bigint} n - Non-negative integer to convert
  * @param {boolean} withHyphen - Whether to use hyphen separators
  * @returns {string} French words
  */
-function integerToWords (n, withHyphen = false) {
+function integerToWords(n, withHyphen = false) {
   if (n === 0n) return ZERO
 
   // Fast path: numbers < 1000
@@ -203,7 +229,8 @@ function integerToWords (n, withHyphen = false) {
     if (thousands === 1) {
       // "mille" not "un mille"
       result = THOUSAND
-    } else {
+    }
+    else {
       // Check if segment ends with "cents" or "vingts" - need to strip 's' before mille
       const { word: thousandsWord, endsWithCents, endsWithVingts } = buildSegment(thousands)
       let adjustedWord = thousandsWord
@@ -231,12 +258,11 @@ function integerToWords (n, withHyphen = false) {
 
 /**
  * Builds words for numbers >= 1,000,000.
- *
  * @param {bigint} n - Number >= 1,000,000
  * @param {boolean} withHyphen - Whether to use hyphen separators
  * @returns {string} French words
  */
-function buildLargeNumberWords (n, withHyphen) {
+function buildLargeNumberWords(n, withHyphen) {
   const numStr = n.toString()
   const len = numStr.length
 
@@ -269,11 +295,13 @@ function buildLargeNumberWords (n, withHyphen) {
       if (scaleIndex === 0) {
         // Units segment
         parts.push(segWords)
-      } else if (scaleIndex === 1) {
+      }
+      else if (scaleIndex === 1) {
         // Thousands: "mille" not "un mille"
         if (segment === 1) {
           parts.push(THOUSAND)
-        } else {
+        }
+        else {
           // Strip 's' from cents/vingts before mille
           let adjustedWord = segWords
           if (endsWithCents || endsWithVingts) {
@@ -282,7 +310,8 @@ function buildLargeNumberWords (n, withHyphen) {
           parts.push(adjustedWord)
           parts.push(scaleWord)
         }
-      } else {
+      }
+      else {
         // Million and above
         parts.push(segWords)
         parts.push(scaleWord)
@@ -304,12 +333,11 @@ function buildLargeNumberWords (n, withHyphen) {
 
 /**
  * Converts decimal digits to French words.
- *
  * @param {string} decimalPart - Decimal digits (without the point)
  * @param {boolean} withHyphen - Whether to use hyphen separators
  * @returns {string} French words for decimal part
  */
-function decimalPartToWords (decimalPart, withHyphen) {
+function decimalPartToWords(decimalPart, withHyphen) {
   let result = ''
   const sep = withHyphen ? '-' : ' '
 
@@ -331,30 +359,37 @@ function decimalPartToWords (decimalPart, withHyphen) {
   return result
 }
 
+/**
+ * @typedef {object} CardinalOptions
+ * @property {boolean} [withHyphenSeparator] - Use hyphens between all words
+ */
+
+/** @type {Required<CardinalOptions>} */
+export const cardinalDefaults = { withHyphenSeparator: false }
+
 /**
  * Converts a numeric value to French 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
- * @param {Object} [options] - Optional configuration
- * @param {boolean} [options.withHyphenSeparator=false] - Use hyphens between all words
+ * @param {CardinalOptions} [options] - Optional configuration
  * @returns {string} The number in French words
  * @throws {TypeError} If value is not a valid numeric type
  * @throws {Error} If value is not a valid number format
- *
  * @example
  * toCardinal(21)           // 'vingt et un'
  * toCardinal(80)           // 'quatre-vingts'
  * toCardinal(1000000)      // 'un million'
  */
-function toCardinal (value, options) {
-  options = validateOptions(options)
+function toCardinal(value, options) {
   const { isNegative, integerPart, decimalPart } = parseCardinalValue(value)
+  // Both the integer part and the decimal's significant digits are spelled via
+  // the scale builder, so both must clear the ceiling.
+  checkMax(integerPart, cardinalMax, decimalPart)
 
   // Apply option defaults
-  const { withHyphenSeparator = false } = options
+  const { withHyphenSeparator } = resolveOptions(options, cardinalDefaults)
 
   let result = ''
   const sep = withHyphenSeparator ? '-' : ' '
@@ -383,11 +418,10 @@ function toCardinal (value, options) {
  * - Drop final -e before adding -ième (quatre → quatrième)
  * - cinq → cinquième (add -u- before -ième)
  * - neuf → neuvième (f → v before -ième)
- *
  * @param {string} cardinalWord - Cardinal word to convert
  * @returns {string} Ordinal form
  */
-function cardinalToOrdinal (cardinalWord) {
+function cardinalToOrdinal(cardinalWord) {
   // Handle special endings
   if (cardinalWord.endsWith('cinq')) {
     // cinq → cinquième (add 'u')
@@ -401,16 +435,16 @@ function cardinalToOrdinal (cardinalWord) {
 
   // Drop plural -s from cents/vingts/millions/etc. (quatre-vingts → quatre-vingtième)
   // Note: "trois", "six" also end in s but that's not a plural
-  if (cardinalWord.endsWith('cents') ||
-      cardinalWord.endsWith('vingts') ||
-      cardinalWord.endsWith('millions') ||
-      cardinalWord.endsWith('milliards') ||
-      cardinalWord.endsWith('billions') ||
-      cardinalWord.endsWith('billiards') ||
-      cardinalWord.endsWith('trillions') ||
-      cardinalWord.endsWith('trilliards') ||
-      cardinalWord.endsWith('quadrillions') ||
-      cardinalWord.endsWith('quadrilliards')) {
+  if (cardinalWord.endsWith('cents')
+    || cardinalWord.endsWith('vingts')
+    || cardinalWord.endsWith('millions')
+    || cardinalWord.endsWith('milliards')
+    || cardinalWord.endsWith('billions')
+    || cardinalWord.endsWith('billiards')
+    || cardinalWord.endsWith('trillions')
+    || cardinalWord.endsWith('trilliards')
+    || cardinalWord.endsWith('quadrillions')
+    || cardinalWord.endsWith('quadrilliards')) {
     return cardinalWord.slice(0, -1) + ORDINAL_SUFFIX
   }
 
@@ -425,11 +459,10 @@ function cardinalToOrdinal (cardinalWord) {
 
 /**
  * Converts a positive integer to French ordinal words.
- *
  * @param {bigint} n - Positive integer
  * @returns {string} French ordinal words
  */
-function integerToOrdinal (n) {
+function integerToOrdinal(n) {
   // Special case: 1 → premier
   if (n === 1n) {
     return PREMIER
@@ -445,12 +478,10 @@ function integerToOrdinal (n) {
  *
  * French ordinals: premier (1st), then cardinal + ième.
  * Special rules: quatre→quatrième, cinq→cinquième, neuf→neuvième.
- *
  * @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)    // 'premier'
  * toOrdinal(2)    // 'deuxième'
@@ -461,8 +492,9 @@ function integerToOrdinal (n) {
  * toOrdinal(100)  // 'centième'
  * toOrdinal(1000) // 'millième'
  */
-function toOrdinal (value) {
+function toOrdinal(value) {
   const integerPart = parseOrdinalValue(value)
+  checkMax(integerPart, ordinalMax)
   return integerToOrdinal(integerPart)
 }
 
@@ -470,16 +502,21 @@ function toOrdinal (value) {
 // CURRENCY: toCurrency(value, options?)
 // ============================================================================
 
+/**
+ * @typedef {object} CurrencyOptions
+ * @property {boolean} [and] - Use "et" between euros and centimes
+ */
+
+/** @type {Required<CurrencyOptions>} */
+export const currencyDefaults = { and: true }
+
 /**
  * Converts a numeric value to French currency words (Euro).
- *
  * @param {number | string | bigint} value - The currency amount to convert
- * @param {Object} [options] - Optional configuration
- * @param {boolean} [options.and=true] - Use "et" between euros and centimes
+ * @param {CurrencyOptions} [options] - Optional configuration
  * @returns {string} The amount in French 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)                 // 'quarante-deux euros et cinquante centimes'
  * toCurrency(1)                     // 'un euro'
@@ -487,10 +524,10 @@ function toOrdinal (value) {
  * toCurrency(0.01)                  // 'un centime'
  * toCurrency(42.50, { and: false }) // 'quarante-deux euros cinquante centimes'
  */
-function toCurrency (value, options) {
-  options = validateOptions(options)
+function toCurrency(value, options) {
   const { isNegative, dollars: euros, cents: centimes } = parseCurrencyValue(value)
-  const { and: useAnd = true } = options
+  checkMax(euros, currencyMax)
+  const { and: useAnd } = resolveOptions(options, currencyDefaults)
 
   // Build result
   let result = ''

package/src/gu-IN.d.ts

@@ -1,18 +1,18 @@
+export const cardinalMax: bigint;
+export const ordinalMax: bigint;
+export const currencyMax: bigint;
 /**
  * Converts a numeric value to Gujarati words.
- *
  * @param {number | string | bigint} value - The numeric value to convert
  * @returns {string} The number in Gujarati words
  */
 export function toCardinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Gujarati 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 Gujarati currency words (Indian Rupee).
- *
  * @param {number | string | bigint} value - The currency amount to convert
  * @returns {string} The amount in Gujarati 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/gu-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} Gujarati 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} Gujarati 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) {
+/**
+ * Converts the fractional digits to per-digit Gujarati words.
+ * @param {string} decimalPart - Decimal digits as a string
+ * @returns {string} Gujarati words for each digit
+ */
+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 Gujarati words.
- *
  * @param {number | string | bigint} value - The numeric value to convert
  * @returns {string} The number in Gujarati 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 Gujarati ordinal words.
  *
  * Gujarati ordinals: First 6 are irregular, then add -મું suffix.
- *
  * @param {bigint} n - Positive integer to convert
  * @returns {string} Gujarati 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 Gujarati 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 Gujarati currency words (Indian Rupee).
- *
  * @param {number | string | bigint} value - The currency amount to convert
  * @returns {string} The amount in Gujarati 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 = ''

package/src/ha-NG.d.ts

@@ -1,18 +1,18 @@
+export const cardinalMax: bigint;
+export const ordinalMax: bigint;
+export const currencyMax: bigint;
 /**
  * Converts a numeric value to Hausa words.
- *
  * @param {number | string | bigint} value - The numeric value to convert
  * @returns {string} The number in Hausa words
  */
 export function toCardinal(value: number | string | bigint): string;
 /**
  * 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'
@@ -23,12 +23,10 @@ export function toOrdinal(value: number | string | bigint): string;
  * 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'