n2words 5.0.0 → 5.1.0

package/src/yo-NG.d.ts

@@ -1,18 +1,18 @@
+export const cardinalMax: null;
+export const ordinalMax: null;
+export const currencyMax: null;
 /**
  * Converts a numeric value to Yoruba words.
- *
  * @param {number | string | bigint} value - The numeric value to convert
  * @returns {string} The number in Yoruba words
  */
 export function toCardinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Yoruba 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)    // 'àkọ́kọ́'
  * toOrdinal(2)    // 'ìkejì'
@@ -23,12 +23,10 @@ export function toOrdinal(value: number | string | bigint): string;
  * Converts a numeric value to Yoruba currency words (Nigerian Naira).
  *
  * Uses náírà (naira) and kọ́bọ̀ (kobo).
- *
  * @param {number | string | bigint} value - The currency amount to convert
  * @returns {string} The amount in Yoruba 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)     // 'èjì lé lógójì náírà'
  * toCurrency(1.50)   // 'ọ̀kan náírà àti àádọ́ta kọ́bọ̀'

package/src/yo-NG.js

@@ -19,6 +19,12 @@
 import { parseCardinalValue } from './utils/parse-cardinal.js'
 import { parseCurrencyValue } from './utils/parse-currency.js'
 import { parseOrdinalValue } from './utils/parse-ordinal.js'
+import { UNBOUNDED } from './utils/scale.js'
+
+// No fixed scale ceiling — the vigesimal speller composes every magnitude.
+export const cardinalMax = UNBOUNDED
+export const ordinalMax = UNBOUNDED
+export const currencyMax = UNBOUNDED
 
 // ============================================================================
 // Vocabulary (module-level constants)
@@ -36,7 +42,7 @@ const ONES = [
   'èje', // 7
   'ẹ̀jọ', // 8
   'ẹ̀sán', // 9
-  'ẹ̀wá' // 10
+  'ẹ̀wá', // 10
 ]
 
 // Numbers 11-14 (additive: X + 10, using "lá")
@@ -45,7 +51,7 @@ const TEENS_ADD = [
   'ọ̀kànlá', // 11 = 1 + 10
   'èjìlá', // 12 = 2 + 10
   'ẹ̀talá', // 13 = 3 + 10
-  'ẹ̀rinlá' // 14 = 4 + 10
+  'ẹ̀rinlá', // 14 = 4 + 10
 ]
 
 // Numbers 15-19 (subtractive: 20 - X, using "dín")
@@ -54,12 +60,13 @@ const TEENS_SUB = [
   'ẹ̀rìndínlógún', // 16 = 20 - 4
   'ẹ̀tadínlógún', // 17 = 20 - 3
   'èjìdínlógún', // 18 = 20 - 2
-  'ọ̀kàndínlógún' // 19 = 20 - 1
+  'ọ̀kàndínlógún', // 19 = 20 - 1
 ]
 
 // Decades (base-20 structure)
 // Even decades are multiples of 20
 // Odd decades subtract 10 from next even decade
