n2words 1.24.0 → 3.0.0

package/lib/classes/south-asian-language.js

@@ -1,161 +0,0 @@
-import AbstractLanguage from './abstract-language.js'
-
-/**
- * @typedef {Array<string>} SouthAsianScaleWords
- * Array of scale words for the Indian numbering system, in ascending order.
- * - Index 0: Usually empty/unused (ones place)
- * - Index 1: Thousands (hazaar/হাজার/हजार)
- * - Index 2: Lakhs (lakh/লাখ/लाख)
- * - Index 3: Crores (crore/কোটি/करोड़)
- * - Index 4: Arabs (arab/আরব/अरब)
- * Each index i represents the scale word for groups at position i in the Indian system.
- */
-
-/**
- * @typedef {Array<string>} SouthAsianBelowHundred
- * Array of words for numbers 0-99, indexed directly.
- * belowHundred[0] = word for 0, belowHundred[42] = word for 42, etc.
- */
-
-/**
- * Base class for South Asian languages with shared grouping patterns.
- *
- * This class provides a reusable implementation for South Asian languages that share:
- * - Indian-style number grouping: last 3 digits, then 2-2 (1,23,45,67,89)
- * - Lakh (100,000), Crore (10,000,000), Arab (1,000,000,000) scale words
- * - Standard negative and decimal handling (inherits AbstractLanguage decimal logic,
- *   including `convertDecimalsPerDigit` support when set by subclasses)
- *
- * Used by: Hindi (hi), Bengali (bn), Urdu (ur), Punjabi (pa), Marathi (mr), Gujarati (gu), Kannada (kn)
- *
- * Subclasses MUST define language-specific vocabulary via class properties:
- * - `belowHundred` array with digit and teen words (0-99)
- * - `hundredWord` string used inside `convertBelowThousand`
- * - `scaleWords` array with grouping words (hazaar, lakh, crore, etc.) indexed by grouping level
- * - `negativeWord`, `decimalSeparatorWord`, `zeroWord`, `wordSeparator`
- *
- * @abstract
- * @extends AbstractLanguage
- */
-class SouthAsianLanguage extends AbstractLanguage {
-  /**
-   * Array of words for numbers 0-99 (digits and teens).
-   * Index directly: belowHundred[0] through belowHundred[99].
-   * @type {Array<string>}
-   */
-  belowHundred
-
-  /**
-   * Word for "hundred" in the language (e.g., 'सौ' in Hindi, 'শত' in Bengali).
-   * Used to construct hundreds (e.g., "1 hundred", "2 hundred").
-   * @type {string}
-   */
-  hundredWord
-
-  /**
-   * Array of scale words for Indian-style grouping (hazaar, lakh, crore, arab, etc.).
-   * Index 0 is typically unused (ones place, no scale word).
-   * Index 1 is for thousands, Index 2 for lakhs, Index 3 for crores, etc.
-   * @type {Array<string>}
-   */
-  scaleWords
-
-  /**
-   * Split a number into Indian numbering system groups.
-   *
-   * The Indian system groups differently than Western (3-3-3) systems:
-   * - First group (rightmost): Up to 3 digits (ones, tens, hundreds)
-   * - Subsequent groups: Exactly 2 digits each (thousands, lakhs, crores, etc.)
-   *
-   * This creates the familiar Indian comma pattern: 1,23,45,67,890
-   *
-   * @protected
-   * @param {bigint} number The number to split into groups
-   * @returns {Array<number>} Array of groups from most significant to least significant
-   *
-   * @example
-   * // splitToGroups(1234567n) → [12, 34, 567]
-   * // Reads as: 12 lakhs, 34 thousands, 567 units
-   * // splitToGroups(98765432n) → [9, 87, 65, 432]
-   * // Reads as: 9 crores, 87 lakhs, 65 thousands, 432 units
-   */
-  splitToGroups (number) {
-    const numStr = number.toString()
-
-    if (numStr.length <= 3) {
-      return [Number(numStr)]
-    }
-
-    const groups = []
-    const last3 = numStr.slice(-3)
-    groups.unshift(Number(last3))
-
-    let remaining = numStr.slice(0, -3)
-    while (remaining.length > 0) {
-      const group = remaining.slice(-2)
-      groups.unshift(Number(group))
-      remaining = remaining.slice(0, -2)
-    }
-
-    return groups
-  }
-
-  /**
-   * Convert a number below 1000 to words (0-999).
-   *
-   * @protected
-   * @param {number} number Value between 0 and 999
-   * @returns {string} Language-specific word representation
-   */
-  convertBelowThousand (number) {
-    if (number === 0) return ''
-    if (number < 100) return this.belowHundred[number]
-
-    const hundreds = Math.trunc(number / 100)
-    const remainder = number % 100
-    const parts = []
-
-    if (hundreds === 1) {
-      parts.push(this.belowHundred[1] + ' ' + this.hundredWord)
-    } else {
-      parts.push(this.belowHundred[hundreds] + ' ' + this.hundredWord)
-    }
-
-    if (remainder > 0) {
-      parts.push(this.belowHundred[remainder])
-    }
-
-    return parts.join(' ')
-  }
-
-  /**
-   * Convert whole number to cardinal words using South Asian grouping.
-   *
-   * @param {bigint} number Number to convert
-   * @returns {string} Cardinal representation
-   */
-  convertWholePart (number) {
-    if (number === 0n) {
-      return this.zeroWord
-    }
-
-    const groups = this.splitToGroups(number)
-    const groupCount = groups.length
-    const words = []
-
-    for (let i = 0; i < groupCount; i++) {
-      const groupValue = groups[i]
-      if (groupValue === 0) continue
-
-      const scaleIndex = groupCount - i - 1
-      words.push(this.convertBelowThousand(groupValue))
-      if (scaleIndex > 0 && this.scaleWords[scaleIndex]) {
-        words.push(this.scaleWords[scaleIndex])
-      }
-    }
-
-    return words.join(' ').trim()
-  }
-}
-
-export default SouthAsianLanguage

