n2words 1.23.1 → 2.0.0

package/lib/languages/fa.js

@@ -0,0 +1,144 @@
+import { AbstractLanguage } from '../classes/abstract-language.js'
+
+/**
+ * Persian language converter.
+ *
+ * Supports:
+ * - "و" (and) conjunction for compound numbers
+ * - Recursive conversion for larger numbers
+ */
+export class Persian extends AbstractLanguage {
+  negativeWord = 'منفى'
+  decimalSeparatorWord = 'ممیّز'
+  zeroWord = 'صفر'
+
+  /**
+   * Words for digits 1-9.
+   * @type {Object.<number, string>}
+   */
+  onesWords = {
+    1: 'یک',
+    2: 'دو',
+    3: 'سه',
+    4: 'چهار',
+    5: 'پنج',
+    6: 'شش',
+    7: 'هفت',
+    8: 'هشت',
+    9: 'نه'
+  }
+
+  /**
+   * Words for teen numbers (10-19).
+   * @type {Object.<number, string>}
+   */
+  teensWords = {
+    10: 'ده',
+    11: 'یازده',
+    12: 'دوازده',
+    13: 'سیزده',
+    14: 'چهارده',
+    15: 'پانزده',
+    16: 'شانزده',
+    17: 'هفده',
+    18: 'هجده',
+    19: 'نوزده'
+  }
+
+  /**
+   * Words for multiples of ten (20-90).
+   * @type {Object.<number, string>}
+   */
+  tensWords = {
+    20: 'بیست',
+    30: 'سی',
+    40: 'چهل',
+    50: 'پنجاه',
+    60: 'شصت',
+    70: 'هفتاد',
+    80: 'هشتاد',
+    90: 'نود'
+  }
+
+  /**
+   * Words for hundreds (100-900).
+   * @type {Object.<number, string>}
+   */
+  hundredsWords = {
+    100: 'صد',
+    200: 'دویست',
+    300: 'سيصد',
+    400: 'چهار صد',
+    500: 'پانصد',
+    600: 'ششصد',
+    700: 'هفتصد',
+    800: 'هشتصد',
+    900: 'نهصد'
+  }
+
+  /**
+   * Scale magnitude words.
+   * @type {Object.<number, string>}
+   */
+  scaleWords = {
+    1000: 'هزار',
+    1_000_000: 'میلیون'
+  }
+
+  /** Converts integer part using categorized word tables. */
+  integerToWords (integerPart) {
+    // Zero
+    if (integerPart === 0n) {
+      return this.zeroWord
+    }
+
+    // 1-9
+    if (integerPart <= 9n) {
+      return this.onesWords[integerPart]
+    }
+
+    // 10-19
+    if (integerPart <= 19n) {
+      return this.teensWords[integerPart]
+    }
+
+    // 20-99
+    if (integerPart < 100n) {
+      const ones = integerPart % 10n
+      const tens = integerPart - ones
+      if (ones === 0n) {
+        return this.tensWords[tens]
+      }
+      return `${this.tensWords[tens]} و ${this.onesWords[ones]}`
+    }
+
+    // 100-999
+    if (integerPart < 1000n) {
+      const hundreds = 100n * (integerPart / 100n)
+      const remainder = integerPart - hundreds
+      if (remainder === 0n) {
+        return this.hundredsWords[hundreds]
+      }
+      return `${this.hundredsWords[hundreds]} و ${this.integerToWords(remainder)}`
+    }
+
+    // 1000-999999
+    if (integerPart < 1_000_000n) {
+      const thousandMultiplier = integerPart / 1000n
+      // Persian omits "one" before thousand: 1000 is just "هزار", not "یک هزار"
+      const thousandPrefix = thousandMultiplier === 1n
+        ? ''
+        : this.integerToWords(thousandMultiplier) + ' '
+      const remainder = integerPart % 1000n
+      const suffix = remainder === 0n ? '' : ' ' + this.integerToWords(remainder)
+      return `${thousandPrefix}${this.scaleWords[1000]}${suffix}`
+    }
+
+    // 1000000+
+    const millionMultiplier = integerPart / 1_000_000n
+    const millionPrefix = this.integerToWords(millionMultiplier) + ' ' + this.scaleWords[1_000_000]
+    const remainder = integerPart % 1_000_000n
+    const suffix = remainder === 0n ? '' : ' و ' + this.integerToWords(remainder)
+    return `${millionPrefix}${suffix}`
+  }
+}

