n2words 3.0.0 → 4.0.0

package/lib/languages/sv.d.ts

@@ -1,14 +0,0 @@
-/**
- * Converts a numeric value to Swedish words.
- *
- * @param {number | string | bigint} value - The numeric value to convert
- * @returns {string} The number in Swedish words
- * @throws {TypeError} If value is not a valid numeric type
- * @throws {Error} If value is not a valid number format
- *
- * @example
- * toWords(42)       // 'fyrtio-två'
- * toWords(101)      // 'hundra och ett'
- * toWords(1000000)  // 'en miljon'
- */
-export function toWords(value: number | string | bigint): string;

package/lib/languages/sw.d.ts

@@ -1,7 +0,0 @@
-/**
- * Converts a numeric value to Swahili words.
- *
- * @param {number | string | bigint} value - The numeric value to convert
- * @returns {string} The number in Swahili words
- */
-export function toWords(value: number | string | bigint): string;

package/lib/languages/ta.d.ts

@@ -1,7 +0,0 @@
-/**
- * Converts a numeric value to Tamil words.
- *
- * @param {number | string | bigint} value - The numeric value to convert
- * @returns {string} The number in Tamil words
- */
-export function toWords(value: number | string | bigint): string;

package/lib/languages/te.d.ts

@@ -1,7 +0,0 @@
-/**
- * Converts a numeric value to Telugu words.
- *
- * @param {number | string | bigint} value - The numeric value to convert
- * @returns {string} The number in Telugu words
- */
-export function toWords(value: number | string | bigint): string;

package/lib/languages/th.d.ts

@@ -1,7 +0,0 @@
-/**
- * Converts a numeric value to Thai words.
- *
- * @param {number | string | bigint} value - The numeric value to convert
- * @returns {string} The number in Thai words
- */
-export function toWords(value: number | string | bigint): string;

package/lib/languages/tr.d.ts

@@ -1,18 +0,0 @@
-/**
- * Converts a numeric value to Turkish words.
- *
- * @param {number | string | bigint} value - The numeric value to convert
- * @param {Object} [options] - Conversion options
- * @param {boolean} [options.dropSpaces=false] - Remove spaces for compound form
- * @returns {string} The number in Turkish words
- * @throws {TypeError} If value is not a valid numeric type
- * @throws {Error} If value is not a valid number format
- *
- * @example
- * toWords(21)                        // 'yirmi bir'
- * toWords(21, { dropSpaces: true })  // 'yirmibir'
- * toWords(1000)                      // 'bin'
- */
-export function toWords(value: number | string | bigint, options?: {
-    dropSpaces?: boolean | undefined;
-}): string;

package/lib/languages/tr.js