package/lib/classes/turkic-language.js

@@ -1,63 +0,0 @@
-import GreedyScaleLanguage from './greedy-scale-language.js'
-
-/**
- * @typedef {Object} TurkicWordPair
- * @property {string} word - The Turkic word or phrase
- * @property {bigint} value - The numeric value represented by the word
- */
-
-/**
- * Base class for Turkic languages with shared grammar patterns.
- *
- * This class provides a reusable implementation for Turkic languages that share:
- * - Space-separated number combinations
- * - Implicit 'bir' (one) before hundreds and thousands
- * - Simple multiplication/addition logic
- * - Consistent magnitude handling
- * - Inherits decimal handling from AbstractLanguage via GreedyScaleLanguage
- *   (supports both grouped and per-digit modes via the `convertDecimalsPerDigit` class property).
- *
- * Used by: Turkish (TR), Azerbaijani (AZ)
- *
- * Subclasses MUST define (from GreedyScaleLanguage requirements):
- * - `scaleWordPairs` array of [value, word] pairs as a class property (ordered descending by value).
- * Optionally, language-specific class properties (e.g., `negativeWord`, `zeroWord`, `decimalSeparatorWord`, `wordSeparator`).
- *
- * TurkicLanguage provides a default `mergeScales()` implementation; subclasses may override
- * if specialized merge logic is needed (unlikely for Turkic languages).
- *
- * @abstract
- * @extends GreedyScaleLanguage
- */
-class TurkicLanguage extends GreedyScaleLanguage {
-  /**
-   * Merges two adjacent word-number pairs according to Turkic grammar rules.
-   *
-   * Shared Turkic patterns:
-   * - Implicit 'bir' (one) before hundreds and thousands
-   * - Space separator (wordSeparator property) for all combinations
-   * - Multiplies when right > left (crossing magnitude boundary)
-   * - Adds otherwise (combining same-magnitude components)
-   *
-   * @param {Object} leftPair The left operand as `{ word: bigint }`.
-   * @param {Object} rightPair The right operand as `{ word: bigint }`.
-   * @returns {Object} Merged pair with combined word and resulting number (bigint).
-   */
-  mergeScales (leftPair, rightPair) {
-    const [[leftWord, leftNumber]] = Object.entries(leftPair)
-    const [[rightWord, rightNumber]] = Object.entries(rightPair)
-
-    // Implicit 'bir' (one) before certain magnitudes:
-    // Omit '1' before hundreds (100n) and thousands (1000n) to form natural combinations
-    if (leftNumber === 1n && (rightNumber <= 100n || rightNumber === 1000n)) {
-      return rightPair // Return just the magnitude word (e.g., "yüz", not "bir yüz")
-    }
-
-    // Combine numbers with space separator (wordSeparator from GreedyScaleLanguage):
-    // Multiply when crossing magnitude boundary, add otherwise
-    const mergedNumber = rightNumber > leftNumber ? leftNumber * rightNumber : leftNumber + rightNumber
-    return { [`${leftWord}${this.wordSeparator}${rightWord}`]: mergedNumber }
-  }
-}
-
-export default TurkicLanguage

