n2words 3.1.0 → 4.0.0

package/lib/languages/pl.js

@@ -1,317 +0,0 @@
-/**
- * Polish language converter - Functional Implementation
- *
- * Self-contained module with its own input validation, ready for subpath exports.
- *
- * Polish-specific rules:
- * - Three-form pluralization: 1 = singular, 2-4 = few, 5+ = many
- * - Gender agreement (masculine/feminine for numbers < 1000)
- * - Omit "jeden" before scale words (tysiąc, milion, etc.)
- * - Irregular hundreds: dwieście, trzysta, czterysta, pięćset...
- * - Long scale with -ard forms: miliard, biliard, tryliard
- */
-
-import { parseNumericValue } from '../utils/parse-numeric.js'
-import { validateOptions } from '../utils/validate-options.js'
-
-// ============================================================================
-// Vocabulary (module-level constants)
-// ============================================================================
-
-const ONES_MASC = ['', 'jeden', 'dwa', 'trzy', 'cztery', 'pięć', 'sześć', 'siedem', 'osiem', 'dziewięć']
-const ONES_FEM = ['', 'jedna', 'dwie', 'trzy', 'cztery', 'pięć', 'sześć', 'siedem', 'osiem', 'dziewięć']
-
-const TEENS = ['dziesięć', 'jedenaście', 'dwanaście', 'trzynaście', 'czternaście', 'piętnaście', 'szesnaście', 'siedemnaście', 'osiemnaście', 'dziewiętnaście']
-
-const TENS = ['', '', 'dwadzieścia', 'trzydzieści', 'czterdzieści', 'pięćdziesiąt', 'sześćdziesiąt', 'siedemdziesiąt', 'osiemdziesiąt', 'dziewięćdziesiąt']
-
-// Irregular hundreds
-const HUNDREDS = ['', 'sto', 'dwieście', 'trzysta', 'czterysta', 'pięćset', 'sześćset', 'siedemset', 'osiemset', 'dziewięćset']
-
-// Scale words: [singular, few (2-4), many (5+)]
-const PLURAL_FORMS = {
-  1: ['tysiąc', 'tysiące', 'tysięcy'],
-  2: ['milion', 'miliony', 'milionów'],
-  3: ['miliard', 'miliardy', 'miliardów'],
-  4: ['bilion', 'biliony', 'bilionów'],
-  5: ['biliard', 'biliardy', 'biliardów'],
-  6: ['trylion', 'tryliony', 'trylionów'],
-  7: ['tryliard', 'tryliardy', 'tryliardów'],
-  8: ['kwadrylion', 'kwadryliony', 'kwadrylionów'],
-  9: ['kwaryliard', 'kwadryliardy', 'kwadryliardów'],
-  10: ['kwintylion', 'kwintyliony', 'kwintylionów']
-}
-
-const ZERO = 'zero'
-const NEGATIVE = 'minus'
-const DECIMAL_SEP = 'przecinek'
-
-// ============================================================================
-// Segment Building
-// ============================================================================
-
-/**
- * Builds segment word for 0-999 (masculine form).
- * @param {number} n - Segment value
- * @returns {string} Polish word
- */
-function buildSegment (n) {
-  if (n === 0) return ''
-
-  const ones = n % 10
-  const tens = Math.floor(n / 10) % 10
-  const hundreds = Math.floor(n / 100)
-
-  const parts = []
-
-  // Hundreds
-  if (hundreds > 0) {
-    parts.push(HUNDREDS[hundreds])
-  }
-
-  // Tens and ones
-  if (tens === 1) {
-    // Teens (10-19)
-    parts.push(TEENS[ones])
-  } else {
-    if (tens >= 2) {
-      parts.push(TENS[tens])
-    }
-    if (ones > 0) {
-      parts.push(ONES_MASC[ones])
-    }
-  }
-
-  return parts.join(' ')
-}
-
-/**
- * Builds segment word for 0-999 (feminine form - only differs in ones).
- * @param {number} n - Segment value
- * @returns {string} Polish word
- */
-function buildSegmentFeminine (n) {
-  if (n === 0) return ''
-
-  const ones = n % 10
-  const tens = Math.floor(n / 10) % 10
-  const hundreds = Math.floor(n / 100)
-
-  const parts = []
-
-  // Hundreds
-  if (hundreds > 0) {
-    parts.push(HUNDREDS[hundreds])
-  }
-
-  // Tens and ones - feminine for ones only
-  if (tens === 1) {
-    parts.push(TEENS[ones])
-  } else {
-    if (tens >= 2) {
-      parts.push(TENS[tens])
-    }
-    if (ones > 0) {
-      parts.push(ONES_FEM[ones])
-    }
-  }
-
-  return parts.join(' ')
-}
-
-// ============================================================================
-// Helper Functions
-// ============================================================================
-
-/**
- * Polish pluralization: 1 = singular, 2-4 = few, else = many.
- * Special case: 11-19 always use many form.
- *
- * @param {bigint} n - Number to pluralize
- * @param {string[]} forms - [singular, few, many]
- * @returns {string} Correct plural form
- */
-function pluralize (n, forms) {
-  if (n === 1n) {
-    return forms[0]
-  }
-
-  const lastDigit = n % 10n
-  const lastTwoDigits = n % 100n
-
-  // Teens (11-19) always use many form
-  // 2-4 use few form (but not 12-14)
-  if (lastDigit >= 2n && lastDigit <= 4n && (lastTwoDigits < 10n || lastTwoDigits > 20n)) {
-    return forms[1]
-  }
-
-  return forms[2]
-}
-
-// ============================================================================
-// Conversion Functions
-// ============================================================================
-
-/**
- * Converts a non-negative integer to Polish words.
- *
- * @param {bigint} n - Non-negative integer to convert
- * @param {Object} options - Conversion options
- * @returns {string} Polish words
- */
-function integerToWords (n, options = {}) {
-  if (n === 0n) return ZERO
-
-  // Fast path: numbers < 1000
-  if (n < 1000n) {
-    return options.gender === 'feminine' ? buildSegmentFeminine(Number(n)) : buildSegment(Number(n))
-  }
-
-  // Fast path: numbers < 1,000,000 (thousands)
-  if (n < 1_000_000n) {
-    const thousands = Number(n / 1000n)
-    const remainder = Number(n % 1000n)
-
-    const scaleWord = pluralize(BigInt(thousands), PLURAL_FORMS[1])
-
-    let result
-    if (thousands === 1) {
-      // Omit "jeden" before tysiąc
-      result = scaleWord
-    } else {
-      result = buildSegment(thousands) + ' ' + scaleWord
-    }
-
-    if (remainder > 0) {
-      result += ' ' + buildSegment(remainder)
-    }
-
-    return result
-  }
-
-  // For numbers >= 1,000,000, use scale decomposition
-  return buildLargeNumberWords(n, options)
-}
-
-/**
- * Builds words for numbers >= 1,000,000.
- * Uses BigInt division for faster segment extraction.
- *
- * @param {bigint} n - Number >= 1,000,000
- * @param {Object} options - Conversion options
- * @returns {string} Polish words
- */
-function buildLargeNumberWords (n, options) {
-  // Extract segments using BigInt division (faster than string slicing)
-  // Segments stored least-significant first (index 0 = ones, 1 = thousands, etc.)
-  const segmentValues = []
-  let temp = n
-  while (temp > 0n) {
-    segmentValues.push(temp % 1000n)
-    temp = temp / 1000n
-  }
-
-  // Build result string directly
-  let result = ''
-
-  for (let i = segmentValues.length - 1; i >= 0; i--) {
-    const segment = segmentValues[i]
-    if (segment === 0n) continue
-
-    const segmentWord = buildSegment(Number(segment))
-
-    if (result) result += ' '
-
-    if (i === 0) {
-      // Units segment
-      result += segmentWord
-    } else {
-      // Scale word needed
-      const forms = PLURAL_FORMS[i]
-      if (forms) {
-        const scaleWord = pluralize(segment, forms)
-
-        if (segment === 1n) {
-          // Omit "jeden" before scale words
-          result += scaleWord
-        } else {
-          result += segmentWord + ' ' + scaleWord
-        }
-      }
-    }
-  }
-
-  return result
-}
-
-/**
- * Converts decimal digits to Polish words.
- *
- * @param {string} decimalPart - Decimal digits (without the point)
- * @param {Object} options - Conversion options
- * @returns {string} Polish words for decimal part
- */
-function decimalPartToWords (decimalPart, options) {
-  let result = ''
-
-  // Handle leading zeros
-  let i = 0
-  while (i < decimalPart.length && decimalPart[i] === '0') {
-    if (result) result += ' '
-    result += ZERO
-    i++
-  }
-
-  // Convert remainder as a single number
-  const remainder = decimalPart.slice(i)
-  if (remainder) {
-    if (result) result += ' '
-    result += integerToWords(BigInt(remainder), options)
-  }
-
-  return result
-}
-
-/**
- * Converts a numeric value to Polish words.
- *
- * This is the main public API. It accepts any valid numeric input
- * (number, string, or bigint) and handles parsing internally.
- *
- * @param {number | string | bigint} value - The numeric value to convert
- * @param {Object} [options] - Conversion options
- * @param {string} [options.gender='masculine'] - Gender for numbers < 1000
- * @returns {string} The number in Polish words
- * @throws {TypeError} If value is not a valid numeric type
- * @throws {Error} If value is not a valid number format
- *
- * @example
- * toWords(1)                          // 'jeden'
- * toWords(1, { gender: 'feminine' })  // 'jedna'
- * toWords(1000)                       // 'tysiąc'
- * toWords(2000)                       // 'dwa tysiące'
- */
-function toWords (value, options) {
-  options = validateOptions(options)
-  const { isNegative, integerPart, decimalPart } = parseNumericValue(value)
-
-  let result = ''
-
-  if (isNegative) {
-    result = NEGATIVE + ' '
-  }
-
-  result += integerToWords(integerPart, options)
-
-  if (decimalPart) {
-    result += ' ' + DECIMAL_SEP + ' ' + decimalPartToWords(decimalPart, options)
-  }
-
-  return result
-}
-
-// ============================================================================
-// Public API
-// ============================================================================
-
-export { toWords }

