n2words 1.24.0 → 3.0.0

package/lib/languages/lt.js

@@ -1,171 +1,310 @@
-import SlavicLanguage from '../classes/slavic-language.js'
+/**
+ * Lithuanian language converter - Functional Implementation
+ *
+ * A performance-optimized number-to-words converter using precomputed lookup tables.
+ *
+ * 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ų']
+]
+
+// ============================================================================
+// Precomputed Lookup Tables (built once at module load)
+// ============================================================================
 
 /**
- * @typedef {Object} SlavicOptions
- * @property {boolean} [feminine=false] Use feminine forms for numbers.
+ * 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(' ')
+}
 
 /**
- * Lithuanian language converter.
- *
- * Implements Lithuanian number words using the Slavic language pattern:
- * - Lithuanian number words (vienas/viena, du/dvi, trys, keturi...)
- * - Gender-aware forms (masculine/feminine)
- * - Baltic three-form pluralization (tūkstantis/tūkstančiai/tūkstančių)
- * - Lithuanian-specific declension patterns
- *
- * Key Features:
- * - Three-form pluralization system shared across Slavic/Baltic languages
- *   * Form 1 (singular): 1 (e.g., "tūkstantis")
- *   * Form 2 (few): 2-4, 22-24, 32-34... excluding teens (e.g., "tūkstančiai")
- *   * Form 3 (many): all other numbers (e.g., "tūkstančių")
- * - Chunk-based decomposition (splits into groups of 3 digits: ones, thousands, millions, etc.)
- * - Large number handling via thousands[] array with indexed [singular, few, many] forms
- * - Gender-specific number forms for 1 and 2 (masculine/feminine dual forms)
+ * 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(' ')
+}
+
+// Precompute all 1000 segment words (0-999)
+const SEGMENTS_MASC = new Array(1000)
+const SEGMENTS_FEM = new Array(1000)
+
+for (let i = 0; i < 1000; i++) {
+  SEGMENTS_MASC[i] = buildSegment(i)
+  SEGMENTS_FEM[i] = buildSegmentFeminine(i)
+}
+
+// ============================================================================
+// 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
  *
- * Features:
- * - Dual gender forms (vienas/viena, du/dvi, keturi/keturios)
- * - Complex declension patterns for large numbers
- * - Baltic language characteristics
+ * @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.
  *
- * Inherits from SlavicLanguage as Lithuanian uses similar pluralization.
+ * @param {bigint} n - Non-negative integer to convert
+ * @param {Object} options - Conversion options
+ * @returns {string} Lithuanian words
  */
