n2words 1.24.0 → 2.0.0

package/lib/n2words.js

@@ -1,258 +1,541 @@
 /**
+ * n2words - Convert numbers to words in multiple languages
+ *
+ * This file is the main entry point for the n2words library.
+ * It exports converter functions for all supported languages.
+ *
+ * ## For Contributors
+ *
+ * When adding a new language, this file must be updated in THREE sections:
+ * 1. Language Imports - Add import statement (alphabetically sorted)
+ * 2. Language Converters - Create converter with makeConverter() (alphabetically sorted)
+ * 3. Exports - Add to export list (alphabetically sorted)
+ *
+ * Use the scaffolding tool to automate this process:
+ *   npm run lang:add <language-code>
+ *
+ * ## Public API Structure
+ *
+ * Each language exports a converter function:
+ *   - Name: `{LanguageName}Converter` (e.g., EnglishConverter, SpanishConverter)
+ *   - Signature: `(value: NumericValue, options?: Options) => string`
+ *   - Input: number, bigint, or string (numeric strings only)
+ *   - Output: Words representing the number in the target language
+ *
+ * Languages without options use signature: `(value: NumericValue) => string`
+ * Languages with options define a typedef (e.g., ArabicOptions) and use: `(value: NumericValue, options?: ArabicOptions) => string`
+ *
  * @module n2words
  */
 
