n2words 2.0.0 → 3.0.0

package/lib/languages/fil.js

@@ -1,121 +1,222 @@
-import { GreedyScaleLanguage } from '../classes/greedy-scale-language.js'
-
 /**
- * Filipino language converter.
+ * Filipino language converter - Functional Implementation
+ *
+ * Self-contained converter with precomputed lookup tables.
  *
- * Supports:
- * - "ng" connectors between words
- * - Implicit "one" omission
- * - Special linkers for certain tens (e.g., "limampung")
+ * Key features:
+ * - Linker "ng" after vowels: "isang daang" (100)
+ * - Linker " na " after consonants: "siyam na daang" (900)
+ * - Special tens with linker: "limampung anim" (56)
+ * - Per-digit decimal reading
  */
-export class Filipino extends GreedyScaleLanguage {
-  negativeWord = 'negatibo'
-  decimalSeparatorWord = 'punto'
-  zeroWord = 'zero'
-  usePerDigitDecimals = true // Read decimals digit-by-digit
-
-  scaleWords = [
-    [1000000000000n, 'trilyong'],
-    [1000000000n, 'milyong'],
-    [1000000n, 'milyong'],
-    [1000n, 'libong'],
-    [100n, 'daang'],
-
-    // Tens
-    [90n, 'siyamnapu'],
-    [80n, 'walumpu'],
-    [70n, 'pitumpu'],
-    [60n, 'animnapu'],
-    [50n, 'limampu'],
-    [40n, 'apatnapu'],
-    [30n, 'tatlumpu'],
-    [20n, 'dalawampu'],
-
-    // Teens (must come before 10 to be matched first)
-    [19n, 'labinsiyam'],
-    [18n, 'labingwalo'],
-    [17n, 'labimpito'],
-    [16n, 'labinanum'],
-    [15n, 'labinlima'],
-    [14n, 'labinapat'],
-    [13n, 'labintatlo'],
-    [12n, 'labindalawa'],
-    [11n, 'labinisa'],
-    [10n, 'sampu'],
-
-    // Ones
-    [9n, 'siyam'],
-    [8n, 'walo'],
-    [7n, 'pito'],
-    [6n, 'anim'],
-    [5n, 'lima'],
-    [4n, 'apat'],
-    [3n, 'tatlo'],
-    [2n, 'dalawa'],
-    [1n, 'isa'],
-    [0n, 'zero']
-  ]
-
-  /** Converts integer part with explicit zero handling. */
-  integerToWords (integerPart) {
-    // Handle zero explicitly
-    if (integerPart === 0n) {
-      return this.zeroWord
-    }
-    return super.integerToWords(integerPart)
+
+import { parseNumericValue } from '../utils/parse-numeric.js'
+
+// ============================================================================
+// Vocabulary
+// ============================================================================
+
+const ONES = ['', 'isa', 'dalawa', 'tatlo', 'apat', 'lima', 'anim', 'pito', 'walo', 'siyam']
+const TEENS = ['sampu', 'labinisa', 'labindalawa', 'labintatlo', 'labinapat', 'labinlima', 'labinanum', 'labimpito', 'labingwalo', 'labinsiyam']
+const TENS = ['', '', 'dalawampu', 'tatlumpu', 'apatnapu', 'limampu', 'animnapu', 'pitumpu', 'walumpu', 'siyamnapu']
+
+// Scale words include linker (end with "ng")
+const HUNDRED = 'daang'
+const THOUSAND = 'libong'
+
+const ZERO = 'zero'
+const NEGATIVE = 'negatibo'
+const DECIMAL_SEP = 'punto'
+
+// Short scale with linker
+const SCALE_WORDS = ['', THOUSAND, 'milyong', 'bilyong', 'trilyong']
+
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
+const VOWELS = ['a', 'e', 'i', 'o', 'u']
+
+function addLinker (word) {
+  const lastChar = word[word.length - 1]
+  if (VOWELS.includes(lastChar)) {
+    return word + 'ng'
   }
+  return word + ' na'
+}
 
-  /** Combines two word-sets with Filipino connector and linker rules. */
-  combineWordSets (preceding, following) {
-    const precedingWord = Object.keys(preceding)[0]
-    const followingWord = Object.keys(following)[0]
-    const precedingValue = Object.values(preceding)[0]
-    const followingValue = Object.values(following)[0]
+// ============================================================================
+// Precomputed Lookup Table
+// ============================================================================
 
-    // Don't merge zero with anything - just return the non-zero value
-    if (precedingValue === 0n) {
-      return following
-    }
-    if (followingValue === 0n) {
-      return preceding
-    }
+function buildSegment (n) {
+  if (n === 0) return ''
 
-    // Implicit "one" - omit when adding with values < 100
-    if (precedingValue === 1n && followingValue < 100n) {
-      return following
-    }
+  const ones = n % 10
+  const tensDigit = Math.floor(n / 10) % 10
+  const hundredsDigit = Math.floor(n / 100)
+
+  const parts = []
 
-    // Multiply when following is a scale word AND following > preceding
-    // Use "ng" connector for Filipino, but consonant-ending words use " na "
-    if (followingValue > precedingValue && followingValue >= 100n) {
-      // Words ending in consonants (not vowels) use " na " instead of "ng"
-      const vowels = ['a', 'e', 'i', 'o', 'u']
-      const lastChar = precedingWord[precedingWord.length - 1]
-      if (!vowels.includes(lastChar)) {
-        return {
-          [`${precedingWord} na ${followingWord}`]: precedingValue * followingValue
-        }
-      }
-      // Vowel-ending words add "ng"
-      return {
-        [`${precedingWord}ng ${followingWord}`]: precedingValue * followingValue
-      }
+  // Hundreds: "isang daan", "dalawang daan", "siyam na daan"
+  if (hundredsDigit > 0) {
+    const hundredPrefix = addLinker(ONES[hundredsDigit])
+    parts.push(hundredPrefix + ' ' + HUNDRED)
+  }
+
+  // Tens and ones
+  const tensOnes = n % 100
+
+  if (tensOnes === 0) {
+    // Just hundreds
+  } else if (tensOnes < 10) {
+    // Single digit
+    parts.push(ONES[ones])
+  } else if (tensOnes < 20) {
+    // Teens (10-19)
+    parts.push(TEENS[ones])
+  } else if (ones === 0) {
+    // Even tens (20, 30, 40, etc.)
+    parts.push(TENS[tensDigit])
+  } else {
+    // Tens + ones
+    // limampu (50) gets special linker: "limampung anim" (56)
+    if (tensDigit === 5) {
+      parts.push(TENS[tensDigit] + 'ng ' + ONES[ones])
+    } else {
+      parts.push(TENS[tensDigit] + ' ' + ONES[ones])
     }
+  }
 
-    // Special Filipino rule: certain tens words take "-ng" linker when followed by ones
-    // Only limampu (50) confirmed to use this pattern
-    if (precedingValue >= 10n && precedingValue < 100n && followingValue >= 1n && followingValue < 10n) {
-      const tensWithNg = ['limampu']
-      if (tensWithNg.includes(precedingWord)) {
-        return {
-          [`${precedingWord}ng ${followingWord}`]: precedingValue + followingValue
-        }
-      }
+  return parts.join(' ')
+}
+
+const SEGMENTS = new Array(1000)
+for (let i = 0; i < 1000; i++) {
+  SEGMENTS[i] = buildSegment(i)
+}
+
+/**
+ * Builds segment with linker added to last word (for use before scale words).
+ */
+function buildSegmentWithLinker (n) {
+  const segmentWord = SEGMENTS[n]
+  if (!segmentWord) return ''
+
+  // Find the last space to get the last word
+  const lastSpaceIdx = segmentWord.lastIndexOf(' ')
+  if (lastSpaceIdx === -1) {
+    // Single word
+    const lastChar = segmentWord[segmentWord.length - 1]
+    if (lastChar === 'g' && segmentWord.endsWith('ng')) {
+      return segmentWord // Already has linker
     }
+    return addLinker(segmentWord)
+  }
+
+  // Multi-word: add linker to last word
+  const prefix = segmentWord.slice(0, lastSpaceIdx + 1)
+  const lastWord = segmentWord.slice(lastSpaceIdx + 1)
 
-    // Default: space for addition
-    return {
-      [`${precedingWord} ${followingWord}`]: precedingValue + followingValue
+  if (lastWord.endsWith('ng')) {
+    return segmentWord // Already has linker
+  }
+  return prefix + addLinker(lastWord)
+}
+
+// Precompute segments with linker for scale word usage
+const SEGMENTS_WITH_LINKER = new Array(1000)
+for (let i = 0; i < 1000; i++) {
+  SEGMENTS_WITH_LINKER[i] = buildSegmentWithLinker(i)
+}
+
+// ============================================================================
+// Conversion Functions
+// ============================================================================
+
+function integerToWords (n) {
+  if (n === 0n) return ZERO
+
+  if (n < 1000n) {
+    return SEGMENTS[Number(n)]
+  }
+
+  return buildLargeNumberWords(n)
+}
+
+/**
+ * Builds words for large numbers using BigInt division.
+ * @param {bigint} n - Number >= 1000
+ * @returns {string} Filipino words
+ */
+function buildLargeNumberWords (n) {
+  // Extract segments using BigInt division (faster than string slicing)
+  const segmentValues = []
+  let temp = n
+  while (temp > 0n) {
+    segmentValues.push(Number(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 === 0) continue
+
+    const scaleWord = SCALE_WORDS[i] || ''
+
+    if (result) result += ' '
+
+    if (i === 0) {
+      result += SEGMENTS[segment]
+    } else {
+      // Add linker to segment before scale word
+      const segmentWord = SEGMENTS_WITH_LINKER[segment]
+      result += segmentWord + ' ' + scaleWord
     }
   }
+
+  return result
 }
+
+function decimalPartToWords (decimalPart) {
+  // Per-digit decimal reading
+  const digits = []
+  for (const char of decimalPart) {
+    const d = parseInt(char, 10)
+    digits.push(d === 0 ? ZERO : ONES[d])
+  }
+  return digits.join(' ')
+}
+
+/**
+ * Converts a numeric value to Filipino words.
+ *
+ * @param {number | string | bigint} value - The numeric value to convert
+ * @returns {string} The number in Filipino 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/fr-BE.d.ts

@@ -1,11 +1,11 @@
 /**
- * French (Belgium) language converter.
+ * Converts a numeric value to Belgian French words.
  *
- * Supports:
- * - Belgian regional variants: "septante" (70) and "nonante" (90)
- * - Simplified tens naming (no complex arithmetic)
- * - Inherits all other French grammar rules
+ * @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
  */
-export class FrenchBelgium extends French {
-}
-import { French } from './fr.js';
+export function toWords(value: number | string | bigint, options?: {
+    withHyphenSeparator?: boolean | undefined;
+}): string;

package/lib/languages/fr-BE.js

@@ -1,25 +1,300 @@
-import { French } from './fr.js'
+/**
+ * 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
+}
 
 /**
- * French (Belgium) language converter.
+ * Converts a numeric value to Belgian French words.
  *
- * Supports:
- * - Belgian regional variants: "septante" (70) and "nonante" (90)
- * - Simplified tens naming (no complex arithmetic)
- * - Inherits all other French grammar rules
+ * @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
  */
-export class FrenchBelgium extends French {
-  constructor (options = {}) {
-    super(options)
-
-    // Insert 90n ('nonante') after 80n and 70n ('septante') after 60n
-    const tuples = [...this.scaleWords]
-    // Find index of 80n and insert 90n after it
-    const idx80 = tuples.findIndex(tuple => tuple[0] === 80n)
-    if (idx80 !== -1) tuples.splice(idx80, 0, [90n, 'nonante'])
-    // Find index of 60n and insert 70n after it
-    const idx60 = tuples.findIndex(tuple => tuple[0] === 60n)
-    if (idx60 !== -1) tuples.splice(idx60, 0, [70n, 'septante'])
-    this.scaleWords = tuples
+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 }