n2words 1.23.1 → 1.24.0

package/lib/languages/ms.js

@@ -0,0 +1,146 @@
+import AbstractLanguage from '../classes/abstract-language.js'
+
+/**
+ * Malay (Bahasa Melayu) language converter.
+ *
+ * Conventions:
+ * - Base-10 structure
+ * - "Se-" prefix for singular units (seratus, seribu, sejuta, sebilion, setrilion)
+ * - Space-separated components (no conjunction like "dan" for tens/ones)
+ * - Grouping by thousands (ribu, juta, bilion, trilion)
+ */
+export class Malay extends AbstractLanguage {
+  negativeWord = 'minus'
+  decimalSeparatorWord = 'perpuluhan'
+  zeroWord = 'sifar'
+  base = {
+    0: [],
+    1: ['satu'],
+    2: ['dua'],
+    3: ['tiga'],
+    4: ['empat'],
+    5: ['lima'],
+    6: ['enam'],
+    7: ['tujuh'],
+    8: ['lapan'],
+    9: ['sembilan']
+  }
+
+  thousands = {
+    3: 'ribu',
+    6: 'juta',
+    9: 'bilion',
+    12: 'trilion'
+  }
+
+  splitBy3 (number) {
+    const blocks = []
+    const stringNumber = number.toString()
+    const length = stringNumber.length
+    let firstBlock
+
+    if (length < 3) {
+      blocks.push([stringNumber])
+    } else {
+      const firstBlockLength = length % 3
+
+      if (firstBlockLength > 0) {
+        firstBlock = [stringNumber.slice(0, firstBlockLength)]
+        blocks.push(firstBlock)
+      }
+
+      for (let index = firstBlockLength; index < length; index += 3) {
+        const nextBlock = [stringNumber.slice(index, index + 3)]
+        blocks.push(nextBlock)
+      }
+    }
+    return blocks
+  }
+
+  spell (blocks) {
+    let wordBlocks = []
+    let spelling
+    const firstBlock = blocks[0]
+    if (firstBlock[0].length === 1) {
+      spelling = firstBlock[0] === '0' ? ['sifar'] : this.base[Math.trunc(firstBlock[0])]
+    } else if (firstBlock[0].length === 2) {
+      spelling = this.getTens(firstBlock[0])
+    } else {
+      spelling = [...this.getHundreds(firstBlock[0][0]), ...this.getTens(firstBlock[0].slice(1, 3))]
+    }
+    wordBlocks = [...wordBlocks, [firstBlock[0], spelling]]
+    for (let index = 1; index < blocks.length; index++) {
+      let block = blocks[index]
+      spelling = [...this.getHundreds(block[0][0]), ...this.getTens(block[0].slice(1, 3))]
+      block = [...block, spelling]
+      wordBlocks = [...wordBlocks, block]
+    }
+    return wordBlocks
+  }
+
+  getHundreds (number) { // 'ratus'
+    if (number === '1') {
+      return ['seratus']
+    } else if (number === '0') {
+      return []
+    } else {
+      return [...this.base[Math.trunc(number)], 'ratus']
+    }
+  }
+
+  getTens (number) { // 'puluh' and 'belas'
+    if (number[0] === '1') {
+      if (number[1] === '0') {
+        return ['sepuluh']
+      } else if (number[1] === '1') {
+        return ['sebelas']
+      }
+      return [...this.base[Math.trunc(number[1])], 'belas']
+    }
+
+    if (number[0] === '0') {
+      return this.base[Math.trunc(number[1])]
+    }
+
+    return [...this.base[Math.trunc(number[0])], 'puluh', ...this.base[Math.trunc(number[1])]]
+  }
+
+  join (wordBlocks) {
+    const wordList = []
+    const length = wordBlocks.length - 1
+
+    for (let index = 0; index <= length; index++) {
+      const words = wordBlocks[index][1]
+      const isLast = index === length
+      const scaleWord = isLast ? null : this.thousands[(length - index) * 3]
+
+      if (!isLast && words.length === 1 && words[0] === 'satu') {
+        // Use se- prefix for singular scale units: seribu, sejuta, sebilion, setrilion
+        wordList.push('se' + scaleWord)
+        continue
+      }
+
+      // Add current block words
+      for (const w of words) wordList.push(w)
+
+      // Append scale word if applicable and current block contributed words
+      if (!isLast && words.length > 0) {
+        wordList.push(scaleWord)
+      }
+    }
+
+    return wordList.join(' ')
+  }
+
+  convertWholePart (number) {
+    return this.join(
+      this.spell(
+        this.splitBy3(number)
+      )
+    ).trim()
+  }
+}
+
+export default function convertToWords (value, options = {}) {
+  return new Malay(options).convertToWords(value)
+}

