n2words 1.23.1 → 2.0.0

package/lib/languages/ar.js

@@ -0,0 +1,159 @@
+import { AbstractLanguage } from '../classes/abstract-language.js'
+
+/**
+ * Arabic language converter.
+ *
+ * Supports:
+ * - Gender agreement (masculine/feminine forms)
+ * - Complex pluralization (singular/dual/plural)
+ * - Traditional Arabic number naming conventions
+ * - Right-to-left text orientation
+ */
+export class Arabic extends AbstractLanguage {
+  negativeWord = 'ناقص'
+  decimalSeparatorWord = 'فاصلة'
+  zeroWord = 'صفر'
+
+  tensWords = ['عشرون', 'ثلاثون', 'أربعون', 'خمسون', 'ستون', 'سبعون', 'ثمانون', 'تسعون']
+  hundredsWords = ['', 'مائة', 'مئتان', 'ثلاثمائة', 'أربعمائة', 'خمسمائة', 'ستمائة', 'سبعمائة', 'ثمانمائة', 'تسعمائة']
+
+  // Magnitude words with three forms: singular, appended (tanween), plural
+  scaleWords = ['مائة', 'ألف', 'مليون', 'مليار', 'تريليون', 'كوادريليون', 'كوينتليون', 'سكستيليون']
+  scaleAppendedWords = ['', 'ألفاً', 'مليوناً', 'ملياراً', 'تريليوناً', 'كوادريليوناً', 'كوينتليوناً', 'سكستيليوناً']
+  scalePluralWords = ['', 'آلاف', 'ملايين', 'مليارات', 'تريليونات', 'كوادريليونات', 'كوينتليونات', 'سكستيليونات']
+
+  // Dual forms (Arabic has singular, dual, plural)
+  dualWords = ['مئتان', 'ألفان', 'مليونان', 'ملياران', 'تريليونان', 'كوادريليونان', 'كوينتليونان', 'سكستيليونان']
+  dualAppendedWords = ['مئتا', 'ألفا', 'مليونا', 'مليارا', 'تريليونا', 'كوادريليونا', 'كوينتليونا', 'سكستيليونا']
+
+  // Gender-specific number words (1-19)
+  ones = {
+    masculine: [
+      'واحد', 'اثنان', 'ثلاثة', 'أربعة', 'خمسة', 'ستة', 'سبعة', 'ثمانية', 'تسعة', 'عشرة',
+      'أحد عشر', 'اثنا عشر', 'ثلاثة عشر', 'أربعة عشر', 'خمسة عشر', 'ستة عشر', 'سبعة عشر', 'ثمانية عشر', 'تسعة عشر'
+    ],
+    feminine: [
+      'واحدة', 'اثنتان', 'ثلاث', 'أربع', 'خمس', 'ست', 'سبع', 'ثمان', 'تسع', 'عشر',
+      'إحدى عشرة', 'اثنتا عشرة', 'ثلاث عشرة', 'أربع عشرة', 'خمس عشرة', 'ست عشرة', 'سبع عشرة', 'ثماني عشرة', 'تسع عشرة'
+    ]
+  }
+
+  constructor (options = {}) {
+    super()
+
+    this.setOptions({
+      gender: 'masculine'
+    }, options)
+
+    // Allow custom negativeWord via options
+    if (options.negativeWord !== undefined) {
+      this.negativeWord = options.negativeWord
+    }
+  }
+
+  /** Selects masculine or feminine number forms based on options. */
+  get selectedOnes () {
+    return this.ones[this.options.gender === 'feminine' ? 'feminine' : 'masculine']
+  }
+
+  /** Converts a 3-digit segment (0-999) to Arabic words with gender/plural rules. */
+  segmentToWords (groupNumber, groupLevel, fullNumber) {
+    const tens = groupNumber % 100
+    const hundredsRaw = groupNumber / 100
+    const hundreds = Math.trunc(hundredsRaw)
+    let returnValue = ''
+
+    // Process hundreds
+    if (hundreds > 0) {
+      if (tens === 0 && hundreds === 2) {
+        returnValue = this.dualWords[0]
+      } else {
+        const hundredsWord = this.hundredsWords[hundreds]
+        if (hundredsWord) {
+          returnValue = hundredsWord
+          if (tens !== 0) {
+            returnValue += ' و'
+          }
+        }
+      }
+    }
+
+    // Process tens and ones
+    if (tens > 0) {
+      if (tens < 20) { // 1 -> 19
+        if (tens === 2 && hundreds === 0 && groupLevel > 0) {
+          // Cache expensive log10 calculation
+          const numValue = Number(fullNumber)
+          const pow = Math.trunc(Math.log10(numValue))
+          if (pow % 3 === 0 && fullNumber === BigInt(2 * Math.pow(10, pow))) {
+            returnValue = groupNumber === 2 ? this.dualWords[groupLevel] : this.dualAppendedWords[groupLevel]
+          } else {
+            returnValue = this.dualWords[groupLevel]
+          }
+        } else if (tens === 1 && groupLevel > 0) {
+          returnValue += this.scaleWords[groupLevel]
+        } else {
+          returnValue += this.selectedOnes[tens - 1]
+        }
+      } else { // 20 -> 99
+        const ones = tens % 10
+        const tensIndex = Math.trunc(tens / 10) - 2
+
+        if (ones > 0) {
+          returnValue += this.selectedOnes[ones - 1]
+          returnValue += ' و'
+        }
+        returnValue += this.tensWords[tensIndex]
+      }
+    }
+
+    return returnValue
+  }
+
+  /** Converts integer part to Arabic words by processing 3-digit groups. */
+  integerToWords (integerPart) {
+    if (integerPart === 0n) {
+      return this.zeroWord
+    }
+    let temp = integerPart
+    let group = 0
+    let result = ''
+
+    // Process each group of 3 digits (right to left)
+    while (temp > 0n) {
+      const numberToProcess = Number(temp % 1000n)
+      temp = temp / 1000n
+
+      if (numberToProcess > 0) {
+        const groupDescription = this.segmentToWords(numberToProcess, group, integerPart)
+
+        if (groupDescription) {
+          // Add group name for thousands, millions, etc.
+          if (group > 0) {
+            if (result) {
+              result = ' و' + result
+            }
+
+            if (numberToProcess > 2) {
+              const remainder = numberToProcess % 100
+              if (remainder === 1) {
+                result = this.scaleWords[group] + ' ' + result
+              } else if (numberToProcess >= 3 && numberToProcess <= 10) {
+                result = this.scalePluralWords[group] + ' ' + result
+              } else {
+                result = (result ? this.scaleAppendedWords[group] : this.scaleWords[group]) + ' ' + result
+              }
+            }
+          }
+
+          // Add group description (prepend for RTL)
+          result = groupDescription + ' ' + result
+        }
+      }
+
+      group++
+    }
+
+    return result.replace(/\s+/g, ' ').trim()
+  }
+}

