n2words 1.20.0 → 1.22.0

package/lib/i18n/en.js

@@ -1,4 +1,4 @@
-import BaseLanguage from '../classes/BaseLanguage.js';
+import BaseLanguage from '../classes/base-language.js';
 
 /**
  * This class is for converting numbers to english words.
@@ -12,14 +12,14 @@ export class English extends BaseLanguage {
     }, options);
 
     super(options, [
-      [1000000000000000000000000000n, 'octillion'],
-      [1000000000000000000000000n, 'septillion'],
-      [1000000000000000000000n, 'sextillion'],
-      [1000000000000000000n, 'quintillion'],
-      [1000000000000000n, 'quadrillion'],
-      [1000000000000n, 'trillion'],
-      [1000000000n, 'billion'],
-      [1000000n, 'million'],
+      [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'],
@@ -61,16 +61,16 @@ export class English extends BaseLanguage {
    */
   merge(lPair, rPair) {
     const lText = Object.keys(lPair)[0];
-    const lNum = BigInt(Object.values(lPair)[0]);
+    const lNumber = BigInt(Object.values(lPair)[0]);
     const rText = Object.keys(rPair)[0];
-    const rNum = BigInt(Object.values(rPair)[0]);
+    const rNumber = BigInt(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 };
+    if (lNumber == 1 && rNumber < 100) return { [rText]: rNumber };
+    else if (100 > lNumber && lNumber > rNumber) return { [`${lText}-${rText}`]: lNumber + rNumber };
+    else if (lNumber >= 100 && 100 > rNumber) return { [`${lText} and ${rText}`]: lNumber + rNumber };
+    else if (rNumber > lNumber) return { [`${lText} ${rText}`]: lNumber * rNumber };
 
-    return { [`${lText} ${rText}`]: lNum + rNum };
+    return { [`${lText} ${rText}`]: lNumber + rNumber };
   }
 }
 
@@ -78,9 +78,9 @@ export class English 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 English(options).floatToCardinal(value);
 }

package/lib/i18n/es.d.ts

