n2words 3.1.0 → 4.0.0

package/lib/languages/hr.js

@@ -1,224 +0,0 @@
-/**
- * Croatian 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 (dvjesto, tristo, etc.)
- * - Long scale naming with -ard forms
- */
-
-import { parseNumericValue } from '../utils/parse-numeric.js'
-import { validateOptions } from '../utils/validate-options.js'
-
-// ============================================================================
-// Vocabulary
-// ============================================================================
-
-const ONES_MASC = ['', 'jedan', 'dva', 'tri', 'četiri', 'pet', 'šest', 'sedam', 'osam', 'devet']
-const ONES_FEM = ['', 'jedna', 'dvije', 'tri', 'četiri', 'pet', 'šest', 'sedam', 'osam', 'devet']
-
-const TEENS = ['deset', 'jedanaest', 'dvanaest', 'trinaest', 'četrnaest', 'petnaest', 'šesnaest', 'sedamnaest', 'osamnaest', 'devetnaest']
-const TENS = ['', '', 'dvadeset', 'trideset', 'četrdeset', 'pedeset', 'šezdeset', 'sedamdeset', 'osamdeset', 'devedeset']
-
-// Croatian has irregular hundreds
-const HUNDREDS = ['', 'sto', 'dvjesto', 'tristo', 'četiristo', 'petsto', 'šesto', 'sedamsto', 'osamsto', 'devetsto']
-
-const ZERO = 'nula'
-const NEGATIVE = 'minus'
-const DECIMAL_SEP = 'zarez'
-
-// Scale words: [singular, few, many]
-// Thousands (index 0) are feminine, rest are masculine
-const SCALE_FORMS = [
-  ['tisuća', 'tisuće', 'tisuća'],
-  ['milijun', 'milijuna', 'milijuna'],
-  ['milijarda', 'milijarde', 'milijarda'],
-  ['bilijun', 'bilijuna', 'bilijuna'],
-  ['bilijarda', 'bilijarde', 'bilijarda'],
-  ['trilijun', 'trilijuna', 'trilijuna'],
-  ['trilijarda', 'trilijarde', 'trilijarda'],
-  ['kvadrilijun', 'kvadrilijuna', 'kvadrilijuna'],
-  ['kvadrilijarda', 'kvadrilijarde', 'kvadrilijarda']
-]
-
-// ============================================================================
-// 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
-
-  if (n < 1000n) {
-    return options.gender === 'feminine' ? buildSegmentFem(Number(n)) : buildSegmentMasc(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) {
-        parts.push(options.gender === '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 Croatian 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 Croatian 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/hu.d.ts

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

package/lib/languages/id.d.ts

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

package/lib/languages/it.d.ts

@@ -1,19 +0,0 @@
-/**
- * Converts a numeric value to Italian 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 Italian words
- * @throws {TypeError} If value is not a valid numeric type
- * @throws {Error} If value is not a valid number format
- *
- * @example
- * toWords(28)           // 'ventotto'
- * toWords(23)           // 'ventitré'
- * toWords(1000)         // 'mille'
- * toWords(2000)         // 'duemila'
- * toWords(1000000)      // 'un milione'
- */
-export function toWords(value: number | string | bigint): string;

package/lib/languages/ja.d.ts

@@ -1,17 +0,0 @@
-/**
- * Converts a numeric value to Japanese 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 Japanese kanji words
- * @throws {TypeError} If value is not a valid numeric type
- * @throws {Error} If value is not a valid number format
- *
- * @example
- * toWords(42)           // '四十二'
- * toWords(10000)        // '一万'
- * toWords(100000000)    // '一億'
- */
-export function toWords(value: number | string | bigint): string;

package/lib/languages/ka.d.ts

@@ -1,17 +0,0 @@
-/**
- * Converts a numeric value to Georgian 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 Georgian words
- * @throws {TypeError} If value is not a valid numeric type
- * @throws {Error} If value is not a valid number format
- *
- * @example
- * toWords(21)           // 'ოცდაერთი'
- * toWords(100)          // 'ასი'
- * toWords(1000)         // 'ათასი'
- */
-export function toWords(value: number | string | bigint): string;

package/lib/languages/kn.d.ts

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

package/lib/languages/ko.d.ts

@@ -1,14 +0,0 @@
-/**
- * Converts a numeric value to Korean words.
- *
- * @param {number | string | bigint} value - The numeric value to convert
- * @returns {string} The number in Korean words
- * @throws {TypeError} If value is not a valid numeric type
- * @throws {Error} If value is not a valid number format
- *
- * @example
- * toWords(21)         // '이십일'
- * toWords(10000)      // '만'
- * toWords(1000000)    // '백만'
- */
-export function toWords(value: number | string | bigint): string;

package/lib/languages/lt.d.ts

@@ -1,18 +0,0 @@
-/**
- * Converts a numeric value to Lithuanian words.
- *
- * @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 Lithuanian words
- * @throws {TypeError} If value is not a valid numeric type
- * @throws {Error} If value is not a valid number format
- *
- * @example
- * toWords(42)                          // 'keturiasdešimt du'
- * toWords(1, { gender: 'feminine' })   // 'viena'
- * toWords(1000000)                     // 'vienas milijonas'
- */
-export function toWords(value: number | string | bigint, options?: {
-    gender?: string | undefined;
-}): string;

package/lib/languages/lt.js

@@ -1,301 +0,0 @@
-/**
- * Lithuanian language converter - Functional Implementation
- *
- * Self-contained module with its own input validation, ready for subpath exports.
- *
- * Key features:
- * - Three-form pluralization (singular/plural/genitive)
- * - Gender agreement (masculine/feminine for numbers < 1000)
- * - Two-form hundreds (šimtas/šimtai)
- * - Long scale naming
- */
-
-import { parseNumericValue } from '../utils/parse-numeric.js'
-import { validateOptions } from '../utils/validate-options.js'
-
-// ============================================================================
-// Vocabulary (module-level constants)
-// ============================================================================
-
-const ONES_MASC = ['', 'vienas', 'du', 'trys', 'keturi', 'penki', 'šeši', 'septyni', 'aštuoni', 'devyni']
-const ONES_FEM = ['', 'viena', 'dvi', 'trys', 'keturios', 'penkios', 'šešios', 'septynios', 'aštuonios', 'devynios']
-
-const TEENS = ['dešimt', 'vienuolika', 'dvylika', 'trylika', 'keturiolika', 'penkiolika', 'šešiolika', 'septyniolika', 'aštuoniolika', 'devyniolika']
-const TENS = ['', '', 'dvidešimt', 'trisdešimt', 'keturiasdešimt', 'penkiasdešimt', 'šešiasdešimt', 'septyniasdešimt', 'aštuoniasdešimt', 'devyniasdešimt']
-
-// Hundreds: šimtas (singular), šimtai (plural)
-const HUNDRED_SINGULAR = 'šimtas'
-const HUNDRED_PLURAL = 'šimtai'
-
-const ZERO = 'nulis'
-const NEGATIVE = 'minus'
-const DECIMAL_SEP = 'kablelis'
-
-// Scale words: [singular, plural, genitive]
-const SCALE_FORMS = [
-  ['tūkstantis', 'tūkstančiai', 'tūkstančių'],
-  ['milijonas', 'milijonai', 'milijonų'],
-  ['milijardas', 'milijardai', 'milijardų'],
-  ['trilijonas', 'trilijonai', 'trilijonų'],
-  ['kvadrilijonas', 'kvadrilijonai', 'kvadrilijonų'],
-  ['kvintilijonas', 'kvintilijonai', 'kvintilijonų'],
-  ['sikstilijonas', 'sikstilijonai', 'sikstilijonų'],
-  ['septilijonas', 'septilijonai', 'septilijonų'],
-  ['oktilijonas', 'oktilijonai', 'oktilijonų']
-]
-
-// ============================================================================
-// Segment Building
-// ============================================================================
-
-/**
- * Builds segment word for 0-999 (masculine form).
- */
-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 - Lithuanian always includes the numeral
-  if (hundreds > 0) {
-    parts.push(ONES_MASC[hundreds])
-    parts.push(hundreds === 1 ? HUNDRED_SINGULAR : HUNDRED_PLURAL)
-  }
-
-  // Tens
-  if (tens > 1) {
-    parts.push(TENS[tens])
-  }
-
-  // Teens or ones
-  if (tens === 1) {
-    parts.push(TEENS[ones])
-  } else if (ones > 0) {
-    parts.push(ONES_MASC[ones])
-  }
-
-  return parts.join(' ')
-}
-
-/**
- * Builds segment word for 0-999 (feminine form - only differs in ones).
- */
-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 - always masculine
-  if (hundreds > 0) {
-    parts.push(ONES_MASC[hundreds])
-    parts.push(hundreds === 1 ? HUNDRED_SINGULAR : HUNDRED_PLURAL)
-  }
-
-  // Tens
-  if (tens > 1) {
-    parts.push(TENS[tens])
-  }
-
-  // Teens or ones - feminine for ones only
-  if (tens === 1) {
-    parts.push(TEENS[ones])
-  } else if (ones > 0) {
-    parts.push(ONES_FEM[ones])
-  }
-
-  return parts.join(' ')
-}
-
-// ============================================================================
-// Pluralization
-// ============================================================================
-
-/**
- * Lithuanian pluralization rules.
- * - Singular: ends in 1 (except 11)
- * - Plural: ends in 2-9 (except 12-19)
- * - Genitive: 0, 10-19, or ends in 0
- *
- * @param {number} n - The segment value
- * @param {string[]} forms - [singular, plural, genitive]
- * @returns {string} The appropriate form
- */
-function pluralize (n, forms) {
-  if (n === 0) return forms[2]
-
-  const lastDigit = n % 10
-  const lastTwoDigits = n % 100
-
-  // 10-19 always use genitive
-  if (lastTwoDigits >= 10 && lastTwoDigits <= 19) {
-    return forms[2]
-  }
-
-  // Ends in 0 → genitive
-  if (lastDigit === 0) {
-    return forms[2]
-  }
-
-  // Ends in 1 → singular
-  if (lastDigit === 1) {
-    return forms[0]
-  }
-
-  // Ends in 2-9 → plural
-  return forms[1]
-}
-
-// ============================================================================
-// Conversion Functions
-// ============================================================================
-
-/**
- * Converts a non-negative integer to Lithuanian words.
- *
- * @param {bigint} n - Non-negative integer to convert
- * @param {Object} options - Conversion options
- * @returns {string} Lithuanian words
- */
-function integerToWords (n, options = {}) {
-  if (n === 0n) return ZERO
-
-  // Fast path: numbers < 1000
-  if (n < 1000n) {
-    const num = Number(n)
-    return options.gender === 'feminine' ? buildSegmentFeminine(num) : buildSegment(num)
-  }
-
-  // For numbers >= 1000, feminine only applies to final segment if < 1000
-  // But the fixture shows feminine NOT applying for n >= 1000
-  // So we use masculine for all segments when n >= 1000
-  return buildLargeNumberWords(n, options)
-}
-
-/**
- * Builds words for numbers >= 1000.
- *
- * @param {bigint} n - Number >= 1000
- * @param {Object} options - Conversion options
- * @returns {string} Lithuanian words
- */
-function buildLargeNumberWords (n, options) {
-  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 = buildSegment(segment)
-
-      if (scaleIndex === 0) {
-        // Units segment - use masculine (feminine doesn't apply when n >= 1000)
-        parts.push(segmentWord)
-      } else {
-        // Segment with scale word
-        const scaleForms = SCALE_FORMS[scaleIndex - 1]
-        const scaleWord = pluralize(segment, scaleForms)
-        parts.push(segmentWord + ' ' + scaleWord)
-      }
-    }
-
-    scaleIndex--
-  }
-
-  return parts.join(' ')
-}
-
-/**
- * Converts decimal digits to Lithuanian words.
- *
- * @param {string} decimalPart - Decimal digits (without the point)
- * @param {Object} options - Conversion options
- * @returns {string} Lithuanian 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 Lithuanian words.
- *
- * @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 Lithuanian words
- * @throws {TypeError} If value is not a valid numeric type
- * @throws {Error} If value is not a valid number format
- *
- * @example
- * toWords(42)                          // 'keturiasdešimt du'
- * toWords(1, { gender: 'feminine' })   // 'viena'
- * toWords(1000000)                     // 'vienas milijonas'
- */
-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/lv.d.ts

@@ -1,18 +0,0 @@
-/**
- * Converts a numeric value to Latvian words.
- *
- * @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 Latvian words
- * @throws {TypeError} If value is not a valid numeric type
- * @throws {Error} If value is not a valid number format
- *
- * @example
- * toWords(42)                          // 'četrdesmit divi'
- * toWords(1, { gender: 'feminine' })   // 'viena'
- * toWords(1000)                        // 'tūkstotis'
- */
-export function toWords(value: number | string | bigint, options?: {
-    gender?: string | undefined;
-}): string;