n2words 1.23.1 → 2.0.0

package/lib/languages/nl.js

@@ -0,0 +1,155 @@
+import { GreedyScaleLanguage } from '../classes/greedy-scale-language.js'
+
+/**
+ * Dutch language converter.
+ *
+ * Supports:
+ * - Optional "en" (and) separator for tens
+ * - Optional comma before hundreds
+ * - Compound word formation without hyphenation
+ */
+export class Dutch extends GreedyScaleLanguage {
+  negativeWord = 'min'
+  decimalSeparatorWord = 'komma'
+  zeroWord = 'nul'
+
+  scaleWords = [
+    [1_000_000_000_000_000_000_000_000_000n, 'quadriljard'],
+    [1_000_000_000_000_000_000_000_000n, 'quadriljoen'],
+    [1_000_000_000_000_000_000_000n, 'triljard'],
+    [1_000_000_000_000_000_000n, 'triljoen'],
+    [1_000_000_000_000_000n, 'biljard'],
+    [1_000_000_000_000n, 'biljoen'],
+    [1_000_000_000n, 'miljard'],
+    [1_000_000n, 'miljoen'],
+    [1000n, 'duizend'],
+    [100n, 'honderd'],
+    [90n, 'negentig'],
+    [80n, 'tachtig'],
+    [70n, 'zeventig'],
+    [60n, 'zestig'],
+    [50n, 'vijftig'],
+    [40n, 'veertig'],
+    [30n, 'dertig'],
+    [20n, 'twintig'],
+    [19n, 'negentien'],
+    [18n, 'achttien'],
+    [17n, 'zeventien'],
+    [16n, 'zestien'],
+    [15n, 'vijftien'],
+    [14n, 'veertien'],
+    [13n, 'dertien'],
+    [12n, 'twaalf'],
+    [11n, 'elf'],
+    [10n, 'tien'],
+    [9n, 'negen'],
+    [8n, 'acht'],
+    [7n, 'zeven'],
+    [6n, 'zes'],
+    [5n, 'vijf'],
+    [4n, 'vier'],
+    [3n, 'drie'],
+    [2n, 'twee'],
+    [1n, 'één'],
+    [0n, 'nul']
+  ]
+
+  constructor (options = {}) {
+    super()
+
+    this.setOptions({
+      includeOptionalAnd: false,
+      noHundredPairing: false,
+      accentOne: true
+    }, options)
+
+    if (!this.options.accentOne) {
+      this.scaleWords[this.scaleWords.length - 2][1] = 'een'
+    }
+  }
+
+  /** Combines two word-sets according to Dutch grammar rules. */
+  combineWordSets (preceding, following) {
+    let precedingWord = Object.keys(preceding)[0]
+    let followingWord = Object.keys(following)[0]
+    const precedingValue = Object.values(preceding)[0] // BigInt
+    const followingValue = Object.values(following)[0] // BigInt
+
+    // Implicit "een": omit before large multipliers ("miljoen" not "een miljoen")
+    if (precedingValue === 1n) {
+      if (followingValue < 1_000_000n) {
+        return following
+      }
+      precedingWord = this.options.accentOne ? 'één' : 'een'
+    }
+
+    // Handle multiplication and spacing
+    if (followingValue > precedingValue) {
+      let hadSpace = false
+      // Large scale words (millions+): add space before multiplier
+      if (followingValue >= 1_000_000n) {
+        precedingWord += ' '
+        hadSpace = true
+      } else if (followingValue > 100n) {
+        // Hundreds and above: add space after multiplier
+        followingWord += ' '
+        hadSpace = true
+      }
+      // Convert 'één' to 'een' in compounds (when no space or accentOne disabled)
+      if (!hadSpace || !this.options.accentOne) {
+        precedingWord = precedingWord.replace(/één/g, 'een')
+        followingWord = followingWord.replace(/één/g, 'een')
+      }
+      return { [`${precedingWord}${followingWord}`]: precedingValue * followingValue }
+    }
+
+    // Track if we're adding a space (which keeps words separate)
+    let hasSpace = false
+
+    if (followingValue < 10n && precedingValue > 10n && precedingValue < 100n) {
+      const temporary = followingWord
+      followingWord = precedingWord
+      const andTxt = temporary.endsWith('e') ? 'ën' : 'en'
+      precedingWord = `${temporary}${andTxt}`
+    } else if (followingValue < 13n && precedingValue < 1000n && this.options.includeOptionalAnd) {
+      precedingWord = `${precedingWord}en`
+    } else if (followingValue < 13n && precedingValue >= 1000n && this.options.includeOptionalAnd) {
+      followingWord = ` en ${followingWord}`
+      hasSpace = true
+    } else if (precedingValue >= 1_000_000n) {
+      precedingWord += ' '
+      hasSpace = true
+    } else if (precedingValue === 1000n) {
+      precedingWord += ' '
+      hasSpace = true
+    }
+
+    // Convert 'één' to 'een' in direct compounds (no space)
+    // Keep 'één' only if there's a space AND accentOne=true
+    if (!hasSpace) {
+      precedingWord = precedingWord.replace(/één/g, 'een')
+      followingWord = followingWord.replace(/één/g, 'een')
+    } else if (!this.options.accentOne) {
+      precedingWord = precedingWord.replace(/één/g, 'een')
+      followingWord = followingWord.replace(/één/g, 'een')
+    }
+
+    return { [`${precedingWord}${followingWord}`]: precedingValue + followingValue }
+  }
+
+  integerToWords (integerPart) {
+    if (integerPart >= 1100n && integerPart < 10_000n && !this.options.noHundredPairing) {
+      const high = integerPart / 100n
+      const low = integerPart % 100n
+      if (high % 10n !== 0n) {
+        let result = super.integerToWords(high) + 'honderd'
+        if (low) {
+          result +=
+            (this.options.includeOptionalAnd ? ' en ' : ' ') + super.integerToWords(low)
+        }
+        return result
+      }
+    }
+    return super.integerToWords(integerPart)
+  }
+}

