n2words 1.23.1 → 2.0.0

package/lib/languages/it.js

@@ -0,0 +1,132 @@
+import { AbstractLanguage } from '../classes/abstract-language.js'
+
+/**
+ * Italian language converter.
+ *
+ * Supports:
+ * - Phonetic contractions (vowel elision: "ventotto" not "ventiotto")
+ * - Accentuation rules for "tre" in compounds ("ventitré")
+ * - Custom word construction for irregular patterns
+ */
+export class Italian extends AbstractLanguage {
+  negativeWord = 'meno'
+  decimalSeparatorWord = 'virgola'
+  zeroWord = 'zero'
+
+  onesWords = [
+    this.zeroWord, 'uno', 'due', 'tre', 'quattro', 'cinque', 'sei', 'sette', 'otto',
+    'nove', 'dieci', 'undici', 'dodici', 'tredici', 'quattordici', 'quindici',
+    'sedici', 'diciassette', 'diciotto', 'diciannove'
+  ]
+
+  tensWords = { 2: 'venti', 3: 'trenta', 4: 'quaranta', 6: 'sessanta' }
+
+  exponentPrefixes = [this.zeroWord, 'm', 'b', 'tr', 'quadr', 'quint', 'sest', 'sett', 'ott', 'nov', 'dec']
+
+  /** Adds accent to final "tre" in compound words (ventitré). */
+  accentuate (string) {
+    const splittedString = string.split(' ')
+
+    const result = splittedString.map(word => {
+      return word.slice(-3) === 'tre' && word.length > 3 ? word.replaceAll('tré', 'tre').slice(0, -3) + 'tré' : word.replaceAll('tré', 'tre')
+    })
+    return result.join(' ')
+  }
+
+  /** Omits word if it represents zero. */
+  omitIfZero (numberToString) {
+    return numberToString === this.zeroWord ? '' : numberToString
+  }
+
+  /** Removes duplicate vowels for phonetic contractions. */
+  phoneticContraction (string) {
+    return string.replaceAll('oo', 'o').replaceAll('ao', 'o').replaceAll('io', 'o').replaceAll('au', 'u').replaceAll('iu', 'u')
+  }
+
+  /** Converts tens (20-99) with phonetic contractions. */
+  tensToCardinal (number) {
+    const tens = Math.floor(number / 10)
+    const units = number % 10
+    const prefix = Object.prototype.hasOwnProperty.call(this.tensWords, tens) ? this.tensWords[tens] : this.onesWords[tens].slice(0, -1) + 'anta'
+    const postfix = this.omitIfZero(this.onesWords[units])
+    return this.phoneticContraction(prefix + postfix)
+  }
+
+  /** Converts hundreds (100-999) with "cento" composition. */
+  hundredsToCardinal (number) {
+    const hundreds = Math.floor(number / 100)
+    let prefix = 'cento'
+    if (hundreds !== 1) {
+      prefix = this.onesWords[hundreds] + prefix
+    }
+    const postfix = this.omitIfZero(this.integerToWords(number % 100))
+    return this.phoneticContraction(prefix + postfix)
+  }
+
+  /** Converts thousands (1000-999999) with "mille/mila" composition. */
+  thousandsToCardinal (number) {
+    const thousands = Math.floor(number / 1000)
+    const prefix = thousands === 1 ? 'mille' : this.integerToWords(thousands) + 'mila'
+    const postfix = this.omitIfZero(this.integerToWords(number % 1000))
+    return prefix + postfix
+  }
+
+  /** Converts exponent length to Italian scale word (milione, miliardo, etc.). */
+  exponentLengthToString (exponentLength) {
+    const prefix = this.exponentPrefixes[Math.floor(exponentLength / 6)]
+    return exponentLength % 6 === 0 ? prefix + 'ilione' : prefix + 'iliardo'
+  }
+
+  /** Converts large numbers (millions and above) with exponent-based naming. */
+  bigNumberToCardinal (number) {
+    const digits = [...number.toString()]
+
+    let preDigits = digits.length % 3
+    if (preDigits === 0) {
+      preDigits = 3
+    }
+
+    const multiplier = digits.slice(0, preDigits) // first `preDigits` elements
+    const exponent = digits.slice(preDigits) // without the first `preDigits` elements
+
+    let prefix, postfix
+    let infix = this.exponentLengthToString(exponent.length)
+
+    if (multiplier.join('') === '1') {
+      prefix = 'un '
+    } else {
+      prefix = this.integerToWords(Math.trunc(Number(multiplier.join(''))))
+      infix = ' ' + infix.slice(0, -1) + 'i' // without last element
+    }
+
+    const isSetsEqual = (a, b) => a.size === b.size && [...a].every(value => b.has(value))
+    if (isSetsEqual(new Set(exponent), new Set(['0']))) {
+      postfix = ''
+    } else {
+      postfix = this.integerToWords(Math.trunc(exponent.join('')))
+
+      infix += (postfix.includes(' e ') ? ', ' : ' e ')
+    }
+
+    return prefix + infix + postfix
+  }
+
+  /** Converts integer part using Italian custom algorithm with accentuation. */
+  integerToWords (integerPart) {
+    let words = ''
+
+    if (integerPart < 20) {
+      words = this.onesWords[integerPart]
+    } else if (integerPart < 100) {
+      words = this.tensToCardinal(Number(integerPart))
+    } else if (integerPart < 1000) {
+      words = this.hundredsToCardinal(Number(integerPart))
+    } else if (integerPart < 1_000_000) {
+      words = this.thousandsToCardinal(Number(integerPart))
+    } else {
+      words = this.bigNumberToCardinal(integerPart)
+    }
+
+    return this.accentuate(words)
+  }
+}

