n2words 5.0.0 → 5.1.0

package/src/sr-Latn-RS.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 { western } from './utils/scale.js'
+import { resolveOptions } from './utils/resolve-options.js'
 
 // ============================================================================
 // Vocabulary
@@ -56,7 +58,7 @@ const ORDINAL_SCALES = [
   'trilioniti',
   'trilijarditi',
   'kvadrilioniti',
-  'kvadrilijarditi'
+  'kvadrilijarditi',
 ]
 
 // ============================================================================
@@ -79,14 +81,27 @@ const SCALE_FORMS = [
   ['trilion', 'triliona', 'triliona'],
   ['trilijarda', 'trilijarde', 'trilijarda'],
   ['kvadrilion', 'kvadriliona', 'kvadriliona'],
-  ['kvadrilijarda', 'kvadrilijarde', 'kvadrilijarda']
+  ['kvadrilijarda', 'kvadrilijarde', 'kvadrilijarda'],
 ]
 
+// Supported magnitude ceilings (checked at the public entry points). Both the
+// cardinal SCALE_FORMS and the ORDINAL_SCALES tables cover units + N scale
+// groups, so values must stay below 10^((length + 1) * 3) = 10^30.
+export const cardinalMax = western(SCALE_FORMS.length)
+export const ordinalMax = western(ORDINAL_SCALES.length)
+export const currencyMax = western(SCALE_FORMS.length)
+
 // ============================================================================
 // Segment Building
 // ============================================================================
 