package/lib/languages/pa.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Punjabi language converter.
+ *
+ * Supports:
+ * - Indian numbering system (ਹਜ਼ਾਰ, ਲੱਖ, ਕਰੋੜ)
+ * - Gurmukhi script
+ * - Complete word forms for 0-99
+ */
+export class Punjabi extends SouthAsianLanguage {
+}
+import { SouthAsianLanguage } from '../classes/south-asian-language.js';

package/lib/languages/pa.js

@@ -0,0 +1,131 @@
+import { SouthAsianLanguage } from '../classes/south-asian-language.js'
+
+/**
+ * Punjabi language converter.
+ *
+ * Supports:
+ * - Indian numbering system (ਹਜ਼ਾਰ, ਲੱਖ, ਕਰੋੜ)
+ * - Gurmukhi script
+ * - Complete word forms for 0-99
+ */
+export class Punjabi extends SouthAsianLanguage {
+  negativeWord = 'ਮਾਇਨਸ'
+  decimalSeparatorWord = 'ਦਸ਼ਮਲਵ'
+  zeroWord = 'ਸਿਫ਼ਰ'
+  hundredWord = 'ਸੌ'
+
+  belowHundredWords = [
+    'ਸਿਫ਼ਰ',
+    'ਇੱਕ',
+    'ਦੋ',
+    'ਤਿੰਨ',
+    'ਚਾਰ',
+    'ਪੰਜ',
+    'ਛੇ',
+    'ਸੱਤ',
+    'ਅੱਠ',
+    'ਨੌਂ',
+    'ਦੱਸ',
+    'ਗਿਆਰਾਂ',
+    'ਬਾਰਾਂ',
+    'ਤੇਰਾਂ',
+    'ਚੌਦਾਂ',
+    'ਪੰਦਰਾਂ',
+    'ਸੋਲਾਂ',
+    'ਸਤਾਰਾਂ',
+    'ਅਠਾਰਾਂ',
+    'ਉੱਨੀ',
+    'ਵੀਹ',
+    'ਇੱਕੀ',
+    'ਬਾਈ',
+    'ਤੇਈ',
+    'ਚੌਬੀ',
+    'ਪੱਚੀ',
+    'ਛੱਬੀ',
+    'ਸਤਾਈ',
+    'ਅਠਾਈ',
+    'ਉਨੱਤੀ',
+    'ਤੀਹ',
+    'ਇਕੱਤੀ',
+    'ਬੱਤੀ',
+    'ਤੇਤੀ',
+    'ਚੌਂਤੀ',
+    'ਪੈਂਤੀ',
+    'ਛੱਤੀ',
+    'ਸੈਂਤੀ',
+    'ਅਠੱਤੀ',
+    'ਉਨਤਾਲੀ',
+    'ਚਾਲੀ',
+    'ਇਕਤਾਲੀ',
+    'ਬਿਆਲੀ',
+    'ਤਿਰਤਾਲੀ',
+    'ਚੁਵਾਲੀ',
+    'ਪੰਤਾਲੀ',
+    'ਛਿਆਲੀ',
+    'ਸੈਂਤਾਲੀ',
+    'ਅਠਤਾਲੀ',
+    'ਉਨੰਜਾ',
+    'ਪੰਜਾਹ',
+    'ਇਕਵੰਜਾ',
+    'ਬਵੰਜਾ',
+    'ਤਰਵੰਜਾ',
+    'ਚੁਰਵੰਜਾ',
+    'ਪੰਜਵੰਜਾ',
+    'ਛਪੰਜਾ',
+    'ਸੱਤਵੰਜਾ',
+    'ਅਠਵੰਜਾ',
+    'ਉਨਾਹਠ',
+    'ਸੱਠ',
+    'ਇਕਾਹਠ',
+    'ਬਾਹਠ',
+    'ਤਰਸਠ',
+    'ਚੌਂਸਠ',
+    'ਪੈਂਸਠ',
+    'ਛਿਆਸਠ',
+    'ਸੜਸਠ',
+    'ਅੜਸਠ',
+    'ਉਣਹੱਤਰ',
+    'ਸਤੱਰ',
+    'ਇਕਹੱਤਰ',
+    'ਬਹੱਤਰ',
+    'ਤਹੱਤਰ',
+    'ਚੌਹੱਤਰ',
+    'ਪੰਝਹੱਤਰ',
+    'ਛਿਹੱਤਰ',
+    'ਸਤੱਤਰ',
+    'ਅਠੱਤਰ',
+    'ਉਨਾਸੀ',
+    'ਅੱਸੀ',
+    'ਇਕਿਆਸੀ',
+    'ਬਿਆਸੀ',
+    'ਤਰਿਆਸੀ',
+    'ਚੌਰਿਆਸੀ',
+    'ਪਚਾਸੀ',
+    'ਛਿਆਸੀ',
+    'ਸੱਤਾਸੀ',
+    'ਅਠਾਸੀ',
+    'ਨਵਾਸੀ',
+    'ਨੱਬੇ',
+    'ਇਕਾਨਵੇਂ',
+    'ਬਾਨਵੇਂ',
+    'ਤਰਾਨਵੇਂ',
+    'ਚੁਰਾਨਵੇਂ',
+    'ਪੰਚਾਨਵੇਂ',
+    'ਛਿਆਨਵੇਂ',
+    'ਸਤਾਨਵੇਂ',
+    'ਅਠਾਨਵੇਂ',
+    'ਨਿਨਾਨਵੇਂ'
+  ]
+
+  scaleWords = [
+    '',
+    'ਹਜ਼ਾਰ',
+    'ਲੱਖ',
+    'ਕਰੋੜ',
+    'ਅਰਬ',
+    'ਖਰਬ',
+    'ਨੀਲ',
+    'ਪਦਮ',
+    'ਸ਼ੰਖ'
+  ]
+}

