n2words 1.23.1 → 2.0.0

package/lib/languages/da.js

@@ -0,0 +1,120 @@
+import { GreedyScaleLanguage } from '../classes/greedy-scale-language.js'
+
+/**
+ * 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 {
+  negativeWord = 'minus'
+  decimalSeparatorWord = 'komma'
+  zeroWord = 'nul'
+
+  scaleWords = [
+    [1_000_000_000_000_000_000_000_000_000n, 'quadrillarder'],
+    [1_000_000_000_000_000_000_000_000n, 'quadrillioner'],
+    [1_000_000_000_000_000_000_000n, 'trillarder'],
+    [1_000_000_000_000_000_000n, 'trillioner'],
+    [1_000_000_000_000_000n, 'billarder'],
+    [1_000_000_000_000n, 'billioner'],
+    [1_000_000_000n, 'millarder'],
+    [1_000_000n, 'millioner'],
+    [1000n, 'tusind'],
+    [100n, 'hundrede'],
+    [90n, 'halvfems'],
+    [80n, 'firs'],
+    [70n, 'halvfjerds'],
+    [60n, 'treds'],
+    [50n, 'halvtreds'],
+    [40n, 'fyrre'],
+    [30n, 'tredive'],
+    [20n, 'tyve'],
+    [19n, 'nitten'],
+    [18n, 'atten'],
+    [17n, 'sytten'],
+    [16n, 'seksten'],
+    [15n, 'femten'],
+    [14n, 'fjorten'],
+    [13n, 'tretten'],
+    [12n, 'tolv'],
+    [11n, 'elleve'],
+    [10n, 'ti'],
+    [9n, 'ni'],
+    [8n, 'otte'],
+    [7n, 'syv'],
+    [6n, 'seks'],
+    [5n, 'fem'],
+    [4n, 'fire'],
+    [3n, 'tre'],
+    [2n, 'to'],
+    [1n, 'et'],
+    [0n, 'nul']
+  ]
+
+  constructor (options = {}) {
+    super()
+
+    this.setOptions({
+      ordFlag: false
+    }, options)
+  }
+
+  /** Combines two word-sets with Danish vigesimal and reversal rules. */
+  combineWordSets (preceding, following) {
+    let precedingWord = Object.keys(preceding)[0]
+    let followingWord = Object.keys(following)[0]
+    const precedingValue = Object.values(preceding)[0] // BigInt (e.g., 1n, 100n, 1000n)
+    const followingValue = Object.values(following)[0] // BigInt (e.g., magnitude level like 100n, 1000n)
+
+    // Prepend "et" to hundreds and thousands (not "en") for proper Danish form
+    if (followingValue === 100n || followingValue === 1000n) {
+      following = { [`et${followingWord}`]: followingValue }
+    }
+
+    // Implicit '1' handling: omit '1' before most magnitudes (except millions/ordinals)
+    if (precedingValue === 1n) {
+      if (followingValue < 1_000_000n || this.options.ordFlag) {
+        return following // Just the magnitude word (e.g., "hundrede" not "en hundrede")
+      }
+      precedingWord = 'en' // Explicit "en" (one) for millions and above
+    }
+
+    // Multiplication across magnitude boundaries
+    if (followingValue > precedingValue) {
+      // Space for million+ (e.g., "en million", "to millioner")
+      if (followingValue >= 1_000_000n) {
+        precedingWord += ' '
+      }
+      return { [`${precedingWord}${followingWord}`]: precedingValue * followingValue }
+    }
+
+    // Addition with separator rules:
+    // "og" (and) for hundreds + smaller numbers
+    if (precedingValue >= 100n && precedingValue < 1000n) {
+      precedingWord += ' og '
+    } else if (precedingValue >= 1000n && precedingValue <= 100_000n) {
+      // Special "e og" for thousands (e.g., "tusinde og tyve")
+      precedingWord += 'e og '
+    }
+
+    // Units-before-tens reversal (Danish vigesimal pattern):
+    // For small units (< 10) with tens (10-99), swap order: "tre og tyve" (25)
+    if (followingValue < 10n && precedingValue > 10n && precedingValue < 100n) {
+      if (followingValue === 1n) {
+        followingWord = 'en' // Convert 1 to "en" for vigesimal context
+      }
+      // Swap positions: units go after "og", tens go before
+      const temporary = followingWord
+      followingWord = precedingWord
+      precedingWord = temporary + 'og'
+    } else if (precedingValue >= 1_000_000n) {
+      // Space for large magnitudes (millions+)
+      precedingWord += ' '
+    }
+
+    return { [`${precedingWord}${followingWord}`]: precedingValue + followingValue }
+  }
+}

