n2words 1.24.0 → 3.0.0

package/lib/languages/fil.js

@@ -1,162 +1,222 @@
 /**
- * Filipino (Tagalog) language implementation for n2words
+ * Filipino language converter - Functional Implementation
  *
- * Uses scale-based system with irregular patterns for numbers 1-19.
- * Filipino numbers follow patterns like: sampu (10), labinisa (11), dalawampu (20)
+ * Self-contained converter with precomputed lookup tables.
  *
- * @module lib/languages/tl
- * @example
- * import fil from './lib/languages/fil.js'
- * tl(42) // 'apatnapu dalawa'
- * tl(1000) // 'isang libo'
+ * 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
  */
 
-import GreedyScaleLanguage from '../classes/greedy-scale-language.js'
+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'
+}
+
+// ============================================================================
+// Precomputed Lookup Table
+// ============================================================================
+
+function buildSegment (n) {
+  if (n === 0) return ''
+
+  const ones = n % 10
+  const tensDigit = Math.floor(n / 10) % 10
+  const hundredsDigit = Math.floor(n / 100)
+
+  const parts = []
+
+  // 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])
+    }
+  }
+
+  return parts.join(' ')
+}
+
+const SEGMENTS = new Array(1000)
+for (let i = 0; i < 1000; i++) {
+  SEGMENTS[i] = buildSegment(i)
+}
 
 /**
- * Filipino language implementation
- * Extends GreedyScaleLanguage with scale-based number conversion
+ * Builds segment with linker added to last word (for use before scale words).
  */
-class FilipinoLanguage extends GreedyScaleLanguage {
-  negativeWord = 'negatibo'
-  decimalSeparatorWord = 'punto'
-  zeroWord = 'zero'
-  convertDecimalsPerDigit = true // Read decimals digit-by-digit
-
-  scaleWordPairs = [
-    [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']
-  ]
-
-  /**
-   * Convert a whole number to Filipino words.
-   * Overrides parent to handle zero explicitly.
-   *
-   * @param {bigint} wholeNumber The whole number to convert.
-   * @returns {string} The Filipino representation.
-   */
-  convertWholePart (wholeNumber) {
-    // Handle zero explicitly
-    if (wholeNumber === 0n) {
-      return this.zeroWord
+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 super.convertWholePart(wholeNumber)
+    return addLinker(segmentWord)
   }
 
-  /**
-   * Merge two word-sets according to Filipino grammar rules.
-   *
-   * Features Filipino-specific rules:
-   * - "ng" connector between words
-   * - Consonant-ending words use "na" instead of "ng"
-   * - Implicit "one" omission ("isang daan" → "daan")
-   *
-   * @param {Object} leftWordSet Left word-set as `{ word: BigInt }`.
-   * @param {Object} rightWordSet Right word-set as `{ word: BigInt }`.
-   * @returns {Object} Merged word-set with combined text and value.
-   */
-  mergeScales (leftWordSet, rightWordSet) {
-    const leftWord = Object.keys(leftWordSet)[0]
-    const rightWord = Object.keys(rightWordSet)[0]
-    const leftValue = Object.values(leftWordSet)[0]
-    const rightValue = Object.values(rightWordSet)[0]
-
-    // Don't merge zero with anything - just return the non-zero value
-    if (leftValue === 0n) {
-      return rightWordSet
-    }
-    if (rightValue === 0n) {
-      return leftWordSet
-    }
+  // Multi-word: add linker to last word
+  const prefix = segmentWord.slice(0, lastSpaceIdx + 1)
+  const lastWord = segmentWord.slice(lastSpaceIdx + 1)
 
-    // Implicit "one" - omit when adding with values < 100
-    if (leftValue === 1n && rightValue < 100n) {
-      return rightWordSet
-    }
+  if (lastWord.endsWith('ng')) {
+    return segmentWord // Already has linker
+  }
+  return prefix + addLinker(lastWord)
+}
 
-    // Multiply when right is a scale word AND right > left
-    // Use "ng" connector for Filipino, but consonant-ending words use " na "
-    if (rightValue > leftValue && rightValue >= 100n) {
-      // Words ending in consonants (not vowels) use " na " instead of "ng"
-      const vowels = ['a', 'e', 'i', 'o', 'u']
-      const lastChar = leftWord[leftWord.length - 1]
-      if (!vowels.includes(lastChar)) {
-        return {
-          [`${leftWord} na ${rightWord}`]: leftValue * rightValue
-        }
-      }
-      // Vowel-ending words add "ng"
-      return {
-        [`${leftWord}ng ${rightWord}`]: leftValue * rightValue
-      }
-    }
+// 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)
+}
 
-    // Special Filipino rule: certain tens words take "-ng" linker when followed by ones
-    // Only limampu (50) confirmed to use this pattern
-    if (leftValue >= 10n && leftValue < 100n && rightValue >= 1n && rightValue < 10n) {
-      const tensWithNg = ['limampu']
-      if (tensWithNg.includes(leftWord)) {
-        return {
-          [`${leftWord}ng ${rightWord}`]: leftValue + rightValue
-        }
-      }
-    }
+// ============================================================================
+// 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] || ''
 
-    // Default: space for addition
-    return {
-      [`${leftWord} ${rightWord}`]: leftValue + rightValue
+    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(' ')
 }
 
 /**
- * Convert a number to Filipino words
+ * Converts a numeric value to Filipino words.
  *
- * @param {number|string|bigint} value - The number to convert
- * @param {Object} [options={}] - Conversion options
- * @returns {string} The Filipino word representation
- * @example
- * convertToWords(42) // 'apatnapu dalawa'
- * convertToWords(1000) // 'isang libo'
- * convertToWords(123456) // 'isang daang dalawampung tatlong libong apat na daang limampung anim'
+ * @param {number | string | bigint} value - The numeric value to convert
+ * @returns {string} The number in Filipino words
  */
-export default function convertToWords (value, options = {}) {
-  return new FilipinoLanguage(options).convertToWords(value)
+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

@@ -0,0 +1,11 @@
+/**
+ * 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
+ */
+export function toWords(value: number | string | bigint, options?: {
+    withHyphenSeparator?: boolean | undefined;
+}): string;