package/lib/{i18n/uk.d.ts → languages/pl.d.ts}

@@ -1,13 +1,13 @@
 /**
- * Converts a value to cardinal (written) form.
- * @param {number|string|bigint} value Number to be convert.
- * @param {object} [options] Options for class.
- * @returns {string} Value in cardinal (written) format.
- * @throws {Error} Value cannot be invalid.
+ * Polish language converter.
+ *
+ * Supports:
+ * - Three-form pluralization (one/few/many)
+ * - Polish-specific declension patterns
+ * - Distinctive Polish phonology and orthography
  */
-export default function floatToCardinal(value: number | string | bigint, options?: object): string;
-export class N2WordsUK extends N2WordsRU {
-    ones: {
+export class Polish extends SlavicLanguage {
+    onesWords: {
         1: string;
         2: string;
         3: string;
@@ -18,7 +18,7 @@ export class N2WordsUK extends N2WordsRU {
         8: string;
         9: string;
     };
-    onesFeminine: {
+    onesFeminineWords: {
         1: string;
         2: string;
         3: string;
@@ -29,7 +29,7 @@ export class N2WordsUK extends N2WordsRU {
         8: string;
         9: string;
     };
-    tens: {
+    teensWords: {
         0: string;
         1: string;
         2: string;
@@ -41,7 +41,7 @@ export class N2WordsUK extends N2WordsRU {
         8: string;
         9: string;
     };
-    twenties: {
+    twentiesWords: {
         2: string;
         3: string;
         4: string;
@@ -51,7 +51,7 @@ export class N2WordsUK extends N2WordsRU {
         8: string;
         9: string;
     };
-    hundreds: {
+    hundredsWords: {
         1: string;
         2: string;
         3: string;
@@ -62,7 +62,7 @@ export class N2WordsUK extends N2WordsRU {
         8: string;
         9: string;
     };
-    thousands: {
+    pluralForms: {
         1: string[];
         2: string[];
         3: string[];
@@ -74,5 +74,7 @@ export class N2WordsUK extends N2WordsRU {
         9: string[];
         10: string[];
     };
+    /** Implements Polish-specific three-form pluralization rules. */
+    pluralize(n: any, forms: any): any;
 }
-import { N2WordsRU } from './ru.js';
+import { SlavicLanguage } from '../classes/slavic-language.js';

package/lib/languages/pl.js

@@ -0,0 +1,110 @@
+import { SlavicLanguage } from '../classes/slavic-language.js'
+
+/**
+ * Polish language converter.
+ *
+ * Supports:
+ * - Three-form pluralization (one/few/many)
+ * - Polish-specific declension patterns
+ * - Distinctive Polish phonology and orthography
+ */
+export class Polish extends SlavicLanguage {
+  negativeWord = 'minus'
+  decimalSeparatorWord = 'przecinek'
+  zeroWord = 'zero'
+
+  onesWords = {
+    1: 'jeden',
+    2: 'dwa',
+    3: 'trzy',
+    4: 'cztery',
+    5: 'pięć',
+    6: 'sześć',
+    7: 'siedem',
+    8: 'osiem',
+    9: 'dziewięć'
+  }
+
+  onesFeminineWords = {
+    1: 'jedna',
+    2: 'dwie',
+    3: 'trzy',
+    4: 'cztery',
+    5: 'pięć',
+    6: 'sześć',
+    7: 'siedem',
+    8: 'osiem',
+    9: 'dziewięć'
+  }
+
+  teensWords = {
+    0: 'dziesięć',
+    1: 'jedenaście',
+    2: 'dwanaście',
+    3: 'trzynaście',
+    4: 'czternaście',
+    5: 'piętnaście',
+    6: 'szesnaście',
+    7: 'siedemnaście',
+    8: 'osiemnaście',
+    9: 'dziewiętnaście'
+  }
+
+  twentiesWords = {
+    2: 'dwadzieścia',
+    3: 'trzydzieści',
+    4: 'czterdzieści',
+    5: 'pięćdziesiąt',
+    6: 'sześćdziesiąt',
+    7: 'siedemdziesiąt',
+    8: 'osiemdziesiąt',
+    9: 'dziewięćdziesiąt'
+  }
+
+  hundredsWords = {
+    1: 'sto',
+    2: 'dwieście',
+    3: 'trzysta',
+    4: 'czterysta',
+    5: 'pięćset',
+    6: 'sześćset',
+    7: 'siedemset',
+    8: 'osiemset',
+    9: 'dziewięćset'
+  }
+
+  pluralForms = {
+    1: ['tysiąc', 'tysiące', 'tysięcy'], // 10^ 3
+    2: ['milion', 'miliony', 'milionów'], // 10^ 6
+    3: ['miliard', 'miliardy', 'miliardów'], // 10^ 9
+    4: ['bilion', 'biliony', 'bilionów'], // 10^ 12
+    5: ['biliard', 'biliardy', 'biliardów'], // 10^ 15
+    6: ['trylion', 'tryliony', 'trylionów'], // 10^ 18
+    7: ['tryliard', 'tryliardy', 'tryliardów'], // 10^ 21
+    8: ['kwadrylion', 'kwadryliony', 'kwadrylionów'], // 10^ 24
+    9: ['kwaryliard', 'kwadryliardy', 'kwadryliardów'], // 10^ 27
+    10: ['kwintylion', 'kwintyliony', 'kwintylionów'] // 10^ 30
+  }
+
+  /**
+   * Polish omits "one" before scale words.
+   * e.g., 1000 is "tysiąc" not "jeden tysiąc"
+   */
+  omitOneBeforeScale = true
+
+  /** Implements Polish-specific three-form pluralization rules. */
+  pluralize (n, forms) {
+    if (n === 1n) {
+      return forms[0]
+    }
+
+    const lastDigit = n % 10n
+    const lastTwoDigits = n % 100n
+
+    if (lastDigit < 5n && lastDigit > 1n && (lastTwoDigits < 10n || lastTwoDigits > 20n)) {
+      return forms[1]
+    }
+
+    return forms[2]
+  }
+}

package/lib/languages/pt.d.ts

@@ -0,0 +1,29 @@
+/**
+ * (European) Portuguese language converter.
+ *
+ * Supports:
+ * - Gender-aware hundreds (duzentos, trezentos)
+ * - "e" (and) conjunction for number combinations
+ * - Post-processing to normalize word flow
+ */
+export class Portuguese extends GreedyScaleLanguage {
+    static POSTCLEAN_REGEX: RegExp;
+    scaleWords: (string | bigint)[][];
+    hundredsWords: {
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    finalizeWords(words: any): any;
+    /** Combines two word-sets according to Portuguese grammar rules. */
+    combineWordSets(preceding: any, following: any): {
+        [x: string]: any;
+    };
+}
+import { GreedyScaleLanguage } from '../classes/greedy-scale-language.js';

package/lib/languages/pt.js

@@ -0,0 +1,112 @@
+import { GreedyScaleLanguage } from '../classes/greedy-scale-language.js'
+
+/**
+ * (European) Portuguese language converter.
+ *
+ * Supports:
+ * - Gender-aware hundreds (duzentos, trezentos)
+ * - "e" (and) conjunction for number combinations
+ * - Post-processing to normalize word flow
+ */
+export class Portuguese extends GreedyScaleLanguage {
+  negativeWord = 'menos'
+  decimalSeparatorWord = 'vírgula'
+  zeroWord = 'zero'
+
+  scaleWords = [
+    [1_000_000_000_000_000_000_000_000n, 'quatrilião'],
+    [1_000_000_000_000_000_000n, 'trilião'],
+    [1_000_000_000_000n, 'bilião'],
+    [1_000_000n, 'milião'],
+    [1000n, 'mil'],
+    [100n, 'cem'],
+    [90n, 'noventa'],
+    [80n, 'oitenta'],
+    [70n, 'setenta'],
+    [60n, 'sessenta'],
+    [50n, 'cinquenta'],
+    [40n, 'quarenta'],
+    [30n, 'trinta'],
+    [20n, 'vinte'],
+    [19n, 'dezanove'],
+    [18n, 'dezoito'],
+    [17n, 'dezassete'],
+    [16n, 'dezasseis'],
+    [15n, 'quinze'],
+    [14n, 'catorze'],
+    [13n, 'treze'],
+    [12n, 'doze'],
+    [11n, 'onze'],
+    [10n, 'dez'],
+    [9n, 'nove'],
+    [8n, 'oito'],
+    [7n, 'sete'],
+    [6n, 'seis'],
+    [5n, 'cinco'],
+    [4n, 'quatro'],
+    [3n, 'três'],
+    [2n, 'dois'],
+    [1n, 'um'],
+    [0n, 'zero']
+  ]
+
+  hundredsWords = {
+    1: 'cento',
+    2: 'duzentos',
+    3: 'trezentos',
+    4: 'quatrocentos',
+    5: 'quinhentos',
+    6: 'seiscentos',
+    7: 'setecentos',
+    8: 'oitocentos',
+    9: 'novecentos'
+  }
+
+  // Pre-compiled regex patterns for postClean - avoid recompilation
+  static POSTCLEAN_REGEX = / e (.*entos?) (?=.*e)/g
+
+  finalizeWords (words) {
+    return words.replaceAll(Portuguese.POSTCLEAN_REGEX, ' $1 ')
+  }
+
+  /** Combines two word-sets according to Portuguese grammar rules. */
+  combineWordSets (preceding, following) {
+    // Extract words and numeric values
+    let precedingWord = Object.keys(preceding)[0]
+    let followingWord = Object.keys(following)[0]
+    const precedingValue = Object.values(preceding)[0] // BigInt
+    const followingValue = Object.values(following)[0] // BigInt
+
+    // Implicit "um": omit before millions ("um milhão" → "milhão")
+    if (precedingValue === 1n) {
+      if (followingValue < 1_000_000n) return { [followingWord]: followingValue }
+      precedingWord = 'um'
+    } else if (precedingValue === 100n && followingValue % 1000n !== 0n) {
+      // Special handling: "cem" (100) becomes "cento" when followed by non-thousands
+      precedingWord = 'cento'
+    }
+
+    if (followingValue < precedingValue) {
+      return { [`${precedingWord} e ${followingWord}`]: precedingValue + followingValue }
+    }
+
+    // Handle "milião" -> "milhão" conversion
+    if (followingWord === 'milião') followingWord = 'milhão'
+
+    // Pluralization logic for large numbers
+    if (precedingValue > 1n) {
+      if (followingValue % 1_000_000_000n === 0n) {
+        followingWord = followingWord.replace('bilião', 'biliões')
+      } else if (followingValue % 1_000_000n === 0n) {
+        followingWord = followingWord.replace('milhão', 'milhões')
+      }
+    }
+
+    if (followingValue === 100n) {
+      precedingWord = this.hundredsWords[precedingValue]
+      return { [`${precedingWord}`]: precedingValue * followingValue }
+    }
+
+    return { [`${precedingWord} ${followingWord}`]: precedingValue * followingValue }
+  }
+}