package/lib/languages/pt.d.ts

@@ -1,17 +0,0 @@
-/**
- * Converts a numeric value to Portuguese words.
- *
- * This is the main public API. It accepts any valid numeric input
- * (number, string, or bigint) and handles parsing internally.
- *
- * @param {number | string | bigint} value - The numeric value to convert
- * @returns {string} The number in Portuguese words
- * @throws {TypeError} If value is not a valid numeric type
- * @throws {Error} If value is not a valid number format
- *
- * @example
- * toWords(21)           // 'vinte e um'
- * toWords(100)          // 'cem'
- * toWords(1000000)      // 'um milhão'
- */
-export function toWords(value: number | string | bigint): string;

package/lib/languages/ro.d.ts

@@ -1,18 +0,0 @@
-/**
- * Converts a numeric value to Romanian words.
- *
- * @param {number | string | bigint} value - The numeric value to convert
- * @param {Object} [options] - Conversion options
- * @param {string} [options.gender='masculine'] - Gender for numbers
- * @returns {string} The number in Romanian words
- * @throws {TypeError} If value is not a valid numeric type
- * @throws {Error} If value is not a valid number format
- *
- * @example
- * toWords(21)                        // 'douăzeci și unu'
- * toWords(1, { gender: 'feminine' }) // 'una'
- * toWords(1000)                      // 'o mie'
- */
-export function toWords(value: number | string | bigint, options?: {
-    gender?: string | undefined;
-}): string;