+/** @type {Record<number, string>} */
 const DECADES = {
   20: 'ogún', // 20 = 20 × 1
   30: 'ọgbọ̀n', // 30 = 20 + 10 (special word)
@@ -69,10 +76,11 @@ const DECADES = {
   70: 'àádọ́rin', // 70 = 80 - 10
   80: 'ogórin', // 80 = 20 × 4
   90: 'àádọ́rùn', // 90 = 100 - 10
-  100: 'ọgọ́rùn' // 100 = 20 × 5
+  100: 'ọgọ́rùn', // 100 = 20 × 5
 }
 
 // Prefixes for adding to decades (lé lógún, lé lọgbọ̀n, etc.)
+/** @type {Record<number, string>} */
 const DECADE_ADD_SUFFIX = {
   20: 'lógún',
   30: 'lọgbọ̀n',
@@ -82,10 +90,11 @@ const DECADE_ADD_SUFFIX = {
   70: 'láàádọ́rin',
   80: 'lógórin',
   90: 'láàádọ́rùn',
-  100: 'lọ́gọ́rùn'
+  100: 'lọ́gọ́rùn',
 }
 
 // Prefixes for subtracting from decades (dín lógójì, etc.)
+/** @type {Record<number, string>} */
 const DECADE_SUB_SUFFIX = {
   20: 'dínlógún',
   30: 'dínlọgbọ̀n',
@@ -95,7 +104,7 @@ const DECADE_SUB_SUFFIX = {
   70: 'dínláàádọ́rin',
   80: 'dínlógórin',
   90: 'dínláàádọ́rùn',
-  100: 'dínlọ́gọ́rùn'
+  100: 'dínlọ́gọ́rùn',
 }
 
 // Scale words
@@ -135,8 +144,10 @@ const KOBO = 'kọ́bọ̀'
 
 /**
  * Builds word for numbers 0-99
+ * @param {number} n - Integer in the range 0-99
+ * @returns {string} Yoruba words for the number
  */
-function buildUnder100 (n) {
+function buildUnder100(n) {
   if (n === 0) return ''
   if (n <= 10) return ONES[n]
 
@@ -169,8 +180,10 @@ function buildUnder100 (n) {
 
 /**
  * Converts hundreds (100-999)
+ * @param {number} n - Integer in the range 0-999
+ * @returns {string} Yoruba words for the number
  */
-function convertHundreds (n) {
+function convertHundreds(n) {
   if (n < 100) return buildUnder100(n)
 
   const hundreds = Math.trunc(n / 100)
@@ -189,11 +202,14 @@ function convertHundreds (n) {
   // Build hundreds
   if (hundreds === 1) {
     result = HUNDRED
-  } else if (hundreds === 2) {
+  }
+  else if (hundreds === 2) {
     result = TWO_HUNDRED
-  } else if (hundreds === 4) {
+  }
+  else if (hundreds === 4) {
     result = FOUR_HUNDRED
-  } else {
+  }
+  else {
     // Other hundreds: X ọgọ́rùn
     result = ONES[hundreds] + ' ' + HUNDRED
   }
@@ -207,11 +223,10 @@ function convertHundreds (n) {
 
 /**
  * Converts a non-negative integer to Yoruba words.
- *
  * @param {bigint} n - Non-negative integer to convert
  * @returns {string} Yoruba words
  */
-function integerToWords (n) {
+function integerToWords(n) {
   if (n === 0n) return ZERO
 
   // Fast path: numbers < 100
@@ -234,7 +249,8 @@ function integerToWords (n) {
     remaining = remaining % 1_000_000n
     if (millions === 1n) {
       parts.push(MILLION + ' kan')
-    } else {
+    }
+    else {
       parts.push(MILLION + ' ' + integerToWords(millions))
     }
   }
@@ -246,13 +262,17 @@ function integerToWords (n) {
 
     if (thousands === 1n) {
       parts.push(THOUSAND + ' kan')
-    } else if (thousands === 10n) {
+    }
+    else if (thousands === 10n) {
       parts.push(TEN_THOUSAND)
-    } else if (thousands === 20n) {
+    }
+    else if (thousands === 20n) {
       parts.push(TWENTY_THOUSAND)
-    } else if (thousands < 100n) {
+    }
+    else if (thousands < 100n) {
       parts.push(THOUSAND + ' ' + buildUnder100(Number(thousands)))
-    } else {
+    }
+    else {
       parts.push(THOUSAND + ' ' + convertHundreds(Number(thousands)))
     }
   }
@@ -262,13 +282,16 @@ function integerToWords (n) {
     if (remaining < 100n) {
       if (parts.length > 0) {
         parts.push(AND + ' ' + buildUnder100(Number(remaining)))
-      } else {
+      }
+      else {
         parts.push(buildUnder100(Number(remaining)))
       }
-    } else {
+    }
+    else {
       if (parts.length > 0) {
         parts.push(AND + ' ' + convertHundreds(Number(remaining)))
-      } else {
+      }
+      else {
         parts.push(convertHundreds(Number(remaining)))
       }
     }
@@ -279,11 +302,10 @@ function integerToWords (n) {
 
 /**
  * Converts decimal digits to Yoruba words.
- *
  * @param {string} decimalPart - Decimal digits
  * @returns {string} Yoruba words for decimal
  */
-function decimalPartToWords (decimalPart) {
+function decimalPartToWords(decimalPart) {
   const parts = []
 
   for (const digit of decimalPart) {
@@ -296,11 +318,10 @@ function decimalPartToWords (decimalPart) {
 
 /**
  * Converts a numeric value to Yoruba words.
- *
  * @param {number | string | bigint} value - The numeric value to convert
  * @returns {string} The number in Yoruba words
  */
-function toCardinal (value) {
+function toCardinal(value) {
   const { isNegative, integerPart, decimalPart } = parseCardinalValue(value)
 
   let result = ''
@@ -326,11 +347,10 @@ function toCardinal (value) {
  * Converts a non-negative integer to Yoruba ordinal words.
  *
  * Yoruba ordinals: àkọ́kọ́ (1st), ìkejì (2nd), ìkẹta (3rd), ìkẹrin (4th), etc.
- *
  * @param {bigint} n - Positive integer to convert
  * @returns {string} Yoruba ordinal words
  */
-function integerToOrdinal (n) {
+function integerToOrdinal(n) {
   // Special forms
   if (n === 1n) return ORDINAL_FIRST
   if (n === 2n) return ORDINAL_SECOND
@@ -341,18 +361,16 @@ function integerToOrdinal (n) {
 
 /**
  * Converts a numeric value to Yoruba 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)    // 'àkọ́kọ́'
  * toOrdinal(2)    // 'ìkejì'
  * toOrdinal(3)    // 'ìkẹẹ̀ta'
  */
-function toOrdinal (value) {
+function toOrdinal(value) {
   const integerPart = parseOrdinalValue(value)
   return integerToOrdinal(integerPart)
 }
@@ -365,18 +383,16 @@ function toOrdinal (value) {
  * Converts a numeric value to Yoruba currency words (Nigerian Naira).
  *
  * Uses náírà (naira) and kọ́bọ̀ (kobo).
- *
  * @param {number | string | bigint} value - The currency amount to convert
  * @returns {string} The amount in Yoruba 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)     // 'èjì lé lógójì náírà'
  * toCurrency(1.50)   // 'ọ̀kan náírà àti àádọ́ta kọ́bọ̀'
  * toCurrency(-5)     // 'àìní àrùn náírà'
  */
-function toCurrency (value) {
+function toCurrency(value) {
   const { isNegative, dollars: naira, cents: kobo } = parseCurrencyValue(value)
 
   let result = ''

package/src/zh-Hans-CN.d.ts

@@ -1,48 +1,73 @@
+export const cardinalMax: bigint;
+export const ordinalMax: bigint;
+export const currencyMax: bigint;
+/**
+ * @typedef {object} CardinalOptions
+ * @property {boolean} [formal] - Use formal/financial numerals
+ */
+/** @type {Required<CardinalOptions>} */
+export const cardinalDefaults: Required<CardinalOptions>;
+/**
+ * @typedef {object} OrdinalOptions
+ * @property {boolean} [formal] - Use formal/financial numerals
+ */
+/** @type {Required<OrdinalOptions>} */
+export const ordinalDefaults: Required<OrdinalOptions>;
+/**
+ * @typedef {object} CurrencyOptions
+ * @property {boolean} [formal] - Use formal/financial numerals
+ */
+/** @type {Required<CurrencyOptions>} */
+export const currencyDefaults: Required<CurrencyOptions>;
+export type CardinalOptions = {
+    /**
+     * - Use formal/financial numerals
+     */
+    formal?: boolean | undefined;
+};
+export type OrdinalOptions = {
+    /**
+     * - Use formal/financial numerals
+     */
+    formal?: boolean | undefined;
+};
+export type CurrencyOptions = {
+    /**
+     * - Use formal/financial numerals
+     */
+    formal?: boolean | undefined;
+};
 /**
  * Converts a numeric value to Simplified Chinese words.
- *
  * @param {number | string | bigint} value - The numeric value to convert
- * @param {Object} [options] - Optional configuration
- * @param {boolean} [options.formal=true] - Use formal/financial numerals
+ * @param {CardinalOptions} [options] - Optional configuration
  * @returns {string} The number in Simplified Chinese words
  */
-export function toCardinal(value: number | string | bigint, options?: {
-    formal?: boolean | undefined;
-}): string;
+export function toCardinal(value: number | string | bigint, options?: CardinalOptions): string;
 /**
  * Converts a numeric value to Simplified Chinese ordinal words.
- *
  * @param {number | string | bigint} value - The numeric value to convert (positive integer)
- * @param {Object} [options] - Optional configuration
- * @param {boolean} [options.formal=true] - Use formal/financial numerals
+ * @param {OrdinalOptions} [options] - Optional configuration
  * @returns {string} The number as ordinal words
  * @throws {TypeError} If value is not a valid numeric type
  * @throws {RangeError} If value is negative, zero, or has a decimal part
- *
  * @example
  * toOrdinal(1)                    // '第壹'
  * toOrdinal(1, { formal: false }) // '第一'
  * toOrdinal(10)                   // '第壹拾'
  */
-export function toOrdinal(value: number | string | bigint, options?: {
-    formal?: boolean | undefined;
-}): string;
+export function toOrdinal(value: number | string | bigint, options?: OrdinalOptions): string;
 /**
  * Converts a numeric value to Simplified Chinese currency words (Yuan/Renminbi).
- *
  * @param {number | string | bigint} value - The currency amount to convert
- * @param {Object} [options] - Optional configuration
- * @param {boolean} [options.formal=true] - Use formal/financial numerals
+ * @param {CurrencyOptions} [options] - Optional configuration
  * @returns {string} The amount in Simplified Chinese 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.05)                     // '伍分'
  * toCurrency(42.50, { formal: false }) // '四十二元五角整'
  */
-export function toCurrency(value: number | string | bigint, options?: {
-    formal?: boolean | undefined;
-}): string;
+export function toCurrency(value: number | string | bigint, options?: CurrencyOptions): string;

package/src/zh-Hans-CN.js

@@ -13,7 +13,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 } from './utils/scale.js'
+import { resolveOptions } from './utils/resolve-options.js'
 
 // ============================================================================
 // Vocabulary
@@ -35,6 +37,17 @@ const THOUSAND_FORMAL = '仟'
 const WAN_WORD = '万' // 10,000
 const YI_WORD = '亿' // 100,000,000
 
+// Supported magnitude ceiling (checked at the public entry points). Numbers
+// >= 亿 (10^8) split into n / 10^8, which is then spelled by convertBelowYi —
+// itself only valid below 亿. So the ceiling is 亿² = 10^16. Ordinal (第 +
+// cardinal) and currency build on the cardinal, so they share it. Decimals are
+// spelled digit-by-digit, so they have no ceiling.
+// No scale table — bounded by the convertBelowYi recursion (亿² = 10^16),
+// declared via the escape hatch and verified by the gate. The three forms share it.
+export const cardinalMax = bounded(16)
+export const ordinalMax = bounded(16)
+export const currencyMax = bounded(16)
+
 const ZERO = '零'
 const NEGATIVE = '负'
 const DECIMAL_SEP = '点'
@@ -69,8 +82,14 @@ const ZHENG = '整'
 
 /**
  * Convert number below 万 (10,000) to words using direct string concatenation.
+ * @param {bigint} value The integer (0-9999) to convert
+ * @param {string[]} ones Digit words for 0-9
+ * @param {string} ten Word for the tens place
+ * @param {string} hundred Word for the hundreds place
+ * @param {string} thousand Word for the thousands place
+ * @returns {string} The number in words
  */
-function convertBelowWan (value, ones, ten, hundred, thousand) {
+function convertBelowWan(value, ones, ten, hundred, thousand) {
   if (value === 0n) return ''
 
   let result = ''
@@ -91,7 +110,8 @@ function convertBelowWan (value, ones, ten, hundred, thousand) {
     if (needsZero) result += ZERO
     result += ones[Number(hundredsVal)] + hundred
     needsZero = hundredsRemainder > 0n && hundredsRemainder < 10n
-  } else if (thousandsVal > 0n && hundredsRemainder > 0n) {
+  }
+  else if (thousandsVal > 0n && hundredsRemainder > 0n) {
     needsZero = true
   }
 
@@ -102,7 +122,8 @@ function convertBelowWan (value, ones, ten, hundred, thousand) {
     if (needsZero) result += ZERO
     result += ones[Number(tensVal)] + ten
     needsZero = false
-  } else if ((hundredsVal > 0n || thousandsVal > 0n) && onesVal > 0n) {
+  }
+  else if ((hundredsVal > 0n || thousandsVal > 0n) && onesVal > 0n) {
     needsZero = true
   }
 
@@ -117,8 +138,14 @@ function convertBelowWan (value, ones, ten, hundred, thousand) {
 
 /**
  * Convert number below 亿 (100 million) to words.
+ * @param {bigint} value The integer to convert
+ * @param {string[]} ones Digit words for 0-9
+ * @param {string} ten Word for the tens place
+ * @param {string} hundred Word for the hundreds place
+ * @param {string} thousand Word for the thousands place
+ * @returns {string} The number in words
  */
-function convertBelowYi (value, ones, ten, hundred, thousand) {
+function convertBelowYi(value, ones, ten, hundred, thousand) {
   if (value === 0n) return ''
 
   if (value >= 10_000n) {
@@ -139,7 +166,13 @@ function convertBelowYi (value, ones, ten, hundred, thousand) {
   return convertBelowWan(value, ones, ten, hundred, thousand)
 }
 
-function integerToWords (n, formal = true) {
+/**
+ * Convert an integer to Simplified Chinese words.
+ * @param {bigint} n The integer to convert
+ * @param {boolean} [formal] Use formal/financial numerals
+ * @returns {string} The integer in Simplified Chinese words
+ */
+function integerToWords(n, formal = true) {
   if (n === 0n) return ZERO
 
   const ones = formal ? ONES_FORMAL : ONES_COMMON
@@ -167,8 +200,11 @@ function integerToWords (n, formal = true) {
 
 /**
  * Convert decimal digits to words using direct concatenation.
+ * @param {string} decimalString The decimal digits to convert
+ * @param {string[]} ones Digit words for 0-9
+ * @returns {string} The decimal digits in words
  */
-function decimalDigitsToWords (decimalString, ones) {
+function decimalDigitsToWords(decimalString, ones) {
   let result = ''
   for (let i = 0; i < decimalString.length; i++) {
     result += ones[Number(decimalString[i])]
@@ -176,20 +212,26 @@ function decimalDigitsToWords (decimalString, ones) {
   return result
 }
 
+/**
+ * @typedef {object} CardinalOptions
+ * @property {boolean} [formal] - Use formal/financial numerals
+ */
+
+/** @type {Required<CardinalOptions>} */
+export const cardinalDefaults = { formal: true }
+
 /**
  * Converts a numeric value to Simplified Chinese words.
- *
  * @param {number | string | bigint} value - The numeric value to convert
- * @param {Object} [options] - Optional configuration
- * @param {boolean} [options.formal=true] - Use formal/financial numerals
+ * @param {CardinalOptions} [options] - Optional configuration
  * @returns {string} The number in Simplified Chinese words
  */
-function toCardinal (value, options) {
-  options = validateOptions(options)
+function toCardinal(value, options) {
   const { isNegative, integerPart, decimalPart } = parseCardinalValue(value)
+  checkMax(integerPart, cardinalMax)
 
   // Apply option defaults
-  const { formal = true } = options
+  const { formal } = resolveOptions(options, cardinalDefaults)
 
   let result = isNegative ? NEGATIVE : ''
 
@@ -211,34 +253,38 @@ function toCardinal (value, options) {
  * Converts a positive integer to Simplified Chinese ordinal words.
  *
  * Chinese ordinals: 第 prefix + cardinal number.
- *
  * @param {bigint} n - Positive integer to convert
  * @param {boolean} formal - Use formal numerals
  * @returns {string} Simplified Chinese ordinal words
  */
-function integerToOrdinal (n, formal) {
+function integerToOrdinal(n, formal) {
   return ORDINAL_PREFIX + integerToWords(n, formal)
 }
 
+/**
+ * @typedef {object} OrdinalOptions
+ * @property {boolean} [formal] - Use formal/financial numerals
+ */
+
+/** @type {Required<OrdinalOptions>} */
+export const ordinalDefaults = { formal: true }
+
 /**
  * Converts a numeric value to Simplified Chinese ordinal words.
- *
  * @param {number | string | bigint} value - The numeric value to convert (positive integer)
- * @param {Object} [options] - Optional configuration
- * @param {boolean} [options.formal=true] - Use formal/financial numerals
+ * @param {OrdinalOptions} [options] - Optional configuration
  * @returns {string} The number as ordinal words
  * @throws {TypeError} If value is not a valid numeric type
  * @throws {RangeError} If value is negative, zero, or has a decimal part
- *
  * @example
  * toOrdinal(1)                    // '第壹'
  * toOrdinal(1, { formal: false }) // '第一'
  * toOrdinal(10)                   // '第壹拾'
  */
-function toOrdinal (value, options) {
-  options = validateOptions(options)
+function toOrdinal(value, options) {
   const integerPart = parseOrdinalValue(value)
-  const { formal = true } = options
+  checkMax(integerPart, ordinalMax)
+  const { formal } = resolveOptions(options, ordinalDefaults)
   return integerToOrdinal(integerPart, formal)
 }
 
@@ -246,26 +292,31 @@ function toOrdinal (value, options) {
 // CURRENCY: toCurrency(value, options?)
 // ============================================================================
 
+/**
+ * @typedef {object} CurrencyOptions
+ * @property {boolean} [formal] - Use formal/financial numerals
+ */
+
+/** @type {Required<CurrencyOptions>} */
+export const currencyDefaults = { formal: true }
+
 /**
  * Converts a numeric value to Simplified Chinese currency words (Yuan/Renminbi).
- *
  * @param {number | string | bigint} value - The currency amount to convert
- * @param {Object} [options] - Optional configuration
- * @param {boolean} [options.formal=true] - Use formal/financial numerals
+ * @param {CurrencyOptions} [options] - Optional configuration
  * @returns {string} The amount in Simplified Chinese 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.05)                     // '伍分'
  * toCurrency(42.50, { formal: false }) // '四十二元五角整'
  */
-function toCurrency (value, options) {
-  options = validateOptions(options)
+function toCurrency(value, options) {
   const { isNegative, dollars: yuan, cents } = parseCurrencyValue(value)
-  const { formal = true } = options
+  checkMax(yuan, currencyMax)
+  const { formal } = resolveOptions(options, currencyDefaults)
 
   const ones = formal ? ONES_FORMAL : ONES_COMMON
   const yuanWord = formal ? YUAN_FORMAL : YUAN_COMMON
@@ -286,7 +337,8 @@ function toCurrency (value, options) {
   // Jiao part (1/10)
   if (jiao > 0n) {
     result += ones[Number(jiao)] + JIAO
-  } else if (yuan > 0n && fen > 0n) {
+  }
+  else if (yuan > 0n && fen > 0n) {
     // Need zero placeholder between yuan and fen
     result += ZERO
   }
@@ -294,7 +346,8 @@ function toCurrency (value, options) {
   // Fen part (1/100)
   if (fen > 0n) {
     result += ones[Number(fen)] + FEN
-  } else if (yuan > 0n || jiao > 0n) {
+  }
+  else if (yuan > 0n || jiao > 0n) {
     // Add 整 (zheng) to indicate whole amount
     result += ZHENG
   }