-function pluralize (n, forms) {
+/**
+ * Selects the correct plural form based on Serbian grammar rules.
+ * @param {number | bigint} n - The count
+ * @param {string[]} forms - Plural forms [one, few, many]
+ * @returns {string} The selected plural form
+ */
+function pluralize(n, forms) {
   const num = typeof n === 'bigint' ? Number(n) : n
   const lastDigit = num % 10
   const lastTwoDigits = num % 100
@@ -100,7 +115,12 @@ function pluralize (n, forms) {
   return forms[2]
 }
 
-function buildSegmentMasc (n) {
+/**
+ * Builds the masculine word form for a 0-999 segment.
+ * @param {number} n - Segment value 0-999
+ * @returns {string} The segment words
+ */
+function buildSegmentMasc(n) {
   if (n === 0) return ''
 
   const onesDigit = n % 10
@@ -119,14 +139,20 @@ function buildSegmentMasc (n) {
 
   if (tensDigit === 1) {
     parts.push(TEENS[onesDigit])
-  } else if (onesDigit > 0) {
+  }
+  else if (onesDigit > 0) {
     parts.push(ONES_MASC[onesDigit])
   }
 
   return parts.join(' ')
 }
 
-function buildSegmentFem (n) {
+/**
+ * Builds the feminine word form for a 0-999 segment.
+ * @param {number} n - Segment value 0-999
+ * @returns {string} The segment words
+ */
+function buildSegmentFem(n) {
   if (n === 0) return ''
 
   const onesDigit = n % 10
@@ -145,7 +171,8 @@ function buildSegmentFem (n) {
 
   if (tensDigit === 1) {
     parts.push(TEENS[onesDigit])
-  } else if (onesDigit > 0) {
+  }
+  else if (onesDigit > 0) {
     parts.push(ONES_FEM[onesDigit])
   }
 
@@ -156,7 +183,13 @@ function buildSegmentFem (n) {
 // Conversion Functions
 // ============================================================================
 
-function integerToWords (n, gender) {
+/**
+ * Converts a non-negative integer to Serbian words.
+ * @param {bigint} n - The integer to convert
+ * @param {('masculine'|'feminine')} gender - Grammatical gender
+ * @returns {string} The integer in Serbian words
+ */
+function integerToWords(n, gender) {
   if (n === 0n) return ZERO
 
   if (n < 1000n) {
@@ -166,7 +199,13 @@ function integerToWords (n, gender) {
   return buildLargeNumberWords(n, gender)
 }
 
-function buildLargeNumberWords (n, gender) {
+/**
+ * Builds words for numbers >= 1000 using scale decomposition.
+ * @param {bigint} n - The integer to convert (>= 1000)
+ * @param {('masculine'|'feminine')} gender - Grammatical gender
+ * @returns {string} The number in Serbian words
+ */
+function buildLargeNumberWords(n, gender) {
   const numStr = n.toString()
   const len = numStr.length
 
@@ -193,7 +232,8 @@ function buildLargeNumberWords (n, gender) {
     if (segment !== 0) {
       if (scaleIndex === 0) {
         parts.push(gender === 'feminine' ? buildSegmentFem(segment) : buildSegmentMasc(segment))
-      } else {
+      }
+      else {
         const scaleForms = SCALE_FORMS[scaleIndex - 1]
         const scaleWord = pluralize(segment, scaleForms)
         // Thousands (scaleIndex=1) are feminine, others masculine
@@ -209,7 +249,13 @@ function buildLargeNumberWords (n, gender) {
   return parts.join(' ')
 }
 
-function decimalPartToWords (decimalPart, gender) {
+/**
+ * Converts the decimal-part digit string to Serbian words.
+ * @param {string} decimalPart - The fractional digits as a string
+ * @param {('masculine'|'feminine')} gender - Grammatical gender
+ * @returns {string} The decimal part in Serbian words
+ */
+function decimalPartToWords(decimalPart, gender) {
   let result = ''
   let i = 0
 
@@ -228,20 +274,31 @@ function decimalPartToWords (decimalPart, gender) {
   return result
 }
 
+/**
+ * @typedef {object} CardinalOptions
+ * @property {('masculine'|'feminine')} [gender] - Grammatical gender
+ */
+
+/** @type {Required<CardinalOptions>} */
+export const cardinalDefaults = { gender: 'masculine' }
+
+/** @type {{ gender: ReadonlyArray<Required<CardinalOptions>['gender']> }} */
+export const cardinalValues = { gender: ['masculine', 'feminine'] }
+
 /**
  * Converts a numeric value to Serbian (Latin) 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 {CardinalOptions} [options] - Optional configuration
  * @returns {string} The number in Serbian Latin words
  */
-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 { gender = 'masculine' } = options
+  const { gender } = resolveOptions(options, cardinalDefaults, cardinalValues)
 
   let result = ''
 
@@ -265,11 +322,10 @@ function toCardinal (value, options) {
 /**
  * Builds ordinal for a 0-99 segment when it's the final (ordinal) part.
  * Returns ordinal form: "prvi", "dvadeset prvi", etc.
- *
  * @param {number} n - Number 0-99
  * @returns {string} Ordinal words
  */
-function buildOrdinalTensOnes (n) {
+function buildOrdinalTensOnes(n) {
   if (n === 0) return ''
 
   const onesDigit = n % 10
@@ -300,11 +356,10 @@ function buildOrdinalTensOnes (n) {
  *
  * In Serbian ordinals, only the LAST component becomes ordinal.
  * E.g., 121 = "sto dvadeset prvi" (one hundred twenty first)
- *
  * @param {bigint} n - Positive integer to convert
  * @returns {string} Ordinal Serbian words
  */
-function integerToOrdinal (n) {
+function integerToOrdinal(n) {
   // Fast path: numbers < 100
   if (n < 100n) {
     return buildOrdinalTensOnes(Number(n))
@@ -352,11 +407,10 @@ function integerToOrdinal (n) {
 /**
  * Builds ordinal words for numbers >= 1,000,000.
  * All segments except the final one are cardinal; final segment is ordinal.
- *
  * @param {bigint} n - Number >= 1,000,000
  * @returns {string} Ordinal Serbian words
  */
-function buildLargeOrdinal (n) {
+function buildLargeOrdinal(n) {
   const numStr = n.toString()
   const len = numStr.length
 
@@ -394,22 +448,26 @@ function buildLargeOrdinal (n) {
         // Units position (no scale)
         if (isLastNonZero) {
           parts.push(integerToOrdinal(BigInt(segment)))
-        } else {
+        }
+        else {
           parts.push(buildSegmentMasc(segment))
         }
-      } else {
+      }
+      else {
         // Has scale word
         if (isLastNonZero) {
           // This scale position is the final ordinal
           if (segment === 1) {
             parts.push(ORDINAL_SCALES[scaleIndex - 1])
-          } else {
+          }
+          else {
             // Use cardinal segment + ordinal scale
             const isFeminine = scaleIndex === 1 // thousands are feminine
             const segmentWord = isFeminine ? buildSegmentFem(segment) : buildSegmentMasc(segment)
             parts.push(segmentWord + ' ' + ORDINAL_SCALES[scaleIndex - 1])
           }
-        } else {
+        }
+        else {
           // Not the final segment: use cardinal
           const scaleForms = SCALE_FORMS[scaleIndex - 1]
           const scaleWord = pluralize(segment, scaleForms)
@@ -428,12 +486,10 @@ function buildLargeOrdinal (n) {
 
 /**
  * Converts a numeric value to Serbian ordinal words (masculine nominative).
- *
  * @param {number | string | bigint} value - The numeric value to convert (must be a positive integer)
  * @returns {string} The number as ordinal words (e.g., "prvi", "četrdeset drugi")
  * @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)    // 'prvi'
  * toOrdinal(2)    // 'drugi'
@@ -443,8 +499,9 @@ function buildLargeOrdinal (n) {
  * toOrdinal(100)  // 'stoti'
  * toOrdinal(1000) // 'hiljaditi'
  */
-function toOrdinal (value) {
+function toOrdinal(value) {
   const integerPart = parseOrdinalValue(value)
+  checkMax(integerPart, ordinalMax)
   return integerToOrdinal(integerPart)
 }
 
@@ -452,16 +509,21 @@ function toOrdinal (value) {
 // CURRENCY: toCurrency(value, options?)
 // ============================================================================
 
+/**
+ * @typedef {object} CurrencyOptions
+ * @property {boolean} [and] - Use "i" between dinars and para
+ */
+
+/** @type {Required<CurrencyOptions>} */
+export const currencyDefaults = { and: true }
+
 /**
  * Converts a numeric value to Serbian currency words (Serbian Dinar).
- *
  * @param {number | string | bigint} value - The currency amount to convert
- * @param {Object} [options] - Optional configuration
- * @param {boolean} [options.and=true] - Use "i" between dinars and para
+ * @param {CurrencyOptions} [options] - Optional configuration
  * @returns {string} The amount in Serbian 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)                    // 'četrdeset dva dinara i pedeset para'
  * toCurrency(1)                        // 'jedan dinar'
@@ -469,10 +531,10 @@ function toOrdinal (value) {
  * toCurrency(0.01)                     // 'jedna para'
  * toCurrency(42.50, { and: false })    // 'četrdeset dva dinara pedeset para'
  */
-function toCurrency (value, options) {
-  options = validateOptions(options)
+function toCurrency(value, options) {
   const { isNegative, dollars: dinars, cents: para } = parseCurrencyValue(value)
-  const { and: useAnd = true } = options
+  checkMax(dinars, currencyMax)
+  const { and: useAnd } = resolveOptions(options, currencyDefaults)
 
   // Build result
   let result = ''

package/src/sv-SE.d.ts

@@ -1,11 +1,12 @@
+export const cardinalMax: bigint;
+export const ordinalMax: bigint;
+export const currencyMax: bigint;
 /**
  * Converts a numeric value to Swedish words.
- *
  * @param {number | string | bigint} value - The numeric value to convert
  * @returns {string} The number in Swedish words
  * @throws {TypeError} If value is not a valid numeric type
  * @throws {Error} If value is not a valid number format
- *
  * @example
  * toCardinal(42)       // 'fyrtio-två'
  * toCardinal(101)      // 'hundra och ett'
@@ -14,12 +15,10 @@
 export function toCardinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Swedish 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)    // 'första'
  * toOrdinal(2)    // 'andra'
@@ -30,12 +29,10 @@ export function toOrdinal(value: number | string | bigint): string;
  * Converts a numeric value to Swedish currency words (Swedish Krona).
  *
  * Uses krona/kronor and öre (100 öre = 1 krona).
- *
  * @param {number | string | bigint} value - The currency amount to convert
  * @returns {string} The amount in Swedish currency words
  * @throws {TypeError} If value is not a valid numeric type
  * @throws {Error} If value is not a valid number format
- *
  * @example
  * toCurrency(1)      // 'en krona'
  * toCurrency(42)     // 'fyrtio-två kronor'

package/src/sv-SE.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 { western } from './utils/scale.js'
 
 // ============================================================================
 // Vocabulary (module-level constants)
@@ -33,12 +35,22 @@ const DECIMAL_SEP = 'komma'
 // Scale words (long scale with -ard forms)
 const SCALES = ['tusen', 'miljon', 'miljard', 'biljon', 'biljard', 'triljon', 'triljard', 'kvadriljon']
 
+// Supported magnitude ceiling (checked at the public entry points). SCALES is
+// indexed [scaleIndex - 1] from 'tusen' (10^3), so segments are [units, then
+// one per SCALES entry] -> ceiling 10^((SCALES.length + 1) * 3) = 10^27.
+// Ordinal (cardinal + suffix) and currency build on the cardinal, and the
+// decimal is spelled via integerToWords, so all share it.
+export const cardinalMax = western(SCALES.length)
+export const ordinalMax = western(SCALES.length)
+export const currencyMax = western(SCALES.length)
+
 // ============================================================================
 // Ordinal Vocabulary
 // ============================================================================
 
 // Swedish ordinals: 1st-2nd use -a (första, andra), then -de suffix
 // Numbers ending in 1, 2 (except 11, 12) use special forms
+/** @type {Record<number, string>} */
 const ORDINAL_ONES = {
   1: 'första',
   2: 'andra',
@@ -51,7 +63,7 @@ const ORDINAL_ONES = {
   9: 'nionde',
   10: 'tionde',
   11: 'elfte',
-  12: 'tolfte'
+  12: 'tolfte',
 }
 
 // ============================================================================
@@ -69,8 +81,10 @@ const ORE = 'öre' // same singular and plural
 /**
  * Builds segment word for 0-999.
  * Returns object with word and metadata for "och" logic.
+ * @param {number} n - Integer in range 0-999
+ * @returns {{word: string, hasHundred: boolean, lessThan100: boolean}} Segment word with "och" metadata
  */
-function buildSegment (n) {
+function buildSegment(n) {
   if (n === 0) return { word: '', hasHundred: false, lessThan100: false }
 
   const ones = n % 10
@@ -85,7 +99,8 @@ function buildSegment (n) {
     hasHundred = true
     if (hundreds === 1) {
       parts.push(HUNDRED)
-    } else {
+    }
+    else {
       parts.push(ONES[hundreds] + ' ' + HUNDRED)
     }
   }
@@ -94,22 +109,27 @@ function buildSegment (n) {
   let tensOnesWord = ''
   if (tens === 1) {
     tensOnesWord = TEENS[ones]
-  } else if (tens >= 2) {
+  }
+  else if (tens >= 2) {
     if (ones > 0) {
       tensOnesWord = TENS[tens] + '-' + ONES[ones]
-    } else {
+    }
+    else {
       tensOnesWord = TENS[tens]
     }
-  } else if (ones > 0) {
+  }
+  else if (ones > 0) {
     tensOnesWord = ONES[ones]
   }
 
   // Combine with "och" after hundreds if there's a remainder
   if (hasHundred && tensOnesWord) {
     return { word: parts[0] + ' och ' + tensOnesWord, hasHundred: true, lessThan100: false }
-  } else if (hasHundred) {
+  }
+  else if (hasHundred) {
     return { word: parts[0], hasHundred: true, lessThan100: false }
-  } else {
+  }
+  else {
     return { word: tensOnesWord, hasHundred: false, lessThan100: true }
   }
 }
@@ -120,11 +140,10 @@ function buildSegment (n) {
 
 /**
  * Converts a non-negative integer to Swedish words.
- *
  * @param {bigint} n - Non-negative integer to convert
  * @returns {string} Swedish words
  */
-function integerToWords (n) {
+function integerToWords(n) {
   if (n === 0n) return ZERO
 
   // Fast path: numbers < 1000
@@ -145,7 +164,8 @@ function integerToWords (n) {
       // Insert "och" if remainder < 100 (doesn't have hundred)
       if (remainderResult.lessThan100) {
         result += ' och ' + remainderResult.word
-      } else {
+      }
+      else {
         result += ' ' + remainderResult.word
       }
     }
@@ -159,11 +179,10 @@ function integerToWords (n) {
 
 /**
  * Builds words for numbers >= 1,000,000.
- *
  * @param {bigint} n - Number >= 1,000,000
  * @returns {string} Swedish words
  */
-function buildLargeNumberWords (n) {
+function buildLargeNumberWords(n) {
   const numStr = n.toString()
   const len = numStr.length
 
@@ -197,9 +216,10 @@ function buildLargeNumberWords (n) {
         parts.push({
           word: segmentResult.word,
           hasHundred: segmentResult.hasHundred,
-          isScale: false
+          isScale: false,
         })
-      } else {
+      }
+      else {
         // Segment with scale word
         const scaleWord = SCALES[scaleIndex - 1]
 
@@ -208,10 +228,12 @@ function buildLargeNumberWords (n) {
           // Omit "ett" before tusen, use "en" before million+
           if (scaleIndex === 1) {
             segmentWord = '' // Just "tusen"
-          } else {
+          }
+          else {
             segmentWord = 'en' // "en miljon"
           }
-        } else {
+        }
+        else {
           segmentWord = segmentResult.word
         }
 
@@ -232,11 +254,10 @@ function buildLargeNumberWords (n) {
 /**
  * Joins parts with Swedish "och" rules.
  * Insert "och" before final segment if it follows a scale word and doesn't have "hundra".
- *
- * @param {Array} parts - Parts with metadata
+ * @param {Array<{word: string, hasHundred: boolean, isScale: boolean}>} parts - Parts with metadata
  * @returns {string} Joined string
  */
-function joinSwedishParts (parts) {
+function joinSwedishParts(parts) {
   if (parts.length === 0) return ZERO
   if (parts.length === 1) return parts[0].word
 
@@ -262,11 +283,10 @@ function joinSwedishParts (parts) {
 
 /**
  * Converts decimal digits to Swedish words.
- *
  * @param {string} decimalPart - Decimal digits (without the point)
  * @returns {string} Swedish words for decimal part
  */
-function decimalPartToWords (decimalPart) {
+function decimalPartToWords(decimalPart) {
   let result = ''
 
   // Handle leading zeros
@@ -289,19 +309,20 @@ function decimalPartToWords (decimalPart) {
 
 /**
  * Converts a numeric value to Swedish words.
- *
  * @param {number | string | bigint} value - The numeric value to convert
  * @returns {string} The number in Swedish words
  * @throws {TypeError} If value is not a valid numeric type
  * @throws {Error} If value is not a valid number format
- *
  * @example
  * toCardinal(42)       // 'fyrtio-två'
  * toCardinal(101)      // 'hundra och ett'
  * toCardinal(1000000)  // 'en miljon'
  */
-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 = ''
 
@@ -327,11 +348,10 @@ function toCardinal (value) {
  *
  * Swedish ordinals: första (1st), andra (2nd), tredje (3rd), etc.
  * Most use cardinal + de suffix, with special forms 1-12.
- *
  * @param {bigint} n - Positive integer to convert
  * @returns {string} Swedish ordinal words
  */
-function integerToOrdinal (n) {
+function integerToOrdinal(n) {
   // Special forms for 1-12
   if (n >= 1n && n <= 12n) {
     return ORDINAL_ONES[Number(n)]
@@ -348,19 +368,18 @@ function integerToOrdinal (n) {
 
 /**
  * Converts a numeric value to Swedish 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)    // 'första'
  * toOrdinal(2)    // 'andra'
  * toOrdinal(21)   // 'tjugo-ettde'
  */
-function toOrdinal (value) {
+function toOrdinal(value) {
   const integerPart = parseOrdinalValue(value)
+  checkMax(integerPart, ordinalMax)
   return integerToOrdinal(integerPart)
 }
 
@@ -372,19 +391,18 @@ function toOrdinal (value) {
  * Converts a numeric value to Swedish currency words (Swedish Krona).
  *
  * Uses krona/kronor and öre (100 öre = 1 krona).
- *
  * @param {number | string | bigint} value - The currency amount to convert
  * @returns {string} The amount in Swedish currency words
  * @throws {TypeError} If value is not a valid numeric type
  * @throws {Error} If value is not a valid number format
- *
  * @example
  * toCurrency(1)      // 'en krona'
  * toCurrency(42)     // 'fyrtio-två kronor'
  * toCurrency(1.50)   // 'en krona och femtio öre'
  */
-function toCurrency (value) {
+function toCurrency(value) {
   const { isNegative, dollars: kronor, cents: ore } = parseCurrencyValue(value)
+  checkMax(kronor, currencyMax)
 
   let result = ''
   if (isNegative) {
@@ -396,7 +414,8 @@ function toCurrency (value) {
     // Use "en" for 1 krona (not "ett")
     if (kronor === 1n) {
       result += 'en ' + KRONA
-    } else {
+    }
+    else {
       result += integerToWords(kronor) + ' ' + KRONOR
     }
   }

package/src/sw-KE.d.ts

@@ -1,18 +1,18 @@
+export const cardinalMax: bigint;
+export const ordinalMax: bigint;
+export const currencyMax: bigint;
 /**
  * Converts a numeric value to Swahili words.
- *
  * @param {number | string | bigint} value - The numeric value to convert
  * @returns {string} The number in Swahili words
  */
 export function toCardinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Swahili 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)    // 'wa kwanza'
  * toOrdinal(2)    // 'wa pili'
@@ -23,12 +23,10 @@ export function toOrdinal(value: number | string | bigint): string;
  * Converts a numeric value to Swahili currency words (Kenyan Shilling).
  *
  * Uses shilingi and senti (100 senti = 1 shilingi).
- *
  * @param {number | string | bigint} value - The currency amount to convert
  * @returns {string} The amount in Swahili 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)     // 'shilingi arobaini na mbili'
  * toCurrency(1.50)   // 'shilingi moja na senti hamsini'