package/lib/languages/ja.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Japanese language converter.
+ *
+ * Supports:
+ * - Kanji numerals (一, 二, 三, etc.)
+ * - Grouping by 万 (10,000) instead of 1,000
+ * - Special 一 (one) omission rules (十, 百, 千 but 一万, 一億)
+ */
+export class Japanese extends AbstractLanguage {
+    onesWords: string[];
+    scaleWords: string[];
+    /** Converts a segment of up to 4 digits to Japanese kanji with 一 omission rules. */
+    segmentToWords(num: any): string;
+    /** Converts integer part using Japanese 万-based grouping system. */
+    integerToWords(integerPart: any): string;
+}
+import { AbstractLanguage } from '../classes/abstract-language.js';

package/lib/languages/ja.js

@@ -0,0 +1,137 @@
+import { AbstractLanguage } from '../classes/abstract-language.js'
+
+/**
+ * Japanese language converter.
+ *
+ * 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
+  usePerDigitDecimals = true // Enable digit-by-digit decimal conversion
+
+  // Ones words used for group conversion (1-9)
+  onesWords = ['一', '二', '三', '四', '五', '六', '七', '八', '九']
+
+  // Scale words for grouping by 10^4
+  scaleWords = [
+    '', // 10^0 (ones)
+    '万', // 10^4 (man)
+    '億', // 10^8 (oku)
+    '兆', // 10^12 (chō)
+    '京', // 10^16 (kei)
+    '垓', // 10^20 (gai)
+    '秭', // 10^24 (jo/shi)
+    '穣', // 10^28 (jō)
+    '溝', // 10^32 (kō)
+    '澗', // 10^36 (kan)
+    '正', // 10^40 (sei)
+    '載', // 10^44 (sai)
+    '極', // 10^48 (goku)
+    '恒河沙', // 10^52 (gōgasha)
+    '阿僧祇', // 10^56 (asōgi)
+    '那由他', // 10^60 (nayuta)
+    '不可思議', // 10^64 (fukashigi)
+    '無量大数' // 10^68 (muryōtaisū)
+  ]
+
+  /** Converts a segment of up to 4 digits to Japanese kanji with 一 omission rules. */
+  segmentToWords (num) {
+    if (num === 0n) return ''
+
+    const thousands = num / 1000n
+    const hundreds = (num % 1000n) / 100n
+    const tens = (num % 100n) / 10n
+    const ones = num % 10n
+
+    let result = ''
+
+    // Thousands (千)
+    if (thousands > 0n) {
+      // Always omit 一 before 千 when thousands === 1
+      if (thousands === 1n) {
+        result += '千'
+      } else {
+        result += this.onesWords[Number(thousands) - 1] + '千'
+      }
+    }
+
+    // Hundreds (百)
+    if (hundreds > 0n) {
+      // Always omit 一 before 百 when hundreds === 1
+      if (hundreds === 1n) {
+        result += '百'
+      } else {
+        result += this.onesWords[Number(hundreds) - 1] + '百'
+      }
+    }
+
+    // Tens (十)
+    if (tens > 0n) {
+      // Always omit 一 before 十 when tens === 1
+      if (tens === 1n) {
+        result += '十'
+      } else {
+        result += this.onesWords[Number(tens) - 1] + '十'
+      }
+    }
+
+    // Ones
+    if (ones > 0n) {
+      result += this.onesWords[Number(ones) - 1]
+    }
+
+    return result
+  }
+
+  /** Converts integer part using Japanese 万-based grouping system. */
+  integerToWords (integerPart) {
+    if (integerPart === 0n) {
+      return this.zeroWord
+    }
+
+    let temp = integerPart
+    let scaleIndex = 0
+    const groups = []
+
+    // Split into groups of 4 digits (万-based system)
+    while (temp > 0n) {
+      const group = temp % 10000n
+      if (group > 0n) {
+        groups.push({ value: group, scale: scaleIndex })
+      }
+      temp = temp / 10000n
+      scaleIndex++
+    }
+
+    // Reverse to process from highest to lowest
+    groups.reverse()
+
+    let result = ''
+
+    for (let i = 0; i < groups.length; i++) {
+      const { value, scale } = groups[i]
+
+      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.scaleWords[scale]
+        } else {
+          result += groupStr + this.scaleWords[scale]
+        }
+      } else {
+        result += groupStr
+      }
+    }
+
+    return result
+  }
+}

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