package/lib/languages/nb.js

@@ -0,0 +1,120 @@
+import GreedyScaleLanguage from '../classes/greedy-scale-language.js'
+
+/**
+ * Norwegian language converter.
+ *
+ * GreedyScaleLanguage with inline Norwegian merge rules:
+ * - Hyphenation for compound numbers (e.g., "tjueen")
+ * - "og" (and) for hundreds combinations
+ * - Comma separation for non-magnitude additions
+ * - Implicit '1' before tens and magnitudes
+ * - Space separators for large numbers
+ */
+export class Norwegian extends GreedyScaleLanguage {
+  negativeWord = 'minus'
+  decimalSeparatorWord = 'komma'
+  zeroWord = 'null'
+  scaleWordPairs = [
+    [1_000_000_000_000_000_000_000_000_000_000_000n, 'quintillard'],
+    [1_000_000_000_000_000_000_000_000_000_000n, 'quintillion'],
+    [1_000_000_000_000_000_000_000_000_000n, 'quadrillard'],
+    [1_000_000_000_000_000_000_000_000n, 'quadrillion'],
+    [1_000_000_000_000_000_000_000n, 'trillard'],
+    [1_000_000_000_000_000_000n, 'trillion'],
+    [1_000_000_000_000_000n, 'billard'],
+    [1_000_000_000_000n, 'billion'],
+    [1_000_000_000n, 'millard'],
+    [1_000_000n, 'million'],
+    [1000n, 'tusen'],
+    [100n, 'hundre'],
+    [90n, 'nitti'],
+    [80n, 'åtti'],
+    [70n, 'sytti'],
+    [60n, 'seksti'],
+    [50n, 'femti'],
+    [40n, 'førti'],
+    [30n, 'tretti'],
+    [20n, 'tjue'],
+    [19n, 'nitten'],
+    [18n, 'atten'],
+    [17n, 'sytten'],
+    [16n, 'seksten'],
+    [15n, 'femten'],
+    [14n, 'fjorten'],
+    [13n, 'tretten'],
+    [12n, 'tolv'],
+    [11n, 'elleve'],
+    [10n, 'ti'],
+    [9n, 'ni'],
+    [8n, 'åtte'],
+    [7n, 'syv'],
+    [6n, 'seks'],
+    [5n, 'fem'],
+    [4n, 'fire'],
+    [3n, 'tre'],
+    [2n, 'to'],
+    [1n, 'en'],
+    [0n, 'null']
+  ]
+
+  /**
+   * Merges two adjacent word-number pairs according to Norwegian grammar rules.
+   *
+   * Norwegian-specific rules:
+   * - Implicit \"en\": `mergeScales({ 'en': 1n }, { 'hundre': 100n })` → `{ 'hundre': 100n }`
+   * - Hyphenation for compound tens: `mergeScales({ 'tjue': 20n }, { 'en': 1n })` → `{ 'tjue-en': 21n }`
+   * - \"og\" (and) after hundreds: `mergeScales({ 'hundre': 100n }, { 'en': 1n })` → `{ 'hundre og en': 101n }`
+   * - Space-separated for large numbers (thousands+)
+   * - Comma separator for non-magnitude additions (e.g., \"tusen, en\")
+   *
+   * @param {Object} leftPair The left operand as `{ word: BigInt }`.
+   * @param {Object} rightPair The right operand as `{ word: BigInt }`.
+   * @returns {Object} Merged pair with combined word and resulting numeric value.
+   *
+   * @example
+   * mergeScales({ 'en': 1n }, { 'hundre': 100n }); // { 'hundre': 100n }
+   * mergeScales({ 'tjue': 20n }, { 'tre': 3n }); // { 'tjue-tre': 23n }
+   */
+  // Norwegian merge rules mirror the former Scandinavian base logic
+  mergeScales (leftPair, rightPair) {
+    const leftWord = Object.keys(leftPair)[0]
+    const rightWord = Object.keys(rightPair)[0]
+    const leftNumber = Object.values(leftPair)[0]
+    const rightNumber = Object.values(rightPair)[0]
+
+    if (leftNumber === 1n && rightNumber < 100n) {
+      return rightPair
+    }
+
+    if (leftNumber < 100n && leftNumber > rightNumber) {
+      return { [`${leftWord}-${rightWord}`]: leftNumber + rightNumber }
+    }
+
+    if (leftNumber >= 100n && rightNumber < 100n) {
+      return { [`${leftWord} og ${rightWord}`]: leftNumber + rightNumber }
+    }
+
+    if (rightNumber > leftNumber) {
+      return { [`${leftWord} ${rightWord}`]: leftNumber * rightNumber }
+    }
+
+    return { [`${leftWord}, ${rightWord}`]: leftNumber + rightNumber }
+  }
+}
+
+/**
+ * Converts a number to Norwegian cardinal (written) form.
+ *
+ * @param {number|string|bigint} value The number to convert.
+ * @param {Object} [options] Conversion options (see Norwegian class options).
+ * @returns {string} The number expressed in Norwegian words.
+ * @throws {TypeError} If value is NaN or invalid type.
+ * @throws {Error} If value is an invalid number string.
+ *
+ * @example
+ * convertToWords(42); // 'førti-to'
+ * convertToWords('1.5'); // 'en komma fem'
+ */
+export default function convertToWords (value, options = {}) {
+  return new Norwegian(options).convertToWords(value)
+}