package/lib/languages/fil.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Filipino language converter.
+ *
+ * Supports:
+ * - "ng" connectors between words
+ * - Implicit "one" omission
+ * - Special linkers for certain tens (e.g., "limampung")
+ */
+export class Filipino extends GreedyScaleLanguage {
+    scaleWords: (string | bigint)[][];
+    /** Converts integer part with explicit zero handling. */
+    integerToWords(integerPart: any): string;
+    /** Combines two word-sets with Filipino connector and linker rules. */
+    combineWordSets(preceding: any, following: any): any;
+}
+import { GreedyScaleLanguage } from '../classes/greedy-scale-language.js';

package/lib/languages/fil.js

@@ -0,0 +1,121 @@
+import { GreedyScaleLanguage } from '../classes/greedy-scale-language.js'
+
+/**
+ * Filipino language converter.
+ *
+ * Supports:
+ * - "ng" connectors between words
+ * - Implicit "one" omission
+ * - Special linkers for certain tens (e.g., "limampung")
+ */
+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)
+  }
+
+  /** 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]
+
+    // Don't merge zero with anything - just return the non-zero value
+    if (precedingValue === 0n) {
+      return following
+    }
+    if (followingValue === 0n) {
+      return preceding
+    }
+
+    // Implicit "one" - omit when adding with values < 100
+    if (precedingValue === 1n && followingValue < 100n) {
+      return following
+    }
+
+    // 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
+      }
+    }
+
+    // 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
+        }
+      }
+    }
+
+    // Default: space for addition
+    return {
+      [`${precedingWord} ${followingWord}`]: precedingValue + followingValue
+    }
+  }
+}

package/lib/languages/fr-BE.d.ts

@@ -0,0 +1,11 @@
+/**
+ * French (Belgium) language converter.
+ *
+ * Supports:
+ * - Belgian regional variants: "septante" (70) and "nonante" (90)
+ * - Simplified tens naming (no complex arithmetic)
+ * - Inherits all other French grammar rules
+ */
+export class FrenchBelgium extends French {
+}
+import { French } from './fr.js';

package/lib/languages/fr-BE.js

@@ -0,0 +1,25 @@
+import { French } from './fr.js'
+
+/**
+ * French (Belgium) language converter.
+ *
+ * Supports:
+ * - Belgian regional variants: "septante" (70) and "nonante" (90)
+ * - Simplified tens naming (no complex arithmetic)
+ * - Inherits all other French grammar rules
+ */
+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
+  }
+}

package/lib/languages/fr.d.ts

@@ -0,0 +1,15 @@
+/**
+ * French language converter.
+ *
+ * Supports:
+ * - Pluralization of "cent" (hundred) and other words
+ * - "et" (and) before odd numbers in tens place
+ * - Optional hyphenation for compound numbers
+ */
+export class French extends GreedyScaleLanguage {
+    constructor(options?: {});
+    scaleWords: (string | bigint)[][];
+    /** Combines two word-sets with French pluralization and hyphenation rules. */
+    combineWordSets(preceding: any, following: any): any;
+}
+import { GreedyScaleLanguage } from '../classes/greedy-scale-language.js';

package/lib/languages/fr.js

