n2words 3.0.0 → 4.0.0

package/lib/languages/fr-BE.js

@@ -1,300 +0,0 @@
-/**
- * French (Belgium) language converter - Functional Implementation
- *
- * Self-contained converter with precomputed lookup tables.
- *
- * Belgian French differences from standard French:
- * - septante (70) instead of soixante-dix
- * - nonante (90) instead of quatre-vingt-dix
- * - Keeps quatre-vingts (80) like standard French
- * - Uses "septante et un" (71), "nonante et un" (91)
- */
-
-import { parseNumericValue } from '../utils/parse-numeric.js'
-import { validateOptions } from '../utils/validate-options.js'
-
-// ============================================================================
-// Vocabulary
-// ============================================================================
-
-const ONES = ['', 'un', 'deux', 'trois', 'quatre', 'cinq', 'six', 'sept', 'huit', 'neuf']
-const TEENS = ['dix', 'onze', 'douze', 'treize', 'quatorze', 'quinze', 'seize', 'dix-sept', 'dix-huit', 'dix-neuf']
-const TENS = ['', '', 'vingt', 'trente', 'quarante', 'cinquante', 'soixante', 'septante', 'quatre-vingt', 'nonante']
-
-// Scale words (long scale with -ard forms)
-const SCALES = ['million', 'billion', 'trillion', 'quadrillion']
-const SCALES_ARD = ['milliard', 'billiard', 'trilliard', 'quadrilliard']
-
-const THOUSAND = 'mille'
-const HUNDRED = 'cent'
-const ZERO = 'zéro'
-const NEGATIVE = 'moins'
-const DECIMAL_SEP = 'virgule'
-
-// ============================================================================
-// Precomputed Lookup Tables
-// ============================================================================
-
-function buildSegment (n) {
-  if (n === 0) return { word: '', endsWithCents: false, endsWithVingts: false }
-
-  const tensOnes = n % 100
-  const hundreds = Math.floor(n / 100)
-
-  const parts = []
-  let endsWithCents = false
-  let endsWithVingts = false
-
-  // Hundreds
-  if (hundreds > 0) {
-    if (hundreds === 1) {
-      parts.push(HUNDRED)
-    } else {
-      if (tensOnes === 0) {
-        parts.push(ONES[hundreds] + ' ' + HUNDRED + 's')
-        endsWithCents = true
-      } else {
-        parts.push(ONES[hundreds] + ' ' + HUNDRED)
-      }
-    }
-  }
-
-  // Tens and ones - Belgian pattern
-  if (tensOnes === 0) {
-    // Just hundreds
-  } else if (tensOnes < 10) {
-    parts.push(ONES[tensOnes])
-  } else if (tensOnes < 17) {
-    parts.push(TEENS[tensOnes - 10])
-  } else if (tensOnes < 20) {
-    parts.push(TEENS[tensOnes - 10])
-  } else if (tensOnes < 70) {
-    // 20-69: standard pattern
-    const t = Math.floor(tensOnes / 10)
-    const o = tensOnes % 10
-    if (o === 0) {
-      parts.push(TENS[t])
-    } else if (o === 1) {
-      parts.push(TENS[t] + ' et ' + ONES[1])
-    } else {
-      parts.push(TENS[t] + '-' + ONES[o])
-    }
-  } else if (tensOnes < 80) {
-    // 70-79: septante pattern (Belgian)
-    const o = tensOnes % 10
-    if (o === 0) {
-      parts.push('septante')
-    } else if (o === 1) {
-      parts.push('septante et ' + ONES[1])
-    } else {
-      parts.push('septante-' + ONES[o])
-    }
-  } else if (tensOnes === 80) {
-    // 80: quatre-vingts (same as standard)
-    parts.push('quatre-vingts')
-    endsWithVingts = true
-  } else if (tensOnes < 90) {
-    // 81-89: quatre-vingt-X (same as standard)
-    const remainder = tensOnes - 80
-    parts.push('quatre-vingt-' + ONES[remainder])
-  } else {
-    // 90-99: nonante pattern (Belgian)
-    const o = tensOnes % 10
-    if (o === 0) {
-      parts.push('nonante')
-    } else if (o === 1) {
-      parts.push('nonante et ' + ONES[1])
-    } else {
-      parts.push('nonante-' + ONES[o])
-    }
-  }
-
-  return { word: parts.join(' '), endsWithCents, endsWithVingts }
-}
-
-// Precompute all 1000 segment words
-const SEGMENTS = new Array(1000)
-const SEGMENTS_ENDS_CENTS = new Array(1000)
-const SEGMENTS_ENDS_VINGTS = new Array(1000)
-
-for (let i = 0; i < 1000; i++) {
-  const result = buildSegment(i)
-  SEGMENTS[i] = result.word
-  SEGMENTS_ENDS_CENTS[i] = result.endsWithCents
-  SEGMENTS_ENDS_VINGTS[i] = result.endsWithVingts
-}
-
-// ============================================================================
-// Helper Functions
-// ============================================================================
-
-function getScaleWord (scaleIndex, segment) {
-  if (scaleIndex === 1) return THOUSAND
-
-  if (scaleIndex % 2 === 0) {
-    const arrayIndex = (scaleIndex / 2) - 1
-    const baseWord = SCALES[arrayIndex]
-    if (!baseWord) return ''
-    return segment > 1n ? baseWord + 's' : baseWord
-  } else {
-    const arrayIndex = ((scaleIndex - 1) / 2) - 1
-    const ardWord = SCALES_ARD[arrayIndex]
-    if (!ardWord) return THOUSAND
-    return segment > 1n ? ardWord + 's' : ardWord
-  }
-}
-
-// ============================================================================
-// Conversion Functions
-// ============================================================================
-
-function integerToWords (n, withHyphen = false) {
-  if (n === 0n) return ZERO
-
-  if (n < 1000n) {
-    const word = SEGMENTS[Number(n)]
-    return withHyphen ? word.replace(/ /g, '-') : word
-  }
-
-  if (n < 1_000_000n) {
-    const thousands = Number(n / 1000n)
-    const remainder = Number(n % 1000n)
-
-    let result
-    if (thousands === 1) {
-      result = THOUSAND
-    } else {
-      let thousandsWord = SEGMENTS[thousands]
-      if (SEGMENTS_ENDS_CENTS[thousands] || SEGMENTS_ENDS_VINGTS[thousands]) {
-        thousandsWord = thousandsWord.slice(0, -1)
-      }
-      result = thousandsWord + (withHyphen ? '-' : ' ') + THOUSAND
-    }
-
-    if (remainder > 0) {
-      result += (withHyphen ? '-' : ' ') + SEGMENTS[remainder]
-    }
-
-    if (withHyphen) {
-      result = result.replace(/ /g, '-')
-    }
-
-    return result
-  }
-
-  return buildLargeNumberWords(n, withHyphen)
-}
-
-function buildLargeNumberWords (n, withHyphen) {
-  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) {
-      const scaleWord = scaleIndex > 0 ? getScaleWord(scaleIndex, BigInt(segment)) : ''
-
-      if (scaleIndex === 0) {
-        parts.push(SEGMENTS[segment])
-      } else if (scaleIndex === 1) {
-        if (segment === 1) {
-          parts.push(THOUSAND)
-        } else {
-          let segWords = SEGMENTS[segment]
-          if (SEGMENTS_ENDS_CENTS[segment] || SEGMENTS_ENDS_VINGTS[segment]) {
-            segWords = segWords.slice(0, -1)
-          }
-          parts.push(segWords)
-          parts.push(scaleWord)
-        }
-      } else {
-        parts.push(SEGMENTS[segment])
-        parts.push(scaleWord)
-      }
-    }
-
-    scaleIndex--
-  }
-
-  const sep = withHyphen ? '-' : ' '
-  let result = parts.join(sep)
-
-  if (withHyphen) {
-    result = result.replace(/ /g, '-')
-  }
-
-  return result
-}
-
-function decimalPartToWords (decimalPart, withHyphen) {
-  let result = ''
-  const sep = withHyphen ? '-' : ' '
-
-  let i = 0
-  while (i < decimalPart.length && decimalPart[i] === '0') {
-    if (result) result += sep
-    result += ZERO
-    i++
-  }
-
-  const remainder = decimalPart.slice(i)
-  if (remainder) {
-    if (result) result += sep
-    result += integerToWords(BigInt(remainder), withHyphen)
-  }
-
-  return result
-}
-
-/**
- * Converts a numeric value to Belgian French words.
- *
- * @param {number | string | bigint} value - The numeric value to convert
- * @param {Object} [options] - Optional configuration
- * @param {boolean} [options.withHyphenSeparator=false] - Use hyphens between words
- * @returns {string} The number in Belgian French words
- */
-function toWords (value, options) {
-  options = validateOptions(options)
-  const { isNegative, integerPart, decimalPart } = parseNumericValue(value)
-  const withHyphen = options.withHyphenSeparator || false
-
-  let result = ''
-  const sep = withHyphen ? '-' : ' '
-
-  if (isNegative) {
-    result = NEGATIVE + sep
-  }
-
-  result += integerToWords(integerPart, withHyphen)
-
-  if (decimalPart) {
-    result += sep + DECIMAL_SEP + sep + decimalPartToWords(decimalPart, withHyphen)
-  }
-
-  return result
-}
-
-// ============================================================================
-// Exports
-// ============================================================================
-
-export { toWords }