@@ -0,0 +1,42 @@
+import { SouthAsianLanguage } from '../classes/south-asian-language.js'
+
+/**
+ * Kannada language converter.
+ *
+ * Supports:
+ * - Indian numbering system (ಸಾವಿರ, ಲಕ್ಷ, ಕೋಟಿ)
+ * - Kannada script
+ * - Complete word forms for 0-99
+ */
+export class Kannada extends SouthAsianLanguage {
+  negativeWord = 'ಋಣಾತ್ಮಕ'
+  decimalSeparatorWord = 'ದಶಮಾಂಶ'
+  zeroWord = 'ಸೊನ್ನೆ'
+  hundredWord = 'ನೂರು'
+  usePerDigitDecimals = true
+
+  belowHundredWords = [
+    'ಸೊನ್ನೆ', 'ಒಂದು', 'ಎರಡು', 'ಮೂರು', 'ನಾಲ್ಕು', 'ಐದು', 'ಆರು', 'ಏಳು', 'ಎಂಟು', 'ಒಂಬತ್ತು',
+    'ಹತ್ತು', 'ಹನ್ನೊಂದು', 'ಹನ್ನೆರಡು', 'ಹದಿಮೂರು', 'ಹದಿನಾಲ್ಕು', 'ಹದಿನೈದು', 'ಹದಿನಾರು', 'ಹದಿನೇಳು', 'ಹದಿನೆಂಟು', 'ಹತ್ತೊಂಬತ್ತು',
+    'ಇಪ್ಪತ್ತು', 'ಇಪ್ಪತ್ತೊಂದು', 'ಇಪ್ಪತ್ತೆರಡು', 'ಇಪ್ಪತ್ತಮೂರು', 'ಇಪ್ಪತ್ತನಾಲ್ಕು', 'ಇಪ್ಪತ್ತೈದು', 'ಇಪ್ಪತ್ತಾರು', 'ಇಪ್ಪತ್ತೇಳು', 'ಇಪ್ಪತ್ತೆಂಟು', 'ಇಪ್ಪತ್ತೊಂಬತ್ತು',
+    'ಮೂವತ್ತು', 'ಮೂವತ್ತೊಂದು', 'ಮೂವತ್ತೆರಡು', 'ಮೂವತ್ತಮೂರು', 'ಮೂವತ್ತನಾಲ್ಕು', 'ಮೂವತ್ತೈದು', 'ಮೂವತ್ತಾರು', 'ಮೂವತ್ತೇಳು', 'ಮೂವತ್ತೆಂಟು', 'ಮೂವತ್ತೊಂಬತ್ತು',
+    'ನಲವತ್ತು', 'ನಲವತ್ತೊಂದು', 'ನಲವತ್ತೆರಡು', 'ನಲವತ್ತಮೂರು', 'ನಲವತ್ತನಾಲ್ಕು', 'ನಲವತ್ತೈದು', 'ನಲವತ್ತಾರು', 'ನಲವತ್ತೇಳು', 'ನಲವತ್ತೆಂಟು', 'ನಲವತ್ತೊಂಬತ್ತು',
+    'ಐವತ್ತು', 'ಐವತ್ತೊಂದು', 'ಐವತ್ತೆರಡು', 'ಐವತ್ತಮೂರು', 'ಐವತ್ತನಾಲ್ಕು', 'ಐವತ್ತೈದು', 'ಐವತ್ತಾರು', 'ಐವತ್ತೇಳು', 'ಐವತ್ತೆಂಟು', 'ಐವತ್ತೊಂಬತ್ತು',
+    'ಅರವತ್ತು', 'ಅರವತ್ತೊಂದು', 'ಅರವತ್ತೆರಡು', 'ಅರವತ್ತಮೂರು', 'ಅರವತ್ತನಾಲ್ಕು', 'ಅರವತ್ತೈದು', 'ಅರವತ್ತಾರು', 'ಅರವತ್ತೇಳು', 'ಅರವತ್ತೆಂಟು', 'ಅರವತ್ತೊಂಬತ್ತು',
+    'ಎಪ್ಪತ್ತು', 'ಎಪ್ಪತ್ತೊಂದು', 'ಎಪ್ಪತ್ತೆರಡು', 'ಎಪ್ಪತ್ತಮೂರು', 'ಎಪ್ಪತ್ತನಾಲ್ಕು', 'ಎಪ್ಪತ್ತೈದು', 'ಎಪ್ಪತ್ತಾರು', 'ಎಪ್ಪತ್ತೇಳು', 'ಎಪ್ಪತ್ತೆಂಟು', 'ಎಪ್ಪತ್ತೊಂಬತ್ತು',
+    'ಎಂಬತ್ತು', 'ಎಂಬತ್ತೊಂದು', 'ಎಂಬತ್ತೆರಡು', 'ಎಂಬತ್ತಮೂರು', 'ಎಂಬತ್ತನಾಲ್ಕು', 'ಎಂಬತ್ತೈದು', 'ಎಂಬತ್ತಾರು', 'ಎಂಬತ್ತೇಳು', 'ಎಂಬತ್ತೆಂಟು', 'ಎಂಬತ್ತೊಂಬತ್ತು',
+    'ತೊಂಬತ್ತು', 'ತೊಂಬತ್ತೊಂದು', 'ತೊಂಬತ್ತೆರಡು', 'ತೊಂಬತ್ತಮೂರು', 'ತೊಂಬತ್ತನಾಲ್ಕು', 'ತೊಂಬತ್ತೈದು', 'ತೊಂಬತ್ತಾರು', 'ತೊಂಬತ್ತೇಳು', 'ತೊಂಬತ್ತೆಂಟು', 'ತೊಂಬತ್ತೊಂಬತ್ತು'
+  ]
+
+  scaleWords = [
+    '', // units
+    'ಸಾವಿರ', // thousand (1,000)
+    'ಲಕ್ಷ', // lakh (100,000)
+    'ಕೋಟಿ', // crore (10,000,000)
+    'ಅಬ್ಜ', // arab (1,000,000,000)
+    'ಖರ್ವ', // kharab (100,000,000,000)
+    'ನೀಲ', // neel (10,000,000,000,000)
+    'ಪದ್ಮ', // padma (1,000,000,000,000,000)
+    'ಶಂಖ' // shankh (100,000,000,000,000,000)
+  ]
+}

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

