n2words 1.24.0 → 3.0.0

package/lib/classes/abstract-language.js

@@ -1,261 +0,0 @@
-/**
- * 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
- */
-class AbstractLanguage {
-  /**
-   * Word that precedes negative numbers (e.g., "minus", "negative", "moins").
-   * @type {string}
-   */
-  negativeWord = ''
-
-  /**
-   * Word that separates whole and decimal parts (e.g., "point", "virgule", "comma").
-   * @type {string}
-   */
-  decimalSeparatorWord = ''
-
-  /**
-   * Word representation for the digit 0 (e.g., "zero", "zéro", "null").
-   * @type {string}
-   */
-  zeroWord = ''
-
-  /**
-   * Character(s) used to separate words in the output (typically a space).
-   * @type {string}
-   */
-  wordSeparator = ' '
-
-  /**
-   * 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 = 0n
-
-  /**
-   * 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 = false
-
-  /**
-   * 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 = 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
-   */
-  convertDigitToWord (digit) {
-    const idx = Number(digit)
-    if (idx === 0) return this.zeroWord
-
-    if (Array.isArray(this.digits)) {
-      if (this.digits.length === 10) {
-        return this.digits[idx] ?? this.zeroWord
-      }
-      if (this.digits.length === 9) {
-        return this.digits[idx - 1] ?? this.zeroWord
-      }
-    }
-
-    return this.convertWholePart(digit)
-  }
-
-  /**
-   * 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']
-   */
-  decimalDigitsToWords (decimalString) {
-    const words = []
-    const len = decimalString.length
-
-    if (this.convertDecimalsPerDigit) {
-      for (let i = 0; i < len; i++) {
-        const decimalDigit = BigInt(decimalString[i])
-        words.push(this.convertDigitToWord(decimalDigit))
-      }
-      return words
-    }
-
-    // Default grouped-decimal behavior with leading zero preservation
-    let i = 0
-    while (i < len && decimalString[i] === '0') {
-      words.push(this.zeroWord)
-      i++
-    }
-
-    if (i === len) return words
-
-    const remainingDigits = decimalString.slice(i)
-    words.push(this.convertWholePart(BigInt(remainingDigits)))
-
-    return words
-  }
-
-  /**
-   * 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.
-   */
-  convertToWords (value) {
-    // Normalize and validate input
-    const inputType = typeof value
-
-    if (inputType === 'number') {
-      if (Number.isNaN(value)) throw new TypeError('NaN is not an accepted number.')
-      value = value.toString()
-    } else if (inputType === 'string') {
-      value = value.trim()
-      if (value.length === 0 || Number.isNaN(Number(value))) { throw new Error('Invalid number format: "' + value + '"') }
-    } else if (inputType !== 'bigint') {
-      throw new TypeError(
-        'Invalid variable type, expected number|string|bigint, received: ' + inputType
-      )
-    }
-
-    const words = []
-
-    // Detect negativity and strip sign for further processing.
-    // Must check before type coercion for BigInt (comparison works but slice does not).
-    let isNegative = false
-    if (inputType === 'bigint') {
-      if (value < 0n) {
-        isNegative = true
-        value = -value
-      }
-    } else {
-      // For strings, check first character before normalization
-      if (value[0] === '-') {
-        isNegative = true
-        value = value.slice(1)
-      }
-    }
-
-    // Extract whole and decimal parts based on type.
-    // BigInt has no decimal point; strings may contain a single '.'.
-    // Default whole part to '0' if empty (e.g., '.5' -> '0' + '.5')
-    let wholeNumber
-    let decimalPart
-    if (inputType === 'bigint') {
-      wholeNumber = value
-    } else {
-      const decimalPointIndex = value.indexOf('.')
-      if (decimalPointIndex === -1) {
-        wholeNumber = BigInt(value)
-      } else {
-        const wholePartString = value.slice(0, decimalPointIndex) || '0'
-        wholeNumber = BigInt(wholePartString)
-        decimalPart = value.slice(decimalPointIndex + 1)
-      }
-    }
-
-    this.cachedWholeNumber = wholeNumber
-
-    if (isNegative) words.push(this.negativeWord)
-
-    words.push(this.convertWholePart(wholeNumber))
-
-    // Append decimal portion if present (separator + fractional digits)
-    if (decimalPart) {
-      words.push(this.decimalSeparatorWord)
-      words.push(...this.decimalDigitsToWords(decimalPart))
-    }
-
-    return words.join(this.wordSeparator)
-  }
-
-  /**
-   * 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) {
-    throw new Error('convertWholePart() must be implemented by subclass')
-  }
-}
-
-export default AbstractLanguage

package/lib/classes/greedy-scale-language.js

@@ -1,195 +0,0 @@
-import AbstractLanguage from './abstract-language.js'
-
-/**
- * @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']]
- */
-
-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
-
-  /**
-   * 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) {
-    const matchingPair = this.scaleWordPairs.find((pair) => pair[0] === scaleValue)
-    return matchingPair?.[1]
-  }
-
-  /**
-   * 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.
-   */
-  decomposeToScales (wholeNumber) {
-    const decomposeWordSets = []
-    let remainingValue = wholeNumber
-
-    do {
-      const matchingScaleWordPair = this.scaleWordPairs.find((scaleWordPair) => remainingValue >= scaleWordPair[0])
-      if (!matchingScaleWordPair) break
-
-      const multiplier = remainingValue === 0n ? 1n : remainingValue / matchingScaleWordPair[0]
-
-      if (multiplier === 1n) {
-        decomposeWordSets.push({ [this.getScaleWord(1n)]: 1n })
-      } else {
-        decomposeWordSets.push(this.decomposeToScales(multiplier))
-      }
-
-      decomposeWordSets.push({ [matchingScaleWordPair[1]]: matchingScaleWordPair[0] })
-
-      remainingValue = remainingValue === 0n ? 0n : remainingValue % matchingScaleWordPair[0]
-    } while (remainingValue > 0n)
-
-    return decomposeWordSets
-  }
-
-  /**
-   * 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.
-   */
-  mergeWordSets (mergeWordSetsList) {
-    while (mergeWordSetsList.length > 1) {
-      const [firstWordSet, secondWordSet, ...remainingWordSets] = mergeWordSetsList
-
-      if (!Array.isArray(firstWordSet) && !Array.isArray(secondWordSet)) {
-        const merged = this.mergeScales(firstWordSet, secondWordSet)
-        mergeWordSetsList = remainingWordSets.length > 0 ? [merged, remainingWordSets] : [merged]
-        continue
-      }
-
-      const normalizedWordSets = mergeWordSetsList.map((wordSetElement) => {
-        if (!Array.isArray(wordSetElement)) return wordSetElement
-        return wordSetElement.length === 1 ? wordSetElement[0] : this.mergeWordSets(wordSetElement)
-      })
-
-      mergeWordSetsList = normalizedWordSets
-    }
-
-    return mergeWordSetsList[0]
-  }
-
-  /**
-   * 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 }
-   */
-  mergeScales (leftWordSet, rightWordSet) {
-    throw new Error('mergeScales() must be implemented by subclass')
-  }
-
-  /**
-   * 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.
-   */
-  finalizeWords (output) {
-    return output.trimEnd()
-  }
-
-  /**
-   * 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) {
-    const decomposeWordSets = this.decomposeToScales(wholeNumber)
-    const mergedWordSet = this.mergeWordSets(decomposeWordSets)
-    const resultString = Object.keys(mergedWordSet)[0]
-    return this.finalizeWords(resultString)
-  }
-}
-
-export default GreedyScaleLanguage

package/lib/classes/slavic-language.js

@@ -1,251 +0,0 @@
-import AbstractLanguage from './abstract-language.js'
-
-/**
- * @typedef {string[]} SlavicPluralForms
- * Array of three plural forms for Slavic languages:
- * - [0]: Singular form (for numbers ending in 1, except 11)
- * - [1]: Few form (for numbers ending in 2-4, except 12-14)
- * - [2]: Many form (for all other numbers: 0, 5-20, and numbers ending in 0, 5-9, 11-19)
- */
-
-/**
- * @typedef {Object.<string, SlavicPluralForms>} SlavicThousandsMap
- * Mapping from power indices to their plural forms.
- * Example: { '0': ['тысяча', 'тысячи', 'тысяч'], '1': ['миллион', 'миллиона', 'миллионов'] }
- */
-
-/**
- * Base class for Slavic and related languages with complex pluralization.
- *
- * This class provides a reusable implementation for languages that share:
- * - Three-form pluralization (singular/few/many)
- * - Gender-aware number forms (masculine/feminine for 1, 2)
- * - Hundreds, tens, ones decomposition
- * - Chunk-based large number handling (thousands, millions, etc.)
- * - Inherits decimal handling from AbstractLanguage (supports both grouped and
- *   per-digit modes via the `convertDecimalsPerDigit` class property).
- *
- * Used by: Russian, Czech, Polish, Ukrainian, Serbian, Croatian,
- * as well as Baltic (Lithuanian, Latvian) and Hebrew languages.
- *
- * Subclasses MUST define these properties with language-specific vocabulary:
- * - `ones` - Object mapping 1-9 to masculine forms
- * - `onesFeminine` - Object mapping 1-9 to feminine forms
- * - `tens` - Object mapping 0-9 to teen numbers (10-19)
- * - `twenties` - Object mapping 2-9 to tens (20-90)
- * - `hundreds` - Object mapping 1-9 to hundreds (100-900)
- * - `thousands` - Object mapping power indices to [singular, few, many] forms
- * - `feminine` - Boolean indicating if feminine forms should be used (optional)
- *
- * @abstract
- * @extends AbstractLanguage
- */
-class SlavicLanguage extends AbstractLanguage {
-  /**
-   * Masculine forms for digits 1-9.
-   *
-   * @type {object}
-   */
-  ones = {}
-
-  /**
-   * Feminine forms for digits 1-9.
-   *
-   * @type {object}
-   */
-  onesFeminine = {}
-
-  /**
-   * Words for tens (10, 20, 30, etc.).
-   *
-   * @type {object}
-   */
-  tens = {}
-
-  /**
-   * Special forms for 21-29 in some languages.
-   *
-   * @type {object}
-   */
-  twenties = {}
-
-  /**
-   * Words for hundreds (100, 200, 300, etc.).
-   *
-   * @type {object}
-   */
-  hundreds = {}
-
-  /**
-   * Scale words for thousands, millions, etc.
-   *
-   * @type {object}
-   */
-  thousands = {}
-
-  /**
-   * Use feminine forms for numbers (affects 1-9).
-   *
-   * @type {boolean}
-   */
-  feminine
-
-  /**
-   * Initializes the Slavic language converter with language-specific options.
-   *
-   * @param {Object} [options={}] Configuration options.
-   * @param {boolean} [options.feminine=false] Use feminine forms for numbers (affects gender agreement).
-   */
-  constructor ({ feminine = false } = {}) {
-    super()
-
-    this.feminine = feminine
-  }
-
-  /**
-   * Converts a whole number to its word representation.
-   *
-   * This method implements the Slavic number construction algorithm:
-   * 1. Split number into 3-digit chunks (right to left)
-   * 2. For each chunk: convert hundreds, tens, ones
-   * 3. Apply gender rules for ones (feminine for thousands, or when feminine=true)
-   * 4. Add pluralized power word (thousand/million/billion/etc.)
-   * 5. Join all parts with spaces
-   *
-   * @param {bigint} number The whole number to convert (non-negative).
-   * @returns {string} The number in words.
-   */
-  convertWholePart (number) {
-    if (number === 0n) {
-      return this.zeroWord
-    }
-
-    const words = []
-    const chunks = this.splitByX(number.toString(), 3)
-    let chunkIndex = chunks.length
-
-    for (const chunkValue of chunks) {
-      chunkIndex = chunkIndex - 1
-
-      if (chunkValue === 0n) {
-        continue
-      }
-
-      const [onesDigit, tensDigit, hundredsDigit] = this.getDigits(chunkValue)
-
-      if (hundredsDigit > 0n) {
-        words.push(this.hundreds[hundredsDigit])
-      }
-
-      if (tensDigit > 1n) {
-        words.push(this.twenties[tensDigit])
-      }
-
-      // Handle teens (10-19) or ones (1-9)
-      if (tensDigit === 1n) {
-        // Teens: use tens array directly
-        words.push(this.tens[onesDigit])
-      } else if (onesDigit > 0n) {
-        // Ones: use feminine form for thousands (chunkIndex 1) or when feminine=true (chunkIndex 0)
-        const onesArray =
-          chunkIndex === 1 || (this.feminine && chunkIndex === 0)
-            ? this.onesFeminine
-            : this.ones
-        words.push(onesArray[onesDigit])
-      }
-
-      // Add power word (thousand, million, etc.) with proper pluralization
-      if (chunkIndex > 0) {
-        words.push(this.pluralize(chunkValue, this.thousands[chunkIndex]))
-      }
-    }
-
-    return words.join(' ')
-  }
-
-  /**
-   * Splits a number string into chunks of X digits.
-   *
-   * Example: splitByX('1234567', 3) => [1n, 234n, 567n]
-   *
-   * @param {string} numberString The number as a string.
-   * @param {number} chunkSize Chunk size (typically 3 for thousands grouping).
-   * @returns {bigint[]} Array of BigInt chunks.
-   */
-  splitByX (numberString, chunkSize) {
-    const chunks = []
-    const stringLength = numberString.length
-
-    if (stringLength > chunkSize) {
-      const remainderLength = stringLength % chunkSize
-
-      if (remainderLength > 0) {
-        chunks.push(BigInt(numberString.slice(0, remainderLength)))
-      }
-
-      for (let i = remainderLength; i < stringLength; i += chunkSize) {
-        chunks.push(BigInt(numberString.slice(i, i + chunkSize)))
-      }
-    } else {
-      chunks.push(BigInt(numberString))
-    }
-
-    return chunks
-  }
-
-  /**
-   * Extracts individual digits from a number (units, tens, hundreds).
-   *
-   * Returns digits in reverse order: [ones, tens, hundreds]
-   * Example: 456 => [6n, 5n, 4n]
-   *
-   * @param {bigint} value The number to extract digits from (0-999).
-   * @returns {bigint[]} Array of [ones, tens, hundreds] as BigInts.
-   */
-  getDigits (value) {
-    // Direct BigInt arithmetic is faster than string manipulation
-    const onesPlace = value % 10n
-    const tensPlace = (value / 10n) % 10n
-    const hundredsPlace = value / 100n
-    return [onesPlace, tensPlace, hundredsPlace]
-  }
-
-  /**
-   * Selects the correct plural form based on Slavic pluralization rules.
-   *
-   * Slavic languages use three forms:
-   * - Form 0 (singular): numbers ending in 1 (but not 11)
-   * - Form 1 (few): numbers ending in 2-4 (but not 12-14)
-   * - Form 2 (many): all other numbers (0, 5-20, 25-30, etc.)
-   *
-   * Examples (Russian):
-   * - 1, 21, 31... => тысяча (form 0)
-   * - 2-4, 22-24, 32-34... => тысячи (form 1)
-   * - 0, 5-20, 25-30... => тысяч (form 2)
-   *
-   * @param {bigint} n The number to check.
-   * @param {string[]} forms Array of [singular, few, many] forms.
-   * @returns {string} The appropriate form for the number.
-   */
-  pluralize (number, pluralForms) {
-    const remainder100 = number % 100n
-    const remainder10 = number % 10n
-
-    // Check if in 11-19 range (special case)
-    if (remainder100 >= 10n && remainder100 <= 20n) {
-      return pluralForms[2] // Always use "many" form for 11-20
-    }
-
-    if (remainder10 === 1n) {
-      return pluralForms[0] // Singular
-    }
-
-    if (remainder10 >= 2n && remainder10 <= 4n) {
-      return pluralForms[1] // Few (2-4)
-    }
-
-    return pluralForms[2] // Many
-  }
-}
-
-export default SlavicLanguage