-export class Lithuanian extends SlavicLanguage {
-  negativeWord = 'minus'
-  decimalSeparatorWord = 'kablelis'
-  zeroWord = 'nulis'
-  ones = {
-    1: 'vienas',
-    2: 'du',
-    3: 'trys',
-    4: 'keturi',
-    5: 'penki',
-    6: 'šeši',
-    7: 'septyni',
-    8: 'aštuoni',
-    9: 'devyni'
-  }
-
-  onesFeminine = {
-    1: 'viena',
-    2: 'dvi',
-    3: 'trys',
-    4: 'keturios',
-    5: 'penkios',
-    6: 'šešios',
-    7: 'septynios',
-    8: 'aštuonios',
-    9: 'devynios'
-  }
-
-  tens = {
-    0: 'dešimt',
-    1: 'vienuolika',
-    2: 'dvylika',
-    3: 'trylika',
-    4: 'keturiolika',
-    5: 'penkiolika',
-    6: 'šešiolika',
-    7: 'septyniolika',
-    8: 'aštuoniolika',
-    9: 'devyniolika'
-  }
-
-  twenties = {
-    2: 'dvidešimt',
-    3: 'trisdešimt',
-    4: 'keturiasdešimt',
-    5: 'penkiasdešimt',
-    6: 'šešiasdešimt',
-    7: 'septyniasdešimt',
-    8: 'aštuoniasdešimt',
-    9: 'devyniasdešimt'
-  }
-
-  hundreds = ['šimtas', 'šimtai']
-
-  thousands = {
-    1: ['tūkstantis', 'tūkstančiai', 'tūkstančių'],
-    2: ['milijonas', 'milijonai', 'milijonų'],
-    3: ['milijardas', 'milijardai', 'milijardų'],
-    4: ['trilijonas', 'trilijonai', 'trilijonų'],
-    5: ['kvadrilijonas', 'kvadrilijonai', 'kvadrilijonų'],
-    6: ['kvintilijonas', 'kvintilijonai', 'kvintilijonų'],
-    7: ['sikstilijonas', 'sikstilijonai', 'sikstilijonų'],
-    8: ['septilijonas', 'septilijonai', 'septilijonų'],
-    9: ['oktilijonas', 'oktilijonai', 'oktilijonų'],
-    10: ['naintilijonas', 'naintilijonai', 'naintilijonų']
-  }
-
-  pluralize (n, forms) {
-    if (n === 0n) {
-      return forms[2]
-    }
+function integerToWords (n, options = {}) {
+  if (n === 0n) return ZERO
 
-    const [n1, n2] = this.getDigits(n)
+  // Fast path: numbers < 1000 (direct lookup)
+  if (n < 1000n) {
+    const segments = options.gender === 'feminine' ? SEGMENTS_FEM : SEGMENTS_MASC
+    return segments[Number(n)]
+  }
 
-    if (n2 === 1n || n1 === 0n) {
-      return forms[2]
-    }
+  // 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)
+}
 
-    if (n1 === 1n) {
-      return forms[0]
-    }
+/**
+ * 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
 
-    return forms[1]
+  // 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
   }
 
-  convertWholePart (number) {
-    if (number === 0n) {
-      return this.zeroWord
-    }
-    const words = []
-    const chunks = this.splitByX(number.toString(), 3)
-    let index = chunks.length
-    for (const x of chunks) {
-      index = index - 1
-      if (x === 0n) {
-        continue
-      }
-      const [n1, n2, n3] = this.getDigits(x)
-      if (n3 > 0n) {
-        words.push(this.ones[n3])
-        if (n3 > 1n) {
-          words.push(this.hundreds[1])
-        } else {
-          words.push(this.hundreds[0])
-        }
-      }
-      if (n2 > 1n) {
-        words.push(this.twenties[n2])
-      }
-      if (n2 === 1n) {
-        words.push(this.tens[n1])
-      } else if (n1 > 0n) {
-        if ((index === 1 || (this.feminine && index === 0)) && number < 1000n) {
-          words.push(this.onesFeminine[n1])
-        } else {
-          words.push(this.ones[n1])
-        }
-      }
-      if (index > 0) {
-        words.push(this.pluralize(x, this.thousands[index]))
+  // 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 = SEGMENTS_MASC[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)
       }
     }
-    return words.join(' ')
+
+    scaleIndex--
   }
+
+  return parts.join(' ')
 }
 
 /**
- * Converts a number to Lithuanian cardinal (written) form.
+ * Converts decimal digits to Lithuanian words.
  *
- * @param {number|string|bigint} value The number to convert.
- * @param {Object} [options={}] Configuration options.
- * @param {boolean} [options.feminine=false] Use feminine forms for numbers.
- * @returns {string} The number expressed in Lithuanian words.
- * @throws {TypeError} If value is NaN or invalid type.
- * @throws {Error} If value is an invalid number string.
+ * @param {string} decimalPart - Decimal digits (without the point)
+ * @param {Object} options - Conversion options
+ * @returns {string} Lithuanian words for decimal part
  */
-export default function convertToWords (value, options = {}) {
-  return new Lithuanian(options).convertToWords(value)
+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

@@ -0,0 +1,18 @@
+/**
+ * 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;