n2words 1.12.2 → 1.14.0

package/lib/i18n/DE.mjs

@@ -1,52 +1,51 @@
-import N2WordsBase from '../classes/N2WordsBase.mjs';
+import BaseLanguage from '../classes/BaseLanguage.mjs';
 
-export class N2WordsDE extends N2WordsBase {
+export class N2WordsDE extends BaseLanguage {
   constructor() {
-    super();
-
-    this.negativeWord = 'minus';
-    this.separatorWord = 'komma';
-    this.zero = 'null';
-    this.cards = [
-      { '1000000000000000000000000000': 'Quadrilliarde' },
-      { '1000000000000000000000000': 'Quadrillion' },
-      { '1000000000000000000000': 'Trilliarde' },
-      { 1000000000000000000: 'Trillion' },
-      { 1000000000000000: 'Billiarde' },
-      { 1000000000000: 'Billion' },
-      { 1000000000: 'Milliarde' },
-      { 1000000: 'Million' },
-      { 1000: 'tausend' },
-      { 100: 'hundert' },
-      { 90: 'neunzig' },
-      { 80: 'achtzig' },
-      { 70: 'siebzig' },
-      { 60: 'sechzig' },
-      { 50: 'fünfzig' },
-      { 40: 'vierzig' },
-      { 30: 'dreißig' },
-      { 20: 'zwanzig' },
-      { 19: 'neunzehn' },
-      { 18: 'achtzehn' },
-      { 17: 'siebzehn' },
-      { 16: 'sechzehn' },
-      { 15: 'fünfzehn' },
-      { 14: 'vierzehn' },
-      { 13: 'dreizehn' },
-      { 12: 'zwölf' },
-      { 11: 'elf' },
-      { 10: 'zehn' },
-      { 9: 'neun' },
-      { 8: 'acht' },
-      { 7: 'sieben' },
-      { 6: 'sechs' },
-      { 5: 'fünf' },
-      { 4: 'vier' },
-      { 3: 'drei' },
-      { 2: 'zwei' },
-      { 1: 'eins' },
-      { 0: 'null' }
-    ];
+    super({
+      negativeWord: 'minus',
+      separatorWord: 'komma',
+      zero: 'null'
+    },[
+      [1000000000000000000000000000n, 'Quadrilliarde'],
+      [1000000000000000000000000n, 'Quadrillion'],
+      [1000000000000000000000n, 'Trilliarde'],
+      [1000000000000000000n, 'Trillion'],
+      [1000000000000000n, 'Billiarde'],
+      [1000000000000n, 'Billion'],
+      [1000000000n, 'Milliarde'],
+      [1000000n, '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']
+    ]);
   }
 
   merge(curr, next) {
@@ -94,6 +93,12 @@ export class N2WordsDE extends N2WordsBase {
   }
 }
 
-export default function(n) {
-  return new N2WordsDE().floatToCardinal(n);
+/**
+ * Converts a value to cardinal (written) form.
+ * @param {number|string} value Number to be convert.
+ * @throws {Error} Value cannot be invalid.
+ * @returns {string} Value in cardinal (written) format.
+ */
+export default function(value) {
+  return new N2WordsDE().floatToCardinal(value);
 }

package/lib/i18n/DK.mjs

@@ -1,53 +1,53 @@
-import N2WordsBase from '../classes/N2WordsBase.mjs';
+import BaseLanguage from '../classes/BaseLanguage.mjs';
 
-export class N2WordsDK extends N2WordsBase {
-  constructor() {
-    super();
+export class N2WordsDK extends BaseLanguage {
+  ordFlag = false;
 
-    this.negativeWord = 'minus';
-    this.separatorWord = 'komma';
-    this.zero = 'nul';
-    this.ordFlag = false;
-    this.cards = [
-      { '1000000000000000000000000000': 'quadrillarder' },
-      { '1000000000000000000000000': 'quadrillioner' },
-      { '1000000000000000000000': 'trillarder' },
-      { '1000000000000000000': 'trillioner' },
-      { '1000000000000000': 'billarder' },
-      { '1000000000000': 'billioner' },
-      { '1000000000': 'millarder' },
-      { '1000000': 'millioner' },
-      { '1000': 'tusind' },
-      { '100': 'hundrede' },
-      { '90': 'halvfems' },
-      { '80': 'firs' },
-      { '70': 'halvfjerds' },
-      { '60': 'treds' },
-      { '50': 'halvtreds' },
-      { '40': 'fyrre' },
-      { '30': 'tredive' },
-      { '20': 'tyve' },
-      { '19': 'nitten' },
-      { '18': 'atten' },
-      { '17': 'sytten' },
-      { '16': 'seksten' },
-      { '15': 'femten' },
-      { '14': 'fjorten' },
-      { '13': 'tretten' },
-      { '12': 'tolv' },
-      { '11': 'elleve' },
-      { '10': 'ti' },
-      { '9': 'ni' },
-      { '8': 'otte' },
-      { '7': 'syv' },
-      { '6': 'seks' },
-      { '5': 'fem' },
-      { '4': 'fire' },
-      { '3': 'tre' },
-      { '2': 'to' },
-      { '1': 'et' },
-      { '0': 'nul' }
-    ];
+  constructor() {
+    super({
+      negativeWord: 'minus',
+      separatorWord: 'komma',
+      zero: 'nul',
+    },[
+      [1000000000000000000000000000n, 'quadrillarder'],
+      [1000000000000000000000000n, 'quadrillioner'],
+      [1000000000000000000000n, 'trillarder'],
+      [1000000000000000000n, 'trillioner'],
+      [1000000000000000n, 'billarder'],
+      [1000000000000n, 'billioner'],
+      [1000000000n, 'millarder'],
+      [1000000n, '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']
+    ]);
   }
 
   merge(curr, next) {
@@ -93,6 +93,12 @@ export class N2WordsDK extends N2WordsBase {
   }
 }
 
-export default function(n) {
-  return new N2WordsDK().floatToCardinal(n);
+/**
+ * Converts a value to cardinal (written) form.
+ * @param {number|string} value Number to be convert.
+ * @throws {Error} Value cannot be invalid.
+ * @returns {string} Value in cardinal (written) format.
+ */
+export default function(value) {
+  return new N2WordsDK().floatToCardinal(value);
 }

package/lib/i18n/EN.mjs

@@ -1,72 +1,83 @@
-import N2WordsBase from '../classes/N2WordsBase.mjs';
+import BaseLanguage from '../classes/BaseLanguage.mjs';
 
-class N2WordsEN extends N2WordsBase {
+/**
+ * This class is for converting numbers to english words.
+ */
+class English extends BaseLanguage {
   constructor() {
-    super();
-
-    this.negativeWord = 'minus';
-    this.separatorWord = 'point';
-    this.zero = 'zero';
-    this.cards = [
-      { '1000000000000000000000000000': 'octillion' },
-      { '1000000000000000000000000': 'septillion' },
-      { '1000000000000000000000': 'sextillion' },
-      { '1000000000000000000': 'quintillion' },
-      { '1000000000000000': 'quadrillion' },
-      { '1000000000000': 'trillion' },
-      { '1000000000': 'billion' },
-      { '1000000': 'million' },
-      { '1000': 'thousand' },
-      { '100': 'hundred' },
-      { '90': 'ninety' },
-      { '80': 'eighty' },
-      { '70': 'seventy' },
-      { '60': 'sixty' },
-      { '50': 'fifty' },
-      { '40': 'forty' },
-      { '30': 'thirty' },
-      { '20': 'twenty' },
-      { '19': 'nineteen' },
-      { '18': 'eighteen' },
-      { '17': 'seventeen' },
-      { '16': 'sixteen' },
-      { '15': 'fifteen' },
-      { '14': 'fourteen' },
-      { '13': 'thirteen' },
-      { '12': 'twelve' },
-      { '11': 'eleven' },
-      { '10': 'ten' },
-      { '9': 'nine' },
-      { '8': 'eight' },
-      { '7': 'seven' },
-      { '6': 'six' },
-      { '5': 'five' },
-      { '4': 'four' },
-      { '3': 'three' },
-      { '2': 'two' },
-      { '1': 'one' },
-      { '0': 'zero' }
-    ];
+    super({
+      negativeWord: 'minus',
+      separatorWord: 'point',
+      zero: 'zero'
+    },[
+      [1000000000000000000000000000n, 'octillion'],
+      [1000000000000000000000000n, 'septillion'],
+      [1000000000000000000000n, 'sextillion'],
+      [1000000000000000000n, 'quintillion'],
+      [1000000000000000n, 'quadrillion'],
+      [1000000000000n, 'trillion'],
+      [1000000000n, 'billion'],
+      [1000000n, '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']
+    ]);
   }
 
   /**
-   *
-   *
+   * Merge word set pairs
    * @param {object} lPair {'one':1}
    * @param {object} rPair {'hundred':100}
    * @returns {object} {'one hundred': 100}
    */
   merge(lPair, rPair) {
-    const lText = Object.keys(lPair)[0]; const lNum = parseInt(Object.values(lPair)[0]);
-    const rText = Object.keys(rPair)[0]; const rNum = parseInt(Object.values(rPair)[0]);
+    const lText = Object.keys(lPair)[0];
+    const lNum = parseInt(Object.values(lPair)[0]);
+    const rText = Object.keys(rPair)[0];
+    const rNum = parseInt(Object.values(rPair)[0]);
+
     if (lNum == 1 && rNum < 100) return { [rText]: rNum };
     else if (100 > lNum && lNum > rNum) return { [`${lText}-${rText}`]: lNum + rNum };
     else if (lNum >= 100 && 100 > rNum) return { [`${lText} and ${rText}`]: lNum + rNum };
     else if (rNum > lNum) return { [`${lText} ${rText}`]: lNum * rNum };
+
     return { [`${lText} ${rText}`]: lNum + rNum };
   }
 }
 
-export default function(n) {
-  return new N2WordsEN().floatToCardinal(n);
+/**
+ * Converts a value to cardinal (written) form.
+ * @param {number|string} value Number to be convert.
+ * @throws {Error} Value cannot be invalid.
+ * @returns {string} Value in cardinal (written) format.
+ */
+export default function(value) {
+  return new English().floatToCardinal(value);
 }

package/lib/i18n/ES.mjs

@@ -1,58 +1,58 @@
-import N2WordsBase from '../classes/N2WordsBase.mjs';
+import BaseLanguage from '../classes/BaseLanguage.mjs';
 
-export class N2WordsES extends N2WordsBase {
-  constructor() {
-    super();
+export class N2WordsES extends BaseLanguage {
+  genderStem = 'o';
 
-    this.genderStem = 'o';
-    this.negativeWord = 'menos';
-    this.separatorWord = 'punto';
-    this.zero = 'cero';
-    this.cards = [
-      { '1000000000000000000000000': 'cuatrillón' },
-      { '1000000000000000000': 'trillón' },
-      { '1000000000000': 'billón' },
-      { '1000000': 'millón' },
-      { '1000': 'mil' },
-      { '100': 'cien' },
-      { '90': 'noventa' },
-      { '80': 'ochenta' },
-      { '70': 'setenta' },
-      { '60': 'sesenta' },
-      { '50': 'cincuenta' },
-      { '40': 'cuarenta' },
-      { '30': 'treinta' },
-      { '29': 'veintinueve' },
-      { '28': 'veintiocho' },
-      { '27': 'veintisiete' },
-      { '26': 'veintiséis' },
-      { '25': 'veinticinco' },
-      { '24': 'veinticuatro' },
-      { '23': 'veintitrés' },
-      { '22': 'veintidós' },
-      { '21': 'veintiuno' },
-      { '20': 'veinte' },
-      { '19': 'diecinueve' },
-      { '18': 'dieciocho' },
-      { '17': 'diecisiete' },
-      { '16': 'dieciseis' },
-      { '15': 'quince' },
-      { '14': 'catorce' },
-      { '13': 'trece' },
-      { '12': 'doce' },
-      { '11': 'once' },
-      { '10': 'diez' },
-      { '9': 'nueve' },
-      { '8': 'ocho' },
-      { '7': 'siete' },
-      { '6': 'seis' },
-      { '5': 'cinco' },
-      { '4': 'cuatro' },
-      { '3': 'tres' },
-      { '2': 'dos' },
-      { '1': 'uno' },
-      { '0': 'cero' }
-    ];
+  constructor() {
+    super({
+      negativeWord: 'menos',
+      separatorWord: 'punto',
+      zero: 'cero'
+    },[
+      [1000000000000000000000000n, 'cuatrillón'],
+      [1000000000000000000n, 'trillón'],
+      [1000000000000n, 'billón'],
+      [1000000n, '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']
+    ]);
   }
 
   merge(curr, next) {
@@ -93,6 +93,12 @@ export class N2WordsES extends N2WordsBase {
   }
 }
 
-export default function(n) {
-  return new N2WordsES().floatToCardinal(n);
+/**
+ * Converts a value to cardinal (written) form.
+ * @param {number|string} value Number to be convert.
+ * @throws {Error} Value cannot be invalid.
+ * @returns {string} Value in cardinal (written) format.
+ */
+export default function(value) {
+  return new N2WordsES().floatToCardinal(value);
 }