n2words 1.24.0 → 2.0.0

package/lib/languages/ja.js

@@ -1,44 +1,25 @@
-import AbstractLanguage from '../classes/abstract-language.js'
+import { AbstractLanguage } from '../classes/abstract-language.js'
 
 /**
  * Japanese language converter.
  *
- * Converts numbers to Japanese kanji numerals using the Sino-Japanese system:
- * - Uses kanji characters (一, 二, 三, etc.)
- * - Grouping by 万 (man, 10,000) and 億 (oku, 100,000,000)
- * - Unique scale units: 兆 (chō, trillion), 京 (kei, 10^16)
- * - Special rules for 1: omitted before 十 (10), 百 (100), 千 (1000), but kept for 万 and above
- *
- * Key Features:
- * - Sino-Japanese number system (standard for general counting)
- * - Grouping by powers of 10,000 (万-based system, not 1,000)
- * - Scale units: 万 (10^4), 億 (10^8), 兆 (10^12), 京 (10^16)
- * - Special handling of 一 (one) prefix
- * - Support for very large numbers up to 無量大数 (10^68)
- *
- * Algorithm:
- * 1. Split number into groups of 4 digits (万-based, not 3-digit thousand-based)
- * 2. Convert each group to kanji using special rules
- * 3. Append appropriate scale word (万, 億, 兆, etc.)
- * 4. Join all groups
- *
- * Special Rules:
- * - 10, 100, 1000: Don't use 一 prefix (十, 百, 千 not 一十, 一百, 一千)
- * - 10,000+: Keep 一 prefix (一万, 一億, 一兆)
- * - Zero: 零 or 〇 (both acceptable, 零 is more formal)
+ * Supports:
+ * - Kanji numerals (一, 二, 三, etc.)
+ * - Grouping by 万 (10,000) instead of 1,000
+ * - Special 一 (one) omission rules (十, 百, 千 but 一万, 一億)
  */
 export class Japanese extends AbstractLanguage {
   negativeWord = 'マイナス'
   decimalSeparatorWord = '点'
   zeroWord = '零'
   wordSeparator = '' // Japanese doesn't use spaces between characters
-  convertDecimalsPerDigit = true // Enable digit-by-digit decimal conversion
+  usePerDigitDecimals = true // Enable digit-by-digit decimal conversion
 
-  // Digits used for group conversion (1-9)
-  digits = ['一', '二', '三', '四', '五', '六', '七', '八', '九']
+  // Ones words used for group conversion (1-9)
+  onesWords = ['一', '二', '三', '四', '五', '六', '七', '八', '九']
 
   // Scale words for grouping by 10^4
-  scales = [
+  scaleWords = [
     '', // 10^0 (ones)
     '万', // 10^4 (man)
     '億', // 10^8 (oku)
@@ -59,19 +40,8 @@ export class Japanese extends AbstractLanguage {
     '無量大数' // 10^68 (muryōtaisū)
   ]
 
-  /**
-   * Converts a group of up to 4 digits to Japanese kanji.
-   * Handles special rules for omitting 一 before 十, 百, 千.
-   *
-   * Rule: Within a group, omit 一 before 十/百/千 EXCEPT when:
-   * - It's a lower group (not isTopGroup) AND
-   * - It would be the only character in that position
-   *
-   * @param {bigint} num - Number from 0 to 9999
-   * @param {boolean} isTopGroup - Whether this is the highest non-zero group
-   * @returns {string} Japanese kanji representation
-   */
-  convertGroup (num, isTopGroup = false) {
+  /** Converts a segment of up to 4 digits to Japanese kanji with 一 omission rules. */
+  segmentToWords (num) {
     if (num === 0n) return ''
 
     const thousands = num / 1000n
@@ -87,7 +57,7 @@ export class Japanese extends AbstractLanguage {
       if (thousands === 1n) {
         result += '千'
       } else {
-        result += this.digits[Number(thousands) - 1] + '千'
+        result += this.onesWords[Number(thousands) - 1] + '千'
       }
     }
 
@@ -97,7 +67,7 @@ export class Japanese extends AbstractLanguage {
       if (hundreds === 1n) {
         result += '百'
       } else {
-        result += this.digits[Number(hundreds) - 1] + '百'
+        result += this.onesWords[Number(hundreds) - 1] + '百'
       }
     }
 
@@ -107,30 +77,25 @@ export class Japanese extends AbstractLanguage {
       if (tens === 1n) {
         result += '十'
       } else {
-        result += this.digits[Number(tens) - 1] + '十'
+        result += this.onesWords[Number(tens) - 1] + '十'
       }
     }
 
     // Ones
     if (ones > 0n) {
-      result += this.digits[Number(ones) - 1]
+      result += this.onesWords[Number(ones) - 1]
     }
 
     return result
   }
 
-  /**
-   * Converts a BigInt number to Japanese cardinal form.
-   *
-   * @param {bigint} number - The number to convert
-   * @returns {string} Japanese kanji representation
-   */
-  convertWholePart (number) {
-    if (number === 0n) {
+  /** Converts integer part using Japanese 万-based grouping system. */
+  integerToWords (integerPart) {
+    if (integerPart === 0n) {
       return this.zeroWord
     }
 
-    let temp = number
+    let temp = integerPart
     let scaleIndex = 0
     const groups = []
 
@@ -151,17 +116,16 @@ export class Japanese extends AbstractLanguage {
 
     for (let i = 0; i < groups.length; i++) {
       const { value, scale } = groups[i]
-      const isTopGroup = (i === 0)
 
-      const groupStr = this.convertGroup(value, isTopGroup)
+      const groupStr = this.segmentToWords(value)
 
       // For scales >= 1 (万 and above), always add the scale word
       if (scale >= 1) {
         // Special case: if group is 1 and scale >= 1, we need 一 before the scale
         if (value === 1n) {
-          result += '一' + this.scales[scale]
+          result += '一' + this.scaleWords[scale]
         } else {
-          result += groupStr + this.scales[scale]
+          result += groupStr + this.scaleWords[scale]
         }
       } else {
         result += groupStr
@@ -171,20 +135,3 @@ export class Japanese extends AbstractLanguage {
     return result
   }
 }
-
-/**
- * Converts a value to cardinal (written) form in Japanese.
- *
- * @param {number|string|bigint} value - Number to convert.
- * @param {Object} [options] - Options for the converter.
- * @returns {string} Value in Japanese kanji numerals.
- * @throws {Error} If value is invalid.
- *
- * @example
- * convertToWords(42, { lang: 'ja' }); // '四十二'
- * convertToWords(1000, { lang: 'ja' }); // '千'
- * convertToWords(10000, { lang: 'ja' }); // '一万'
- */
-export default function convertToWords (value, options = {}) {
-  return new Japanese(options).convertToWords(value)
-}

package/lib/languages/kn.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Kannada language converter.
+ *
+ * Supports:
+ * - Indian numbering system (ಸಾವಿರ, ಲಕ್ಷ, ಕೋಟಿ)
+ * - Kannada script
+ * - Complete word forms for 0-99
+ */
+export class Kannada extends SouthAsianLanguage {
+}
+import { SouthAsianLanguage } from '../classes/south-asian-language.js';

package/lib/languages/kn.js

@@ -1,27 +1,21 @@
-/**
- * Converts numbers to their word representation in Kannada (ಕನ್ನಡ).
- * @module languages/kn
- */
-
-import SouthAsianLanguage from '../classes/south-asian-language.js'
+import { SouthAsianLanguage } from '../classes/south-asian-language.js'
 
 /**
- * Kannada language implementation using Indian-style number grouping.
- * @extends SouthAsianLanguage
+ * Kannada language converter.
+ *
+ * Supports:
+ * - Indian numbering system (ಸಾವಿರ, ಲಕ್ಷ, ಕೋಟಿ)
+ * - Kannada script
+ * - Complete word forms for 0-99
  */
-class KannadaLanguage extends SouthAsianLanguage {
+export class Kannada extends SouthAsianLanguage {
   negativeWord = 'ಋಣಾತ್ಮಕ'
   decimalSeparatorWord = 'ದಶಮಾಂಶ'
   zeroWord = 'ಸೊನ್ನೆ'
   hundredWord = 'ನೂರು'
-  convertDecimalsPerDigit = true
+  usePerDigitDecimals = true
 
-  /**
-   * Array of number words from 0 to 99.
-   * Index matches the number value.
-   * @type {string[]}
-   */
-  belowHundred = [
+  belowHundredWords = [
     'ಸೊನ್ನೆ', 'ಒಂದು', 'ಎರಡು', 'ಮೂರು', 'ನಾಲ್ಕು', 'ಐದು', 'ಆರು', 'ಏಳು', 'ಎಂಟು', 'ಒಂಬತ್ತು',
     'ಹತ್ತು', 'ಹನ್ನೊಂದು', 'ಹನ್ನೆರಡು', 'ಹದಿಮೂರು', 'ಹದಿನಾಲ್ಕು', 'ಹದಿನೈದು', 'ಹದಿನಾರು', 'ಹದಿನೇಳು', 'ಹದಿನೆಂಟು', 'ಹತ್ತೊಂಬತ್ತು',
     'ಇಪ್ಪತ್ತು', 'ಇಪ್ಪತ್ತೊಂದು', 'ಇಪ್ಪತ್ತೆರಡು', 'ಇಪ್ಪತ್ತಮೂರು', 'ಇಪ್ಪತ್ತನಾಲ್ಕು', 'ಇಪ್ಪತ್ತೈದು', 'ಇಪ್ಪತ್ತಾರು', 'ಇಪ್ಪತ್ತೇಳು', 'ಇಪ್ಪತ್ತೆಂಟು', 'ಇಪ್ಪತ್ತೊಂಬತ್ತು',
@@ -34,11 +28,6 @@ class KannadaLanguage extends SouthAsianLanguage {
     'ತೊಂಬತ್ತು', 'ತೊಂಬತ್ತೊಂದು', 'ತೊಂಬತ್ತೆರಡು', 'ತೊಂಬತ್ತಮೂರು', 'ತೊಂಬತ್ತನಾಲ್ಕು', 'ತೊಂಬತ್ತೈದು', 'ತೊಂಬತ್ತಾರು', 'ತೊಂಬತ್ತೇಳು', 'ತೊಂಬತ್ತೆಂಟು', 'ತೊಂಬತ್ತೊಂಬತ್ತು'
   ]
 
-  /**
-   * Scale words for powers of ten in Indian numbering system.
-   * Index 0 = units, 1 = thousand, 2 = lakh, 3 = crore, etc.
-   * @type {string[]}
-   */
   scaleWords = [
     '', // units
     'ಸಾವಿರ', // thousand (1,000)
@@ -50,22 +39,4 @@ class KannadaLanguage extends SouthAsianLanguage {
     'ಪದ್ಮ', // padma (1,000,000,000,000,000)
     'ಶಂಖ' // shankh (100,000,000,000,000,000)
   ]
-
-  /**
-   * Converts numbers using the belowHundred array directly.
-   */
-}
-
-/**
- * Converts a number to its word representation in Kannada.
- * @param {number|string|bigint} value - The number to convert
- * @param {Object} [options={}] - Conversion options
- * @returns {string} The word representation of the number
- * @example
- * convertToWords(42) // 'ನಲವತ್ತೆರಡು'
- * convertToWords(1000) // 'ಒಂದು ಸಾವಿರ'
- * convertToWords(100000) // 'ಒಂದು ಲಕ್ಷ'
- */
-export default function convertToWords (value, options = {}) {
-  return new KannadaLanguage(options).convertToWords(value)
 }

package/lib/languages/ko.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Korean language converter.
+ *
+ * Supports:
+ * - Hangul numerals (일, 이, 삼, etc.)
+ * - Grouping by 만 (10,000) system
+ * - Implicit '일' (one) omission before multipliers
+ */
+export class Korean extends GreedyScaleLanguage {
+    scaleWords: (string | bigint)[][];
+    /** Combines two word-sets according to Korean grammar rules. */
+    combineWordSets(preceding: any, following: any): any;
+}
+import { GreedyScaleLanguage } from '../classes/greedy-scale-language.js';

package/lib/languages/ko.js

@@ -1,18 +1,19 @@
-import GreedyScaleLanguage from '../classes/greedy-scale-language.js'
+import { GreedyScaleLanguage } from '../classes/greedy-scale-language.js'
 
 /**
  * Korean language converter.
  *
- * Features:
- * - Space-separated for large numbers (>= 만/10,000)
- * - Concatenated for smaller numbers
- * - Omits '일' (1) before multipliers
+ * Supports:
+ * - Hangul numerals (일, 이, 삼, etc.)
+ * - Grouping by 만 (10,000) system
+ * - Implicit '일' (one) omission before multipliers
  */
 export class Korean extends GreedyScaleLanguage {
   negativeWord = '마이너스'
   decimalSeparatorWord = '점'
   zeroWord = '영'
-  scaleWordPairs = [
+
+  scaleWords = [
     [10_000_000_000_000_000_000_000_000_000n, '양'],
     [1_000_000_000_000_000_000_000_000n, '자'],
     [100_000_000_000_000_000_000n, '해'],
@@ -35,49 +36,20 @@ export class Korean extends GreedyScaleLanguage {
     [0n, '영']
   ]
 
-  /**
-   * Merges two adjacent word-number pairs according to Korean grammar rules.
-   *
-   * Korean-specific rules:
-   * - Omits '일' (1) before multipliers <= 만 (10,000)
-   * - Concatenates without space for small numbers (< 만)
-   * - Separates with space for large numbers (>= 만)
-   * - Multiplies when right > left, adds when left > right
-   *
-   * @param {Object} leftPair The left operand as `{ word: number }`.
-   * @param {Object} rightPair The right operand as `{ word: number }`.
-   * @returns {Object} Merged pair with combined word and resulting number.
-   */
-  mergeScales (leftPair, rightPair) {
-    const leftWord = Object.keys(leftPair)[0]
-    const rightWord = Object.keys(rightPair)[0]
-    const leftNumber = Object.values(leftPair)[0] // BigInt
-    const rightNumber = Object.values(rightPair)[0] // BigInt
+  /** Combines two word-sets according to Korean grammar rules. */
+  combineWordSets (preceding, following) {
+    const precedingWord = Object.keys(preceding)[0]
+    const followingWord = Object.keys(following)[0]
+    const precedingValue = Object.values(preceding)[0] // BigInt
+    const followingValue = Object.values(following)[0] // BigInt
 
     // Implicit "일": omit 1 before multipliers up to 만 (10,000)
-    if (leftNumber === 1n && rightNumber <= 10_000n) return rightPair
+    if (precedingValue === 1n && followingValue <= 10_000n) return following
     // Concatenate (no space) for small numbers less than 만
-    if (leftNumber < 10_000n && leftNumber > rightNumber) return { [`${leftWord}${rightWord}`]: leftNumber + rightNumber }
+    if (precedingValue < 10_000n && precedingValue > followingValue) return { [`${precedingWord}${followingWord}`]: precedingValue + followingValue }
     // Space-separate for large numbers (>= 만) when adding
-    if (leftNumber >= 10_000n && leftNumber > rightNumber) return { [`${leftWord} ${rightWord}`]: leftNumber + rightNumber }
+    if (precedingValue >= 10_000n && precedingValue > followingValue) return { [`${precedingWord} ${followingWord}`]: precedingValue + followingValue }
     // Multiply for all scale combinations
-    return { [`${leftWord}${rightWord}`]: leftNumber * rightNumber }
+    return { [`${precedingWord}${followingWord}`]: precedingValue * followingValue }
   }
 }
-
-/**
- * Converts a number to Korean cardinal (written) form.
- *
- * @param {number|string|bigint} value The number to convert.
- * @param {Object} [options] Conversion options (see Korean class options).
- * @returns {string} The number expressed in Korean words.
- * @throws {TypeError} If value is NaN or invalid type.
- * @throws {Error} If value is an invalid number string.
- *
- * @example
- * convertToWords(42); // '사십이'
- * convertToWords(10001); // '만 일'
- */
-export default function convertToWords (value, options = {}) {
-  return new Korean(options).convertToWords(value)
-}

package/lib/languages/lt.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Lithuanian language converter.
+ *
+ * Supports:
+ * - Three-form pluralization (one/few/many)
+ * - Gender agreement (vienas/viena, du/dvi)
+ * - Baltic declension patterns
+ */
+export class Lithuanian extends SlavicLanguage {
+    onesWords: {
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    onesFeminineWords: {
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    teensWords: {
+        0: string;
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    twentiesWords: {
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    hundredsWords: string[];
+    pluralForms: {
+        1: string[];
+        2: string[];
+        3: string[];
+        4: string[];
+        5: string[];
+        6: string[];
+        7: string[];
+        8: string[];
+        9: string[];
+        10: string[];
+    };
+    pluralize(n: any, forms: any): any;
+    integerToWords(integerPart: any): string;
+}
+import { SlavicLanguage } from '../classes/slavic-language.js';

package/lib/languages/lt.js

@@ -1,40 +1,19 @@
-import SlavicLanguage from '../classes/slavic-language.js'
-
-/**
- * @typedef {Object} SlavicOptions
- * @property {boolean} [feminine=false] Use feminine forms for numbers.
- */
+import { SlavicLanguage } from '../classes/slavic-language.js'
 
 /**
  * Lithuanian language converter.
  *
- * Implements Lithuanian number words using the Slavic language pattern:
- * - Lithuanian number words (vienas/viena, du/dvi, trys, keturi...)
- * - Gender-aware forms (masculine/feminine)
- * - Baltic three-form pluralization (tūkstantis/tūkstančiai/tūkstančių)
- * - Lithuanian-specific declension patterns
- *
- * Key Features:
- * - Three-form pluralization system shared across Slavic/Baltic languages
- *   * Form 1 (singular): 1 (e.g., "tūkstantis")
- *   * Form 2 (few): 2-4, 22-24, 32-34... excluding teens (e.g., "tūkstančiai")
- *   * Form 3 (many): all other numbers (e.g., "tūkstančių")
- * - Chunk-based decomposition (splits into groups of 3 digits: ones, thousands, millions, etc.)
- * - Large number handling via thousands[] array with indexed [singular, few, many] forms
- * - Gender-specific number forms for 1 and 2 (masculine/feminine dual forms)
- *
- * Features:
- * - Dual gender forms (vienas/viena, du/dvi, keturi/keturios)
- * - Complex declension patterns for large numbers
- * - Baltic language characteristics
- *
- * Inherits from SlavicLanguage as Lithuanian uses similar pluralization.
+ * Supports:
+ * - Three-form pluralization (one/few/many)
+ * - Gender agreement (vienas/viena, du/dvi)
+ * - Baltic declension patterns
  */
 export class Lithuanian extends SlavicLanguage {
   negativeWord = 'minus'
   decimalSeparatorWord = 'kablelis'
   zeroWord = 'nulis'
-  ones = {
+
+  onesWords = {
     1: 'vienas',
     2: 'du',
     3: 'trys',
@@ -46,7 +25,7 @@ export class Lithuanian extends SlavicLanguage {
     9: 'devyni'
   }
 
-  onesFeminine = {
+  onesFeminineWords = {
     1: 'viena',
     2: 'dvi',
     3: 'trys',
@@ -58,7 +37,7 @@ export class Lithuanian extends SlavicLanguage {
     9: 'devynios'
   }
 
-  tens = {
+  teensWords = {
     0: 'dešimt',
     1: 'vienuolika',
     2: 'dvylika',
@@ -71,7 +50,7 @@ export class Lithuanian extends SlavicLanguage {
     9: 'devyniolika'
   }
 
-  twenties = {
+  twentiesWords = {
     2: 'dvidešimt',
     3: 'trisdešimt',
     4: 'keturiasdešimt',
@@ -82,9 +61,9 @@ export class Lithuanian extends SlavicLanguage {
     9: 'devyniasdešimt'
   }
 
-  hundreds = ['šimtas', 'šimtai']
+  hundredsWords = ['šimtas', 'šimtai']
 
-  thousands = {
+  pluralForms = {
     1: ['tūkstantis', 'tūkstančiai', 'tūkstančių'],
     2: ['milijonas', 'milijonai', 'milijonų'],
     3: ['milijardas', 'milijardai', 'milijardų'],
@@ -102,7 +81,7 @@ export class Lithuanian extends SlavicLanguage {
       return forms[2]
     }
 
-    const [n1, n2] = this.getDigits(n)
+    const [n1, n2] = this.extractDigits(n)
 
     if (n2 === 1n || n1 === 0n) {
       return forms[2]
@@ -115,57 +94,43 @@ export class Lithuanian extends SlavicLanguage {
     return forms[1]
   }
 
-  convertWholePart (number) {
-    if (number === 0n) {
+  integerToWords (integerPart) {
+    if (integerPart === 0n) {
       return this.zeroWord
     }
     const words = []
-    const chunks = this.splitByX(number.toString(), 3)
-    let index = chunks.length
-    for (const x of chunks) {
+    const segments = this.splitToSegments(integerPart.toString(), 3)
+    let index = segments.length
+    for (const x of segments) {
       index = index - 1
       if (x === 0n) {
         continue
       }
-      const [n1, n2, n3] = this.getDigits(x)
+      const [n1, n2, n3] = this.extractDigits(x)
       if (n3 > 0n) {
-        words.push(this.ones[n3])
+        words.push(this.onesWords[n3])
         if (n3 > 1n) {
-          words.push(this.hundreds[1])
+          words.push(this.hundredsWords[1])
         } else {
-          words.push(this.hundreds[0])
+          words.push(this.hundredsWords[0])
         }
       }
       if (n2 > 1n) {
-        words.push(this.twenties[n2])
+        words.push(this.twentiesWords[n2])
       }
       if (n2 === 1n) {
-        words.push(this.tens[n1])
+        words.push(this.teensWords[n1])
       } else if (n1 > 0n) {
-        if ((index === 1 || (this.feminine && index === 0)) && number < 1000n) {
-          words.push(this.onesFeminine[n1])
+        if ((index === 1 || (this.options.gender === 'feminine' && index === 0)) && integerPart < 1000n) {
+          words.push(this.onesFeminineWords[n1])
         } else {
-          words.push(this.ones[n1])
+          words.push(this.onesWords[n1])
         }
       }
       if (index > 0) {
-        words.push(this.pluralize(x, this.thousands[index]))
+        words.push(this.pluralize(x, this.pluralForms[index]))
       }
     }
     return words.join(' ')
   }
 }
-
-/**
- * Converts a number to Lithuanian cardinal (written) form.
- *
- * @param {number|string|bigint} value The number to convert.
- * @param {Object} [options={}] Configuration options.
- * @param {boolean} [options.feminine=false] Use feminine forms for numbers.
- * @returns {string} The number expressed in Lithuanian 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 Lithuanian(options).convertToWords(value)
-}

package/lib/languages/lv.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Latvian language converter.
+ *
+ * Supports:
+ * - Three-form pluralization (one/few/many)
+ * - Latvian diacritical marks (ī, ā, ē, ū)
+ * - Compound number formation (divdesmit, trīsdesmit)
+ */
+export class Latvian extends SlavicLanguage {
+    onesWords: {
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    onesFeminineWords: {
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    teensWords: {
+        0: string;
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    twentiesWords: {
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    hundredsWords: string[];
+    pluralForms: {
+        1: string[];
+        2: string[];
+        3: string[];
+        4: string[];
+        5: string[];
+        6: string[];
+        7: string[];
+        8: string[];
+        9: string[];
+        10: string[];
+    };
+    pluralize(n: any, forms: any): any;
+    integerToWords(integerPart: any): string;
+}
+import { SlavicLanguage } from '../classes/slavic-language.js';