package/lib/languages/pa-Guru.js

@@ -1,126 +0,0 @@
-import SouthAsianLanguage from '../classes/south-asian-language.js'
-
-class Punjabi extends SouthAsianLanguage {
-  negativeWord = 'ਮਾਇਨਸ'
-  decimalSeparatorWord = 'ਦਸ਼ਮਲਵ'
-  zeroWord = 'ਸਿਫ਼ਰ'
-  hundredWord = 'ਸੌ'
-  belowHundred = [
-    'ਸਿਫ਼ਰ',
-    'ਇੱਕ',
-    'ਦੋ',
-    'ਤਿੰਨ',
-    'ਚਾਰ',
-    'ਪੰਜ',
-    'ਛੇ',
-    'ਸੱਤ',
-    'ਅੱਠ',
-    'ਨੌਂ',
-    'ਦੱਸ',
-    'ਗਿਆਰਾਂ',
-    'ਬਾਰਾਂ',
-    'ਤੇਰਾਂ',
-    'ਚੌਦਾਂ',
-    'ਪੰਦਰਾਂ',
-    'ਸੋਲਾਂ',
-    'ਸਤਾਰਾਂ',
-    'ਅਠਾਰਾਂ',
-    'ਉੱਨੀ',
-    'ਵੀਹ',
-    'ਇੱਕੀ',
-    'ਬਾਈ',
-    'ਤੇਈ',
-    'ਚੌਬੀ',
-    'ਪੱਚੀ',
-    'ਛੱਬੀ',
-    'ਸਤਾਈ',
-    'ਅਠਾਈ',
-    'ਉਨੱਤੀ',
-    'ਤੀਹ',
-    'ਇਕੱਤੀ',
-    'ਬੱਤੀ',
-    'ਤੇਤੀ',
-    'ਚੌਂਤੀ',
-    'ਪੈਂਤੀ',
-    'ਛੱਤੀ',
-    'ਸੈਂਤੀ',
-    'ਅਠੱਤੀ',
-    'ਉਨਤਾਲੀ',
-    'ਚਾਲੀ',
-    'ਇਕਤਾਲੀ',
-    'ਬਿਆਲੀ',
-    'ਤਿਰਤਾਲੀ',
-    'ਚੁਵਾਲੀ',
-    'ਪੰਤਾਲੀ',
-    'ਛਿਆਲੀ',
-    'ਸੈਂਤਾਲੀ',
-    'ਅਠਤਾਲੀ',
-    'ਉਨੰਜਾ',
-    'ਪੰਜਾਹ',
-    'ਇਕਵੰਜਾ',
-    'ਬਵੰਜਾ',
-    'ਤਰਵੰਜਾ',
-    'ਚੁਰਵੰਜਾ',
-    'ਪੰਜਵੰਜਾ',
-    'ਛਪੰਜਾ',
-    'ਸੱਤਵੰਜਾ',
-    'ਅਠਵੰਜਾ',
-    'ਉਨਾਹਠ',
-    'ਸੱਠ',
-    'ਇਕਾਹਠ',
-    'ਬਾਹਠ',
-    'ਤਰਸਠ',
-    'ਚੌਂਸਠ',
-    'ਪੈਂਸਠ',
-    'ਛਿਆਸਠ',
-    'ਸੜਸਠ',
-    'ਅੜਸਠ',
-    'ਉਣਹੱਤਰ',
-    'ਸਤੱਰ',
-    'ਇਕਹੱਤਰ',
-    'ਬਹੱਤਰ',
-    'ਤਹੱਤਰ',
-    'ਚੌਹੱਤਰ',
-    'ਪੰਝਹੱਤਰ',
-    'ਛਿਹੱਤਰ',
-    'ਸਤੱਤਰ',
-    'ਅਠੱਤਰ',
-    'ਉਨਾਸੀ',
-    'ਅੱਸੀ',
-    'ਇਕਿਆਸੀ',
-    'ਬਿਆਸੀ',
-    'ਤਰਿਆਸੀ',
-    'ਚੌਰਿਆਸੀ',
-    'ਪਚਾਸੀ',
-    'ਛਿਆਸੀ',
-    'ਸੱਤਾਸੀ',
-    'ਅਠਾਸੀ',
-    'ਨਵਾਸੀ',
-    'ਨੱਬੇ',
-    'ਇਕਾਨਵੇਂ',
-    'ਬਾਨਵੇਂ',
-    'ਤਰਾਨਵੇਂ',
-    'ਚੁਰਾਨਵੇਂ',
-    'ਪੰਚਾਨਵੇਂ',
-    'ਛਿਆਨਵੇਂ',
-    'ਸਤਾਨਵੇਂ',
-    'ਅਠਾਨਵੇਂ',
-    'ਨਿਨਾਨਵੇਂ'
-  ]
-
-  scaleWords = [
-    '',
-    'ਹਜ਼ਾਰ',
-    'ਲੱਖ',
-    'ਕਰੋੜ',
-    'ਅਰਬ',
-    'ਖਰਬ',
-    'ਨੀਲ',
-    'ਪਦਮ',
-    'ਸ਼ੰਖ'
-  ]
-}
-
-export default function convertToWords (value, options = {}) {
-  return new Punjabi(options).convertToWords(value)
-}