@@ -2,15 +2,15 @@
  * 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 N2WordsES extends BaseLanguage {
     constructor(options: any);
     genderStem: any;
-    merge(curr: any, next: any): {
+    merge(current: any, next: any): {
         [x: string]: bigint;
     };
 }
-import BaseLanguage from '../classes/BaseLanguage.js';
+import BaseLanguage from '../classes/base-language.js';

package/lib/i18n/es.js

@@ -1,4 +1,4 @@
-import BaseLanguage from '../classes/BaseLanguage.js';
+import BaseLanguage from '../classes/base-language.js';
 
 export class N2WordsES extends BaseLanguage {
   genderStem;
@@ -12,10 +12,10 @@ export class N2WordsES extends BaseLanguage {
     }, options);
 
     super(options, [
-      [1000000000000000000000000n, 'cuatrillón'],
-      [1000000000000000000n, 'trillón'],
-      [1000000000000n, 'billón'],
-      [1000000n, 'millón'],
+      [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'],
@@ -60,41 +60,41 @@ export class N2WordsES extends BaseLanguage {
     this.genderStem = options.genderStem;
   }
 
-  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 = 'un';
-    } else if (cNum == 100 && nNum % 1000n != 0) {
+    } else if (cNumber == 100 && nNumber % 1000n != 0) {
       cText += 't' + this.genderStem;
     }
 
-    if (nNum < cNum) {
-      if (cNum < 100) {
-        return { [`${cText} y ${nText}`]: cNum + nNum };
+    if (nNumber < cNumber) {
+      if (cNumber < 100) {
+        return { [`${cText} y ${nText}`]: cNumber + nNumber };
       }
-      return { [`${cText} ${nText}`]: cNum + nNum };
-    } else if (nNum % 1000000n == 0 && cNum > 1) {
+      return { [`${cText} ${nText}`]: cNumber + nNumber };
+    } else if (nNumber % 1_000_000n == 0 && cNumber > 1) {
       nText = nText.slice(0, -3) + 'lones';
     }
 
-    if (nNum == 100) {
-      if (cNum == 5) {
+    if (nNumber == 100) {
+      if (cNumber == 5) {
         cText = 'quinien';
         nText = '';
-      } else if (cNum == 7) {
+      } else if (cNumber == 7) {
         cText = 'sete';
-      } else if (cNum == 9) {
+      } else if (cNumber == 9) {
         cText = 'nove';
       }
       nText += 't' + this.genderStem + 's';
     } else {
       nText = ' ' + nText;
     }
-    return { [`${cText}${nText}`]: cNum * nNum };
+    return { [`${cText}${nText}`]: cNumber * nNumber };
   }
 }
 
@@ -102,9 +102,9 @@ export class N2WordsES 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 N2WordsES(options).floatToCardinal(value);
 }

package/lib/i18n/fa.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 N2WordsFA extends AbstractLanguage {
     constructor(options: any);
     namedNumbers: {
@@ -51,4 +51,4 @@ export class N2WordsFA extends AbstractLanguage {
     };
     toCardinal(number: any): any;
 }
-import AbstractLanguage from '../classes/AbstractLanguage.js';
+import AbstractLanguage from '../classes/abstract-language.js';

package/lib/i18n/fa.js

@@ -1,4 +1,4 @@
-import AbstractLanguage from '../classes/AbstractLanguage.js';
+import AbstractLanguage from '../classes/abstract-language.js';
 
 export class N2WordsFA extends AbstractLanguage {
   namedNumbers = {
@@ -40,7 +40,7 @@ export class N2WordsFA extends AbstractLanguage {
     800: 'هشتصد',
     900: 'نهصد',
     1000: 'هزار',
-    1000000: 'میلیون',
+    1_000_000: 'میلیون',
   };
 
   constructor(options) {
@@ -70,7 +70,7 @@ export class N2WordsFA extends AbstractLanguage {
       return `${this.namedNumbers[xhundred]} و ${tail}`;
     }
 
-    if (number > 1000n && number < 1000000n) {
+    if (number > 1000n && number < 1_000_000n) {
       let thousandMultiplier = number / 1000n;
       let namedThousandMultiplier =
         (thousandMultiplier == 1n
@@ -83,11 +83,11 @@ export class N2WordsFA extends AbstractLanguage {
       return `${namedThousandMultiplier}${tail}`;
     }
 
-    if (number > 1000000n) {
-      let millionMultiplier = number / 1000000n;
+    if (number > 1_000_000n) {
+      let millionMultiplier = number / 1_000_000n;
       let namedMillion =
-        this.toCardinal(millionMultiplier) + ' ' + this.namedNumbers[1000000];
-      let tailNumber = number - millionMultiplier * 1000000n;
+        this.toCardinal(millionMultiplier) + ' ' + this.namedNumbers[1_000_000];
+      let tailNumber = number - millionMultiplier * 1_000_000n;
       let tail = tailNumber == 0n ? '' : ' و ' + this.toCardinal(tailNumber);
       return `${namedMillion}${tail}`;
     }
@@ -98,9 +98,9 @@ export class N2WordsFA 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 N2WordsFA(options).floatToCardinal(value);
 }

package/lib/i18n/fr-BE.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 N2WordsFRBE extends N2WordsFR {
 }
 import { N2WordsFR } from './fr.js';

package/lib/i18n/fr-BE.js

@@ -12,9 +12,9 @@ export class N2WordsFRBE extends N2WordsFR {
  * 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 N2WordsFRBE(options).floatToCardinal(value);
 }

package/lib/i18n/fr.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 N2WordsFR extends BaseLanguage {
     constructor(options: any);
-    merge(curr: any, next: any): {
+    merge(current: any, next: any): {
         [x: string]: bigint;
     };
 }
-import BaseLanguage from '../classes/BaseLanguage.js';
+import BaseLanguage from '../classes/base-language.js';

package/lib/i18n/fr.js

@@ -1,4 +1,4 @@
-import BaseLanguage from '../classes/BaseLanguage.js';
+import BaseLanguage from '../classes/base-language.js';
 
 export class N2WordsFR extends BaseLanguage {
   constructor(options) {
@@ -10,14 +10,14 @@ export class N2WordsFR extends BaseLanguage {
     }, options);
 
     super(options, [
-      [1000000000000000000000000000n, 'quadrilliard'],
-      [1000000000000000000000000n, 'quadrillion'],
-      [1000000000000000000000n, 'trilliard'],
-      [1000000000000000000n, 'trillion'],
-      [1000000000000000n, 'billiard'],
-      [1000000000000n, 'billion'],
-      [1000000000n, 'milliard'],
-      [1000000n, 'million'],
+      [1_000_000_000_000_000_000_000_000_000n, 'quadrilliard'],
+      [1_000_000_000_000_000_000_000_000n, 'quadrillion'],
+      [1_000_000_000_000_000_000_000n, 'trilliard'],
+      [1_000_000_000_000_000_000n, 'trillion'],
+      [1_000_000_000_000_000n, 'billiard'],
+      [1_000_000_000_000n, 'billion'],
+      [1_000_000_000n, 'milliard'],
+      [1_000_000n, 'million'],
       [1000n, 'mille'],
       [100n, 'cent'],
       ...(['BE'].includes(options._region) ? [[90n, 'nonante']] : []),
@@ -51,37 +51,37 @@ export class N2WordsFR extends BaseLanguage {
     ]);
   }
 
-  merge(curr, next) { // {'cent':100}, {'vingt-cinq':25}
-    let cText = Object.keys(curr)[0];
+  merge(current, next) { // {'cent':100}, {'vingt-cinq':25}
+    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 };
       }
     } else {
       if (
-        ((cNum - 80n) % 100n == 0 || (cNum % 100n == 0 && cNum < 1000)) &&
-        nNum < 1000000 &&
-        cText[cText.length - 1] == 's'
+        ((cNumber - 80n) % 100n == 0 || (cNumber % 100n == 0 && cNumber < 1000)) &&
+        nNumber < 1_000_000 &&
+        cText.at(-1) == 's'
       ) {
         cText = cText.slice(0, -1); // without last elem
       }
       if (
-        cNum < 1000 && nNum != 1000 &&
-        nText[nText.length - 1] != 's' &&
-        nNum % 100n == 0
+        cNumber < 1000 && nNumber != 1000 &&
+        nText.at(-1) != 's' &&
+        nNumber % 100n == 0
       ) {
         nText += 's';
       }
     }
-    if (nNum < cNum && cNum < 100) {
-      if (nNum % 10n == 1 && cNum != 80) return { [`${cText} et ${nText}`]: cNum + nNum };
-      return { [`${cText}-${nText}`]: cNum + nNum };
+    if (nNumber < cNumber && cNumber < 100) {
+      if (nNumber % 10n == 1 && cNumber != 80) return { [`${cText} et ${nText}`]: cNumber + nNumber };
+      return { [`${cText}-${nText}`]: cNumber + nNumber };
     }
-    if (nNum > cNum) return { [`${cText} ${nText}`]: cNum * nNum };
-    return { [`${cText} ${nText}`]: cNum + nNum };
+    if (nNumber > cNumber) return { [`${cText} ${nText}`]: cNumber * nNumber };
+    return { [`${cText} ${nText}`]: cNumber + nNumber };
   }
 }
 
@@ -89,9 +89,9 @@ export class N2WordsFR 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 N2WordsFR(options).floatToCardinal(value);
 }

package/lib/i18n/he.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 N2WordsHE extends N2WordsRU {
     and: any;
     ones: {

package/lib/i18n/he.js

@@ -58,10 +58,8 @@ export class N2WordsHE extends N2WordsRU {
   };
 
   constructor(options) {
-    /**
-     * @todo Confirm `negativeWord`
-     * @todo Set `separatorWord`
-     */
+    // TODO Confirm `negativeWord`
+    // TODO Set `separatorWord`
     options = Object.assign({
       negativeWord: 'מינוס',
       //separatorWord: ,
@@ -80,17 +78,16 @@ export class N2WordsHE 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;
       }
 
       const [n1, n2, n3] = this.getDigits(x);
 
-      if (i > 0) {
+      if (index > 0) {
         words.push(this.thousands[n1]);
         continue;
       }
@@ -116,7 +113,7 @@ export class N2WordsHE extends N2WordsRU {
     }
 
     if (words.length > 1) {
-      words[words.length - 1] = this.and + words[words.length - 1];
+      words[words.length - 1] = this.and + words.at(-1);
     }
 
     return words.join(' ');
@@ -127,9 +124,9 @@ export class N2WordsHE 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 N2WordsHE(options).floatToCardinal(value);
 }

package/lib/i18n/hr.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 N2WordsHR extends N2WordsRU {
     ones: {
         1: string[];

package/lib/i18n/hr.js

@@ -91,10 +91,9 @@ export class N2WordsHR 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; }
       const [n1, n2, n3] = this.getDigits(x);
       if (n3 > 0) {
@@ -106,12 +105,12 @@ export class N2WordsHR extends N2WordsRU {
       if (n2 == 1) {
         words.push(this.tens[n1]);
       } else if (n1 > 0) {
-        const isFeminine = (this.feminine || this.SCALE[i][3]);
-        const genderIdx = isFeminine ? 1 : 0;
-        words.push(this.ones[n1][genderIdx]);
+        const isFeminine = (this.feminine || this.SCALE[index][3]);
+        const genderIndex = isFeminine ? 1 : 0;
+        words.push(this.ones[n1][genderIndex]);
       }
-      if ((i > 0) && (x != 0)) {
-        words.push(this.pluralize(x, this.SCALE[i]));
+      if ((index > 0) && (x != 0)) {
+        words.push(this.pluralize(x, this.SCALE[index]));
       }
     }
     return words.join(' ');
@@ -122,9 +121,9 @@ export class N2WordsHR 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 N2WordsHR(options).floatToCardinal(value);
 }

package/lib/i18n/hu.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 N2WordsHU extends BaseLanguage {
     constructor(options: any);
     tensToCardinal(number: any): string;
@@ -14,4 +14,4 @@ export class N2WordsHU extends BaseLanguage {
     bigNumberToCardinal(number: any): string;
     toCardinal(number: any, zero?: string): string;
 }
-import BaseLanguage from '../classes/BaseLanguage.js';
+import BaseLanguage from '../classes/base-language.js';

package/lib/i18n/hu.js

@@ -1,4 +1,4 @@
-import BaseLanguage from '../classes/BaseLanguage.js';
+import BaseLanguage from '../classes/base-language.js';
 
 export class N2WordsHU extends BaseLanguage {
   constructor(options) {
@@ -9,14 +9,14 @@ export class N2WordsHU extends BaseLanguage {
     }, options);
 
     super(options, [
-      [1000000000000000000000000000n, 'quadrilliárd'],
-      [1000000000000000000000000n, 'quadrillió'],
-      [1000000000000000000000n, 'trilliárd'],
-      [1000000000000000000n, 'trillió'],
-      [1000000000000000n, 'billiárd'],
-      [1000000000000n, 'billió'],
-      [1000000000n, 'milliárd'],
-      [1000000n, 'millió'],
+      [1_000_000_000_000_000_000_000_000_000n, 'quadrilliárd'],
+      [1_000_000_000_000_000_000_000_000n, 'quadrillió'],
+      [1_000_000_000_000_000_000_000n, 'trilliárd'],
+      [1_000_000_000_000_000_000n, 'trillió'],
+      [1_000_000_000_000_000n, 'billiárd'],
+      [1_000_000_000_000n, 'billió'],
+      [1_000_000_000n, 'milliárd'],
+      [1_000_000n, 'millió'],
       [1000n, 'ezer'],
       [100n, 'száz'],
       [90n, 'kilencven'],
@@ -92,11 +92,11 @@ export class N2WordsHU extends BaseLanguage {
 
   bigNumberToCardinal(number) {
     const numberLength = number.toString().length;
-    let digits = (numberLength % 3 !== 0) ? numberLength : numberLength - 2;
+    let digits = (numberLength % 3 === 0) ? numberLength - 2 : numberLength;
     let exp = 10 ** (Math.floor(digits / 3) * 3);
     let prefix = this.toCardinal(number / BigInt(exp), '');
     let rest = this.toCardinal(number % BigInt(exp), '');
-    let postfix = (rest !== '') ? ('-' + rest) : '';
+    let postfix = (rest === '') ? '' : ('-' + rest);
     return prefix + this.getCardWord(exp) + postfix;
   }
 
@@ -113,7 +113,7 @@ export class N2WordsHU extends BaseLanguage {
       words = this.tensToCardinal(Number(number));
     } else if (number < 1000n) {
       words = this.hundredsToCardinal(Number(number));
-    } else if (number < 1000000n) {
+    } else if (number < 1_000_000n) {
       words = this.thousandsToCardinal(Number(number));
     } else {
       words = this.bigNumberToCardinal(number);
@@ -127,9 +127,9 @@ export class N2WordsHU 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 N2WordsHU(options).floatToCardinal(value);
 }

package/lib/i18n/id.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 N2WordsID extends AbstractLanguage {
     constructor(options: any);
     base: {
@@ -35,9 +35,9 @@ export class N2WordsID extends AbstractLanguage {
     };
     splitBy3(number: any): any[][];
     spell(blocks: any): any[];
-    getHundreds(number: any): any;
+    getHundreds(number: any): any[];
     getTens(number: any): any;
     join(wordBlocks: any): string;
     toCardinal(number: any): string;
 }
-import AbstractLanguage from '../classes/AbstractLanguage.js';
+import AbstractLanguage from '../classes/abstract-language.js';