package/lib/languages/ru.d.ts

@@ -1,11 +0,0 @@
-/**
- * Converts a numeric value to Russian words.
- *
- * @param {number | string | bigint} value - The numeric value to convert
- * @param {Object} [options] - Optional configuration
- * @param {('masculine'|'feminine')} [options.gender='masculine'] - Grammatical gender
- * @returns {string} The number in Russian words
- */
-export function toWords(value: number | string | bigint, options?: {
-    gender?: "masculine" | "feminine" | undefined;
-}): string;

package/lib/languages/ru.js

@@ -1,245 +0,0 @@
-/**
- * Russian language converter - Functional Implementation
- *
- * Self-contained module with its own input validation, ready for subpath exports.
- *
- * Key features:
- * - Three-form pluralization (one/few/many)
- * - Gender: thousands are feminine, millions+ are masculine
- * - Irregular hundreds (двести, триста, etc.)
- * - Long scale naming
- */
-
-import { parseNumericValue } from '../utils/parse-numeric.js'
-import { validateOptions } from '../utils/validate-options.js'
-
-// ============================================================================
-// Vocabulary
-// ============================================================================
-
-const ONES_MASC = ['', 'один', 'два', 'три', 'четыре', 'пять', 'шесть', 'семь', 'восемь', 'девять']
-const ONES_FEM = ['', 'одна', 'две', 'три', 'четыре', 'пять', 'шесть', 'семь', 'восемь', 'девять']
-
-const TEENS = ['десять', 'одиннадцать', 'двенадцать', 'тринадцать', 'четырнадцать', 'пятнадцать', 'шестнадцать', 'семнадцать', 'восемнадцать', 'девятнадцать']
-const TENS = ['', '', 'двадцать', 'тридцать', 'сорок', 'пятьдесят', 'шестьдесят', 'семьдесят', 'восемьдесят', 'девяносто']
-
-// Irregular hundreds
-const HUNDREDS = ['', 'сто', 'двести', 'триста', 'четыреста', 'пятьсот', 'шестьсот', 'семьсот', 'восемьсот', 'девятьсот']
-
-const ZERO = 'ноль'
-const NEGATIVE = 'минус'
-const DECIMAL_SEP = 'запятая'
-
-// Scale words: [singular, few, many]
-// Thousands (index 0) are feminine, rest are masculine
-const SCALE_FORMS = [
-  ['тысяча', 'тысячи', 'тысяч'],
-  ['миллион', 'миллиона', 'миллионов'],
-  ['миллиард', 'миллиарда', 'миллиардов'],
-  ['триллион', 'триллиона', 'триллионов'],
-  ['квадриллион', 'квадриллиона', 'квадриллионов'],
-  ['квинтиллион', 'квинтиллиона', 'квинтиллионов'],
-  ['секстиллион', 'секстиллиона', 'секстиллионов'],
-  ['септиллион', 'септиллиона', 'септиллионов'],
-  ['октиллион', 'октиллиона', 'октиллионов'],
-  ['нониллион', 'нониллиона', 'нониллионов']
-]
-
-// ============================================================================
-// Segment Building
-// ============================================================================
-
-function pluralize (n, forms) {
-  const num = typeof n === 'bigint' ? Number(n) : n
-  const lastDigit = num % 10
-  const lastTwoDigits = num % 100
-
-  if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {
-    return forms[2]
-  }
-
-  if (lastDigit === 1) return forms[0]
-  if (lastDigit >= 2 && lastDigit <= 4) return forms[1]
-  return forms[2]
-}
-
-function buildSegmentMasc (n) {
-  if (n === 0) return ''
-
-  const onesDigit = n % 10
-  const tensDigit = Math.floor(n / 10) % 10
-  const hundredsDigit = Math.floor(n / 100)
-
-  const parts = []
-
-  if (hundredsDigit > 0) {
-    parts.push(HUNDREDS[hundredsDigit])
-  }
-
-  if (tensDigit > 1) {
-    parts.push(TENS[tensDigit])
-  }
-
-  if (tensDigit === 1) {
-    parts.push(TEENS[onesDigit])
-  } else if (onesDigit > 0) {
-    parts.push(ONES_MASC[onesDigit])
-  }
-
-  return parts.join(' ')
-}
-
-function buildSegmentFem (n) {
-  if (n === 0) return ''
-
-  const onesDigit = n % 10
-  const tensDigit = Math.floor(n / 10) % 10
-  const hundredsDigit = Math.floor(n / 100)
-
-  const parts = []
-
-  if (hundredsDigit > 0) {
-    parts.push(HUNDREDS[hundredsDigit])
-  }
-
-  if (tensDigit > 1) {
-    parts.push(TENS[tensDigit])
-  }
-
-  if (tensDigit === 1) {
-    parts.push(TEENS[onesDigit])
-  } else if (onesDigit > 0) {
-    parts.push(ONES_FEM[onesDigit])
-  }
-
-  return parts.join(' ')
-}
-
-// ============================================================================
-// Conversion Functions
-// ============================================================================
-
-function integerToWords (n, options = {}) {
-  if (n === 0n) return ZERO
-
-  const feminine = options.gender === 'feminine'
-
-  if (n < 1000n) {
-    return feminine ? buildSegmentFem(Number(n)) : buildSegmentMasc(Number(n))
-  }
-
-  if (n < 1_000_000n) {
-    const thousands = Number(n / 1000n)
-    const remainder = Number(n % 1000n)
-
-    // Thousands are always feminine in Russian
-    const thousandsWord = buildSegmentFem(thousands)
-    const scaleWord = pluralize(thousands, SCALE_FORMS[0])
-
-    let result = thousandsWord + ' ' + scaleWord
-
-    if (remainder > 0) {
-      result += ' ' + (feminine ? buildSegmentFem(remainder) : buildSegmentMasc(remainder))
-    }
-
-    return result
-  }
-
-  return buildLargeNumberWords(n, options)
-}
-
-function buildLargeNumberWords (n, options) {
-  const feminine = options.gender === 'feminine'
-  const numStr = n.toString()
-  const len = numStr.length
-
-  const segments = []
-  const segmentSize = 3
-
-  const remainderLen = len % segmentSize
-  let pos = 0
-  if (remainderLen > 0) {
-    segments.push(Number(numStr.slice(0, remainderLen)))
-    pos = remainderLen
-  }
-  while (pos < len) {
-    segments.push(Number(numStr.slice(pos, pos + segmentSize)))
-    pos += segmentSize
-  }
-
-  const parts = []
-  let scaleIndex = segments.length - 1
-
-  for (let i = 0; i < segments.length; i++) {
-    const segment = segments[i]
-
-    if (segment !== 0) {
-      if (scaleIndex === 0) {
-        parts.push(feminine ? buildSegmentFem(segment) : buildSegmentMasc(segment))
-      } else {
-        const scaleForms = SCALE_FORMS[scaleIndex - 1]
-        const scaleWord = pluralize(segment, scaleForms)
-        // Thousands (scaleIndex=1) are feminine, others masculine
-        const isFeminine = scaleIndex === 1
-        const segmentWord = isFeminine ? buildSegmentFem(segment) : buildSegmentMasc(segment)
-        parts.push(segmentWord + ' ' + scaleWord)
-      }
-    }
-
-    scaleIndex--
-  }
-
-  return parts.join(' ')
-}
-
-function decimalPartToWords (decimalPart, options) {
-  let result = ''
-  let i = 0
-
-  while (i < decimalPart.length && decimalPart[i] === '0') {
-    if (result) result += ' '
-    result += ZERO
-    i++
-  }
-
-  const remainder = decimalPart.slice(i)
-  if (remainder) {
-    if (result) result += ' '
-    result += integerToWords(BigInt(remainder), options)
-  }
-
-  return result
-}
-
-/**
- * Converts a numeric value to Russian words.
- *
- * @param {number | string | bigint} value - The numeric value to convert
- * @param {Object} [options] - Optional configuration
- * @param {('masculine'|'feminine')} [options.gender='masculine'] - Grammatical gender
- * @returns {string} The number in Russian words
- */
-function toWords (value, options) {
-  options = validateOptions(options)
-  const { isNegative, integerPart, decimalPart } = parseNumericValue(value)
-
-  let result = ''
-
-  if (isNegative) {
-    result = NEGATIVE + ' '
-  }
-
-  result += integerToWords(integerPart, options)
-
-  if (decimalPart) {
-    result += ' ' + DECIMAL_SEP + ' ' + decimalPartToWords(decimalPart, options)
-  }
-
-  return result
-}
-
-// ============================================================================
-// Exports
-// ============================================================================
-
-export { toWords }

package/lib/languages/sr-Cyrl.d.ts

@@ -1,11 +0,0 @@
-/**
- * Converts a numeric value to Serbian (Cyrillic) words.
- *
- * @param {number | string | bigint} value - The numeric value to convert
- * @param {Object} [options] - Optional configuration
- * @param {('masculine'|'feminine')} [options.gender='masculine'] - Grammatical gender
- * @returns {string} The number in Serbian Cyrillic words
- */
-export function toWords(value: number | string | bigint, options?: {
-    gender?: "masculine" | "feminine" | undefined;
-}): string;