package/typings/classes/abstract-language.d.ts

@@ -1,144 +0,0 @@
-export default AbstractLanguage;
-/**
- * Abstract base class for language converters.
- *
- * What this class handles:
- * - Validates and normalizes caller input (`number | string | bigint`), rejecting NaN/invalid strings.
- * - Splits sign, whole, and decimal parts, caching the whole part for languages that need it.
- * - Delegates whole-number wording to `convertWholePart(wholeNumber)` implemented by subclasses.
- * - Converts decimals via `decimalDigitsToWords()`, preserving leading zeros and supporting per-digit mode when `convertDecimalsPerDigit` is true.
- *
- * What subclasses must provide:
- * - `convertWholePart(wholeNumber)` method implementation (required; abstract).
- * - `negativeWord` class property (word preceding negative numbers, e.g., "minus").
- * - `zeroWord` class property (word for digit 0, e.g., "zero").
- * - `decimalSeparatorWord` class property (word between whole and decimal, e.g., "point").
- * - `wordSeparator` class property (word separator in output, typically a space).
- * Optional: override `convertDecimalsPerDigit`, `digits`, or `convertDigitToWord()` for custom behavior.
- *
- * This class stays minimal; language grammar lives in subclasses.
- *
- * @abstract
- */
-declare class AbstractLanguage {
-    /**
-     * Word that precedes negative numbers (e.g., "minus", "negative", "moins").
-     * @type {string}
-     */
-    negativeWord: string;
-    /**
-     * Word that separates whole and decimal parts (e.g., "point", "virgule", "comma").
-     * @type {string}
-     */
-    decimalSeparatorWord: string;
-    /**
-     * Word representation for the digit 0 (e.g., "zero", "zéro", "null").
-     * @type {string}
-     */
-    zeroWord: string;
-    /**
-     * Character(s) used to separate words in the output (typically a space).
-     * @type {string}
-     */
-    wordSeparator: string;
-    /**
-     * Cached whole number portion from the most recent conversion.
-     * Some languages need access to this value during conversion for
-     * pluralization rules or special cases (e.g., Czech, Hebrew).
-     * @type {bigint}
-     */
-    cachedWholeNumber: bigint;
-    /**
-     * Whether to convert decimal digits individually rather than grouped.
-     * - `true`: Each digit converted separately (e.g., "05" → "zero five")
-     * - `false`: Leading zeros preserved, remaining grouped (e.g., "14" → "fourteen")
-     * Used by languages like Japanese, Thai, Tamil, Telugu.
-     * @type {boolean}
-     */
-    convertDecimalsPerDigit: boolean;
-    /**
-     * Optional array of digit words for direct lookup in `convertDigitToWord()`.
-     * - Length 10: indices 0–9 map directly to digit words
-     * - Length 9: indices 0–8 map to words for digits 1–9
-     * - `null`: Falls back to `convertWholePart()` for digit conversion
-     * @type {string[]|null}
-     */
-    digits: string[] | null;
-    /**
-     * Convert a single decimal digit (0-9) to its word representation.
-     *
-     * Default behavior:
-     * - 0 returns the language's `zeroWord`
-     * - If a `digits` array is present, use it for direct lookup
-     *   - Length 10: indices 0–9 map directly
-     *   - Length 9: indices 1–9 map via `idx - 1`
-     * - Otherwise delegate to `convertWholePart(digit)`
-     *
-     * Subclasses may override this for custom logic.
-     *
-     * @protected
-     * @param {bigint} digit A single digit value (0-9) as BigInt
-     * @returns {string} The word representation of the digit
-     */
-    protected convertDigitToWord(digit: bigint): string;
-    /**
-     * Convert the decimal fractional digits into words.
-     *
-    * Behavior depends on the `convertDecimalsPerDigit` class property:
-     *
-     * **Per-digit mode** (`convertDecimalsPerDigit: true`):
-     * - Each decimal digit is converted individually using `convertDigitToWord()`
-     * - Example: "05" -> [zero, 'five'], "14" -> ['one', 'four']
-     * - Used by: Japanese, Thai, Tamil, Telugu
-     *
-     * **Grouped mode** (default, `convertDecimalsPerDigit: false`):
-     * - Leading zeros are preserved as individual `zeroWord` entries
-     * - Remaining digits are grouped and converted as a number
-     * - Example: "05" -> [zero, 'five'], "14" -> ['fourteen']
-     * - Used by: Most languages (English, Spanish, French, etc.)
-     *
-     * @protected
-     * @param {string} decimalString The decimal digits as a string (e.g. `'05'` for 3.05).
-     * @returns {Array<string>} Array of word tokens representing the fractional part.
-     *
-     * @example
-     * // Per-digit mode
-     * decimalDigitsToWords('05'); // -> [this.zeroWord, 'five']
-     * decimalDigitsToWords('14'); // -> ['one', 'four']
-     *
-     * // Grouped mode
-     * decimalDigitsToWords('05'); // -> [this.zeroWord, 'five']
-     * decimalDigitsToWords('14'); // -> ['fourteen']
-     */
-    protected decimalDigitsToWords(decimalString: string): Array<string>;
-    /**
-     * Convert a numeric input into its language cardinal representation.
-     *
-     * This is the public entry point used by consumers. It normalizes the input
-     * (accepting `number | string | bigint`), validates it, splits sign and
-     * fractional parts, and delegates whole-number conversion to
-     * `convertWholePart(BigInt)` and fractional conversion to `decimalDigitsToWords()`.
-     *
-     * Errors and validation:
-     * - Passing `NaN` (as `number`) throws `TypeError`.
-     * - Passing a non-numeric `string` throws `Error`.
-     * - Passing an unsupported type throws `TypeError`.
-     *
-     * @public
-     * @param {number|string|bigint} value Numeric input to convert. Strings may include a single `.` decimal marker.
-     * @returns {string} The localized cardinal string.
-     * @throws {TypeError|Error} For invalid input as described above.
-     */
-    public convertToWords(value: number | string | bigint): string;
-    /**
-     * Convert a BigInt whole number to its cardinal word representation.
-     *
-     * This is a template method that subclasses MUST implement to provide
-     * language-specific number conversion logic.
-     *
-     * @abstract
-     * @param {bigint} wholeNumber The whole number part to convert
-     * @returns {string} The cardinal representation in the target language
-     */
-    convertWholePart(wholeNumber: bigint): string;
-}