@@ -0,0 +1,55 @@
+import { GreedyScaleLanguage } from '../classes/greedy-scale-language.js'
+
+/**
+ * Korean language converter.
+ *
+ * Supports:
+ * - Hangul numerals (일, 이, 삼, etc.)
+ * - Grouping by 만 (10,000) system
+ * - Implicit '일' (one) omission before multipliers
+ */
+export class Korean extends GreedyScaleLanguage {
+  negativeWord = '마이너스'
+  decimalSeparatorWord = '점'
+  zeroWord = '영'
+
+  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, '해'],
+    [10_000_000_000_000_000n, '경'],
+    [1_000_000_000_000n, '조'],
+    [100_000_000n, '억'],
+    [10_000n, '만'],
+    [1000n, '천'],
+    [100n, '백'],
+    [10n, '십'],
+    [9n, '구'],
+    [8n, '팔'],
+    [7n, '칠'],
+    [6n, '육'],
+    [5n, '오'],
+    [4n, '사'],
+    [3n, '삼'],
+    [2n, '이'],
+    [1n, '일'],
+    [0n, '영']
+  ]
+
+  /** 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 (precedingValue === 1n && followingValue <= 10_000n) return following
+    // Concatenate (no space) for small numbers less than 만
+    if (precedingValue < 10_000n && precedingValue > followingValue) return { [`${precedingWord}${followingWord}`]: precedingValue + followingValue }
+    // Space-separate for large numbers (>= 만) when adding
+    if (precedingValue >= 10_000n && precedingValue > followingValue) return { [`${precedingWord} ${followingWord}`]: precedingValue + followingValue }
+    // Multiply for all scale combinations
+    return { [`${precedingWord}${followingWord}`]: precedingValue * followingValue }
+  }
+}

package/lib/{i18n/pl.d.ts → languages/lt.d.ts}

@@ -1,13 +1,13 @@
 /**
- * Converts a value to cardinal (written) form.
- * @param {number|string|bigint} value Number to be convert.
- * @param {object} [options] Options for class.
- * @returns {string} Value in cardinal (written) format.
- * @throws {Error} Value cannot be invalid.
+ * Lithuanian language converter.
+ *
+ * Supports:
+ * - Three-form pluralization (one/few/many)
+ * - Gender agreement (vienas/viena, du/dvi)
+ * - Baltic declension patterns
  */
