n2words 1.24.0 → 2.0.0

package/lib/languages/fa.js

@@ -1,37 +1,22 @@
-import AbstractLanguage from '../classes/abstract-language.js'
+import { AbstractLanguage } from '../classes/abstract-language.js'
 
 /**
- * Persian (Farsi) language converter.
+ * Persian language converter.
  *
- * Converts numbers to Persian words using Persian-Arabic numerals:
- * - Right-to-left script orientation
- * - Base-10 decimal system with Persian number words
- * - Conjunction "و" (va/and) for compound numbers
- * - Traditional Persian number naming conventions
- *
- * Key Features:
- * - Named number lookup table (namedNumbers) for direct mapping 0-999
- * - Group-based algorithm for numbers >= 1000:
- *   1. Split into groups of 3 digits
- *   2. Convert each group to words using named table or recursion
- *   3. Append magnitude word (هزار/میلیون/میلیارد)
- *   4. Join with "و" (and) conjunction
- * - Special compound forms (دویست for 200, سیصد for 300)
- * - Proper Persian grammatical structure
- * - Support for large numbers (thousands, millions, billions, trillions)
- *
- * Features:
- * - Native Persian digits and words
- * - Special compound forms (e.g., دویست for 200, سیصد for 300)
- * - Support for large numbers (thousands, millions)
- * - Proper Persian grammatical structure
+ * Supports:
+ * - "و" (and) conjunction for compound numbers
+ * - Recursive conversion for larger numbers
  */