package/lib/languages/az.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Azerbaijani language converter.
+ *
+ * Supports:
+ * - Implicit "bir" (one) omission before hundreds and thousands
+ * - Turkic language number patterns
+ * - Large numbers up to quintillion
+ */
+export class Azerbaijani extends TurkicLanguage {
+    scaleWords: (string | bigint)[][];
+}
+import { TurkicLanguage } from '../classes/turkic-language.js';

package/lib/languages/az.js

@@ -0,0 +1,42 @@
+import { TurkicLanguage } from '../classes/turkic-language.js'
+
+/**
+ * Azerbaijani language converter.
+ *
+ * Supports:
+ * - Implicit "bir" (one) omission before hundreds and thousands
+ * - Turkic language number patterns
+ * - Large numbers up to quintillion
+ */
+export class Azerbaijani extends TurkicLanguage {
+  negativeWord = 'mənfi'
+  decimalSeparatorWord = 'nöqtə'
+  zeroWord = 'sıfır'
+
+  scaleWords = [[1_000_000_000_000_000_000n, 'kentilyon'],
+    [1_000_000_000_000_000n, 'katrilyon'],
+    [1_000_000_000_000n, 'trilyon'],
+    [1_000_000_000n, 'milyar'],
+    [1_000_000n, 'milyon'],
+    [1000n, 'min'],
+    [100n, 'yüz'],
+    [90n, 'doxsan'],
+    [80n, 'səksən'],
+    [70n, 'yetmiş'],
+    [60n, 'altmış'],
+    [50n, 'əlli'],
+    [40n, 'qırx'],
+    [30n, 'otuz'],
+    [20n, 'iyirmi'],
+    [10n, 'on'],
+    [9n, 'doqquz'],
+    [8n, 'səkkiz'],
+    [7n, 'yeddi'],
+    [6n, 'altı'],
+    [5n, 'beş'],
+    [4n, 'dörd'],
+    [3n, 'üç'],
+    [2n, 'iki'],
+    [1n, 'bir'],
+    [0n, 'sıfır']]
+}

