n2words 1.20.0 → 1.22.0

package/lib/i18n/id.js

@@ -1,4 +1,4 @@
-import AbstractLanguage from '../classes/AbstractLanguage.js';
+import AbstractLanguage from '../classes/abstract-language.js';
 
 export class N2WordsID extends AbstractLanguage {
   base = {
@@ -41,22 +41,22 @@ export class N2WordsID extends AbstractLanguage {
   splitBy3(number) {
     // Split to groups of 3 numbers: 1234567 -> [['1'], ['234'], ['567']]
     let blocks = [];
-    let strNumber = number.toString();
-    let length = strNumber.length;
+    let stringNumber = number.toString();
+    let length = stringNumber.length;
     let firstBlock;
 
     if (length < 3) {
-      blocks.push([strNumber]);
+      blocks.push([stringNumber]);
     } else {
       let firstBlockLength = length % 3;
 
       if (firstBlockLength > 0) {
-        firstBlock = [strNumber.slice(0, firstBlockLength)];
+        firstBlock = [stringNumber.slice(0, firstBlockLength)];
         blocks.push(firstBlock);
       }
 
-      for (let i = firstBlockLength; i < length; i += 3) {
-        let nextBlock = [strNumber.slice(i, i + 3)];
+      for (let index = firstBlockLength; index < length; index += 3) {
+        let nextBlock = [stringNumber.slice(index, index + 3)];
         blocks.push(nextBlock);
       }
     }
@@ -71,26 +71,18 @@ export class N2WordsID extends AbstractLanguage {
     let spelling;
     let firstBlock = blocks[0];
     if (firstBlock[0].length == 1) {
-      if (firstBlock[0] == '0') {
-        spelling = ['nol'];
-      } else {
-        spelling = this.base[Math.trunc(firstBlock[0])];
-      }
+      spelling = firstBlock[0] == '0' ? ['nol'] : this.base[Math.trunc(firstBlock[0])];
     } else if (firstBlock[0].length == 2) {
       spelling = this.getTens(firstBlock[0]);
     } else {
-      spelling = this.getHundreds(
-        firstBlock[0][0]
-      ).concat(this.getTens(firstBlock[0].slice(1, 3)));
+      spelling = [...this.getHundreds(firstBlock[0][0]), ...this.getTens(firstBlock[0].slice(1, 3))];
     }
-    wordBlocks = wordBlocks.concat([[firstBlock[0], spelling]]);
-    for (let i = 1; i < blocks.length; i++) {
-      let block = blocks[i];
-      spelling = this.getHundreds(block[0][0]).concat(
-        this.getTens(block[0].slice(1, 3))
-      );
-      block = block.concat([spelling]);
-      wordBlocks = wordBlocks.concat([block]);
+    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;
   }
@@ -101,7 +93,7 @@ export class N2WordsID extends AbstractLanguage {
     } else if (number == '0') {
       return [];
     } else {
-      return this.base[Math.trunc(number)].concat(['ratus']);
+      return [...this.base[Math.trunc(number)], 'ratus'];
     }
   }
 
@@ -112,14 +104,12 @@ export class N2WordsID extends AbstractLanguage {
       } else if (number[1] == '1') {
         return ['sebelas'];
       } else {
-        return this.base[Math.trunc(number[1])].concat(['belas']);
+        return [...this.base[Math.trunc(number[1])], 'belas'];
       }
     } else if (number[0] == '0') {
       return this.base[Math.trunc(number[1])];
     } else {
-      return this.base[Math.trunc(number[0])].concat(['puluh']).concat(
-        [this.base[Math.trunc(number[1])]]
-      );
+      return [...this.base[Math.trunc(number[0])], 'puluh', this.base[Math.trunc(number[1])]];
     }
   }
 
@@ -132,15 +122,15 @@ export class N2WordsID extends AbstractLanguage {
       wordList.push('seribu');
       start = 1;
     }
-    for (let i = start; i < length + 1; i++) {
-      wordList = wordList.concat(wordBlocks[i][1]);
-      if (!wordBlocks[i][1].length) {
+    for (let index = start; index < length + 1; index++) {
+      wordList = [...wordList, ...wordBlocks[index][1]];
+      if (wordBlocks[index][1].length === 0) {
         continue;
       }
-      if (i == length) {
+      if (index == length) {
         break;
       }
-      wordList = wordList.concat([this.thousands[(length - i) * 3]]);
+      wordList = [...wordList, this.thousands[(length - index) * 3]];
     }
     return wordList.join(' ');
   }
@@ -158,9 +148,9 @@ export class N2WordsID extends AbstractLanguage {
  * Converts a value to cardinal (written) form.
  * @param {number|string|bigint} value Number to be convert.
  * @param {object} [options] Options for class.
- * @throws {Error} Value cannot be invalid.
  * @returns {string} Value in cardinal (written) format.
+ * @throws {Error} Value cannot be invalid.
  */
-export default function (value, options = {}) {
+export default function floatToCardinal (value, options = {}) {
   return new N2WordsID(options).floatToCardinal(value);
 }

package/lib/i18n/it.d.ts

@@ -2,10 +2,10 @@
  * Converts a value to cardinal (written) form.
  * @param {number|string|bigint} value Number to be convert.
  * @param {object} [options] Options for class.
- * @throws {Error} Value cannot be invalid.
  * @returns {string} Value in cardinal (written) format.
+ * @throws {Error} Value cannot be invalid.
  */
-export default function _default(value: number | string | bigint, options?: object): string;
+export default function floatToCardinal(value: number | string | bigint, options?: object): string;
 export class N2WordsIT extends BaseLanguage {
     constructor(options: any);
     cardinalWords: string[];
@@ -26,4 +26,4 @@ export class N2WordsIT extends BaseLanguage {
     bigNumberToCardinal(number: any): string;
     toCardinal(number: any): any;
 }
-import BaseLanguage from '../classes/BaseLanguage.js';
+import BaseLanguage from '../classes/base-language.js';

package/lib/i18n/it.js

@@ -1,5 +1,6 @@
-import BaseLanguage from '../classes/BaseLanguage.js';
+import BaseLanguage from '../classes/base-language.js';
 
+// TODO Adapt language to work with {@link BaseLanguage} better
 export class N2WordsIT extends BaseLanguage {
   cardinalWords = [
     this.zero, 'uno', 'due', 'tre', 'quattro', 'cinque', 'sei', 'sette', 'otto',
@@ -19,41 +20,30 @@ export class N2WordsIT extends BaseLanguage {
     }, options);
 
     super(options, []);
-
-    /** @todo Adapt language to work with {@link BaseLanguage} better */
   }
 
   accentuate(string) {
     const splittedString = string.split(' ');
 
     const result = splittedString.map(word => {
-      if (word.slice(-3) == 'tre' && word.length > 3) return word.replace(/tré/g, 'tre').slice(0, -3) + 'tré';
-      else return word.replace(/tré/g, 'tre');
+      return word.slice(-3) == 'tre' && word.length > 3 ? word.replaceAll('tré', 'tre').slice(0, -3) + 'tré' : word.replaceAll('tré', 'tre');
     });
     return result.join(' ');
   }
 
   omitIfZero(numberToString) {
-    if (numberToString == this.zero) {
-      return '';
-    } else {
-      return numberToString;
-    }
+    return numberToString == this.zero ? '' : numberToString;
   }
 
   phoneticContraction(string) {
-    return string.replace(/oo/g, 'o').replace(/ao/g, 'o').replace(/io/g, 'o').replace(/au/g, 'u').replace(/iu/g, 'u');
+    return string.replaceAll('oo', 'o').replaceAll('ao', 'o').replaceAll('io', 'o').replaceAll('au', 'u').replaceAll('iu', 'u');
   }
 
   tensToCardinal(number) {
     const tens = Math.floor(number / 10);
     const units = number % 10;
     let prefix;
-    if (Object.prototype.hasOwnProperty.call(this.strTens, tens)) {
-      prefix = this.strTens[tens];
-    } else {
-      prefix = this.cardinalWords[tens].slice(0, -1) + 'anta';
-    }
+    prefix = Object.prototype.hasOwnProperty.call(this.strTens, tens) ? this.strTens[tens] : this.cardinalWords[tens].slice(0, -1) + 'anta';
     const postfix = this.omitIfZero(this.cardinalWords[units]);
     return this.phoneticContraction(prefix + postfix);
   }
@@ -71,26 +61,18 @@ export class N2WordsIT extends BaseLanguage {
   thousandsToCardinal(number) {
     const thousands = Math.floor(number / 1000);
     let prefix;
-    if (thousands == 1) {
-      prefix = 'mille';
-    } else {
-      prefix = this.toCardinal(thousands) + 'mila';
-    }
+    prefix = thousands == 1 ? 'mille' : this.toCardinal(thousands) + 'mila';
     const postfix = this.omitIfZero(this.toCardinal(number % 1000));
     return prefix + postfix;
   }
 
   exponentLengthToString(exponentLength) {
     const prefix = this.exponentPrefixes[Math.floor(exponentLength / 6)];
-    if (exponentLength % 6 == 0) {
-      return prefix + 'ilione';
-    } else {
-      return prefix + 'iliardo';
-    }
+    return exponentLength % 6 == 0 ? prefix + 'ilione' : prefix + 'iliardo';
   }
 
   bigNumberToCardinal(number) {
-    const digits = number.toString().split('');
+    const digits = [...number.toString()];
 
     let preDigits = digits.length % 3;
     if (preDigits == 0) {
@@ -110,17 +92,15 @@ export class N2WordsIT extends BaseLanguage {
       infix = ' ' + infix.slice(0, -1) + 'i'; // without last element
     }
 
+    // TODO ESLint suggestion
+    // eslint-disable-next-line unicorn/consistent-function-scoping
     const isSetsEqual = (a, b) => a.size == b.size && [...a].every(value => b.has(value));
-    if (!isSetsEqual(new Set(exponent), new Set(['0']))) {
+    if (isSetsEqual(new Set(exponent), new Set(['0']))) {
+      postfix = '';
+    } else {
       postfix = this.toCardinal(Math.trunc(exponent.join('')));
 
-      if (postfix.includes(' e ')) {
-        infix += ', '; // for very large numbers
-      } else {
-        infix += ' e ';
-      }
-    } else {
-      postfix = '';
+      infix += (postfix.includes(' e ') ? ', ' : ' e ');
     }
 
     return prefix + infix + postfix;
@@ -135,7 +115,7 @@ export class N2WordsIT extends BaseLanguage {
       words = this.tensToCardinal(Number(number));
     } else if (number < 1000) {
       words = this.hundredsToCardinal(Number(number));
-    } else if (number < 1000000) {
+    } else if (number < 1_000_000) {
       words = this.thousandsToCardinal(Number(number));
     } else {
       words = this.bigNumberToCardinal(number);
@@ -149,9 +129,9 @@ export class N2WordsIT extends BaseLanguage {
  * Converts a value to cardinal (written) form.
  * @param {number|string|bigint} value Number to be convert.
  * @param {object} [options] Options for class.
- * @throws {Error} Value cannot be invalid.
  * @returns {string} Value in cardinal (written) format.
+ * @throws {Error} Value cannot be invalid.
  */
-export default function (value, options = {}) {
+export default function floatToCardinal (value, options = {}) {
   return new N2WordsIT(options).floatToCardinal(value);
 }

package/lib/i18n/ko.d.ts

@@ -2,14 +2,14 @@
  * Converts a value to cardinal (written) form.
  * @param {number|string|bigint} value Number to be convert.
  * @param {object} [options] Options for class.
- * @throws {Error} Value cannot be invalid.
  * @returns {string} Value in cardinal (written) format.
+ * @throws {Error} Value cannot be invalid.
  */
-export default function _default(value: number | string | bigint, options?: object): string;
+export default function floatToCardinal(value: number | string | bigint, options?: object): string;
 export class N2WordsKO extends BaseLanguage {
     constructor(options: any);
     merge(lPair: any, rPair: any): {
         [x: string]: bigint;
     };
 }
-import BaseLanguage from '../classes/BaseLanguage.js';
+import BaseLanguage from '../classes/base-language.js';

package/lib/i18n/ko.js

@@ -1,4 +1,4 @@
-import BaseLanguage from '../classes/BaseLanguage.js';
+import BaseLanguage from '../classes/base-language.js';
 
 export class N2WordsKO extends BaseLanguage {
   constructor(options) {
@@ -9,13 +9,13 @@ export class N2WordsKO extends BaseLanguage {
     }, options);
 
     super(options, [
-      [10000000000000000000000000000n, '양'],
-      [1000000000000000000000000n, '자'],
-      [100000000000000000000n, '해'],
-      [10000000000000000n, '경'],
-      [1000000000000n, '조'],
-      [100000000n, '억'],
-      [10000n, '만'],
+      [10_000_000_000_000_000_000_000_000_000n, '양'],
+      [1_000_000_000_000_000_000_000_000n, '자'],
+      [100_000_000_000_000_000_000n, '해'],
+      [10_000_000_000_000_000n, '경'],
+      [1_000_000_000_000n, '조'],
+      [100_000_000n, '억'],
+      [10_000n, '만'],
       [1000n, '천'],
       [100n, '백'],
       [10n, '십'],
@@ -35,12 +35,12 @@ export class N2WordsKO extends BaseLanguage {
   merge(lPair, rPair) {
     const lText = Object.keys(lPair)[0];
     const rText = Object.keys(rPair)[0];
-    const lNum = BigInt(Object.values(lPair)[0]);
-    const rNum = BigInt(Object.values(rPair)[0]);
-    if (lNum == 1 && rNum <= 10000) return { [rText]: rNum };
-    else if (10000 > lNum && lNum > rNum) return { [`${lText}${rText}`]: lNum + rNum };
-    else if (lNum >= 10000 && lNum > rNum) return { [`${lText} ${rText}`]: lNum + rNum };
-    else return { [`${lText}${rText}`]: lNum * rNum };
+    const lNumber = BigInt(Object.values(lPair)[0]);
+    const rNumber = BigInt(Object.values(rPair)[0]);
+    if (lNumber == 1 && rNumber <= 10_000) return { [rText]: rNumber };
+    else if (10_000 > lNumber && lNumber > rNumber) return { [`${lText}${rText}`]: lNumber + rNumber };
+    else if (lNumber >= 10_000 && lNumber > rNumber) return { [`${lText} ${rText}`]: lNumber + rNumber };
+    else return { [`${lText}${rText}`]: lNumber * rNumber };
   }
 }
 
@@ -48,9 +48,9 @@ export class N2WordsKO extends BaseLanguage {
  * Converts a value to cardinal (written) form.
  * @param {number|string|bigint} value Number to be convert.
  * @param {object} [options] Options for class.
- * @throws {Error} Value cannot be invalid.
  * @returns {string} Value in cardinal (written) format.
+ * @throws {Error} Value cannot be invalid.
  */
-export default function (value, options = {}) {
+export default function floatToCardinal (value, options = {}) {
   return new N2WordsKO(options).floatToCardinal(value);
 }

package/lib/i18n/lt.d.ts

@@ -2,10 +2,10 @@
  * Converts a value to cardinal (written) form.
  * @param {number|string|bigint} value Number to be convert.
  * @param {object} [options] Options for class.
- * @throws {Error} Value cannot be invalid.
  * @returns {string} Value in cardinal (written) format.
+ * @throws {Error} Value cannot be invalid.
  */
-export default function _default(value: number | string | bigint, options?: object): string;
+export default function floatToCardinal(value: number | string | bigint, options?: object): string;
 export class N2WordsLT extends N2WordsRU {
     ones: {
         1: string;

package/lib/i18n/lt.js

@@ -91,10 +91,9 @@ export class N2WordsLT extends N2WordsRU {
     }
     const words = [];
     const chunks = this.splitByX(number.toString(), 3);
-    let i = chunks.length;
-    for (let j = 0; j < chunks.length; j++) {
-      const x = chunks[j];
-      i = i - 1;
+    let index = chunks.length;
+    for (const x of chunks) {
+      index = index - 1;
       if (x == 0) {
         continue;
       }
@@ -113,14 +112,14 @@ export class N2WordsLT extends N2WordsRU {
       if (n2 == 1) {
         words.push(this.tens[n1]);
       } else if (n1 > 0) {
-        if ((i == 1 || this.feminine && i == 0) && number < 1000) {
+        if ((index == 1 || this.feminine && index == 0) && number < 1000) {
           words.push(this.onesFeminine[n1]);
         } else {
           words.push(this.ones[n1]);
         }
       }
-      if (i > 0) {
-        words.push(this.pluralize(x, this.thousands[i]));
+      if (index > 0) {
+        words.push(this.pluralize(x, this.thousands[index]));
       }
     }
     return words.join(' ');
@@ -131,9 +130,9 @@ export class N2WordsLT extends N2WordsRU {
  * Converts a value to cardinal (written) form.
  * @param {number|string|bigint} value Number to be convert.
  * @param {object} [options] Options for class.
- * @throws {Error} Value cannot be invalid.
  * @returns {string} Value in cardinal (written) format.
+ * @throws {Error} Value cannot be invalid.
  */
-export default function (value, options = {}) {
+export default function floatToCardinal (value, options = {}) {
   return new N2WordsLT(options).floatToCardinal(value);
 }

package/lib/i18n/lv.d.ts

@@ -2,10 +2,10 @@
  * Converts a value to cardinal (written) form.
  * @param {number|string|bigint} value Number to be convert.
  * @param {object} [options] Options for class.
- * @throws {Error} Value cannot be invalid.
  * @returns {string} Value in cardinal (written) format.
+ * @throws {Error} Value cannot be invalid.
  */
-export default function _default(value: number | string | bigint, options?: object): string;
+export default function floatToCardinal(value: number | string | bigint, options?: object): string;
 export class N2WordsLV extends N2WordsRU {
     ones: {
         1: string;

package/lib/i18n/lv.js

@@ -65,11 +65,7 @@ export class N2WordsLV extends N2WordsRU {
   pluralize(n, forms) {
     let form = 2;
     if (n != 0n) {
-      if (n % 10n == 1n && n % 100n != 11n) {
-        form = 0;
-      } else {
-        form = 1;
-      }
+      form = n % 10n == 1n && n % 100n != 11n ? 0 : 1;
     }
     return forms[form];
   }
@@ -80,10 +76,9 @@ export class N2WordsLV extends N2WordsRU {
     }
     const words = [];
     const chunks = this.splitByX(number.toString(), 3);
-    let i = chunks.length;
-    for (let j = 0; j < chunks.length; j++) {
-      const x = chunks[j];
-      i = i - 1;
+    let index = chunks.length;
+    for (const x of chunks) {
+      index = index - 1;
       if (x == 0) {
         continue;
       }
@@ -92,8 +87,7 @@ export class N2WordsLV extends N2WordsRU {
         if (n3 == 1 && n2 == 0 && n1 > 0) {
           words.push(this.hundreds[2]);
         } else if (n3 > 1) {
-          words.push(this.ones[n3]);
-          words.push(this.hundreds[1]);
+          words.push(this.ones[n3], this.hundreds[1]);
         } else {
           words.push(this.hundreds[0]);
         }
@@ -103,11 +97,11 @@ export class N2WordsLV extends N2WordsRU {
       }
       if (n2 == 1) {
         words.push(this.tens[n1]);
-      } else if (n1 > 0 && !(i > 0 && x == 1)) {
+      } else if (n1 > 0 && !(index > 0 && x == 1)) {
         words.push(this.ones[n1]);
       }
-      if (i > 0) {
-        words.push(this.pluralize(x, this.thousands[i]));
+      if (index > 0) {
+        words.push(this.pluralize(x, this.thousands[index]));
       }
     }
     return words.join(' ');
@@ -118,9 +112,9 @@ export class N2WordsLV extends N2WordsRU {
  * Converts a value to cardinal (written) form.
  * @param {number|string|bigint} value Number to be convert.
  * @param {object} [options] Options for class.
- * @throws {Error} Value cannot be invalid.
  * @returns {string} Value in cardinal (written) format.
+ * @throws {Error} Value cannot be invalid.
  */
-export default function (value, options = {}) {
+export default function floatToCardinal (value, options = {}) {
   return new N2WordsLV(options).floatToCardinal(value);
 }

package/lib/i18n/nl.d.ts

@@ -2,19 +2,19 @@
  * Converts a value to cardinal (written) form.
  * @param {number|string|bigint} value Number to be convert.
  * @param {object} [options] Options for class.
- * @throws {Error} Value cannot be invalid.
  * @returns {string} Value in cardinal (written) format.
+ * @throws {Error} Value cannot be invalid.
  */
-export default function _default(value: number | string | bigint, options?: object): string;
+export default function floatToCardinal(value: number | string | bigint, options?: object): string;
 export class N2WordsNL extends BaseLanguage {
     constructor(options: any);
     includeOptionalAnd: any;
     noHundredPairs: any;
-    merge(curr: any, next: any): {
+    merge(current: any, next: any): {
         [x: string]: bigint;
     } | {
         [x: string]: number;
     };
     toCardinal(value: any): string;
 }
-import BaseLanguage from '../classes/BaseLanguage.js';
+import BaseLanguage from '../classes/base-language.js';

package/lib/i18n/nl.js

@@ -1,4 +1,4 @@
-import BaseLanguage from '../classes/BaseLanguage.js';
+import BaseLanguage from '../classes/base-language.js';
 
 export class N2WordsNL extends BaseLanguage {
   includeOptionalAnd;
@@ -14,14 +14,14 @@ export class N2WordsNL extends BaseLanguage {
     }, options);
 
     super(options, [
-      [1000000000000000000000000000n, 'quadriljard'],
-      [1000000000000000000000000n, 'quadriljoen'],
-      [1000000000000000000000n, 'triljard'],
-      [1000000000000000000n, 'triljoen'],
-      [1000000000000000n, 'biljard'],
-      [1000000000000n, 'biljoen'],
-      [1000000000n, 'miljard'],
-      [1000000n, 'miljoen'],
+      [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'],
@@ -58,50 +58,50 @@ export class N2WordsNL extends BaseLanguage {
     this.noHundredPairs = options.noHundredPairs;
   }
 
-  merge(curr, next) {
-    let cText = Object.keys(curr)[0];
+  merge(current, next) {
+    let cText = Object.keys(current)[0];
     let nText = Object.keys(next)[0];
-    const cNum = BigInt(Object.values(curr)[0]);
-    const nNum = BigInt(Object.values(next)[0]);
-    if (cNum == 1) {
-      if (nNum < 1000000) {
-        return { [nText]: nNum };
+    const cNumber = BigInt(Object.values(current)[0]);
+    const nNumber = BigInt(Object.values(next)[0]);
+    if (cNumber == 1) {
+      if (nNumber < 1_000_000) {
+        return { [nText]: nNumber };
       }
       cText = 'een';
     }
 
-    let val = 0;
-    if (nNum > cNum) {
-      if (nNum >= 1000000) {
+    let value = 0;
+    if (nNumber > cNumber) {
+      if (nNumber >= 1_000_000) {
         cText += ' ';
-      } else if (nNum > 100) {
+      } else if (nNumber > 100) {
         nText += ' ';
       }
-      val = cNum * nNum;
+      value = cNumber * nNumber;
     } else {
-      if (nNum < 10 && cNum > 10 && cNum < 100) {
-        const temp = nText;
+      if (nNumber < 10 && cNumber > 10 && cNumber < 100) {
+        const temporary = nText;
         nText = cText;
-        const andTxt = temp.endsWith('e') ? 'ën' : 'en';
-        cText = `${temp}${andTxt}`;
-      } else if (nNum < 13 && cNum < 1000 && this.includeOptionalAnd) {
+        const andTxt = temporary.endsWith('e') ? 'ën' : 'en';
+        cText = `${temporary}${andTxt}`;
+      } else if (nNumber < 13 && cNumber < 1000 && this.includeOptionalAnd) {
         cText = `${cText}en`;
-      } else if (nNum < 13 && cNum >= 1000 && this.includeOptionalAnd) {
+      } else if (nNumber < 13 && cNumber >= 1000 && this.includeOptionalAnd) {
         nText = ` en ${nText}`;
-      } else if (cNum >= 1000000) {
+      } else if (cNumber >= 1_000_000) {
         cText += ' ';
       } else {
-        if (cNum == 1000) {
+        if (cNumber == 1000) {
           cText += ' ';
         }
       }
-      val = cNum + nNum;
+      value = cNumber + nNumber;
     }
-    return { [`${cText}${nText}`]: val };
+    return { [`${cText}${nText}`]: value };
   }
 
   toCardinal(value) {
-    if (value >= 1100n && value < 10000n && !this.noHundredPairs) {
+    if (value >= 1100n && value < 10_000n && !this.noHundredPairs) {
       const high = value / 100n;
       const low = value % 100n;
       if (high % 10n !== 0n) {
@@ -117,9 +117,9 @@ export class N2WordsNL extends BaseLanguage {
  * Converts a value to cardinal (written) form.
  * @param {number|string|bigint} value Number to be convert.
  * @param {object} [options] Options for class.
- * @throws {Error} Value cannot be invalid.
  * @returns {string} Value in cardinal (written) format.
+ * @throws {Error} Value cannot be invalid.
  */
-export default function (value, options = {}) {
+export default function floatToCardinal (value, options = {}) {
   return new N2WordsNL(options).floatToCardinal(value);
 }

package/lib/i18n/no.d.ts

@@ -2,14 +2,14 @@
  * Converts a value to cardinal (written) form.
  * @param {number|string|bigint} value Number to be convert.
  * @param {object} [options] Options for class.
- * @throws {Error} Value cannot be invalid.
  * @returns {string} Value in cardinal (written) format.
+ * @throws {Error} Value cannot be invalid.
  */
-export default function _default(value: number | string | bigint, options?: object): string;
+export default function floatToCardinal(value: number | string | bigint, options?: object): string;
 export class N2WordsNO extends BaseLanguage {
     constructor(options: any);
     merge(lPair: any, rPair: any): {
         [x: string]: bigint;
     };
 }
-import BaseLanguage from '../classes/BaseLanguage.js';
+import BaseLanguage from '../classes/base-language.js';