package/lib/languages/fr.d.ts

@@ -1,21 +0,0 @@
-/**
- * Converts a numeric value to French 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] - Optional configuration
- * @param {boolean} [options.withHyphenSeparator=false] - Use hyphens between all words
- * @returns {string} The number in French words
- * @throws {TypeError} If value is not a valid numeric type
- * @throws {Error} If value is not a valid number format
- *
- * @example
- * toWords(21)           // 'vingt et un'
- * toWords(80)           // 'quatre-vingts'
- * toWords(1000000)      // 'un million'
- */
-export function toWords(value: number | string | bigint, options?: {
-    withHyphenSeparator?: boolean | undefined;
-}): string;

package/lib/languages/gu.d.ts

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

package/lib/languages/gu.js

@@ -1,137 +0,0 @@
-/**
- * Gujarati language converter - Functional Implementation
- *
- * Self-contained converter for South Asian numbering.
- *
- * Key features:
- * - Indian numbering system (હજાર, લાખ, કરોડ)
- * - Gujarati script
- * - 3-2-2 grouping pattern (last 3 digits, then groups of 2)
- * - Complete word forms for 0-99
- * - Per-digit decimal reading
- */
-
-import { parseNumericValue } from '../utils/parse-numeric.js'
-
-// ============================================================================
-// Vocabulary
-// ============================================================================
-
-const ZERO = 'શૂન્ય'
-const NEGATIVE = 'ઋણ'
-const DECIMAL_SEP = 'દશાંશ'
-const HUNDRED = 'સો'
-
-const BELOW_HUNDRED = [
-  'શૂન્ય', 'એક', 'બે', 'ત્રણ', 'ચાર', 'પાંચ', 'છ', 'સાત', 'આઠ', 'નવ',
-  'દસ', 'અગિયાર', 'બાર', 'તેર', 'ચૌદ', 'પંદર', 'સોળ', 'સત્તર', 'અઢાર', 'ઓગણીસ',
-  'વીસ', 'એકવીસ', 'બાવીસ', 'ત્રેવીસ', 'ચોવીસ', 'પચીસ', 'છવ્વીસ', 'સત્તાવીસ', 'અઠ્ઠાવીસ', 'ઓગણત્રીસ',
-  'ત્રીસ', 'એકત્રીસ', 'બત્રીસ', 'તેત્રીસ', 'ચોત્રીસ', 'પાંત્રીસ', 'છત્રીસ', 'સાડત્રીસ', 'અડત્રીસ', 'ઓગણચાલીસ',
-  'ચાલીસ', 'એકતાલીસ', 'બેતાળીસ', 'ત્રેતાળીસ', 'ચુંમાલીસ', 'પિસ્તાલીસ', 'છેતાળીસ', 'સુડતાળીસ', 'અડતાળીસ', 'ઓગણપચાસ',
-  'પચાસ', 'એકાવન', 'બાવન', 'ત્રેપન', 'ચોપન', 'પંચાવન', 'છપ્પન', 'સત્તાવન', 'અઠ્ઠાવન', 'ઓગણસાઠ',
-  'સાઠ', 'એકસઠ', 'બાસઠ', 'ત્રેસઠ', 'ચોસઠ', 'પાંસઠ', 'છાસઠ', 'સડસઠ', 'અડસઠ', 'અગણોસિત્તેર',
-  'સિત્તેર', 'એકોતેર', 'બોતેર', 'તોતેર', 'ચુમોતેર', 'પંચોતેર', 'છોતેર', 'સિત્યોતેર', 'ઇઠ્યોતેર', 'ઓગણાએંસી',
-  'એંસી', 'એક્યાસી', 'બ્યાસી', 'ત્યાસી', 'ચોર્યાસી', 'પંચાસી', 'છ્યાસી', 'સિત્યાસી', 'અઠ્યાસી', 'નેવ્યાસી',
-  'નેવું', 'એકાણું', 'બાણું', 'ત્રાણું', 'ચોરાણું', 'પંચાણું', 'છન્નું', 'સત્તાણું', 'અઠ્ઠાણું', 'નવ્વાણું'
-]
-
-// Scale words: index 0 = units (empty), 1 = thousand, 2 = lakh, 3 = crore, etc.
-const SCALE_WORDS = ['', 'હજાર', 'લાખ', 'કરોડ', 'અબજ', 'ખરબ', 'નીલ', 'પદ્મ', 'શંખ']
-
-// ============================================================================
-// Segment Splitting (inlined for performance)
-// ============================================================================
-
-function groupByThreeThenTwos (n) {
-  const numStr = n.toString()
-  if (numStr.length <= 3) return [Number(numStr)]
-
-  const segments = []
-  segments.unshift(Number(numStr.slice(-3)))
-
-  let remaining = numStr.slice(0, -3)
-  while (remaining.length > 0) {
-    segments.unshift(Number(remaining.slice(-2)))
-    remaining = remaining.slice(0, -2)
-  }
-
-  return segments
-}
-
-function segmentToWords (n) {
-  if (n === 0) return ''
-  if (n < 100) return BELOW_HUNDRED[n]
-
-  const hundreds = Math.trunc(n / 100)
-  const remainder = n % 100
-
-  if (remainder === 0) {
-    return BELOW_HUNDRED[hundreds] + ' ' + HUNDRED
-  }
-  return BELOW_HUNDRED[hundreds] + ' ' + HUNDRED + ' ' + BELOW_HUNDRED[remainder]
-}
-
-// ============================================================================
-// Conversion Functions
-// ============================================================================
-
-function integerToWords (n) {
-  if (n === 0n) return ZERO
-
-  const segments = groupByThreeThenTwos(n)
-  const segmentCount = segments.length
-  const words = []
-
-  for (let i = 0; i < segmentCount; i++) {
-    const segmentValue = segments[i]
-    if (segmentValue === 0) continue
-
-    const scaleIndex = segmentCount - i - 1
-    words.push(segmentToWords(segmentValue))
-    if (scaleIndex > 0 && SCALE_WORDS[scaleIndex]) {
-      words.push(SCALE_WORDS[scaleIndex])
-    }
-  }
-
-  return words.join(' ').trim()
-}
-
-function decimalPartToWords (decimalPart) {
-  // Per-digit decimal reading
-  const digits = []
-  for (const char of decimalPart) {
-    const d = parseInt(char, 10)
-    digits.push(d === 0 ? ZERO : BELOW_HUNDRED[d])
-  }
-  return digits.join(' ')
-}
-
-/**
- * Converts a numeric value to Gujarati words.
- *
- * @param {number | string | bigint} value - The numeric value to convert
- * @returns {string} The number in Gujarati words
- */
-function toWords (value) {
-  const { isNegative, integerPart, decimalPart } = parseNumericValue(value)
-
-  let result = ''
-
-  if (isNegative) {
-    result = NEGATIVE + ' '
-  }
-
-  result += integerToWords(integerPart)
-
-  if (decimalPart) {
-    result += ' ' + DECIMAL_SEP + ' ' + decimalPartToWords(decimalPart)
-  }
-
-  return result
-}
-
-// ============================================================================
-// Exports
-// ============================================================================
-
-export { toWords }

package/lib/languages/ha.d.ts

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

package/lib/languages/hbo.d.ts

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

package/lib/languages/he.d.ts

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