@@ -0,0 +1,106 @@
+import { GreedyScaleLanguage } from '../classes/greedy-scale-language.js'
+
+/**
+ * French language converter.
+ *
+ * Supports:
+ * - Pluralization of "cent" (hundred) and other words
+ * - "et" (and) before odd numbers in tens place
+ * - Optional hyphenation for compound numbers
+ */
+export class French extends GreedyScaleLanguage {
+  negativeWord = 'moins'
+  decimalSeparatorWord = 'virgule'
+  zeroWord = 'zéro'
+
+  scaleWords = [
+    [1_000_000_000_000_000_000_000_000_000n, 'quadrilliard'],
+    [1_000_000_000_000_000_000_000_000n, 'quadrillion'],
+    [1_000_000_000_000_000_000_000n, 'trilliard'],
+    [1_000_000_000_000_000_000n, 'trillion'],
+    [1_000_000_000_000_000n, 'billiard'],
+    [1_000_000_000_000n, 'billion'],
+    [1_000_000_000n, 'milliard'],
+    [1_000_000n, 'million'],
+    [1000n, 'mille'],
+    [100n, 'cent'],
+    [80n, 'quatre-vingts'],
+    [60n, 'soixante'],
+    [50n, 'cinquante'],
+    [40n, 'quarante'],
+    [30n, 'trente'],
+    [20n, 'vingt'],
+    [19n, 'dix-neuf'],
+    [18n, 'dix-huit'],
+    [17n, 'dix-sept'],
+    [16n, 'seize'],
+    [15n, 'quinze'],
+    [14n, 'quatorze'],
+    [13n, 'treize'],
+    [12n, 'douze'],
+    [11n, 'onze'],
+    [10n, 'dix'],
+    [9n, 'neuf'],
+    [8n, 'huit'],
+    [7n, 'sept'],
+    [6n, 'six'],
+    [5n, 'cinq'],
+    [4n, 'quatre'],
+    [3n, 'trois'],
+    [2n, 'deux'],
+    [1n, 'un'],
+    [0n, 'zéro']
+  ]
+
+  constructor (options = {}) {
+    super()
+
+    this.setOptions({
+      withHyphenSeparator: false
+    }, options)
+
+    if (options.withHyphenSeparator) {
+      this.wordSeparator = '-'
+    }
+  }
+
+  /** Combines two word-sets with French pluralization and hyphenation rules. */
+  combineWordSets (preceding, following) {
+    let precedingWord = Object.keys(preceding)[0]
+    let followingWord = Object.keys(following)[0]
+    const precedingValue = Object.values(preceding)[0]
+    const followingValue = Object.values(following)[0]
+
+    if (precedingValue === 1n) {
+      if (followingValue < 1_000_000n) {
+        return following
+      }
+    } else {
+      if (
+        ((precedingValue - 80n) % 100n === 0n || (precedingValue % 100n === 0n && precedingValue < 1000n)) &&
+        followingValue < 1_000_000n &&
+        precedingWord.at(-1) === 's'
+      ) {
+        precedingWord = precedingWord.slice(0, -1)
+      }
+
+      if (
+        precedingValue < 1000n && followingValue !== 1000n &&
+        followingWord.at(-1) !== 's' &&
+        followingValue % 100n === 0n
+      ) {
+        followingWord += 's'
+      }
+    }
+
+    if (followingValue < precedingValue && precedingValue < 100n) {
+      if (followingValue % 10n === 1n && precedingValue !== 80n) {
+        return { [`${precedingWord}${this.wordSeparator}et${this.wordSeparator}${followingWord}`]: precedingValue + followingValue }
+      }
+      return { [`${precedingWord}-${followingWord}`]: precedingValue + followingValue }
+    }
+
+    if (followingValue > precedingValue) return { [`${precedingWord}${this.wordSeparator}${followingWord}`]: precedingValue * followingValue }
+    return { [`${precedingWord}${this.wordSeparator}${followingWord}`]: precedingValue + followingValue }
+  }
+}

package/lib/languages/gu.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Gujarati language converter.
+ *
+ * Supports:
+ * - Indian numbering system (હજાર, લાખ, કરોડ)
+ * - Gujarati script
+ * - Complete word forms for 0-99
+ */
+export class Gujarati extends SouthAsianLanguage {
+}
+import { SouthAsianLanguage } from '../classes/south-asian-language.js';

package/lib/languages/gu.js

