n2words 1.23.0 → 1.24.0

package/package.json

@@ -1,43 +1,24 @@
 {
   "name": "n2words",
-  "version": "1.23.0",
-  "description": "n2words converts a numerical number into a written one, supports 28 languages and has zero dependencies.",
+  "version": "1.24.0",
+  "description": "n2words converts a numerical number into a written one, supports 45 languages and has zero dependencies.",
   "keywords": [
     "n2words",
-    "convert",
-    "number",
-    "word",
-    "text",
-    "natural",
-    "language",
-    "english",
-    "french",
-    "spanish",
-    "german",
-    "portuguese",
-    "italian",
-    "turkish",
-    "russian",
-    "czech",
-    "norwegian",
-    "danish",
-    "polish",
-    "ukrainian",
-    "lithuanian",
-    "latvian",
-    "arabic",
-    "hebrew",
-    "korean",
-    "dutch",
-    "serbian",
-    "farsi",
-    "persian",
-    "chinese",
-    "hungarian",
-    "indonesian",
-    "croatian",
-    "vietnamese",
-    "azerbaijani"
+    "number-to-words",
+    "cardinal",
+    "spellout",
+    "conversion",
+    "internationalization",
+    "localization",
+    "multilingual",
+    "pluralization",
+    "typescript",
+    "browser",
+    "nodejs",
+    "zero-dependencies",
+    "bigint",
+    "formatting",
+    "utility"
   ],
   "homepage": "https://github.com/forzagreen/n2words#readme",
   "bugs": {
@@ -55,35 +36,66 @@
   "sideEffects": false,
   "type": "module",
   "exports": {
-    ".": "./lib/n2words.js",
-    "./i18n/*.js": "./lib/i18n/*.js"
+    ".": {
+      "import": "./lib/n2words.js",
+      "types": "./typings/n2words.d.ts"
+    },
+    "./languages/*": {
+      "import": "./lib/languages/*.js",
+      "types": "./typings/languages/*.d.ts"
+    }
   },
+  "main": "lib/n2words.js",
   "jsdelivr": "dist/n2words.js",
   "unpkg": "dist/n2words.js",
+  "types": "typings/n2words.d.ts",
+  "typesVersions": {
+    "*": {
+      "n2words/*": [
+        "typings/*"
+      ]
+    }
+  },
   "files": [
     "lib/*",
-    "dist/*"
+    "dist/*",
+    "typings/*"
   ],
   "scripts": {
-    "bench": "node bench.js",
-    "build": "webpack --progress",
-    "build:types": "npx -p typescript tsc lib/n2words.js dist/n2words.js --target es6 --module nodenext --allowJs --declaration --emitDeclarationOnly",
-    "coverage": "c8 ava",
-    "docs": "jsdoc -c ./conf.json",
+    "bench:perf": "node bench.js",
+    "bench:memory": "node --expose-gc bench-memory.js",
+    "clean": "npm run types:clean && npm run web:clean && npm run docs:clean && npm run coverage:clean",
+    "coverage:clean": "node -e \"import { rmSync } from 'fs'; try { rmSync('coverage', { recursive: true, force: true }) } catch (e) {}\"",
+    "coverage:generate": "c8 npm run test",
+    "docs:generate": "npm run docs:clean && jsdoc -c ./conf.json && npm run docs:validate",
+    "docs:clean": "node -e \"import { rmSync } from 'fs'; try { rmSync('docs', { recursive: true, force: true }) } catch (e) {}\"",
+    "docs:validate": "echo 'Documentation generated successfully'",
+    "lang:add": "node scripts/add-language.js",
+    "lang:validate": "node scripts/validate-language.js",
     "lint": "npm run lint:js && npm run lint:md",
-    "lint:js": "eslint lib/ test/ examples/ *.js",
-    "lint:md": "markdownlint-cli2 *.md",
-    "test": "ava --verbose",
-    "test:cjs": "ava --verbose test/import.cjs",
-    "test:core": "ava --verbose test/core.js",
-    "test:i18n": "ava --verbose test/i18n.js",
-    "test:web": "ava --verbose test/web.js"
+    "lint:js": "standard examples/ lib/ scripts/ test/ *.js",
+    "lint:md": "markdownlint-cli2 *.md scripts/*.md",
+    "test": "npm run test:unit && npm run test:integration",
+    "test:integration": "ava --verbose test/integration/*.{js,cjs}",
+    "test:unit": "ava --verbose test/unit/*.js",
+    "types:generate": "tsc --project tsconfig.json",
+    "types:clean": "node -e \"import { rmSync } from 'fs'; try { rmSync('typings', { recursive: true, force: true }) } catch (e) {}\"",
+    "types:validate": "tsc --noEmit --project test/tsconfig.test.json && node --import tsx --test test/typescript/*.ts",
+    "web:build": "webpack --progress",
+    "web:clean": "node -e \"import { rmSync } from 'fs'; try { rmSync('dist', { recursive: true, force: true }) } catch (e) {}\"",
+    "web:test": "ava --verbose test/web/*.js"
   },
   "ava": {
+    "extensions": [
+      "js",
+      "cjs"
+    ],
     "files": [
-      "test/*",
-      "!test/web.js"
-    ]
+      "test/unit/*.js",
+      "test/integration/*.{js,cjs}",
+      "test/web/*.js"
+    ],
+    "timeout": "30s"
   },
   "c8": {
     "all": true,
@@ -96,28 +108,24 @@
     ]
   },
   "devDependencies": {
-    "@babel/core": "^7.28.0",
-    "@babel/preset-env": "^7.28.0",
-    "@eslint/js": "^9.32.0",
-    "@stylistic/eslint-plugin-js": "^2.13.0",
+    "@babel/core": "^7.28.5",
+    "@babel/preset-env": "^7.28.5",
     "ava": "^6.4.1",
-    "babel-loader": "^9.2.1",
+    "babel-loader": "^10.0.0",
     "benchmark": "^2.1.4",
     "c8": "^10.1.3",
-    "chalk": "^5.5.0",
-    "chromedriver": "^138.0.5",
-    "core-js": "^3.45.0",
-    "eslint": "^9.32.0",
-    "eslint-plugin-ava": "^15.1.0",
-    "eslint-plugin-jsdoc": "^52.0.3",
-    "eslint-plugin-n": "^17.21.3",
-    "eslint-plugin-unicorn": "^60.0.0",
-    "jsdoc": "^4.0.4",
-    "markdownlint-cli2": "^0.18.1",
+    "chalk": "^5.6.2",
+    "chromedriver": "^143.0.3",
+    "core-js": "^3.47.0",
+    "jsdoc": "^4.0.5",
+    "markdownlint-cli2": "^0.20.0",
     "microtime": "^3.1.1",
-    "selenium-webdriver": "^4.34.0",
-    "webpack": "^5.101.0",
-    "webpack-cli": "^5.1.4"
+    "selenium-webdriver": "^4.39.0",
+    "standard": "^17.1.2",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "webpack": "^5.104.1",
+    "webpack-cli": "^6.0.1"
   },
   "engines": {
     "node": "^20 || ^22 || >=24"

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

@@ -0,0 +1,144 @@
+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

@@ -0,0 +1,148 @@
+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';

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

@@ -0,0 +1,145 @@
+export default SlavicLanguage;
+/**
+ * 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)
+ */
+export type SlavicPluralForms = string[];
+/**
+ * Mapping from power indices to their plural forms.
+ * Example: { '0': ['тысяча', 'тысячи', 'тысяч'], '1': ['миллион', 'миллиона', 'миллионов'] }
+ */
+export type SlavicThousandsMap = {
+    [x: string]: SlavicPluralForms;
+};
+/**
+ * @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
+ */
+declare class SlavicLanguage extends AbstractLanguage {
+    /**
+     * 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 }?: {
+        feminine?: boolean;
+    });
+    /**
+     * Masculine forms for digits 1-9.
+     *
+     * @type {object}
+     */
+    ones: object;
+    /**
+     * Feminine forms for digits 1-9.
+     *
+     * @type {object}
+     */
+    onesFeminine: object;
+    /**
+     * Words for tens (10, 20, 30, etc.).
+     *
+     * @type {object}
+     */
+    tens: object;
+    /**
+     * Special forms for 21-29 in some languages.
+     *
+     * @type {object}
+     */
+    twenties: object;
+    /**
+     * Words for hundreds (100, 200, 300, etc.).
+     *
+     * @type {object}
+     */
+    hundreds: object;
+    /**
+     * Scale words for thousands, millions, etc.
+     *
+     * @type {object}
+     */
+    thousands: object;
+    /**
+     * Use feminine forms for numbers (affects 1-9).
+     *
+     * @type {boolean}
+     */
+    feminine: boolean;
+    /**
+     * 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: string, chunkSize: number): bigint[];
+    /**
+     * 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: bigint): bigint[];
+    /**
+     * 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: any, pluralForms: any): string;
+}
+import AbstractLanguage from './abstract-language.js';