-/** @typedef {'ar'|'az'|'bn'|'cs'|'de'|'da'|'el'|'en'|'es'|'fa'|'fr'|'fr-BE'|'gu'|'he'|'hi'|'hr'|'hu'|'id'|'it'|'ja'|'kn'|'ko'|'lt'|'lv'|'mr'|'ms'|'nl'|'nb'|'pa-Guru'|'pl'|'pt'|'ro'|'ru'|'sr-Latn'|'sv'|'sw'|'ta'|'te'|'th'|'fil'|'tr'|'uk'|'ur'|'vi'|'zh-Hans'} LanguageCode */
+// ============================================================================
+// Language Imports
+// ============================================================================
+
+import { Arabic } from './languages/ar.js'
+import { Azerbaijani } from './languages/az.js'
+import { Bangla } from './languages/bn.js'
+import { Czech } from './languages/cs.js'
+import { Danish } from './languages/da.js'
+import { German } from './languages/de.js'
+import { Greek } from './languages/el.js'
+import { English } from './languages/en.js'
+import { Spanish } from './languages/es.js'
+import { Persian } from './languages/fa.js'
+import { Filipino } from './languages/fil.js'
+import { French } from './languages/fr.js'
+import { FrenchBelgium } from './languages/fr-BE.js'
+import { Gujarati } from './languages/gu.js'
+import { Hebrew } from './languages/he.js'
+import { BiblicalHebrew } from './languages/hbo.js'
+import { Hindi } from './languages/hi.js'
+import { Croatian } from './languages/hr.js'
+import { Hungarian } from './languages/hu.js'
+import { Indonesian } from './languages/id.js'
+import { Italian } from './languages/it.js'
+import { Japanese } from './languages/ja.js'
+import { Kannada } from './languages/kn.js'
+import { Korean } from './languages/ko.js'
+import { Lithuanian } from './languages/lt.js'
+import { Latvian } from './languages/lv.js'
+import { Marathi } from './languages/mr.js'
+import { Malay } from './languages/ms.js'
+import { Dutch } from './languages/nl.js'
+import { NorwegianBokmal } from './languages/nb.js'
+import { Punjabi } from './languages/pa.js'
+import { Polish } from './languages/pl.js'
+import { Portuguese } from './languages/pt.js'
+import { Romanian } from './languages/ro.js'
+import { Russian } from './languages/ru.js'
+import { SerbianCyrillic } from './languages/sr-Cyrl.js'
+import { SerbianLatin } from './languages/sr-Latn.js'
+import { Swedish } from './languages/sv.js'
+import { Swahili } from './languages/sw.js'
+import { Tamil } from './languages/ta.js'
+import { Telugu } from './languages/te.js'
+import { Thai } from './languages/th.js'
+import { Turkish } from './languages/tr.js'
+import { Ukrainian } from './languages/uk.js'
+import { Urdu } from './languages/ur.js'
+import { Vietnamese } from './languages/vi.js'
+import { SimplifiedChinese } from './languages/zh-Hans.js'
+import { TraditionalChinese } from './languages/zh-Hant.js'
+
+// ============================================================================
+// Type Definitions
+// ============================================================================
+//
+// This section defines TypeScript-compatible JSDoc types for:
+// - NumericValue: The input types accepted by all converters
+// - {Language}Options: Optional configuration for languages that support it
+//
+// Keep options typedefs alphabetically sorted for maintainability.
+// ============================================================================
+
+/**
+ * Numeric value that can be converted to words.
+ * Accepts number, bigint, or numeric string representations.
+ * @typedef {number | bigint | string} NumericValue
+ */
 
 /**
  * @typedef {Object} ArabicOptions
- * @property {string} [negativeWord='ناقص'] - Word for negative numbers (minus).
- * @property {boolean} [feminine=false] - Use feminine forms for numbers.
+ * @property {string} [negativeWord] Word for negative numbers
+ * @property {('masculine'|'feminine')} [gender='masculine'] Grammatical gender for number forms
  */
 
 /**
- * @typedef {Object} ChineseOptions
- * @property {boolean} [formal=true] - Use formal/financial numerals (壹贰叁) vs. common numerals (一二三).
+ * @typedef {Object} BiblicalHebrewOptions
+ * @property {string} [andWord='ו'] Conjunction character (typically 'ו' for and)
+ * @property {('masculine'|'feminine')} [gender='masculine'] Grammatical gender for number forms
  */
 
 /**
- * @typedef {Object} HebrewOptions
- * @property {string} [and='ו'] - Conjunction character (typically 'ו' for and).
- * @property {boolean} [biblical=false] - Use biblical scale words instead of modern ones.
- * @property {boolean} [feminine=false] - Use feminine forms for numbers.
+ * @typedef {Object} CroatianOptions
+ * @property {('masculine'|'feminine')} [gender='masculine'] Grammatical gender for number forms
  */
 
 /**
- * @typedef {Object} SpanishOptions
- * @property {('o'|'a'|string)} [genderStem='o'] - Masculine 'o' or feminine 'a' ending.
+ * @typedef {Object} CzechOptions
+ * @property {('masculine'|'feminine')} [gender='masculine'] Grammatical gender for number forms
+ */
+
+/**
+ * @typedef {Object} DanishOptions
+ * @property {boolean} [ordFlag=false] Enable ordinal number conversion
  */
 
 /**
  * @typedef {Object} DutchOptions
- * @property {boolean} [includeOptionalAnd=false] - Include optional "en" separator.
- * @property {boolean} [noHundredPairs=false] - Disable comma before hundreds.
- * @property {boolean} [accentOne=true] - Use accented "één" for one.
+ * @property {boolean} [includeOptionalAnd=false] Include optional "en" separator
+ * @property {boolean} [noHundredPairing=false] Disable hundred-pairing (e.g., "twelve hundred" becomes "one thousand two hundred")
+ * @property {boolean} [accentOne=true] Use accented "één" for one
  */
 
 /**
  * @typedef {Object} FrenchOptions
- * @property {boolean} [withHyphenSeparator=false] - Use hyphens (true) instead of spaces (false) in compounds.
+ * @property {boolean} [withHyphenSeparator=false] Use hyphens (true) instead of spaces (false) in compounds
  */
 
 /**
- * @typedef {Object} TurkishOptions
- * @property {boolean} [dropSpaces=false] - Remove spaces between words if true.
+ * @typedef {Object} FrenchBelgiumOptions
+ * @property {boolean} [withHyphenSeparator=false] Use hyphens (true) instead of spaces (false) in compounds
+ */
+
+/**
+ * @typedef {Object} HebrewOptions
+ * @property {string} [andWord='ו'] Conjunction character (typically 'ו' for and)
+ */
+
+/**
+ * @typedef {Object} LatvianOptions
+ * @property {('masculine'|'feminine')} [gender='masculine'] Grammatical gender for number forms
+ */
+
+/**
+ * @typedef {Object} LithuanianOptions
+ * @property {('masculine'|'feminine')} [gender='masculine'] Grammatical gender for number forms
+ */
+
+/**
+ * @typedef {Object} PolishOptions
+ * @property {('masculine'|'feminine')} [gender='masculine'] Grammatical gender for number forms
  */
 
 /**
  * @typedef {Object} RomanianOptions
- * @property {boolean} [feminine=false] - Use feminine forms for numbers.
+ * @property {('masculine'|'feminine')} [gender='masculine'] Grammatical gender for number forms
  */
 
 /**
- * @typedef {Object} DanishOptions
- * @property {boolean} [ordFlag=false] - Enable ordinal number conversion.
+ * @typedef {Object} RussianOptions
+ * @property {('masculine'|'feminine')} [gender='masculine'] Grammatical gender for number forms
  */
 
 /**
- * @typedef {Object} SlavicOptions
- * @property {boolean} [feminine=false] - Use feminine forms for numbers.
+ * @typedef {Object} SerbianCyrillicOptions
+ * @property {('masculine'|'feminine')} [gender='masculine'] Grammatical gender for number forms
  */
 
 /**
- * Configuration object for number-to-words conversion with comprehensive language support.
- *
- * @typedef {Object} N2WordsOptions
- * @property {LanguageCode} [lang='en'] - Target language code with full autocomplete support.
- *   Supports many languages with regional variants (e.g., 'fr-BE').
- *   Falls back progressively from most-specific to least-specific (e.g., 'fr-BE' -> 'fr').
- *   Throws an error if no match is found after fallback attempts.
- * @property {string} [negativeWord] - (Arabic only) Word for negative numbers.
- * @property {boolean} [feminine] - (Arabic, Hebrew, Romanian, Slavic languages) Use feminine forms.
- * @property {boolean} [formal] - (Chinese only) Use formal/financial numerals.
- * @property {string} [and] - (Hebrew only) Conjunction character.
- * @property {boolean} [biblical] - (Hebrew only) Use biblical scale words.
- * @property {('o'|'a'|string)} [genderStem] - (Spanish only) Gender ending.
- * @property {boolean} [includeOptionalAnd] - (Dutch only) Include optional "en".
- * @property {boolean} [noHundredPairs] - (Dutch only) Disable comma before hundreds.
- * @property {boolean} [accentOne] - (Dutch only) Use accented "één".
- * @property {boolean} [withHyphenSeparator] - (French, Belgian French) Use hyphens.
- * @property {boolean} [dropSpaces] - (Turkish, Azerbaijani) Remove spaces.
- * @property {boolean} [ordFlag] - (Danish only) Enable ordinal conversion.
- *
- * Language-specific options are automatically validated and forwarded to converters.
- * See individual language implementations for detailed option descriptions.
+ * @typedef {Object} SerbianLatinOptions
+ * @property {('masculine'|'feminine')} [gender='masculine'] Grammatical gender for number forms
  */
 