package/lib/languages/bn.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Bangla language converter.
+ *
+ * Supports:
+ * - Indian numbering system (হাজার, লাখ, কোটি)
+ * - Bangla script (Bengali)
+ * - Complete word forms for 0-99
+ */
+export class Bangla extends SouthAsianLanguage {
+}
+import { SouthAsianLanguage } from '../classes/south-asian-language.js';

package/lib/languages/bn.js

@@ -0,0 +1,131 @@
+import { SouthAsianLanguage } from '../classes/south-asian-language.js'
+
+/**
+ * Bangla language converter.
+ *
+ * Supports:
+ * - Indian numbering system (হাজার, লাখ, কোটি)
+ * - Bangla script (Bengali)
+ * - Complete word forms for 0-99
+ */
+export class Bangla extends SouthAsianLanguage {
+  negativeWord = 'মাইনাস'
+  decimalSeparatorWord = 'দশমিক'
+  zeroWord = 'শূন্য'
+  hundredWord = 'শত'
+
+  belowHundredWords = [
+    'শূন্য',
+    'এক',
+    'দুই',
+    'তিন',
+    'চার',
+    'পাঁচ',
+    'ছয়',
+    'সাত',
+    'আট',
+    'নয়',
+    'দশ',
+    'এগারো',
+    'বারো',
+    'তেরো',
+    'চৌদ্দ',
+    'পনেরো',
+    'ষোল',
+    'সতেরো',
+    'আঠারো',
+    'উনিশ',
+    'বিশ',
+    'একুশ',
+    'বাইশ',
+    'তেইশ',
+    'চব্বিশ',
+    'পঁচিশ',
+    'ছাব্বিশ',
+    'সাতাশ',
+    'আঠাশ',
+    'উনত্রিশ',
+    'ত্রিশ',
+    'একত্রিশ',
+    'বত্রিশ',
+    'তেত্রিশ',
+    'চৌত্রিশ',
+    'পঁয়ত্রিশ',
+    'ছত্রিশ',
+    'সাঁইত্রিশ',
+    'আটত্রিশ',
+    'উনচল্লিশ',
+    'চল্লিশ',
+    'একচল্লিশ',
+    'বেয়াল্লিশ',
+    'তেতাল্লিশ',
+    'চুয়াল্লিশ',
+    'পঁয়তাল্লিশ',
+    'ছেচল্লিশ',
+    'সাতচল্লিশ',
+    'আটচল্লিশ',
+    'উনপঞ্চাশ',
+    'পঞ্চাশ',
+    'একান্ন',
+    'বাহান্ন',
+    'তিপ্পান্ন',
+    'চুয়ান্ন',
+    'পঞ্চান্ন',
+    'ছাপ্পান্ন',
+    'সাতান্ন',
+    'আটান্ন',
+    'উনষাট',
+    'ষাট',
+    'একষট্টি',
+    'বাষট্টি',
+    'তেষট্টি',
+    'চৌষট্টি',
+    'পঁয়ষট্টি',
+    'ছেষট্টি',
+    'সাতষট্টি',
+    'আটষট্টি',
+    'ঊনসত্তর',
+    'সত্তর',
+    'একাত্তর',
+    'বাহাত্তর',
+    'তেহাত্তর',
+    'চুয়াত্তর',
+    'পঁচাত্তর',
+    'ছিয়াত্তর',
+    'সাতাত্তর',
+    'আটাত্তর',
+    'উনআশি',
+    'আশি',
+    'একাশি',
+    'বিরাশি',
+    'তিরাশি',
+    'চুরাশি',
+    'পঁচাশি',
+    'ছিয়াশি',
+    'সাতাশি',
+    'আটাশি',
+    'উননব্বই',
+    'নব্বই',
+    'একানব্বই',
+    'বিরানব্বই',
+    'তিরানব্বই',
+    'চুরানব্বই',
+    'পঁচানব্বই',
+    'ছিয়ানব্বই',
+    'সাতানব্বই',
+    'আটানব্বই',
+    'নিরানব্বই'
+  ]
+
+  scaleWords = [
+    '',
+    'হাজার',
+    'লাখ',
+    'কোটি',
+    'আরব',
+    'খরব',
+    'নীল',
+    'পদ্ম',
+    'শঙ্খ'
+  ]
+}