@@ -1,263 +0,0 @@
-/**
- * Turkish language converter - Functional Implementation
- *
- * A performance-optimized number-to-words converter using precomputed lookup tables.
- *
- * Key features:
- * - Omits 'bir' (one) before hundreds and thousands
- * - Optional dropSpaces for compound form
- * - Short scale naming
- */
-
-import { parseNumericValue } from '../utils/parse-numeric.js'
-import { validateOptions } from '../utils/validate-options.js'
-
-// ============================================================================
-// Vocabulary (module-level constants)
-// ============================================================================
-
-const ONES = ['', 'bir', 'iki', 'üç', 'dört', 'beş', 'altı', 'yedi', 'sekiz', 'dokuz']
-
-const TEENS = ['on', 'on bir', 'on iki', 'on üç', 'on dört', 'on beş', 'on altı', 'on yedi', 'on sekiz', 'on dokuz']
-const TENS = ['', '', 'yirmi', 'otuz', 'kırk', 'elli', 'altmış', 'yetmiş', 'seksen', 'doksan']
-
-const HUNDRED = 'yüz'
-const THOUSAND = 'bin'
-
-const ZERO = 'sıfır'
-const NEGATIVE = 'eksi'
-const DECIMAL_SEP = 'virgül'
-
-// Short scale
-const SCALES = ['milyon', 'milyar', 'trilyon', 'katrilyon', 'kentilyon']
-
-// ============================================================================
-// Precomputed Lookup Tables (built once at module load)
-// ============================================================================
-
-/**
- * Builds segment word for 0-999.
- * Omits "bir" before "yüz" (hundred).
- */
-function buildSegment (n, separator = ' ') {
-  if (n === 0) return ''
-
-  const ones = n % 10
-  const tens = Math.floor(n / 10) % 10
-  const hundreds = Math.floor(n / 100)
-
-  const parts = []
-
-  // Hundreds - omit "bir" before yüz
-  if (hundreds > 0) {
-    if (hundreds === 1) {
-      parts.push(HUNDRED)
-    } else {
-      parts.push(ONES[hundreds] + separator + HUNDRED)
-    }
-  }
-
-  // Tens and ones
-  const tensOnes = n % 100
-
-  if (tensOnes === 0) {
-    // Just hundreds
-  } else if (tensOnes < 10) {
-    parts.push(ONES[ones])
-  } else if (tensOnes < 20) {
-    parts.push(TEENS[ones].replace(' ', separator))
-  } else if (ones === 0) {
-    parts.push(TENS[tens])
-  } else {
-    parts.push(TENS[tens] + separator + ONES[ones])
-  }
-
-  return parts.join(separator)
-}
-
-// Precompute all 1000 segment words (0-999) with space separator
-const SEGMENTS = new Array(1000)
-const SEGMENTS_NO_SPACE = new Array(1000)
-
-for (let i = 0; i < 1000; i++) {
-  SEGMENTS[i] = buildSegment(i, ' ')
-  SEGMENTS_NO_SPACE[i] = buildSegment(i, '')
-}
-
-// ============================================================================
-// Conversion Functions
-// ============================================================================
-
-/**
- * Converts a non-negative integer to Turkish words.
- *
- * @param {bigint} n - Non-negative integer to convert
- * @param {Object} options - Conversion options
- * @returns {string} Turkish words
- */
-function integerToWords (n, options = {}) {
-  if (n === 0n) return ZERO
-
-  const sep = options.dropSpaces ? '' : ' '
-  const segments = options.dropSpaces ? SEGMENTS_NO_SPACE : SEGMENTS
-
-  // Fast path: numbers < 1000 (direct lookup)
-  if (n < 1000n) {
-    return segments[Number(n)]
-  }
-
-  // Fast path: numbers < 1,000,000 (thousands)
-  if (n < 1_000_000n) {
-    const thousands = Number(n / 1000n)
-    const remainder = Number(n % 1000n)
-
-    // Omit "bir" before bin (thousand)
-    let result
-    if (thousands === 1) {
-      result = THOUSAND
-    } else {
-      result = segments[thousands] + sep + THOUSAND
-    }
-
-    if (remainder > 0) {
-      result += sep + segments[remainder]
-    }
-
-    return result
-  }
-
-  // For numbers >= 1,000,000, use scale decomposition
-  return buildLargeNumberWords(n, options)
-}
-
-/**
- * Builds words for numbers >= 1,000,000.
- *
- * @param {bigint} n - Number >= 1,000,000
- * @param {Object} options - Conversion options
- * @returns {string} Turkish words
- */
-function buildLargeNumberWords (n, options) {
-  const sep = options.dropSpaces ? '' : ' '
-  const segmentsArr = options.dropSpaces ? SEGMENTS_NO_SPACE : SEGMENTS
-
-  const numStr = n.toString()
-  const len = numStr.length
-
-  // Build segments of 3 digits from right to left
-  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
-  }
-
-  // Convert segments to words
-  const parts = []
-  let scaleIndex = segments.length - 1
-
-  for (let i = 0; i < segments.length; i++) {
-    const segment = segments[i]
-
-    if (segment !== 0) {
-      const segmentWord = segmentsArr[segment]
-
-      if (scaleIndex === 0) {
-        // Units segment
-        parts.push(segmentWord)
-      } else if (scaleIndex === 1) {
-        // Thousands - omit "bir" before bin
-        if (segment === 1) {
-          parts.push(THOUSAND)
-        } else {
-          parts.push(segmentWord + sep + THOUSAND)
-        }
-      } else {
-        // Millions+ - "bir" is kept before scale words
-        const scaleWord = SCALES[scaleIndex - 2]
-        parts.push(segmentWord + sep + scaleWord)
-      }
-    }
-
-    scaleIndex--
-  }
-
-  return parts.join(sep)
-}
-
-/**
- * Converts decimal digits to Turkish words.
- *
- * @param {string} decimalPart - Decimal digits (without the point)
- * @param {Object} options - Conversion options
- * @returns {string} Turkish words for decimal part
- */
-function decimalPartToWords (decimalPart, options) {
-  const sep = options.dropSpaces ? '' : ' '
-  let result = ''
-
-  // Handle leading zeros
-  let i = 0
-  while (i < decimalPart.length && decimalPart[i] === '0') {
-    if (result) result += sep
-    result += ZERO
-    i++
-  }
-
-  // Convert remainder as a single number
-  const remainder = decimalPart.slice(i)
-  if (remainder) {
-    if (result) result += sep
-    result += integerToWords(BigInt(remainder), options)
-  }
-
-  return result
-}
-
-/**
- * Converts a numeric value to Turkish words.
- *
- * @param {number | string | bigint} value - The numeric value to convert
- * @param {Object} [options] - Conversion options
- * @param {boolean} [options.dropSpaces=false] - Remove spaces for compound form
- * @returns {string} The number in Turkish words
- * @throws {TypeError} If value is not a valid numeric type
- * @throws {Error} If value is not a valid number format
- *
- * @example
- * toWords(21)                        // 'yirmi bir'
- * toWords(21, { dropSpaces: true })  // 'yirmibir'
- * toWords(1000)                      // 'bin'
- */
-function toWords (value, options) {
-  options = validateOptions(options)
-  const { isNegative, integerPart, decimalPart } = parseNumericValue(value)
-
-  const sep = options.dropSpaces ? '' : ' '
-  let result = ''
-
-  if (isNegative) {
-    result = NEGATIVE + sep
-  }
-
-  result += integerToWords(integerPart, options)
-
-  if (decimalPart) {
-    result += sep + DECIMAL_SEP + sep + decimalPartToWords(decimalPart, options)
-  }
-
-  return result
-}
-
-// ============================================================================
-// Public API
-// ============================================================================
-
-export { toWords }