-import ar from './languages/ar.js'
-import az from './languages/az.js'
-import cs from './languages/cs.js'
-import de from './languages/de.js'
-import da from './languages/da.js'
-import en from './languages/en.js'
-import es from './languages/es.js'
-import fa from './languages/fa.js'
-import sw from './languages/sw.js'
-import fr from './languages/fr.js'
-import frBE from './languages/fr-BE.js'
-import he from './languages/he.js'
-import hr from './languages/hr.js'
-import hu from './languages/hu.js'
-import id from './languages/id.js'
-import ms from './languages/ms.js'
-import it from './languages/it.js'
-import ja from './languages/ja.js'
-import hi from './languages/hi.js'
-import bn from './languages/bn.js'
-import ko from './languages/ko.js'
-import th from './languages/th.js'
-import ta from './languages/ta.js'
-import te from './languages/te.js'
-import sv from './languages/sv.js'
-import lt from './languages/lt.js'
-import lv from './languages/lv.js'
-import nl from './languages/nl.js'
-import nb from './languages/nb.js'
-import pl from './languages/pl.js'
-import pt from './languages/pt.js'
-import ro from './languages/ro.js'
-import ru from './languages/ru.js'
-import srLatn from './languages/sr-Latn.js'
-import tr from './languages/tr.js'
-import uk from './languages/uk.js'
-import vi from './languages/vi.js'
-import zhHans from './languages/zh-Hans.js'
-import ur from './languages/ur.js'
-import paGuru from './languages/pa-Guru.js'
-import fil from './languages/fil.js'
-import mr from './languages/mr.js'
-import gu from './languages/gu.js'
-import kn from './languages/kn.js'
-import el from './languages/el.js'
+/**
+ * @typedef {Object} SimplifiedChineseOptions
+ * @property {boolean} [formal=true] Use formal/financial numerals (壹贰叁) vs. common numerals (一二三)
+ */
 
 /**
- * Language converter registry.
- * Contains converters for all supported languages, statically imported to work
- * in both Node.js and browser environments (enables bundler dead-code elimination).
- * Keys are language codes (e.g., 'en', 'fr', 'fr-BE'); values are converter functions.
- * @type {Object<string, Function>}
+ * @typedef {Object} SpanishOptions
+ * @property {('masculine'|'feminine')} [gender='masculine'] Grammatical gender for number forms
  */