package/lib/languages/cs.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Czech language converter.
+ *
+ * Supports:
+ * - Three-form pluralization (one/few/many)
+ * - Dynamic decimal separator (celá/celé/celých)
+ * - Gender agreement in number words
+ */
+export class Czech extends SlavicLanguage {
+    constructor(options?: {});
+    onesWords: {
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    onesFeminineWords: {
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    teensWords: {
+        0: string;
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    twentiesWords: {
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    hundredsWords: {
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    pluralForms: {
+        1: string[];
+        2: string[];
+        3: string[];
+        4: string[];
+        5: string[];
+        6: string[];
+        7: string[];
+        8: string[];
+        9: string[];
+        10: string[];
+    };
+    /** Returns decimal separator word based on integer part (celá/celé/celých). */
+    get decimalSeparatorWord(): "celá" | "celé" | "celých";
+    /**
+     * Override toWords to cache integer part before decimal separator is accessed.
+     */
+    toWords(isNegative: any, integerPart: any, decimalPart: any): string;
+    /** Selects Czech plural form: 1 = singular, 2-4 = few, else = many. */
+    pluralize(n: any, forms: any): any;
+    #private;
+}
+import { SlavicLanguage } from '../classes/slavic-language.js';

package/lib/languages/cs.js

@@ -0,0 +1,143 @@
+import { SlavicLanguage } from '../classes/slavic-language.js'
+
+/**
+ * Czech language converter.
+ *
+ * Supports:
+ * - Three-form pluralization (one/few/many)
+ * - Dynamic decimal separator (celá/celé/celých)
+ * - Gender agreement in number words
+ */
+export class Czech extends SlavicLanguage {
+  negativeWord = 'mínus'
+  zeroWord = 'nula'
+
+  onesWords = {
+    1: 'jedna',
+    2: 'dva',
+    3: 'tři',
+    4: 'čtyři',
+    5: 'pět',
+    6: 'šest',
+    7: 'sedm',
+    8: 'osm',
+    9: 'devět'
+  }
+
+  onesFeminineWords = {
+    1: 'jedna',
+    2: 'dvě',
+    3: 'tři',
+    4: 'čtyři',
+    5: 'pět',
+    6: 'šest',
+    7: 'sedm',
+    8: 'osm',
+    9: 'devět'
+  }
+
+  teensWords = {
+    0: 'deset',
+    1: 'jedenáct',
+    2: 'dvanáct',
+    3: 'třináct',
+    4: 'čtrnáct',
+    5: 'patnáct',
+    6: 'šestnáct',
+    7: 'sedmnáct',
+    8: 'osmnáct',
+    9: 'devatenáct'
+  }
+
+  twentiesWords = {
+    2: 'dvacet',
+    3: 'třicet',
+    4: 'čtyřicet',
+    5: 'padesát',
+    6: 'šedesát',
+    7: 'sedmdesát',
+    8: 'osmdesát',
+    9: 'devadesát'
+  }
+
+  hundredsWords = {
+    1: 'sto',
+    2: 'dvě stě',
+    3: 'tři sta',
+    4: 'čtyři sta',
+    5: 'pět set',
+    6: 'šest set',
+    7: 'sedm set',
+    8: 'osm set',
+    9: 'devět set'
+  }
+
+  pluralForms = {
+    1: ['tisíc', 'tisíce', 'tisíc'], // 10^ 3
+    2: ['milion', 'miliony', 'milionů'], // 10^ 6
+    3: ['miliarda', 'miliardy', 'miliard'], // 10^ 9
+    4: ['bilion', 'biliony', 'bilionů'], // 10^ 12
+    5: ['biliarda', 'biliardy', 'biliard'], // 10^ 15
+    6: ['trilion', 'triliony', 'trilionů'], // 10^ 18
+    7: ['triliarda', 'triliardy', 'triliard'], // 10^ 21
+    8: ['kvadrilion', 'kvadriliony', 'kvadrilionů'], // 10^ 24
+    9: ['kvadriliarda', 'kvadriliardy', 'kvadriliard'], // 10^ 27
+    10: ['quintillion', 'quintilliony', 'quintillionů'] // 10^ 30
+  }
+
+  /**
+   * Czech omits "one" before scale words.
+   * e.g., 1000 is "tisíc" not "jedna tisíc"
+   */
+  omitOneBeforeScale = true
+
+  /**
+   * Cached integer part for decimal separator word selection.
+   * Set by toWords() before calling super.toWords().
+   * @private
+   */
+  #integerPart = 0n
+
+  /** Returns decimal separator word based on integer part (celá/celé/celých). */
+  get decimalSeparatorWord () {
+    if (this.#integerPart === 0n || this.#integerPart === 1n) {
+      return 'celá'
+    } else if (this.#integerPart >= 2n && this.#integerPart <= 4n) {
+      return 'celé'
+    } else {
+      return 'celých'
+    }
+  }
+
+  constructor (options = {}) {
+    super(options)
+
+    // Remove the inherited decimalSeparatorWord property so our getter works
+    delete this.decimalSeparatorWord
+  }
+
+  /**
+   * Override toWords to cache integer part before decimal separator is accessed.
+   */
+  toWords (isNegative, integerPart, decimalPart) {
+    this.#integerPart = integerPart
+    return super.toWords(isNegative, integerPart, decimalPart)
+  }
+
+  /** Selects Czech plural form: 1 = singular, 2-4 = few, else = many. */
+  pluralize (n, forms) {
+    if (n === 1n) {
+      return forms[0]
+    }
+
+    // Check if n is in the "few" form range (2-4, 22-24, 32-34, etc., excluding teens)
+    const lastDigit = n % 10n
+    const lastTwoDigits = n % 100n
+
+    if (lastDigit > 1n && lastDigit < 5n && (lastTwoDigits < 10n || lastTwoDigits > 20n)) {
+      return forms[1]
+    }
+
+    return forms[2]
+  }
+}

package/lib/languages/da.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Danish language converter.
+ *
+ * Supports:
+ * - Vigesimal (base-20) number system
+ * - Units-before-tens ordering (e.g., "tre-og-tyve" = 23)
+ * - Optional ordinal numbers via ordFlag option
+ */
+export class Danish extends GreedyScaleLanguage {
+    constructor(options?: {});
+    scaleWords: (string | bigint)[][];
+    /** Combines two word-sets with Danish vigesimal and reversal rules. */
+    combineWordSets(preceding: any, following: any): any;
+}
+import { GreedyScaleLanguage } from '../classes/greedy-scale-language.js';