package/lib/languages/de.d.ts

@@ -0,0 +1,14 @@
+/**
+ * German language converter.
+ *
+ * Supports:
+ * - Compound formation (no separators between words)
+ * - Three forms of 1 (eins/ein/eine)
+ * - Units-before-tens ordering (einundzwanzig = one and twenty)
+ */
+export class German extends GreedyScaleLanguage {
+    scaleWords: (string | bigint)[][];
+    /** Combines two word-sets with German compound formation and reversal rules. */
+    combineWordSets(preceding: any, following: any): any;
+}
+import { GreedyScaleLanguage } from '../classes/greedy-scale-language.js';

package/lib/languages/de.js

@@ -0,0 +1,101 @@
+import { GreedyScaleLanguage } from '../classes/greedy-scale-language.js'
+
+/**
+ * German language converter.
+ *
+ * Supports:
+ * - Compound formation (no separators between words)
+ * - Three forms of 1 (eins/ein/eine)
+ * - Units-before-tens ordering (einundzwanzig = one and twenty)
+ */
+export class German extends GreedyScaleLanguage {
+  negativeWord = 'minus'
+  decimalSeparatorWord = 'komma'
+  zeroWord = 'null'
+
+  scaleWords = [
+    [1_000_000_000_000_000_000_000_000_000n, 'Quadrilliarde'],
+    [1_000_000_000_000_000_000_000_000n, 'Quadrillion'],
+    [1_000_000_000_000_000_000_000n, 'Trilliarde'],
+    [1_000_000_000_000_000_000n, 'Trillion'],
+    [1_000_000_000_000_000n, 'Billiarde'],
+    [1_000_000_000_000n, 'Billion'],
+    [1_000_000_000n, 'Milliarde'],
+    [1_000_000n, 'Million'],
+    [1000n, 'tausend'],
+    [100n, 'hundert'],
+    [90n, 'neunzig'],
+    [80n, 'achtzig'],
+    [70n, 'siebzig'],
+    [60n, 'sechzig'],
+    [50n, 'fünfzig'],
+    [40n, 'vierzig'],
+    [30n, 'dreißig'],
+    [20n, 'zwanzig'],
+    [19n, 'neunzehn'],
+    [18n, 'achtzehn'],
+    [17n, 'siebzehn'],
+    [16n, 'sechzehn'],
+    [15n, 'fünfzehn'],
+    [14n, 'vierzehn'],
+    [13n, 'dreizehn'],
+    [12n, 'zwölf'],
+    [11n, 'elf'],
+    [10n, 'zehn'],
+    [9n, 'neun'],
+    [8n, 'acht'],
+    [7n, 'sieben'],
+    [6n, 'sechs'],
+    [5n, 'fünf'],
+    [4n, 'vier'],
+    [3n, 'drei'],
+    [2n, 'zwei'],
+    [1n, 'eins'],
+    [0n, 'null']
+  ]
+
+  /** Combines two word-sets with German compound formation and reversal 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]
+
+    // Handle form of 1: "eins" → "ein(e)" in certain contexts
+    if (precedingValue === 1n) {
+      if (followingValue === 100n || followingValue === 1000n) {
+        return { [`ein${followingWord}`]: followingValue }
+      }
+      if (followingValue < 1_000_000n) {
+        return following
+      }
+      precedingWord = 'eine'
+    }
+
+    if (followingValue > precedingValue) {
+      // Multiply: apply pluralization rules for millions
+      if (followingValue >= 1_000_000n) {
+        if (precedingValue > 1n) {
+          followingWord += followingWord.at(-1) === 'e' ? 'n' : 'en'
+        }
+        precedingWord += ' '
+      }
+      return { [`${precedingWord}${followingWord}`]: precedingValue * followingValue }
+    }
+
+    // Add: handle special case of tens + units
+    if (followingValue < 10n && precedingValue > 10n && precedingValue < 100n) {
+      // German reverses tens and units (einundzwanzig = one and twenty)
+      if (followingValue === 1n) {
+        followingWord = 'ein'
+      }
+      const temp = followingWord
+      followingWord = precedingWord
+      precedingWord = `${temp}und`
+    } else if (precedingValue >= 1_000_000n) {
+      precedingWord += ' '
+    }
+
+    return { [`${precedingWord}${followingWord}`]: precedingValue + followingValue }
+  }
+}

package/lib/languages/el.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Greek language converter.
+ *
+ * Supports:
+ * - Space-separated number composition
+ * - Implicit "one" (ένα) omission before scale words
+ * - Digit-by-digit decimal reading
+ */
+export class Greek extends GreedyScaleLanguage {
+    scaleWords: (string | bigint)[][];
+    /** Combines two word-sets with Greek space-separation rules. */
+    combineWordSets(preceding: any, following: any): any;
+}
+import { GreedyScaleLanguage } from '../classes/greedy-scale-language.js';

package/lib/languages/el.js

@@ -0,0 +1,90 @@
+import { GreedyScaleLanguage } from '../classes/greedy-scale-language.js'
+
+/**
+ * Greek language converter.
+ *
+ * Supports:
+ * - Space-separated number composition
+ * - Implicit "one" (ένα) omission before scale words
+ * - Digit-by-digit decimal reading
+ */
+export class Greek extends GreedyScaleLanguage {
+  negativeWord = 'μείον'
+  decimalSeparatorWord = 'κόμμα'
+  zeroWord = 'μηδέν'
+  usePerDigitDecimals = true
+
+  scaleWords = [
+    // Large numbers (limited set for now)
+    [1_000_000_000n, 'δισεκατομμύριο'],
+    [1_000_000n, 'εκατομμύριο'],
+    [1000n, 'χίλια'],
+
+    // Hundreds
+    [900n, 'εννιακόσια'],
+    [800n, 'οκτακόσια'],
+    [700n, 'επτακόσια'],
+    [600n, 'εξακόσια'],
+    [500n, 'πεντακόσια'],
+    [400n, 'τετρακόσια'],
+    [300n, 'τριακόσια'],
+    [200n, 'διακόσια'],
+    [100n, 'εκατό'],
+
+    // Tens
+    [90n, 'ενενήντα'],
+    [80n, 'ογδόντα'],
+    [70n, 'εβδομήντα'],
+    [60n, 'εξήντα'],
+    [50n, 'πενήντα'],
+    [40n, 'σαράντα'],
+    [30n, 'τριάντα'],
+    [20n, 'είκοσι'],
+    [19n, 'δεκαεννέα'],
+    [18n, 'δεκαοκτώ'],
+    [17n, 'δεκαεπτά'],
+    [16n, 'δεκαέξι'],
+    [15n, 'δεκαπέντε'],
+    [14n, 'δεκατέσσερα'],
+    [13n, 'δεκατρία'],
+    [12n, 'δώδεκα'],
+    [11n, 'έντεκα'],
+    [10n, 'δέκα'],
+
+    // Singles
+    [9n, 'εννέα'],
+    [8n, 'οκτώ'],
+    [7n, 'επτά'],
+    [6n, 'έξι'],
+    [5n, 'πέντε'],
+    [4n, 'τέσσερα'],
+    [3n, 'τρία'],
+    [2n, 'δύο'],
+    [1n, 'ένα'],
+    [0n, 'μηδέν']
+  ]
+
+  /** Combines two word-sets with Greek space-separation rules. */
+  combineWordSets (preceding, following) {
+    const precedingWord = Object.keys(preceding)[0]
+    const precedingValue = Object.values(preceding)[0]
+    const followingWord = Object.keys(following)[0]
+    const followingValue = Object.values(following)[0]
+
+    // Implicit one: omit "ένα" before any following value (> 0)
+    if (precedingValue === 1n) {
+      return following
+    }
+
+    // No special handling needed for trailing 'ένα';
+    // nested merge will first collapse {1, 'ένα'} -> 'ένα'.
+
+    // Multiplication: larger following scale multiplied by preceding number
+    if (followingValue > precedingValue) {
+      return { [`${precedingWord} ${followingWord}`]: precedingValue * followingValue }
+    }
+
+    // Addition: smaller numbers added together
+    return { [`${precedingWord} ${followingWord}`]: precedingValue + followingValue }
+  }
+}

package/lib/languages/en.d.ts

@@ -0,0 +1,16 @@
+/**
+ * English language converter.
+ *
+ * Supports:
+ * - Hyphenated compounds (e.g., "twenty-three")
+ * - "and" after hundreds (e.g., "one hundred and one")
+ * - Numbers up to octillions
+ */
+export class English extends GreedyScaleLanguage {
+    scaleWords: (string | bigint)[][];
+    /** Combines two word-sets with English hyphenation and "and" rules. */
+    combineWordSets(preceding: any, following: any): {
+        [x: string]: any;
+    };
+}
+import { GreedyScaleLanguage } from '../classes/greedy-scale-language.js';

package/lib/languages/en.js

@@ -0,0 +1,86 @@
+import { GreedyScaleLanguage } from '../classes/greedy-scale-language.js'
+
+/**
+ * English language converter.
+ *
+ * Supports:
+ * - Hyphenated compounds (e.g., "twenty-three")
+ * - "and" after hundreds (e.g., "one hundred and one")
+ * - Numbers up to octillions
+ */
+export class English extends GreedyScaleLanguage {
+  negativeWord = 'minus'
+  decimalSeparatorWord = 'point'
+  zeroWord = 'zero'
+
+  scaleWords = [
+    [1_000_000_000_000_000_000_000_000_000n, 'octillion'],
+    [1_000_000_000_000_000_000_000_000n, 'septillion'],
+    [1_000_000_000_000_000_000_000n, 'sextillion'],
+    [1_000_000_000_000_000_000n, 'quintillion'],
+    [1_000_000_000_000_000n, 'quadrillion'],
+    [1_000_000_000_000n, 'trillion'],
+    [1_000_000_000n, 'billion'],
+    [1_000_000n, 'million'],
+    [1000n, 'thousand'],
+    [100n, 'hundred'],
+    [90n, 'ninety'],
+    [80n, 'eighty'],
+    [70n, 'seventy'],
+    [60n, 'sixty'],
+    [50n, 'fifty'],
+    [40n, 'forty'],
+    [30n, 'thirty'],
+    [20n, 'twenty'],
+    [19n, 'nineteen'],
+    [18n, 'eighteen'],
+    [17n, 'seventeen'],
+    [16n, 'sixteen'],
+    [15n, 'fifteen'],
+    [14n, 'fourteen'],
+    [13n, 'thirteen'],
+    [12n, 'twelve'],
+    [11n, 'eleven'],
+    [10n, 'ten'],
+    [9n, 'nine'],
+    [8n, 'eight'],
+    [7n, 'seven'],
+    [6n, 'six'],
+    [5n, 'five'],
+    [4n, 'four'],
+    [3n, 'three'],
+    [2n, 'two'],
+    [1n, 'one'],
+    [0n, 'zero']
+  ]
+
+  /** Combines two word-sets with English hyphenation and "and" rules. */
+  combineWordSets (preceding, following) {
+    const precedingWord = Object.keys(preceding)[0]
+    const precedingValue = Object.values(preceding)[0]
+    const followingWord = Object.keys(following)[0]
+    const followingValue = Object.values(following)[0]
+
+    // Rule 1: Implicit "one" - omit when multiplying ("one hundred" → "hundred")
+    if (precedingValue === 1n && followingValue < 100n) {
+      return { [followingWord]: followingValue }
+    }
+
+    // Rule 2: Hyphenate compounds under 100 ("twenty-three")
+    if (precedingValue < 100n && precedingValue > followingValue) {
+      return { [`${precedingWord}-${followingWord}`]: precedingValue + followingValue }
+    }
+
+    // Rule 3: Add "and" before units after hundreds ("one hundred and one")
+    if (precedingValue >= 100n && followingValue < 100n) {
+      return { [`${precedingWord} and ${followingWord}`]: precedingValue + followingValue }
+    }
+
+    // Rule 4: Multiply when following > preceding ("one thousand")
+    if (followingValue > precedingValue) {
+      return { [`${precedingWord} ${followingWord}`]: precedingValue * followingValue }
+    }
+
+    return { [`${precedingWord} ${followingWord}`]: precedingValue + followingValue }
+  }
+}

package/lib/languages/es.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Spanish language converter.
+ *
+ * Supports:
+ * - Gender agreement (masculine/feminine via genderStem option)
+ * - "y" conjunction between tens and units
+ * - Special hundred forms (cien/ciento)
+ */
+export class Spanish extends GreedyScaleLanguage {
+    constructor(options?: {});
+    scaleWords: (string | bigint)[][];
+    /** Combines two word-sets with Spanish gender and conjunction rules. */
+    combineWordSets(preceding: any, following: any): any;
+}
+import { GreedyScaleLanguage } from '../classes/greedy-scale-language.js';

package/lib/languages/es.js

@@ -0,0 +1,121 @@
+import { GreedyScaleLanguage } from '../classes/greedy-scale-language.js'
+
+/**
+ * Spanish language converter.
+ *
+ * Supports:
+ * - Gender agreement (masculine/feminine via genderStem option)
+ * - "y" conjunction between tens and units
+ * - Special hundred forms (cien/ciento)
+ */
+export class Spanish extends GreedyScaleLanguage {
+  negativeWord = 'menos'
+  decimalSeparatorWord = 'punto'
+  zeroWord = 'cero'
+
+  scaleWords = [
+    [1_000_000_000_000_000_000_000_000n, 'cuatrillón'],
+    [1_000_000_000_000_000_000n, 'trillón'],
+    [1_000_000_000_000n, 'billón'],
+    [1_000_000n, 'millón'],
+    [1000n, 'mil'],
+    [100n, 'cien'],
+    [90n, 'noventa'],
+    [80n, 'ochenta'],
+    [70n, 'setenta'],
+    [60n, 'sesenta'],
+    [50n, 'cincuenta'],
+    [40n, 'cuarenta'],
+    [30n, 'treinta'],
+    [29n, 'veintinueve'],
+    [28n, 'veintiocho'],
+    [27n, 'veintisiete'],
+    [26n, 'veintiséis'],
+    [25n, 'veinticinco'],
+    [24n, 'veinticuatro'],
+    [23n, 'veintitrés'],
+    [22n, 'veintidós'],
+    [21n, 'veintiuno'],
+    [20n, 'veinte'],
+    [19n, 'diecinueve'],
+    [18n, 'dieciocho'],
+    [17n, 'diecisiete'],
+    [16n, 'dieciseis'],
+    [15n, 'quince'],
+    [14n, 'catorce'],
+    [13n, 'trece'],
+    [12n, 'doce'],
+    [11n, 'once'],
+    [10n, 'diez'],
+    [9n, 'nueve'],
+    [8n, 'ocho'],
+    [7n, 'siete'],
+    [6n, 'seis'],
+    [5n, 'cinco'],
+    [4n, 'cuatro'],
+    [3n, 'tres'],
+    [2n, 'dos'],
+    [1n, 'uno'],
+    [0n, 'cero']
+  ]
+
+  constructor (options = {}) {
+    super()
+
+    this.setOptions({
+      gender: 'masculine'
+    }, options)
+
+    // Apply gender agreement to scale words if feminine
+    if (this.options.gender === 'feminine') {
+      this.scaleWords = this.scaleWords.map(([value, word]) => {
+        if (word === 'veintiuno') return [value, 'veintiuna']
+        if (word === 'uno') return [value, 'una']
+        return [value, word]
+      })
+    }
+  }
+
+  /** Combines two word-sets with Spanish gender and conjunction 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]
+    const genderStem = this.options.gender === 'feminine' ? 'a' : 'o'
+
+    if (precedingValue === 1n) {
+      if (followingValue < 1_000_000n) return following
+      precedingWord = 'un'
+    } else if (precedingValue === 100n && followingValue % 1000n !== 0n) {
+      precedingWord += 't' + genderStem
+    }
+
+    if (followingValue < precedingValue) {
+      if (precedingValue < 100n) {
+        return { [`${precedingWord} y ${followingWord}`]: precedingValue + followingValue }
+      }
+      return { [`${precedingWord} ${followingWord}`]: precedingValue + followingValue }
+    }
+
+    if (followingValue % 1_000_000n === 0n && precedingValue > 1n) {
+      followingWord = followingWord.slice(0, -3) + 'lones'
+    }
+
+    if (followingValue === 100n) {
+      if (precedingValue === 5n) {
+        precedingWord = 'quinien'
+        followingWord = ''
+      } else if (precedingValue === 7n) {
+        precedingWord = 'sete'
+      } else if (precedingValue === 9n) {
+        precedingWord = 'nove'
+      }
+      followingWord += 't' + genderStem + 's'
+    } else {
+      followingWord = ' ' + followingWord
+    }
+
+    return { [`${precedingWord}${followingWord}`]: precedingValue * followingValue }
+  }
+}

package/lib/languages/fa.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Persian language converter.
+ *
+ * Supports:
+ * - "و" (and) conjunction for compound numbers
+ * - Recursive conversion for larger numbers
+ */
+export class Persian extends AbstractLanguage {
+    /**
+     * Words for digits 1-9.
+     * @type {Object.<number, string>}
+     */
+    onesWords: {
+        [x: number]: string;
+    };
+    /**
+     * Words for teen numbers (10-19).
+     * @type {Object.<number, string>}
+     */
+    teensWords: {
+        [x: number]: string;
+    };
+    /**
+     * Words for multiples of ten (20-90).
+     * @type {Object.<number, string>}
+     */
+    tensWords: {
+        [x: number]: string;
+    };
+    /**
+     * Words for hundreds (100-900).
+     * @type {Object.<number, string>}
+     */
+    hundredsWords: {
+        [x: number]: string;
+    };
+    /**
+     * Scale magnitude words.
+     * @type {Object.<number, string>}
+     */
+    scaleWords: {
+        [x: number]: string;
+    };
+    /** Converts integer part using categorized word tables. */
+    integerToWords(integerPart: any): any;
+}
+import { AbstractLanguage } from '../classes/abstract-language.js';