package/lib/languages/uk.d.ts

@@ -1,11 +0,0 @@
-/**
- * Converts a numeric value to Ukrainian 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 Ukrainian words
- */
-export function toWords(value: number | string | bigint, options?: {
-    gender?: "masculine" | "feminine" | undefined;
-}): string;

package/lib/languages/uk.js

@@ -1,218 +0,0 @@
-/**
- * Ukrainian language converter - Functional Implementation
- *
- * Self-contained converter using shared Slavic utilities.
- *
- * Key features:
- * - Three-form pluralization (one/few/many)
- * - Gender: thousands are feminine, millions+ are masculine
- * - Irregular hundreds
- * - Long scale naming
- */
-
-import { parseNumericValue } from '../utils/parse-numeric.js'
-import { validateOptions } from '../utils/validate-options.js'
-
-// ============================================================================
-// Slavic Utilities (inlined for performance)
-// ============================================================================
-
-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 buildAllSegments (onesMasc, onesFem, teens, tens, hundreds) {
-  const masc = new Array(1000)
-  const fem = new Array(1000)
-
-  for (let i = 0; i < 1000; i++) {
-    masc[i] = buildSegment(i, onesMasc, teens, tens, hundreds)
-    fem[i] = buildSegment(i, onesFem, teens, tens, hundreds)
-  }
-
-  return { masc, fem }
-}
-
-function buildSegment (n, ones, teens, tens, hundreds) {
-  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[onesDigit])
-  }
-
-  return parts.join(' ')
-}
-
-// ============================================================================
-// Vocabulary
-// ============================================================================
-
-const ONES_MASC = ['', 'один', 'два', 'три', 'чотири', 'п\'ять', 'шiсть', 'сiм', 'вiсiм', 'дев\'ять']
-const ONES_FEM = ['', 'одна', 'двi', 'три', 'чотири', 'п\'ять', 'шiсть', 'сiм', 'вiсiм', 'дев\'ять']
-
-const TEENS = ['десять', 'одинадцять', 'дванадцять', 'тринадцять', 'чотирнадцять', 'п\'ятнадцять', 'шiстнадцять', 'сiмнадцять', 'вiсiмнадцять', 'дев\'ятнадцять']
-const TENS = ['', '', 'двадцять', 'тридцять', 'сорок', 'п\'ятдесят', 'шiстдесят', 'сiмдесят', 'вiсiмдесят', 'дев\'яносто']
-
-// Irregular hundreds
-const HUNDREDS = ['', 'сто', 'двiстi', 'триста', 'чотириста', 'п\'ятсот', 'шiстсот', 'сiмсот', 'вiсiмсот', 'дев\'ятсот']
-
-const ZERO = 'нуль'
-const NEGATIVE = 'мiнус'
-const DECIMAL_SEP = 'кома'
-
-// Scale words: [singular, few, many]
-// Thousands (index 0) are feminine, rest are masculine
-const SCALE_FORMS = [
-  ['тисяча', 'тисячi', 'тисяч'],
-  ['мiльйон', 'мiльйони', 'мiльйонiв'],
-  ['мiльярд', 'мiльярди', 'мiльярдiв'],
-  ['трильйон', 'трильйони', 'трильйонiв'],
-  ['квадрильйон', 'квадрильйони', 'квадрильйонiв'],
-  ['квiнтильйон', 'квiнтильйони', 'квiнтильйонiв'],
-  ['секстильйон', 'секстильйони', 'секстильйонiв'],
-  ['септильйон', 'септильйони', 'септильйонiв'],
-  ['октильйон', 'октильйони', 'октильйонiв']
-]
-
-// ============================================================================
-// Precomputed Lookup Tables
-// ============================================================================
-
-const { masc: SEGMENTS_MASC, fem: SEGMENTS_FEM } = buildAllSegments(ONES_MASC, ONES_FEM, TEENS, TENS, HUNDREDS)
-
-// ============================================================================
-// Conversion Functions
-// ============================================================================
-
-function integerToWords (n, options = {}) {
-  if (n === 0n) return ZERO
-
-  if (n < 1000n) {
-    const segments = options.gender === 'feminine' ? SEGMENTS_FEM : SEGMENTS_MASC
-    return segments[Number(n)]
-  }
-
-  return buildLargeNumberWords(n, options)
-}
-
-function buildLargeNumberWords (n, options) {
-  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) {
-        const segmentWords = options.gender === 'feminine' ? SEGMENTS_FEM : SEGMENTS_MASC
-        parts.push(segmentWords[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 segmentWords = isFeminine ? SEGMENTS_FEM : SEGMENTS_MASC
-        parts.push(segmentWords[segment] + ' ' + 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 Ukrainian 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 Ukrainian 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/ur.d.ts

@@ -1,7 +0,0 @@
-/**
- * Converts a numeric value to Urdu words.
- *
- * @param {number | string | bigint} value - The numeric value to convert
- * @returns {string} The number in Urdu words
- */
-export function toWords(value: number | string | bigint): string;