-export class Farsi extends AbstractLanguage {
+export class Persian extends AbstractLanguage {
   negativeWord = 'منفى'
   decimalSeparatorWord = 'ممیّز'
   zeroWord = 'صفر'
-  namedNumbers = {
-    0: 'صفر',
+
+  /**
+   * Words for digits 1-9.
+   * @type {Object.<number, string>}
+   */
+  onesWords = {
     1: 'یک',
     2: 'دو',
     3: 'سه',
@@ -40,7 +25,14 @@ export class Farsi extends AbstractLanguage {
     6: 'شش',
     7: 'هفت',
     8: 'هشت',
-    9: 'نه',
+    9: 'نه'
+  }
+
+  /**
+   * Words for teen numbers (10-19).
+   * @type {Object.<number, string>}
+   */
+  teensWords = {
     10: 'ده',
     11: 'یازده',
     12: 'دوازده',
@@ -50,7 +42,14 @@ export class Farsi extends AbstractLanguage {
     16: 'شانزده',
     17: 'هفده',
     18: 'هجده',
-    19: 'نوزده',
+    19: 'نوزده'
+  }
+
+  /**
+   * Words for multiples of ten (20-90).
+   * @type {Object.<number, string>}
+   */
+  tensWords = {
     20: 'بیست',
     30: 'سی',
     40: 'چهل',
@@ -58,7 +57,14 @@ export class Farsi extends AbstractLanguage {
     60: 'شصت',
     70: 'هفتاد',
     80: 'هشتاد',
-    90: 'نود',
+    90: 'نود'
+  }
+
+  /**
+   * Words for hundreds (100-900).
+   * @type {Object.<number, string>}
+   */
+  hundredsWords = {
     100: 'صد',
     200: 'دویست',
     300: 'سيصد',
@@ -67,61 +73,72 @@ export class Farsi extends AbstractLanguage {
     600: 'ششصد',
     700: 'هفتصد',
     800: 'هشتصد',
-    900: 'نهصد',
+    900: 'نهصد'
+  }
+
+  /**
+   * Scale magnitude words.
+   * @type {Object.<number, string>}
+   */
+  scaleWords = {
     1000: 'هزار',
     1_000_000: 'میلیون'
   }
 
-  convertWholePart (number) {
-    if (this.namedNumbers[number] && number !== 1_000_000n) {
-      return this.namedNumbers[number]
+  /** Converts integer part using categorized word tables. */
+  integerToWords (integerPart) {
+    // Zero
+    if (integerPart === 0n) {
+      return this.zeroWord
     }
 
-    if (number > 20n && number < 100n) {
-      const xone = number % 10n
-      const xten = number - xone
-      return `${this.namedNumbers[xten]} و ${this.namedNumbers[xone]}`
+    // 1-9
+    if (integerPart <= 9n) {
+      return this.onesWords[integerPart]
     }
 
-    if (number > 100n && number < 1000n) {
-      const xhundred = 100n * (number / 100n)
-      const tail = this.convertWholePart(number - xhundred)
-      return `${this.namedNumbers[xhundred]} و ${tail}`
+    // 10-19
+    if (integerPart <= 19n) {
+      return this.teensWords[integerPart]
     }
 
-    if (number > 1000n && number < 1_000_000n) {
-      const thousandMultiplier = number / 1000n
-      const namedThousandMultiplier =
-        (thousandMultiplier === 1n
-          ? ''
-          : this.convertWholePart(thousandMultiplier)) +
-        ' ' +
-        this.namedNumbers[1000]
-      const tailNumber = number - thousandMultiplier * 1000n
-      const tail = tailNumber === 0n ? '' : ' ' + this.convertWholePart(tailNumber)
-      return `${namedThousandMultiplier}${tail}`
+    // 20-99
+    if (integerPart < 100n) {
+      const ones = integerPart % 10n
+      const tens = integerPart - ones
+      if (ones === 0n) {
+        return this.tensWords[tens]
+      }
+      return `${this.tensWords[tens]} و ${this.onesWords[ones]}`
     }
 
-    if (number >= 1_000_000n) {
-      const millionMultiplier = number / 1_000_000n
-      const namedMillion =
-        this.convertWholePart(millionMultiplier) + ' ' + this.namedNumbers[1_000_000]
-      const tailNumber = number - millionMultiplier * 1_000_000n
-      const tail = tailNumber === 0n ? '' : ' و ' + this.convertWholePart(tailNumber)
-      return `${namedMillion}${tail}`
+    // 100-999
+    if (integerPart < 1000n) {
+      const hundreds = 100n * (integerPart / 100n)
+      const remainder = integerPart - hundreds
+      if (remainder === 0n) {
+        return this.hundredsWords[hundreds]
+      }
+      return `${this.hundredsWords[hundreds]} و ${this.integerToWords(remainder)}`
     }
-  }
-}
 
-/**
- * Converts a number to Persian cardinal (written) form.
- *
- * @param {number|string|bigint} value The number to convert.
- * @param {Object} [options={}] Configuration options.
- * @returns {string} The number expressed in Persian words.
- * @throws {TypeError} If value is NaN or invalid type.
- * @throws {Error} If value is an invalid number string.
- */
-export default function convertToWords (value, options = {}) {
-  return new Farsi(options).convertToWords(value)
+    // 1000-999999
+    if (integerPart < 1_000_000n) {
+      const thousandMultiplier = integerPart / 1000n
+      // Persian omits "one" before thousand: 1000 is just "هزار", not "یک هزار"
+      const thousandPrefix = thousandMultiplier === 1n
+        ? ''
+        : this.integerToWords(thousandMultiplier) + ' '
+      const remainder = integerPart % 1000n
+      const suffix = remainder === 0n ? '' : ' ' + this.integerToWords(remainder)
+      return `${thousandPrefix}${this.scaleWords[1000]}${suffix}`
+    }
+
+    // 1000000+
+    const millionMultiplier = integerPart / 1_000_000n
+    const millionPrefix = this.integerToWords(millionMultiplier) + ' ' + this.scaleWords[1_000_000]
+    const remainder = integerPart % 1_000_000n
+    const suffix = remainder === 0n ? '' : ' و ' + this.integerToWords(remainder)
+    return `${millionPrefix}${suffix}`
+  }
 }

package/lib/languages/fil.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Filipino language converter.
+ *
+ * Supports:
+ * - "ng" connectors between words
+ * - Implicit "one" omission
+ * - Special linkers for certain tens (e.g., "limampung")
+ */
+export class Filipino extends GreedyScaleLanguage {
+    scaleWords: (string | bigint)[][];
+    /** Converts integer part with explicit zero handling. */
+    integerToWords(integerPart: any): string;
+    /** Combines two word-sets with Filipino connector and linker rules. */
+    combineWordSets(preceding: any, following: any): any;
+}
+import { GreedyScaleLanguage } from '../classes/greedy-scale-language.js';

package/lib/languages/fil.js

@@ -1,29 +1,20 @@
-/**
- * Filipino (Tagalog) language implementation for n2words
- *
- * Uses scale-based system with irregular patterns for numbers 1-19.
- * Filipino numbers follow patterns like: sampu (10), labinisa (11), dalawampu (20)
- *
- * @module lib/languages/tl
- * @example
- * import fil from './lib/languages/fil.js'
- * tl(42) // 'apatnapu dalawa'
- * tl(1000) // 'isang libo'
- */
-
-import GreedyScaleLanguage from '../classes/greedy-scale-language.js'
+import { GreedyScaleLanguage } from '../classes/greedy-scale-language.js'
 
 /**
- * Filipino language implementation
- * Extends GreedyScaleLanguage with scale-based number conversion
+ * Filipino language converter.
+ *
+ * Supports:
+ * - "ng" connectors between words
+ * - Implicit "one" omission
+ * - Special linkers for certain tens (e.g., "limampung")
  */
-class FilipinoLanguage extends GreedyScaleLanguage {
+export class Filipino extends GreedyScaleLanguage {
   negativeWord = 'negatibo'
   decimalSeparatorWord = 'punto'
   zeroWord = 'zero'
-  convertDecimalsPerDigit = true // Read decimals digit-by-digit
+  usePerDigitDecimals = true // Read decimals digit-by-digit
 
-  scaleWordPairs = [
+  scaleWords = [
     [1000000000000n, 'trilyong'],
     [1000000000n, 'milyong'],
     [1000000n, 'milyong'],
@@ -65,98 +56,66 @@ class FilipinoLanguage extends GreedyScaleLanguage {
     [0n, 'zero']
   ]
 
-  /**
-   * Convert a whole number to Filipino words.
-   * Overrides parent to handle zero explicitly.
-   *
-   * @param {bigint} wholeNumber The whole number to convert.
-   * @returns {string} The Filipino representation.
-   */
-  convertWholePart (wholeNumber) {
+  /** Converts integer part with explicit zero handling. */
+  integerToWords (integerPart) {
     // Handle zero explicitly
-    if (wholeNumber === 0n) {
+    if (integerPart === 0n) {
       return this.zeroWord
     }
-    return super.convertWholePart(wholeNumber)
+    return super.integerToWords(integerPart)
   }
 
-  /**
-   * Merge two word-sets according to Filipino grammar rules.
-   *
-   * Features Filipino-specific rules:
-   * - "ng" connector between words
-   * - Consonant-ending words use "na" instead of "ng"
-   * - Implicit "one" omission ("isang daan" → "daan")
-   *
-   * @param {Object} leftWordSet Left word-set as `{ word: BigInt }`.
-   * @param {Object} rightWordSet Right word-set as `{ word: BigInt }`.
-   * @returns {Object} Merged word-set with combined text and value.
-   */
-  mergeScales (leftWordSet, rightWordSet) {
-    const leftWord = Object.keys(leftWordSet)[0]
-    const rightWord = Object.keys(rightWordSet)[0]
-    const leftValue = Object.values(leftWordSet)[0]
-    const rightValue = Object.values(rightWordSet)[0]
+  /** Combines two word-sets with Filipino connector and linker rules. */
+  combineWordSets (preceding, following) {
+    const precedingWord = Object.keys(preceding)[0]
+    const followingWord = Object.keys(following)[0]
+    const precedingValue = Object.values(preceding)[0]
+    const followingValue = Object.values(following)[0]
 
     // Don't merge zero with anything - just return the non-zero value
-    if (leftValue === 0n) {
-      return rightWordSet
+    if (precedingValue === 0n) {
+      return following
     }
-    if (rightValue === 0n) {
-      return leftWordSet
+    if (followingValue === 0n) {
+      return preceding
     }
 
     // Implicit "one" - omit when adding with values < 100
-    if (leftValue === 1n && rightValue < 100n) {
-      return rightWordSet
+    if (precedingValue === 1n && followingValue < 100n) {
+      return following
     }
 
-    // Multiply when right is a scale word AND right > left
+    // Multiply when following is a scale word AND following > preceding
     // Use "ng" connector for Filipino, but consonant-ending words use " na "
-    if (rightValue > leftValue && rightValue >= 100n) {
+    if (followingValue > precedingValue && followingValue >= 100n) {
       // Words ending in consonants (not vowels) use " na " instead of "ng"
       const vowels = ['a', 'e', 'i', 'o', 'u']
-      const lastChar = leftWord[leftWord.length - 1]
+      const lastChar = precedingWord[precedingWord.length - 1]
       if (!vowels.includes(lastChar)) {
         return {
-          [`${leftWord} na ${rightWord}`]: leftValue * rightValue
+          [`${precedingWord} na ${followingWord}`]: precedingValue * followingValue
         }
       }
       // Vowel-ending words add "ng"
       return {
-        [`${leftWord}ng ${rightWord}`]: leftValue * rightValue
+        [`${precedingWord}ng ${followingWord}`]: precedingValue * followingValue
       }
     }
 
     // Special Filipino rule: certain tens words take "-ng" linker when followed by ones
     // Only limampu (50) confirmed to use this pattern
-    if (leftValue >= 10n && leftValue < 100n && rightValue >= 1n && rightValue < 10n) {
+    if (precedingValue >= 10n && precedingValue < 100n && followingValue >= 1n && followingValue < 10n) {
       const tensWithNg = ['limampu']
-      if (tensWithNg.includes(leftWord)) {
+      if (tensWithNg.includes(precedingWord)) {
         return {
-          [`${leftWord}ng ${rightWord}`]: leftValue + rightValue
+          [`${precedingWord}ng ${followingWord}`]: precedingValue + followingValue
         }
       }
     }
 
     // Default: space for addition
     return {
-      [`${leftWord} ${rightWord}`]: leftValue + rightValue
+      [`${precedingWord} ${followingWord}`]: precedingValue + followingValue
     }
   }
 }
-
-/**
- * Convert a number to Filipino words
- *
- * @param {number|string|bigint} value - The number to convert
- * @param {Object} [options={}] - Conversion options
- * @returns {string} The Filipino word representation
- * @example
- * convertToWords(42) // 'apatnapu dalawa'
- * convertToWords(1000) // 'isang libo'
- * convertToWords(123456) // 'isang daang dalawampung tatlong libong apat na daang limampung anim'
- */
-export default function convertToWords (value, options = {}) {
-  return new FilipinoLanguage(options).convertToWords(value)
-}

package/lib/languages/fr-BE.d.ts

@@ -0,0 +1,11 @@
+/**
+ * French (Belgium) language converter.
+ *
+ * Supports:
+ * - Belgian regional variants: "septante" (70) and "nonante" (90)
+ * - Simplified tens naming (no complex arithmetic)
+ * - Inherits all other French grammar rules
+ */
+export class FrenchBelgium extends French {
+}
+import { French } from './fr.js';

package/lib/languages/fr-BE.js

@@ -1,61 +1,25 @@
 import { French } from './fr.js'
 
 /**
- * @typedef {Object} BelgianFrenchOptions
- * @property {boolean} [withHyphenSeparator=false] Use hyphens (true) instead of spaces (false) in compounds.
- */
-
-/**
- * Belgian French language converter.
+ * French (Belgium) language converter.
  *
- * Extends the French converter with Belgian French regional variant:
- * - Uses "septante" (70) instead of "soixante-dix"
- * - Uses "nonante" (90) instead of "quatre-vingt-dix"
- * - Maintains standard French "quatre-vingts" for 80
- * - More regular and logical number system than standard French
- *
- * Features:
- * - Regional number word variations (septante, nonante)
+ * Supports:
+ * - Belgian regional variants: "septante" (70) and "nonante" (90)
  * - Simplified tens naming (no complex arithmetic)
- * - Inherits all other French grammar rules from FR class
- * - Same pluralization and hyphenation patterns as standard French
+ * - Inherits all other French grammar rules
  */
-export class BelgianFrench extends French {
-  /**
-   * Initializes the Belgian French converter.
-   *
-   * @param {BelgianFrenchOptions} [options={}] Configuration options.
-   */
+export class FrenchBelgium extends French {
   constructor (options = {}) {
     super(options)
-    // Fill the empty placeholder slots with Belgian variants
-    // First empty slot (index 10) is for 90n (between 100n and 80n)
-    // Second empty slot (index 12) is for 70n (between 80n and 60n)
-    this.scaleWordPairs = this.scaleWordPairs.map((pair, index) => {
-      if (Array.isArray(pair) && pair.length === 0) {
-        // Check next pair to determine which slot this is
-        const nextPair = this.scaleWordPairs[index + 1]
-        if (nextPair && nextPair[0] === 80n) {
-          return [90n, 'nonante']
-        } else if (nextPair && nextPair[0] === 60n) {
-          return [70n, 'septante']
-        }
-      }
-      return pair
-    })
-  }
-}
 
-/**
- * Converts a number to Belgian French cardinal (written) form.
- *
- * @param {number|string|bigint} value The number to convert.
- * @param {Object} [options={}] Configuration options.
- * @param {boolean} [options.withHyphenSeparator=false] Use hyphens (true) instead of spaces (false) in compounds.
- * @returns {string} The number expressed in Belgian French words.
- * @throws {TypeError} If value is NaN or invalid type.
- * @throws {Error} If value is an invalid number string.
- */
-export default function convertToWords (value, options = {}) {
-  return new BelgianFrench(options).convertToWords(value)
+    // Insert 90n ('nonante') after 80n and 70n ('septante') after 60n
+    const tuples = [...this.scaleWords]
+    // Find index of 80n and insert 90n after it
+    const idx80 = tuples.findIndex(tuple => tuple[0] === 80n)
+    if (idx80 !== -1) tuples.splice(idx80, 0, [90n, 'nonante'])
+    // Find index of 60n and insert 70n after it
+    const idx60 = tuples.findIndex(tuple => tuple[0] === 60n)
+    if (idx60 !== -1) tuples.splice(idx60, 0, [70n, 'septante'])
+    this.scaleWords = tuples
+  }
 }

package/lib/languages/fr.d.ts

@@ -0,0 +1,15 @@
+/**
+ * French language converter.
+ *
+ * Supports:
+ * - Pluralization of "cent" (hundred) and other words
+ * - "et" (and) before odd numbers in tens place
+ * - Optional hyphenation for compound numbers
+ */
+export class French extends GreedyScaleLanguage {
+    constructor(options?: {});
+    scaleWords: (string | bigint)[][];
+    /** Combines two word-sets with French pluralization and hyphenation rules. */
+    combineWordSets(preceding: any, following: any): any;
+}
+import { GreedyScaleLanguage } from '../classes/greedy-scale-language.js';

package/lib/languages/fr.js

@@ -1,24 +1,19 @@
-import GreedyScaleLanguage from '../classes/greedy-scale-language.js'
-
-/**
- * @typedef {Object} FrenchOptions
- * @property {boolean} [withHyphenSeparator=false] Use hyphens (true) instead of spaces (false) in compounds.
- */
+import { GreedyScaleLanguage } from '../classes/greedy-scale-language.js'
 
 /**
  * French language converter.
  *
- * Special handling:
+ * Supports:
  * - Pluralization of "cent" (hundred) and other words
  * - "et" (and) before odd numbers in tens place
- * - Hyphenation for compound numbers
- * - Regional number word variations
+ * - Optional hyphenation for compound numbers
  */
 export class French extends GreedyScaleLanguage {
   negativeWord = 'moins'
   decimalSeparatorWord = 'virgule'
   zeroWord = 'zéro'
-  scaleWordPairs = [
+
+  scaleWords = [
     [1_000_000_000_000_000_000_000_000_000n, 'quadrilliard'],
     [1_000_000_000_000_000_000_000_000n, 'quadrillion'],
     [1_000_000_000_000_000_000_000n, 'trilliard'],
@@ -29,9 +24,7 @@ export class French extends GreedyScaleLanguage {
     [1_000_000n, 'million'],
     [1000n, 'mille'],
     [100n, 'cent'],
-    [],
     [80n, 'quatre-vingts'],
-    [],
     [60n, 'soixante'],
     [50n, 'cinquante'],
     [40n, 'quarante'],
@@ -59,87 +52,55 @@ export class French extends GreedyScaleLanguage {
     [0n, 'zéro']
   ]
 
-  /**
-   * Initializes the French converter with language-specific options.
-   *
-   * @param {FrenchOptions} [options={}] Configuration options.
-   */
-  constructor ({ withHyphenSeparator = false } = {}) {
+  constructor (options = {}) {
     super()
 
-    this.withHyphenSeparator = withHyphenSeparator
+    this.setOptions({
+      withHyphenSeparator: false
+    }, options)
 
-    if (this.withHyphenSeparator) {
+    if (options.withHyphenSeparator) {
       this.wordSeparator = '-'
     }
   }
 
-  /**
-   * Merges two adjacent word-number pairs according to French grammar rules.
-   *
-   * French-specific rules:
-   * - Removes trailing 's' from multiples of 80 or 100 when followed by smaller numbers
-   * - Adds 's' to hundreds when appropriate
-   * - Uses "et" (and) when joining odd numbers to tens (e.g., "vingt et un")
-   * - Hyphens for compound tens (e.g., "vingt-deux")
-   *
-   * @param {Object} currentPair The left operand as `{ word: number }`.
-   * @param {Object} nextPair The right operand as `{ word: number }`.
-   * @returns {Object} Merged pair with combined word and resulting number.
-   */
-  mergeScales (currentPair, nextPair) {
-    let currentWord = Object.keys(currentPair)[0]
-    let nextWord = Object.keys(nextPair)[0]
-    const currentNumber = Object.values(currentPair)[0]
-    const nextNumber = Object.values(nextPair)[0]
+  /** Combines two word-sets with French pluralization and hyphenation rules. */
+  combineWordSets (preceding, following) {
+    let precedingWord = Object.keys(preceding)[0]
+    let followingWord = Object.keys(following)[0]
+    const precedingValue = Object.values(preceding)[0]
+    const followingValue = Object.values(following)[0]
 
-    if (currentNumber === 1n) {
-      if (nextNumber < 1_000_000n) {
-        return nextPair
+    if (precedingValue === 1n) {
+      if (followingValue < 1_000_000n) {
+        return following
       }
     } else {
       if (
-        ((currentNumber - 80n) % 100n === 0n || (currentNumber % 100n === 0n && currentNumber < 1000n)) &&
-        nextNumber < 1_000_000n &&
-        currentWord.at(-1) === 's'
+        ((precedingValue - 80n) % 100n === 0n || (precedingValue % 100n === 0n && precedingValue < 1000n)) &&
+        followingValue < 1_000_000n &&
+        precedingWord.at(-1) === 's'
       ) {
-        currentWord = currentWord.slice(0, -1)
+        precedingWord = precedingWord.slice(0, -1)
       }
 
       if (
-        currentNumber < 1000n && nextNumber !== 1000n &&
-        nextWord.at(-1) !== 's' &&
-        nextNumber % 100n === 0n
+        precedingValue < 1000n && followingValue !== 1000n &&
+        followingWord.at(-1) !== 's' &&
+        followingValue % 100n === 0n
       ) {
-        nextWord += 's'
+        followingWord += 's'
       }
     }
 
-    if (nextNumber < currentNumber && currentNumber < 100n) {
-      if (nextNumber % 10n === 1n && currentNumber !== 80n) {
-        return { [`${currentWord}${this.wordSeparator}et${this.wordSeparator}${nextWord}`]: currentNumber + nextNumber }
+    if (followingValue < precedingValue && precedingValue < 100n) {
+      if (followingValue % 10n === 1n && precedingValue !== 80n) {
+        return { [`${precedingWord}${this.wordSeparator}et${this.wordSeparator}${followingWord}`]: precedingValue + followingValue }
       }
-      return { [`${currentWord}-${nextWord}`]: currentNumber + nextNumber }
+      return { [`${precedingWord}-${followingWord}`]: precedingValue + followingValue }
     }
 
-    if (nextNumber > currentNumber) return { [`${currentWord}${this.wordSeparator}${nextWord}`]: currentNumber * nextNumber }
-    return { [`${currentWord}${this.wordSeparator}${nextWord}`]: currentNumber + nextNumber }
+    if (followingValue > precedingValue) return { [`${precedingWord}${this.wordSeparator}${followingWord}`]: precedingValue * followingValue }
+    return { [`${precedingWord}${this.wordSeparator}${followingWord}`]: precedingValue + followingValue }
   }
 }
-
-/**
- * Converts a number to French cardinal (written) form.
- *
- * @param {number|string|bigint} value The number to convert.
- * @param {Object} [options] Conversion options (see FR class).
- * @returns {string} The number expressed in French words.
- * @throws {TypeError} If value is NaN or invalid type.
- * @throws {Error} If value is an invalid number string.
- *
- * @example
- * convertToWords(42, { lang: 'fr' }); // 'quarante-deux'
- * convertToWords(81, { lang: 'fr' }); // 'quatre-vingt-un'
- */
-export default function convertToWords (value, options = {}) {
-  return new French(options).convertToWords(value)
-}