-const dict = {
-  ar,
-  az,
-  cs,
-  de,
-  da,
-  en,
-  es,
-  fa,
-  sw,
-  fr,
-  'fr-BE': frBE,
-  he,
-  hr,
-  hu,
-  id,
-  ms,
-  it,
-  ja,
-  hi,
-  bn,
-  ko,
-  th,
-  ta,
-  te,
-  sv,
-  lt,
-  lv,
-  nl,
-  nb,
-  pl,
-  pt,
-  ro,
-  ru,
-  'sr-Latn': srLatn,
-  tr,
-  uk,
-  vi,
-  'zh-Hans': zhHans,
-  ur,
-  'pa-Guru': paGuru,
-  fil,
-  mr,
-  gu,
-  kn,
-  el
-}
 
 /**
- * Convert a numeric value to its cardinal (written) form in the requested language.
- *
- * This is the main entry point. The library dispatches synchronously to the appropriate
- * per-language converter based on the `lang` option. For browser builds, language converters
- * are statically imported so bundlers (webpack/rollup) can include them in output; Node.js
- * maintains identical behavior via the same static imports.
+ * @typedef {Object} TraditionalChineseOptions
+ * @property {boolean} [formal=true] Use formal/financial numerals (壹貳參) vs. common numerals (一二三)
+ */
+
+/**
+ * @typedef {Object} TurkishOptions
+ * @property {boolean} [dropSpaces=false] Remove spaces between words if true
+ */
+
+/**
+ * @typedef {Object} UkrainianOptions
+ * @property {('masculine'|'feminine')} [gender='masculine'] Grammatical gender for number forms
+ */
+
+// ============================================================================
+// Converter Factory
+// ============================================================================
+//
+// makeConverter() is a factory function that creates converter functions from
+// language classes. It provides a consistent functional API for all languages:
+//
+//   const result = EnglishConverter(42)                      // "forty-two"
+//   const result = ArabicConverter(1, {gender: 'feminine'})  // "واحدة"
+//
+// This design:
+// - Hides class instantiation details from public API
+// - Ensures each conversion uses a fresh instance
+// - Maintains immutability (no shared state between conversions)
+// ============================================================================
+
+/**
+ * Creates a converter function for a language class.
  *
- * @param {number|string|bigint} value The number to convert. Accepts:
- *   - `number` (integer or floating-point),
- *   - `string` (numeric string, possibly with decimal point),
- *   - `bigint` for very large integers.
- *   Decimal numbers as strings preserve precision that `number` type cannot.
- * @param {N2WordsOptions} [options={}] Optional configuration object.
+ * This factory handles all input validation and normalization at the public API
+ * boundary, then delegates to the language class with pre-processed data.
  *
- * @returns {string} A human-readable cardinal representation of `value` in the
- *   requested language.
+ * @template {Object} [TOptions={}]
+ * @param {new (options?: TOptions) => { toWords: (isNegative: boolean, integerPart: bigint, decimalPart?: string) => string }} LanguageClass - Language class constructor
+ * @returns {(value: NumericValue, options?: TOptions) => string} Converter function
+ */
+function makeConverter (LanguageClass) {
+  /**
+   * @param {NumericValue} value
+   * @param {TOptions} [options]
+   * @returns {string}
+   */
+  return function convertToWords (value, options) {
+    if (options !== undefined && !isPlainObject(options)) {
+      throw new TypeError('options must be a plain object if provided')
+    }
+
+    const { isNegative, integerPart, decimalPart } = parseNumericValue(value)
+    return new LanguageClass(options).toWords(isNegative, integerPart, decimalPart)
+  }
+}
+
+// ============================================================================
+// Input Parsing Utilities
+// ============================================================================
+
+/**
+ * @typedef {Object} ParsedNumericValue
+ * @property {boolean} isNegative - Whether the value is negative
+ * @property {bigint} integerPart - The absolute integer part
+ * @property {string} [decimalPart] - The decimal digits (without the point)
+ */
+
+/**
+ * Parses and validates a numeric value into its components.
+ * Handles number, string, and bigint inputs uniformly.
  *
- * @throws {TypeError} If `options` is provided but is not an object.
- * @throws {Error} If the requested language is unsupported (no match after fallback).
+ * @param {NumericValue} value The value to parse
+ * @returns {ParsedNumericValue} The parsed components
+ * @throws {TypeError} If value is not a valid numeric type
+ * @throws {Error} If value is not a valid number format
+ */
+function parseNumericValue (value) {
+  const type = typeof value
+
+  // BigInt: simplest case - no decimals, no scientific notation
+  if (type === 'bigint') {
+    return value < 0n
+      ? { isNegative: true, integerPart: -value }
+      : { isNegative: false, integerPart: value }
+  }
+
+  // Reject invalid types early
+  if (type !== 'number' && type !== 'string') {
+    throw new TypeError(
+      `Invalid value type: expected number, string, or bigint, received ${type}`
+    )
+  }
+
+  // Convert to normalized string
+  const str = type === 'number'
+    ? numberToString(value)
+    : stringToNormalizedForm(value)
+
+  return parseNumericString(str)
+}
+
+/**
+ * Converts a JavaScript number to a decimal string.
+ * Handles special cases: Infinity, NaN, and scientific notation.
  *
- * @example
- * // Basic usage
- * convertToWords(1, { lang: 'en' }) // => 'one'
- * convertToWords('45.67', { lang: 'en' }) // => 'forty-five point six seven'
- * convertToWords(123n, { lang: 'fr' }) // => 'cent vingt-trois'
+ * @param {number} value The number to convert
+ * @returns {string} Decimal string representation
+ * @throws {Error} If value is not finite
+ */
+function numberToString (value) {
+  if (!Number.isFinite(value)) {
+    throw new Error('Number must be finite (NaN and Infinity are not supported)')
+  }
+
+  const str = value.toString()
+
+  // Expand scientific notation (used for values >= 1e21 or < 1e-6)
+  if (str.includes('e') || str.includes('E')) {
+    return expandScientificNotation(str)
+  }
+
+  return str
+}
+
+/**
+ * Validates and normalizes a string numeric input.
  *
- * @example
- * // Language-specific options (see individual language implementations)
- * convertToWords(1, { lang: 'zh-Hans', formal: true }) // Chinese formal style
- * convertToWords(1, { lang: 'cs', feminine: true }) // Czech feminine form
+ * @param {string} value The string to validate
+ * @returns {string} Trimmed and validated string
+ * @throws {Error} If string is empty or not a valid number format
  */