@@ -0,0 +1,132 @@
+import { SouthAsianLanguage } from '../classes/south-asian-language.js'
+
+/**
+ * Gujarati language converter.
+ *
+ * Supports:
+ * - Indian numbering system (હજાર, લાખ, કરોડ)
+ * - Gujarati script
+ * - Complete word forms for 0-99
+ */
+export class Gujarati extends SouthAsianLanguage {
+  negativeWord = 'ઋણ'
+  decimalSeparatorWord = 'દશાંશ'
+  zeroWord = 'શૂન્ય'
+  hundredWord = 'સો'
+  usePerDigitDecimals = true
+
+  belowHundredWords = [
+    'શૂન્ય',
+    'એક',
+    'બે',
+    'ત્રણ',
+    'ચાર',
+    'પાંચ',
+    'છ',
+    'સાત',
+    'આઠ',
+    'નવ',
+    'દસ',
+    'અગિયાર',
+    'બાર',
+    'તેર',
+    'ચૌદ',
+    'પંદર',
+    'સોળ',
+    'સત્તર',
+    'અઢાર',
+    'ઓગણીસ',
+    'વીસ',
+    'એકવીસ',
+    'બાવીસ',
+    'ત્રેવીસ',
+    'ચોવીસ',
+    'પચીસ',
+    'છવ્વીસ',
+    'સત્તાવીસ',
+    'અઠ્ઠાવીસ',
+    'ઓગણત્રીસ',
+    'ત્રીસ',
+    'એકત્રીસ',
+    'બત્રીસ',
+    'તેત્રીસ',
+    'ચોત્રીસ',
+    'પાંત્રીસ',
+    'છત્રીસ',
+    'સાડત્રીસ',
+    'અડત્રીસ',
+    'ઓગણચાલીસ',
+    'ચાલીસ',
+    'એકતાલીસ',
+    'બેતાળીસ',
+    'ત્રેતાળીસ',
+    'ચુંમાલીસ',
+    'પિસ્તાલીસ',
+    'છેતાળીસ',
+    'સુડતાળીસ',
+    'અડતાળીસ',
+    'ઓગણપચાસ',
+    'પચાસ',
+    'એકાવન',
+    'બાવન',
+    'ત્રેપન',
+    'ચોપન',
+    'પંચાવન',
+    'છપ્પન',
+    'સત્તાવન',
+    'અઠ્ઠાવન',
+    'ઓગણસાઠ',
+    'સાઠ',
+    'એકસઠ',
+    'બાસઠ',
+    'ત્રેસઠ',
+    'ચોસઠ',
+    'પાંસઠ',
+    'છાસઠ',
+    'સડસઠ',
+    'અડસઠ',
+    'અગણોસિત્તેર',
+    'સિત્તેર',
+    'એકોતેર',
+    'બોતેર',
+    'તોતેર',
+    'ચુમોતેર',
+    'પંચોતેર',
+    'છોતેર',
+    'સિત્યોતેર',
+    'ઇઠ્યોતેર',
+    'ઓગણાએંસી',
+    'એંસી',
+    'એક્યાસી',
+    'બ્યાસી',
+    'ત્યાસી',
+    'ચોર્યાસી',
+    'પંચાસી',
+    'છ્યાસી',
+    'સિત્યાસી',
+    'અઠ્યાસી',
+    'નેવ્યાસી',
+    'નેવું',
+    'એકાણું',
+    'બાણું',
+    'ત્રાણું',
+    'ચોરાણું',
+    'પંચાણું',
+    'છન્નું',
+    'સત્તાણું',
+    'અઠ્ઠાણું',
+    'નવ્વાણું'
+  ]
+
+  scaleWords = [
+    '',
+    'હજાર',
+    'લાખ',
+    'કરોડ',
+    'અબજ',
+    'ખરબ',
+    'નીલ',
+    'પદ્મ',
+    'શંખ'
+  ]
+}

package/lib/languages/hbo.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Biblical Hebrew language converter.
+ *
+ * Supports:
+ * - Three-form pluralization (one/few/many)
+ * - Gender agreement (masculine/feminine)
+ * - Optional "ו" (and) conjunction control
+ */
+export class BiblicalHebrew extends SlavicLanguage {
+    constructor(options?: {});
+    onesWords: {
+        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;
+    };
+    pluralForms: {
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    femininePluralForms: {
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    scale: {
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+    };
+    scalePlural: {
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+    };
+    onesFeminineWords: {
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    teensFeminineWords: {
+        0: string;
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    /** Converts integer part with Biblical Hebrew three-form pluralization. */
+    integerToWords(integerPart: any): string;
+}
+import { SlavicLanguage } from '../classes/slavic-language.js';