package/typings/classes/greedy-scale-language.d.ts

@@ -1,148 +0,0 @@
-export default GreedyScaleLanguage;
-export type WordSet = {
-    /**
-     * - The language word or phrase
-     */
-    word: string;
-    /**
-     * - The numeric value represented by the word
-     */
-    value: bigint;
-};
-/**
- * Array of scale word pairs in descending order. Each pair contains:
- * - [0]: BigInt numeric value
- * - [1]: String word representation
- * Must be ordered largest to smallest for the greedy algorithm.
- */
-export type ScaleWordPairs = Array<Array<(bigint | string)>>;
-/**
- * @typedef {Object} WordSet
- * @property {string} word - The language word or phrase
- * @property {bigint} value - The numeric value represented by the word
- */
-/**
- * @typedef {Array.<Array.<(bigint|string)>>} ScaleWordPairs
- * Array of scale word pairs in descending order. Each pair contains:
- * - [0]: BigInt numeric value
- * - [1]: String word representation
- * Must be ordered largest to smallest for the greedy algorithm.
- */
-/**
- * Greedy scale language converter implementing the "highest-matching scale word" algorithm.
- *
- * Responsibilities:
- * - Decompose a whole-number value into a sequence of scale word-sets.
- * - Provide helpers to merge and post-process matched word-sets.
- * - Inherits decimal handling from AbstractLanguage (supports grouped and per-digit
- *   modes via the `convertDecimalsPerDigit` class property).
- *
- * Subclass requirements:
- * - Define `scaleWordPairs` (ordered descending) as `[BigInt, string]` tuples.
- * - Implement `mergeScales(leftWordSet, rightWordSet)` to combine adjacent word-sets
- *   per language grammar.
- *
- * Scale words specification:
- * - `scaleWordPairs` is an Array of 2-tuples: `[BigInt, string]` where the first element
- *   is the numeric value (BigInt) and the second is the word used for that value.
- * - Scale words MUST be ordered from largest to smallest (descending) for the algorithm
- *   to function correctly.
- *
- * @abstract
- * @extends AbstractLanguage
- * @example
- * // Example `scaleWordPairs` for English (descending order):
- * // [[1000000000n, 'billion'], [1000000n, 'million'], [1000n, 'thousand'], [100n, 'hundred'], ..., [1n, 'one']]
- */
-declare class GreedyScaleLanguage extends AbstractLanguage {
-    /**
-     * Array of scale word pairs mapping numeric values to their word representations.
-     *
-     * Each element is a 2-tuple: `[BigInt, string]` where the first element is the
-     * numeric value and the second is the word for that value. The array MUST be
-     * ordered from largest to smallest (descending) for the greedy algorithm to work correctly.
-     *
-     * @type {Array.<Array.<(bigint|string)>>}
-     * @example
-     * // English scale words (descending order):
-     * // [[1000000000n, 'billion'], [1000000n, 'million'], [1000n, 'thousand'], [100n, 'hundred'], ..., [1n, 'one']]
-     */
-    scaleWordPairs: Array<Array<(bigint | string)>>;
-    /**
-     * Return the word associated with an exact scale word-set numeric value.
-     *
-     * @param {bigint|number} scaleValue Numeric word-set object key (prefer BigInt for exact matching).
-     * @returns {string|undefined} The word for the provided scale value, or `undefined`.
-     */
-    getScaleWord(scaleValue: bigint | number): string | undefined;
-    /**
-     * Decompose a whole-number into a sequence of scale word-sets.
-     *
-     * This internal helper returns a nested structure that represents quantities and
-     * their matching scale words (e.g. `[{ 'one': 1n }, { 'hundred': 100n }, ...]`).
-     * The result is designed to be reduced by `mergeWordSets()` using language-specific `mergeScales()`.
-     *
-     * For quantities > 1, the multiplier is recursively decomposed. For quantity = 1,
-     * the implicit "one" is represented with `{ 'one': 1n }` and typically omitted during mergeScales().
-     *
-     * @protected
-     * @param {bigint} wholeNumber The integer value to decompose (BigInt preferred).
-     * @returns {Array<Object|Array>} An array of word-set objects and possibly nested arrays.
-     */
-    protected decomposeToScales(wholeNumber: bigint): Array<any | any[]>;
-    /**
-     * Reduce a nested array of word-sets into a single merged word-set object.
-     *
-     * This method repeatedly applies the subclass `mergeScales()` operation until a single
-     * object remains. It normalizes nested arrays by recursively merging them.
-     *
-     * @protected
-     * @param {Array<Object|Array>} mergeWordSetsList Array of word-set objects and nested arrays.
-     * @returns {Object} Merged word-set where the single object key is the language string
-     *   and its value is the numeric BigInt result for that string.
-     */
-    protected mergeWordSets(mergeWordSetsList: Array<any | any[]>): any;
-    /**
-     * Combine two adjacent word-sets into a single merged word-set.
-     *
-     * This is the core language-specific method that must be implemented by subclasses
-     * to define how adjacent word-sets are combined according to the language's grammar.
-     * For example, English combines "twenty" + "three" → "twenty-three", while
-     * French might combine "quatre-vingts" + "dix" → "quatre-vingt-dix".
-     *
-     * @abstract
-     * @protected
-     * @param {Object} leftWordSet Left operand as `{ word: bigint }` pair.
-     * @param {Object} rightWordSet Right operand as `{ word: bigint }` pair.
-     * @returns {Object} Single merged word-set object with combined text and numeric value.
-     *
-     * @example
-     * // English implementation might handle:
-     * // mergeScales({ 'twenty': 20n }, { 'three': 3n }) → { 'twenty-three': 23n }
-     * // mergeScales({ 'one': 1n }, { 'hundred': 100n }) → { 'one hundred': 100n }
-     */
-    protected mergeScales(leftWordSet: any, rightWordSet: any): any;
-    /**
-     * Final string post-processing hook.
-     *
-     * Subclasses may override to apply language-specific whitespace, punctuation or
-     * orthographic corrections.
-     *
-     * @protected
-     * @param {string} output Merged language string produced by `convertWholePart` flow.
-     * @returns {string} Final formatted string.
-     */
-    protected finalizeWords(output: string): string;
-    /**
-     * Convert an integer value to its language-specific cardinal words.
-     *
-     * This method orchestrates decomposition, merging and final formatting. It does
-     * not handle decimals or sign; those concerns are implemented in
-     * `AbstractLanguage.convertToWords` which calls this helper for the whole-number part.
-     *
-     * @param {bigint|number} wholeNumber Whole-number value to convert (BigInt is preferred).
-     * @returns {string} The cardinal representation for `value` in the language.
-     */
-    convertWholePart(wholeNumber: bigint | number): string;
-}
-import AbstractLanguage from './abstract-language.js';