-export default function floatToCardinal(value: number | string | bigint, options?: object): string;
-export class N2WordsPL extends N2WordsRU {
-    ones: {
+export class Lithuanian extends SlavicLanguage {
+    onesWords: {
         1: string;
         2: string;
         3: string;
@@ -18,8 +18,7 @@ export class N2WordsPL extends N2WordsRU {
         8: string;
         9: string;
     };
-    tens: {
-        0: string;
+    onesFeminineWords: {
         1: string;
         2: string;
         3: string;
@@ -30,7 +29,9 @@ export class N2WordsPL extends N2WordsRU {
         8: string;
         9: string;
     };
-    twenties: {
+    teensWords: {
+        0: string;
+        1: string;
         2: string;
         3: string;
         4: string;
@@ -40,8 +41,7 @@ export class N2WordsPL extends N2WordsRU {
         8: string;
         9: string;
     };
-    hundreds: {
-        1: string;
+    twentiesWords: {
         2: string;
         3: string;
         4: string;
@@ -51,7 +51,8 @@ export class N2WordsPL extends N2WordsRU {
         8: string;
         9: string;
     };
-    thousands: {
+    hundredsWords: string[];
+    pluralForms: {
         1: string[];
         2: string[];
         3: string[];
@@ -63,5 +64,7 @@ export class N2WordsPL extends N2WordsRU {
         9: string[];
         10: string[];
     };
+    pluralize(n: any, forms: any): any;
+    integerToWords(integerPart: any): string;
 }
-import { N2WordsRU } from './ru.js';
+import { SlavicLanguage } from '../classes/slavic-language.js';

package/lib/languages/lt.js

@@ -0,0 +1,136 @@
+import { SlavicLanguage } from '../classes/slavic-language.js'
+
+/**
+ * Lithuanian language converter.
+ *
+ * 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'
+
+  onesWords = {
+    1: 'vienas',
+    2: 'du',
+    3: 'trys',
+    4: 'keturi',
+    5: 'penki',
+    6: 'šeši',
+    7: 'septyni',
+    8: 'aštuoni',
+    9: 'devyni'
+  }
+
+  onesFeminineWords = {
+    1: 'viena',
+    2: 'dvi',
+    3: 'trys',
+    4: 'keturios',
+    5: 'penkios',
+    6: 'šešios',
+    7: 'septynios',
+    8: 'aštuonios',
+    9: 'devynios'
+  }
+
+  teensWords = {
+    0: 'dešimt',
+    1: 'vienuolika',
+    2: 'dvylika',
+    3: 'trylika',
+    4: 'keturiolika',
+    5: 'penkiolika',
+    6: 'šešiolika',
+    7: 'septyniolika',
+    8: 'aštuoniolika',
+    9: 'devyniolika'
+  }
+
+  twentiesWords = {
+    2: 'dvidešimt',
+    3: 'trisdešimt',
+    4: 'keturiasdešimt',
+    5: 'penkiasdešimt',
+    6: 'šešiasdešimt',
+    7: 'septyniasdešimt',
+    8: 'aštuoniasdešimt',
+    9: 'devyniasdešimt'
+  }
+
+  hundredsWords = ['šimtas', 'šimtai']
+
+  pluralForms = {
+    1: ['tūkstantis', 'tūkstančiai', 'tūkstančių'],
+    2: ['milijonas', 'milijonai', 'milijonų'],
+    3: ['milijardas', 'milijardai', 'milijardų'],
+    4: ['trilijonas', 'trilijonai', 'trilijonų'],
+    5: ['kvadrilijonas', 'kvadrilijonai', 'kvadrilijonų'],
+    6: ['kvintilijonas', 'kvintilijonai', 'kvintilijonų'],
+    7: ['sikstilijonas', 'sikstilijonai', 'sikstilijonų'],
+    8: ['septilijonas', 'septilijonai', 'septilijonų'],
+    9: ['oktilijonas', 'oktilijonai', 'oktilijonų'],
+    10: ['naintilijonas', 'naintilijonai', 'naintilijonų']
+  }
+
+  pluralize (n, forms) {
+    if (n === 0n) {
+      return forms[2]
+    }
+
+    const [n1, n2] = this.extractDigits(n)
+
+    if (n2 === 1n || n1 === 0n) {
+      return forms[2]
+    }
+
+    if (n1 === 1n) {
+      return forms[0]
+    }
+
+    return forms[1]
+  }
+
+  integerToWords (integerPart) {
+    if (integerPart === 0n) {
+      return this.zeroWord
+    }
+    const words = []
+    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.extractDigits(x)
+      if (n3 > 0n) {
+        words.push(this.onesWords[n3])
+        if (n3 > 1n) {
+          words.push(this.hundredsWords[1])
+        } else {
+          words.push(this.hundredsWords[0])
+        }
+      }
+      if (n2 > 1n) {
+        words.push(this.twentiesWords[n2])
+      }
+      if (n2 === 1n) {
+        words.push(this.teensWords[n1])
+      } else if (n1 > 0n) {
+        if ((index === 1 || (this.options.gender === 'feminine' && index === 0)) && integerPart < 1000n) {
+          words.push(this.onesFeminineWords[n1])
+        } else {
+          words.push(this.onesWords[n1])
+        }
+      }
+      if (index > 0) {
+        words.push(this.pluralize(x, this.pluralForms[index]))
+      }
+    }
+    return words.join(' ')
+  }
+}