-export default function (value, options = {}) {
-  if (options !== null && options !== undefined && typeof options !== 'object') {
-    throw new TypeError('Options must be an object, received: ' + typeof options)
+function stringToNormalizedForm (value) {
+  const trimmed = value.trim()
+
+  if (trimmed.length === 0) {
+    throw new Error(`Invalid number format: "${value}"`)
+  }
+
+  // Validate by attempting conversion (handles edge cases like "1e21", "-.5", etc.)
+  if (Number.isNaN(Number(trimmed))) {
+    throw new Error(`Invalid number format: "${value}"`)
   }
 
-  if (options === null) {
-    options = {}
+  // Expand scientific notation if present
+  if (trimmed.includes('e') || trimmed.includes('E')) {
+    return expandScientificNotation(trimmed)
   }
 
-  let languageCode = options.lang
+  return trimmed
+}
 
-  if (languageCode === undefined) {
-    return dict.en(value, options)
+/**
+ * Parses a normalized numeric string into its components.
+ *
+ * @param {string} str A normalized decimal string (no scientific notation)
+ * @returns {ParsedNumericValue} The parsed components
+ */
+function parseNumericString (str) {
+  // Extract sign
+  const isNegative = str[0] === '-'
+  if (isNegative) {
+    str = str.slice(1)
   }
 
-  if (typeof languageCode !== 'string') {
-    languageCode = String(languageCode)
+  // Split into integer and decimal parts
+  const dotIndex = str.indexOf('.')
+  if (dotIndex === -1) {
+    return { isNegative, integerPart: BigInt(str) }
   }
 
-  let languageConverter = dict[languageCode]
-  if (languageConverter !== undefined) {
-    return languageConverter(value, options)
+  const integerStr = str.slice(0, dotIndex) || '0'
+  const decimalPart = str.slice(dotIndex + 1)
+
+  return { isNegative, integerPart: BigInt(integerStr), decimalPart }
+}
+
+/**
+ * Expands scientific notation to decimal form.
+ * JavaScript uses scientific notation for values >= 1e21 or < 1e-6.
+ *
+ * @param {string} str String possibly in scientific notation (e.g., "1e+21")
+ * @returns {string} Decimal form (e.g., "1000000000000000000000")
+ */
+function expandScientificNotation (str) {
+  const [mantissa, expStr] = str.toLowerCase().split('e')
+  const exp = parseInt(expStr, 10)
+
+  // Extract digits and determine original decimal position
+  const dotIndex = mantissa.indexOf('.')
+  const digits = dotIndex === -1
+    ? mantissa
+    : mantissa.slice(0, dotIndex) + mantissa.slice(dotIndex + 1)
+  const integerLength = dotIndex === -1 ? mantissa.length : dotIndex
+
+  // Calculate new decimal position after applying exponent
+  const newDotPosition = integerLength + exp
+
+  if (newDotPosition >= digits.length) {
+    // Pure integer: pad with trailing zeros
+    return digits + '0'.repeat(newDotPosition - digits.length)
   }
 
-  // Progressive fallback for regional variants: strip suffix on each iteration.
-  // Example: 'fr-BE-XX' -> try 'fr-BE' -> try 'fr' -> throw error
-  // Uses lastIndexOf for efficiency (O(n) vs O(n²) with repeated substring)
-  let lastDashIndex = languageCode.lastIndexOf('-')
-  while (lastDashIndex > 0) {
-    const candidateLanguageCode = languageCode.slice(0, lastDashIndex)
-    languageConverter = dict[candidateLanguageCode]
-    if (languageConverter !== undefined) {
-      return languageConverter(value, options)
-    }
-    lastDashIndex = candidateLanguageCode.lastIndexOf('-')
+  if (newDotPosition <= 0) {
+    // Pure decimal: pad with leading zeros after decimal point
+    return '0.' + '0'.repeat(-newDotPosition) + digits
   }
 
-  throw new Error('Unsupported language: "' + languageCode + '". Check supported language codes in the documentation.')
+  // Mixed: insert decimal point at new position
+  return digits.slice(0, newDotPosition) + '.' + digits.slice(newDotPosition)
+}
+
+/**
+ * Checks if a value is a plain object (not null, array, or other object types).
+ *
+ * @param {*} value Value to check
+ * @returns {boolean} True if value is a plain object
+ */
+function isPlainObject (value) {
+  if (value === null || typeof value !== 'object') return false
+  const proto = Object.getPrototypeOf(value)
+  return proto === Object.prototype || proto === null
+}
+
+// ============================================================================
+// Language Converters
+// ============================================================================
+//
+// Each converter is created using makeConverter() with explicit type annotations.
+//
+// Pattern for languages WITHOUT options:
+//   const LanguageConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Language))
+//
+// Pattern for languages WITH options:
+//   const LanguageConverter = /** @type {(value: NumericValue, options?: LanguageOptions) => string} */ (makeConverter(Language))
+//
+// IMPORTANT: Keep converters alphabetically sorted by converter name.
+// ============================================================================
+
+const ArabicConverter = /** @type {(value: NumericValue, options?: ArabicOptions) => string} */ (makeConverter(Arabic))
+const AzerbaijaniConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Azerbaijani))
+const BanglaConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Bangla))
+const BiblicalHebrewConverter = /** @type {(value: NumericValue, options?: BiblicalHebrewOptions) => string} */ (makeConverter(BiblicalHebrew))
+const CroatianConverter = /** @type {(value: NumericValue, options?: CroatianOptions) => string} */ (makeConverter(Croatian))
+const CzechConverter = /** @type {(value: NumericValue, options?: CzechOptions) => string} */ (makeConverter(Czech))
+const DanishConverter = /** @type {(value: NumericValue, options?: DanishOptions) => string} */ (makeConverter(Danish))
+const DutchConverter = /** @type {(value: NumericValue, options?: DutchOptions) => string} */ (makeConverter(Dutch))
+const EnglishConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(English))
+const FilipinoConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Filipino))
+const FrenchConverter = /** @type {(value: NumericValue, options?: FrenchOptions) => string} */ (makeConverter(French))
+const FrenchBelgiumConverter = /** @type {(value: NumericValue, options?: FrenchBelgiumOptions) => string} */ (makeConverter(FrenchBelgium))
+const GermanConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(German))
+const GreekConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Greek))
+const GujaratiConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Gujarati))
+const HebrewConverter = /** @type {(value: NumericValue, options?: HebrewOptions) => string} */ (makeConverter(Hebrew))
+const HindiConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Hindi))
+const HungarianConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Hungarian))
+const IndonesianConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Indonesian))
+const ItalianConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Italian))
+const JapaneseConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Japanese))
+const KannadaConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Kannada))
+const KoreanConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Korean))
+const LatvianConverter = /** @type {(value: NumericValue, options?: LatvianOptions) => string} */ (makeConverter(Latvian))
+const LithuanianConverter = /** @type {(value: NumericValue, options?: LithuanianOptions) => string} */ (makeConverter(Lithuanian))
+const MalayConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Malay))
+const MarathiConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Marathi))
+const NorwegianBokmalConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(NorwegianBokmal))
+const PersianConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Persian))
+const PolishConverter = /** @type {(value: NumericValue, options?: PolishOptions) => string} */ (makeConverter(Polish))
+const PortugueseConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Portuguese))
+const PunjabiConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Punjabi))
+const RomanianConverter = /** @type {(value: NumericValue, options?: RomanianOptions) => string} */ (makeConverter(Romanian))
+const RussianConverter = /** @type {(value: NumericValue, options?: RussianOptions) => string} */ (makeConverter(Russian))
+const SerbianCyrillicConverter = /** @type {(value: NumericValue, options?: SerbianCyrillicOptions) => string} */ (makeConverter(SerbianCyrillic))
+const SerbianLatinConverter = /** @type {(value: NumericValue, options?: SerbianLatinOptions) => string} */ (makeConverter(SerbianLatin))
+const SimplifiedChineseConverter = /** @type {(value: NumericValue, options?: SimplifiedChineseOptions) => string} */ (makeConverter(SimplifiedChinese))
+const SpanishConverter = /** @type {(value: NumericValue, options?: SpanishOptions) => string} */ (makeConverter(Spanish))
+const SwahiliConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Swahili))
+const SwedishConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Swedish))
+const TamilConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Tamil))
+const TeluguConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Telugu))
+const ThaiConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Thai))
+const TraditionalChineseConverter = /** @type {(value: NumericValue, options?: TraditionalChineseOptions) => string} */ (makeConverter(TraditionalChinese))
+const TurkishConverter = /** @type {(value: NumericValue, options?: TurkishOptions) => string} */ (makeConverter(Turkish))
+const UkrainianConverter = /** @type {(value: NumericValue, options?: UkrainianOptions) => string} */ (makeConverter(Ukrainian))
+const UrduConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Urdu))
+const VietnameseConverter = /** @type {(value: NumericValue) => string} */ (makeConverter(Vietnamese))
+
+// ============================================================================
+// Exports
+// ============================================================================
+//
+// All converter functions are exported for public use.
+//
+// IMPORTANT: Keep exports alphabetically sorted for maintainability.
+// ============================================================================
+
+export {
+  ArabicConverter,
+  AzerbaijaniConverter,
+  BanglaConverter,
+  BiblicalHebrewConverter,
+  CroatianConverter,
+  CzechConverter,
+  DanishConverter,
+  DutchConverter,
+  EnglishConverter,
+  FilipinoConverter,
+  FrenchConverter,
+  FrenchBelgiumConverter,
+  GermanConverter,
+  GreekConverter,
+  GujaratiConverter,
+  HebrewConverter,
+  HindiConverter,
+  HungarianConverter,
+  IndonesianConverter,
+  ItalianConverter,
+  JapaneseConverter,
+  KannadaConverter,
+  KoreanConverter,
+  LatvianConverter,
+  LithuanianConverter,
+  MalayConverter,
+  MarathiConverter,
+  NorwegianBokmalConverter,
+  PersianConverter,
+  PolishConverter,
+  PortugueseConverter,
+  PunjabiConverter,
+  RomanianConverter,
+  RussianConverter,
+  SerbianCyrillicConverter,
+  SerbianLatinConverter,
+  SimplifiedChineseConverter,
+  SpanishConverter,
+  SwahiliConverter,
+  SwedishConverter,
+  TamilConverter,
+  TeluguConverter,
+  ThaiConverter,
+  TraditionalChineseConverter,
+  TurkishConverter,
+  UkrainianConverter,
+  UrduConverter,
+  VietnameseConverter
 }