package/lib/languages/nl.js

@@ -0,0 +1,206 @@
+import GreedyScaleLanguage from '../classes/greedy-scale-language.js'
+
+/**
+ * @typedef {Object} DutchOptions
+ * @property {boolean} [includeOptionalAnd=false] Include optional "en" separator.
+ * @property {boolean} [noHundredPairs=false] Disable comma before hundreds.
+ * @property {boolean} [accentOne=true] Use accented "één" for one.
+ */
+
+/**
+ * Dutch language converter.
+ *
+ * Features:
+ * - Optional "en" (and) separator for tens (includeOptionalAnd)
+ * - Optional comma before hundreds (noHundredPairs)
+ * - Compound word formation without hyphenation
+ */
+export class Dutch extends GreedyScaleLanguage {
+  negativeWord = 'min'
+  decimalSeparatorWord = 'komma'
+  zeroWord = 'nul'
+  scaleWordPairs = [
+    [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']
+  ]
+
+  /**
+   * Initializes the Dutch converter with language-specific options.
+   *
+   * @param {DutchOptions} [options={}] Configuration options.
+   */
+  constructor ({ includeOptionalAnd = false, noHundredPairs = false, accentOne = true } = {}) {
+    super()
+
+    this.includeOptionalAnd = includeOptionalAnd
+
+    this.noHundredPairs = noHundredPairs
+
+    this.accentOne = accentOne
+    if (!this.accentOne) {
+      this.scaleWordPairs[this.scaleWordPairs.length - 2][1] = 'een'
+    }
+  }
+
+  /**
+   * Merges two adjacent word-number pairs according to Dutch grammar rules.
+   *
+   * Dutch-specific rules:
+   * - Implicit "één": `mergeScales({ 'één': 1n }, { 'duizend': 1000n })` → `{ 'duizend': 1000n }`
+   * - Reversed digit order for tens + units: `mergeScales({ 'twintig': 20n }, { 'één': 1n })` → `{ 'ééntwintig': 21n }`
+   * - Optional "en" separator based on includeOptionalAnd option
+   * - Compound words without separators for most combinations
+   * - Converts 'één' to 'een' in compound words (no accent in compounds)
+   * - Space separators for large numbers (millions+)
+   *
+   * @param {Object} current The left operand as `{ word: BigInt }`.
+   * @param {Object} next The right operand as `{ word: BigInt }`.
+   * @returns {Object} Merged pair with combined word and resulting numeric value.
+   *
+   * @example
+   * mergeScales({ 'één': 1n }, { 'duizend': 1000n }); // { 'duizend': 1000n }
+   * mergeScales({ 'twintig': 20n }, { 'drie': 3n }); // { 'drieentwintig': 23n }
+   */
+  mergeScales (current, next) {
+    let cText = Object.keys(current)[0]
+    let nText = Object.keys(next)[0]
+    const cNumber = Object.values(current)[0] // BigInt
+    const nNumber = Object.values(next)[0] // BigInt
+
+    // Implicit "een": omit before large multipliers ("miljoen" not "een miljoen")
+    if (cNumber === 1n) {
+      if (nNumber < 1_000_000n) {
+        return next
+      }
+      cText = this.accentOne ? 'één' : 'een'
+    }
+
+    // Handle multiplication and spacing
+    if (nNumber > cNumber) {
+      let hadSpace = false
+      // Large scale words (millions+): add space before multiplier
+      if (nNumber >= 1_000_000n) {
+        cText += ' '
+        hadSpace = true
+      } else if (nNumber > 100n) {
+        // Hundreds and above: add space after multiplier
+        nText += ' '
+        hadSpace = true
+      }
+      // Convert 'één' to 'een' in compounds (when no space or accentOne disabled)
+      if (!hadSpace || !this.accentOne) {
+        cText = cText.replace(/één/g, 'een')
+        nText = nText.replace(/één/g, 'een')
+      }
+      return { [`${cText}${nText}`]: cNumber * nNumber }
+    }
+
+    // Track if we're adding a space (which keeps words separate)
+    let hasSpace = false
+
+    if (nNumber < 10n && cNumber > 10n && cNumber < 100n) {
+      const temporary = nText
+      nText = cText
+      const andTxt = temporary.endsWith('e') ? 'ën' : 'en'
+      cText = `${temporary}${andTxt}`
+    } else if (nNumber < 13n && cNumber < 1000n && this.includeOptionalAnd) {
+      cText = `${cText}en`
+    } else if (nNumber < 13n && cNumber >= 1000n && this.includeOptionalAnd) {
+      nText = ` en ${nText}`
+      hasSpace = true
+    } else if (cNumber >= 1_000_000n) {
+      cText += ' '
+      hasSpace = true
+    } else if (cNumber === 1000n) {
+      cText += ' '
+      hasSpace = true
+    }
+
+    // Convert 'één' to 'een' in direct compounds (no space)
+    // Keep 'één' only if there's a space AND accentOne=true
+    if (!hasSpace) {
+      cText = cText.replace(/één/g, 'een')
+      nText = nText.replace(/één/g, 'een')
+    } else if (!this.accentOne) {
+      cText = cText.replace(/één/g, 'een')
+      nText = nText.replace(/één/g, 'een')
+    }
+
+    return { [`${cText}${nText}`]: cNumber + nNumber }
+  }
+
+  convertWholePart (value) {
+    if (value >= 1100n && value < 10_000n && !this.noHundredPairs) {
+      const high = value / 100n
+      const low = value % 100n
+      if (high % 10n !== 0n) {
+        let result = super.convertWholePart(high) + 'honderd'
+        if (low) {
+          result +=
+            (this.includeOptionalAnd ? ' en ' : ' ') + super.convertWholePart(low)
+        }
+        return result
+      }
+    }
+    return super.convertWholePart(value)
+  }
+}
+
+/**
+ * Converts a number to Dutch cardinal (written) form.
+ *
+ * @param {number|string|bigint} value The number to convert.
+ * @param {Object} [options] Conversion options (see Dutch class options).
+ * @param {boolean} [options.includeOptionalAnd=false] Include optional 'en' (and) separator.
+ * @param {boolean} [options.noHundredPairs=false] Don't combine hundreds with tens/units.
+ * @param {boolean} [options.accentOne=true] Use accented 'één' for standalone 1.
+ * @returns {string} The number expressed in Dutch words.
+ * @throws {TypeError} If value is NaN or invalid type.
+ * @throws {Error} If value is an invalid number string.
+ *
+ * @example
+ * convertToWords(1); // 'één' (default accent)
+ * convertToWords(1, { accentOne: false }); // 'een'
+ * convertToWords(21); // 'eenentwintig' (no accent in compounds)
+ * convertToWords(42); // 'tweeenveertig'
+ * convertToWords('1.5'); // 'één komma vijf'
+ */
+export default function convertToWords (value, options = {}) {
+  return new Dutch(options).convertToWords(value)
+}

package/lib/languages/pa-Guru.js

@@ -0,0 +1,126 @@
+import SouthAsianLanguage from '../classes/south-asian-language.js'
+
+class Punjabi extends SouthAsianLanguage {
+  negativeWord = 'ਮਾਇਨਸ'
+  decimalSeparatorWord = 'ਦਸ਼ਮਲਵ'
+  zeroWord = 'ਸਿਫ਼ਰ'
+  hundredWord = 'ਸੌ'
+  belowHundred = [
+    'ਸਿਫ਼ਰ',
+    'ਇੱਕ',
+    'ਦੋ',
+    'ਤਿੰਨ',
+    'ਚਾਰ',
+    'ਪੰਜ',
+    'ਛੇ',
+    'ਸੱਤ',
+    'ਅੱਠ',
+    'ਨੌਂ',
+    'ਦੱਸ',
+    'ਗਿਆਰਾਂ',
+    'ਬਾਰਾਂ',
+    'ਤੇਰਾਂ',
+    'ਚੌਦਾਂ',
+    'ਪੰਦਰਾਂ',
+    'ਸੋਲਾਂ',
+    'ਸਤਾਰਾਂ',
+    'ਅਠਾਰਾਂ',
+    'ਉੱਨੀ',
+    'ਵੀਹ',
+    'ਇੱਕੀ',
+    'ਬਾਈ',
+    'ਤੇਈ',
+    'ਚੌਬੀ',
+    'ਪੱਚੀ',
+    'ਛੱਬੀ',
+    'ਸਤਾਈ',
+    'ਅਠਾਈ',
+    'ਉਨੱਤੀ',
+    'ਤੀਹ',
+    'ਇਕੱਤੀ',
+    'ਬੱਤੀ',
+    'ਤੇਤੀ',
+    'ਚੌਂਤੀ',
+    'ਪੈਂਤੀ',
+    'ਛੱਤੀ',
+    'ਸੈਂਤੀ',
+    'ਅਠੱਤੀ',
+    'ਉਨਤਾਲੀ',
+    'ਚਾਲੀ',
+    'ਇਕਤਾਲੀ',
+    'ਬਿਆਲੀ',
+    'ਤਿਰਤਾਲੀ',
+    'ਚੁਵਾਲੀ',
+    'ਪੰਤਾਲੀ',
+    'ਛਿਆਲੀ',
+    'ਸੈਂਤਾਲੀ',
+    'ਅਠਤਾਲੀ',
+    'ਉਨੰਜਾ',
+    'ਪੰਜਾਹ',
+    'ਇਕਵੰਜਾ',
+    'ਬਵੰਜਾ',
+    'ਤਰਵੰਜਾ',
+    'ਚੁਰਵੰਜਾ',
+    'ਪੰਜਵੰਜਾ',
+    'ਛਪੰਜਾ',
+    'ਸੱਤਵੰਜਾ',
+    'ਅਠਵੰਜਾ',
+    'ਉਨਾਹਠ',
+    'ਸੱਠ',
+    'ਇਕਾਹਠ',
+    'ਬਾਹਠ',
+    'ਤਰਸਠ',
+    'ਚੌਂਸਠ',
+    'ਪੈਂਸਠ',
+    'ਛਿਆਸਠ',
+    'ਸੜਸਠ',
+    'ਅੜਸਠ',
+    'ਉਣਹੱਤਰ',
+    'ਸਤੱਰ',
+    'ਇਕਹੱਤਰ',
+    'ਬਹੱਤਰ',
+    'ਤਹੱਤਰ',
+    'ਚੌਹੱਤਰ',
+    'ਪੰਝਹੱਤਰ',
+    'ਛਿਹੱਤਰ',
+    'ਸਤੱਤਰ',
+    'ਅਠੱਤਰ',
+    'ਉਨਾਸੀ',
+    'ਅੱਸੀ',
+    'ਇਕਿਆਸੀ',
+    'ਬਿਆਸੀ',
+    'ਤਰਿਆਸੀ',
+    'ਚੌਰਿਆਸੀ',
+    'ਪਚਾਸੀ',
+    'ਛਿਆਸੀ',
+    'ਸੱਤਾਸੀ',
+    'ਅਠਾਸੀ',
+    'ਨਵਾਸੀ',
+    'ਨੱਬੇ',
+    'ਇਕਾਨਵੇਂ',
+    'ਬਾਨਵੇਂ',
+    'ਤਰਾਨਵੇਂ',
+    'ਚੁਰਾਨਵੇਂ',
+    'ਪੰਚਾਨਵੇਂ',
+    'ਛਿਆਨਵੇਂ',
+    'ਸਤਾਨਵੇਂ',
+    'ਅਠਾਨਵੇਂ',
+    'ਨਿਨਾਨਵੇਂ'
+  ]
+
+  scaleWords = [
+    '',
+    'ਹਜ਼ਾਰ',
+    'ਲੱਖ',
+    'ਕਰੋੜ',
+    'ਅਰਬ',
+    'ਖਰਬ',
+    'ਨੀਲ',
+    'ਪਦਮ',
+    'ਸ਼ੰਖ'
+  ]
+}
+
+export default function convertToWords (value, options = {}) {
+  return new Punjabi(options).convertToWords(value)
+}