n2words 1.20.0 → 1.22.0

package/lib/i18n/ar.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 Arabic extends AbstractLanguage {
     constructor(options: any);
     number: any;
@@ -24,10 +24,10 @@ export class Arabic extends AbstractLanguage {
     digitFeminineStatus(digit: any): string;
     /**
      * Processes the Arabic group number and returns the corresponding Arabic representation.
-     * @param {number} groupNumber - The number to process. From 1 to 999.
-     * @param {number} groupLevel - The level of the group.
-     *     Example: 12345678 is processed in blocks: '678' (group 0), '345' (group 1), '12' (group 2)
+     * @param {number} groupNumber - The number to process. (Range: 1-999)
+     * @param {number} groupLevel - Group level to process. (See example)
      * @returns {string} The Arabic representation of the group number.
+     * @example 12345678 is processed in blocks of 3: '678' (group 0), '345' (group 1), '12' (group 2).
      */
     processArabicGroup(groupNumber: number, groupLevel: number): string;
     /**
@@ -38,4 +38,4 @@ export class Arabic extends AbstractLanguage {
      */
     toCardinal(number: number): string;
 }
-import AbstractLanguage from '../classes/AbstractLanguage.js';
+import AbstractLanguage from '../classes/abstract-language.js';

package/lib/i18n/ar.js

@@ -1,4 +1,4 @@
-import AbstractLanguage from '../classes/AbstractLanguage.js';
+import AbstractLanguage from '../classes/abstract-language.js';
 
 export class Arabic extends AbstractLanguage {
   number;
@@ -83,23 +83,23 @@ export class Arabic extends AbstractLanguage {
 
   /**
    * Processes the Arabic group number and returns the corresponding Arabic representation.
-   * @param {number} groupNumber - The number to process. From 1 to 999.
-   * @param {number} groupLevel - The level of the group.
-   *     Example: 12345678 is processed in blocks: '678' (group 0), '345' (group 1), '12' (group 2)
+   * @param {number} groupNumber - The number to process. (Range: 1-999)
+   * @param {number} groupLevel - Group level to process. (See example)
    * @returns {string} The Arabic representation of the group number.
+   * @example 12345678 is processed in blocks of 3: '678' (group 0), '345' (group 1), '12' (group 2).
    */
   processArabicGroup(groupNumber, groupLevel) {
     let tens = groupNumber % 100;
     const hundreds = groupNumber / 100;
-    let retVal = '';
+    let returnValue = '';
 
     if (Math.trunc(hundreds) > 0) {
       if (tens == 0 && Math.trunc(hundreds) == 2) {
-        retVal = this.arabicTwos[0];
+        returnValue = this.arabicTwos[0];
       } else {
-        retVal = this.arabicHundreds[Math.trunc(hundreds)];
-        if (retVal != '' && tens != 0) {
-          retVal += ' و';
+        returnValue = this.arabicHundreds[Math.trunc(hundreds)];
+        if (returnValue != '' && tens != 0) {
+          returnValue += ' و';
         }
       }
     }
@@ -108,32 +108,28 @@ export class Arabic extends AbstractLanguage {
       if (tens === 2 && Math.trunc(hundreds) === 0 && groupLevel > 0) {
         const pow = Math.trunc(Math.log10(Number(this.number)));
         if (pow % 3 === 0 && this.number === 2 * Math.pow(10, pow)) {
-          if (groupNumber === 2) {
-            retVal = this.arabicTwos[Math.trunc(groupLevel)];
-          } else {
-            retVal = this.arabicAppendedTwos[Math.trunc(groupLevel)];
-          }
+          returnValue = groupNumber === 2 ? this.arabicTwos[Math.trunc(groupLevel)] : this.arabicAppendedTwos[Math.trunc(groupLevel)];
         } else {
-          retVal = this.arabicTwos[Math.trunc(groupLevel)];
+          returnValue = this.arabicTwos[Math.trunc(groupLevel)];
         }
       } else if (tens === 1 && groupLevel > 0) {
-        retVal += this.arabicGroup[Math.trunc(groupLevel)];
+        returnValue += this.arabicGroup[Math.trunc(groupLevel)];
       } else {
-        retVal += this.digitFeminineStatus(Math.trunc(tens), groupLevel);
+        returnValue += this.digitFeminineStatus(Math.trunc(tens), groupLevel);
       }
     } else if (tens >= 20) { // 20 -> 99
       const ones = tens % 10;
       const tensIndex = (tens / 10) - 2;
       if (ones > 0) {
-        retVal += this.digitFeminineStatus(ones, groupLevel);
+        returnValue += this.digitFeminineStatus(ones, groupLevel);
       }
-      if (retVal != '' && ones != 0) {
-        retVal += ' و';
+      if (returnValue != '' && ones != 0) {
+        returnValue += ' و';
       }
-      retVal += this.arabicTens[Math.trunc(tensIndex)];
+      returnValue += this.arabicTens[Math.trunc(tensIndex)];
     }
 
-    return retVal;
+    return returnValue;
   }
 
   /**
@@ -148,17 +144,17 @@ export class Arabic extends AbstractLanguage {
     }
 
     this.number = number;
-    let tempNumber = number;
-    let tempNumberDec;
+    let temporaryNumber = number;
+    let temporaryNumberDec;
     let group = 0;
-    let retVal = '';
+    let returnValue = '';
 
     // Loop until number has been reduced to zero or less
-    while (tempNumber > 0) {
-      tempNumberDec = tempNumber;
+    while (temporaryNumber > 0) {
+      temporaryNumberDec = temporaryNumber;
       // Get the remaining value after dividing by 1000
-      const numberToProcess = Number(tempNumberDec % 1000n); // Maximum: 999
-      tempNumber = tempNumberDec / 1000n;
+      const numberToProcess = Number(temporaryNumberDec % 1000n); // Maximum: 999
+      temporaryNumber = temporaryNumberDec / 1000n;
 
       // Process "group"
       const groupDescription = this.processArabicGroup(numberToProcess, group);
@@ -168,30 +164,26 @@ export class Arabic extends AbstractLanguage {
         // Is this after the first "group" ? Because nothing is appeded after group 0.
         if (group > 0) { // hundreds, thousands, etc...
           // Is the return value still empty ?
-          if (retVal != '') {
-            retVal = ' و' + retVal;
+          if (returnValue != '') {
+            returnValue = ' و' + returnValue;
           }
 
           if (numberToProcess > 2) {
-            if (numberToProcess % 100 != 1) {
+            if (numberToProcess % 100 == 1) {
+              returnValue = this.arabicGroup[group] + ' ' + returnValue;
+            } else {
               if (numberToProcess >= 3 && numberToProcess <= 10) {
-                retVal = this.arabicPluralGroups[group] + ' ' + retVal;
+                returnValue = this.arabicPluralGroups[group] + ' ' + returnValue;
               } else {
-                if (retVal != '') {
-                  retVal = this.arabicAppendedGroup[group] + ' ' + retVal;
-                } else {
-                  retVal = this.arabicGroup[group] + ' ' + retVal;
-                }
+                returnValue = returnValue == '' ? this.arabicGroup[group] + ' ' + returnValue : this.arabicAppendedGroup[group] + ' ' + returnValue;
               }
-            } else {
-              retVal = this.arabicGroup[group] + ' ' + retVal;
             }
           }
         }
 
         // Add "group" return to output variable
         // NOTE: Language is right-to-left
-        retVal = groupDescription + ' ' + retVal;
+        returnValue = groupDescription + ' ' + returnValue;
       }
 
       // Increase group level/number
@@ -199,9 +191,9 @@ export class Arabic extends AbstractLanguage {
     }
 
     // Replace multiple spaces with one space
-    retVal = retVal.replace(/ +/g, ' ');
+    returnValue = returnValue.replaceAll(/ +/g, ' ');
 
-    return retVal.trim();
+    return returnValue.trim();
   }
 }
 
@@ -209,9 +201,9 @@ export class Arabic 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 Arabic(options).floatToCardinal(value);
 }

package/lib/i18n/az.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 N2WordsAZ 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/az.js

@@ -1,4 +1,4 @@
-import BaseLanguage from '../classes/BaseLanguage.js';
+import BaseLanguage from '../classes/base-language.js';
 
 export class N2WordsAZ extends BaseLanguage {
   constructor(options) {
@@ -9,11 +9,11 @@ export class N2WordsAZ extends BaseLanguage {
     }, options);
 
     super(options, [
-      [1000000000000000000n, 'kentilyon'],
-      [1000000000000000n, 'katrilyon'],
-      [1000000000000n, 'trilyon'],
-      [1000000000n, 'milyar'],
-      [1000000n, 'milyon'],
+      [1_000_000_000_000_000_000n, 'kentilyon'],
+      [1_000_000_000_000_000n, 'katrilyon'],
+      [1_000_000_000_000n, 'trilyon'],
+      [1_000_000_000n, 'milyar'],
+      [1_000_000n, 'milyon'],
       [1000n, 'min'],
       [100n, 'yüz'],
       [90n, 'doxsan'],
@@ -41,15 +41,15 @@ export class N2WordsAZ 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]);
+    const lNumber = BigInt(Object.values(lPair)[0]);
+    const rNumber = BigInt(Object.values(rPair)[0]);
 
-    if (lNum == 1 && (rNum <= 100 || rNum == 1000)) {
-      return { [rText]: rNum };
-    } else if (rNum > lNum) {
-      return { [`${lText}${this.spaceSeparator}${rText}`]: lNum * rNum };
+    if (lNumber == 1 && (rNumber <= 100 || rNumber == 1000)) {
+      return { [rText]: rNumber };
+    } else if (rNumber > lNumber) {
+      return { [`${lText}${this.spaceSeparator}${rText}`]: lNumber * rNumber };
     } else {
-      return { [`${lText}${this.spaceSeparator}${rText}`]: lNum + rNum };
+      return { [`${lText}${this.spaceSeparator}${rText}`]: lNumber + rNumber };
     }
   }
 }
@@ -58,9 +58,9 @@ export class N2WordsAZ 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 N2WordsAZ(options).floatToCardinal(value);
 }

package/lib/i18n/cz.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 N2WordsCZ extends N2WordsRU {
     ones: {
         1: string;

package/lib/i18n/cz.js

@@ -97,10 +97,9 @@ export class N2WordsCZ 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,11 +112,11 @@ export class N2WordsCZ 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(' ');
@@ -128,9 +127,9 @@ export class N2WordsCZ 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 N2WordsCZ(options).floatToCardinal(value);
 }

package/lib/i18n/de.d.ts

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

package/lib/i18n/de.js

@@ -1,4 +1,4 @@
-import BaseLanguage from '../classes/BaseLanguage.js';
+import BaseLanguage from '../classes/base-language.js';
 
 export class N2WordsDE extends BaseLanguage {
   constructor(options) {
@@ -9,14 +9,14 @@ export class N2WordsDE extends BaseLanguage {
     }, options);
 
     super(options, [
-      [1000000000000000000000000000n, 'Quadrilliarde'],
-      [1000000000000000000000000n, 'Quadrillion'],
-      [1000000000000000000000n, 'Trilliarde'],
-      [1000000000000000000n, 'Trillion'],
-      [1000000000000000n, 'Billiarde'],
-      [1000000000000n, 'Billion'],
-      [1000000000n, 'Milliarde'],
-      [1000000n, 'Million'],
+      [1_000_000_000_000_000_000_000_000_000n, 'Quadrilliarde'],
+      [1_000_000_000_000_000_000_000_000n, 'Quadrillion'],
+      [1_000_000_000_000_000_000_000n, 'Trilliarde'],
+      [1_000_000_000_000_000_000n, 'Trillion'],
+      [1_000_000_000_000_000n, 'Billiarde'],
+      [1_000_000_000_000n, 'Billion'],
+      [1_000_000_000n, 'Milliarde'],
+      [1_000_000n, 'Million'],
       [1000n, 'tausend'],
       [100n, 'hundert'],
       [90n, 'neunzig'],
@@ -50,48 +50,44 @@ export class N2WordsDE extends BaseLanguage {
     ]);
   }
 
-  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 == 100 || nNum == 1000) {
-        return { [`ein${nText}`]: nNum };
-      } else 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 == 100 || nNumber == 1000) {
+        return { [`ein${nText}`]: nNumber };
+      } else if (nNumber < 1_000_000) {
+        return { [nText]: nNumber };
       }
       cText = 'eine';
     }
 
-    let val = 0;
-    if (nNum > cNum) {
-      if (nNum >= 1000000) {
-        if (cNum > 1) {
-          if (nText[nText.length - 1] == 'e') {
-            nText += 'n';
-          } else {
-            nText += 'en';
-          }
+    let value = 0;
+    if (nNumber > cNumber) {
+      if (nNumber >= 1_000_000) {
+        if (cNumber > 1) {
+          nText += nText.at(-1) == 'e' ? 'n' : 'en';
         }
         cText += ' ';
       }
-      val = cNum * nNum;
+      value = cNumber * nNumber;
     } else {
-      if (nNum < 10 && cNum > 10 && cNum < 100) {
-        if (nNum == 1) {
+      if (nNumber < 10 && cNumber > 10 && cNumber < 100) {
+        if (nNumber == 1) {
           nText = 'ein';
         }
-        const temp = nText;
+        const temporary = nText;
         nText = cText;
-        cText = `${temp}und`;
-      } else if (cNum >= 1000000) {
+        cText = `${temporary}und`;
+      } else if (cNumber >= 1_000_000) {
         cText += ' ';
       }
-      val = cNum + nNum;
+      value = cNumber + nNumber;
     }
 
-    return { [`${cText}${nText}`]: val };
+    return { [`${cText}${nText}`]: value };
   }
 }
 
@@ -99,9 +95,9 @@ export class N2WordsDE 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 N2WordsDE(options).floatToCardinal(value);
 }

package/lib/i18n/dk.d.ts

@@ -2,13 +2,13 @@
  * 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 N2WordsDK extends BaseLanguage {
     constructor(options: any);
     ordFlag: any;
-    merge(curr: any, next: any): any;
+    merge(current: any, next: any): any;
 }
-import BaseLanguage from '../classes/BaseLanguage.js';
+import BaseLanguage from '../classes/base-language.js';

package/lib/i18n/dk.js

@@ -1,4 +1,4 @@
-import BaseLanguage from '../classes/BaseLanguage.js';
+import BaseLanguage from '../classes/base-language.js';
 
 export class N2WordsDK extends BaseLanguage {
   ordFlag;
@@ -12,14 +12,14 @@ export class N2WordsDK extends BaseLanguage {
     }, options);
 
     super(options, [
-      [1000000000000000000000000000n, 'quadrillarder'],
-      [1000000000000000000000000n, 'quadrillioner'],
-      [1000000000000000000000n, 'trillarder'],
-      [1000000000000000000n, 'trillioner'],
-      [1000000000000000n, 'billarder'],
-      [1000000000000n, 'billioner'],
-      [1000000000n, 'millarder'],
-      [1000000n, 'millioner'],
+      [1_000_000_000_000_000_000_000_000_000n, 'quadrillarder'],
+      [1_000_000_000_000_000_000_000_000n, 'quadrillioner'],
+      [1_000_000_000_000_000_000_000n, 'trillarder'],
+      [1_000_000_000_000_000_000n, 'trillioner'],
+      [1_000_000_000_000_000n, 'billarder'],
+      [1_000_000_000_000n, 'billioner'],
+      [1_000_000_000n, 'millarder'],
+      [1_000_000n, 'millioner'],
       [1000n, 'tusind'],
       [100n, 'hundrede'],
       [90n, 'halvfems'],
@@ -55,46 +55,46 @@ export class N2WordsDK extends BaseLanguage {
     this.ordFlag = options.ordFlag;
   }
 
-  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]);
-    let val;
-    if (nNum == 100 || nNum == 1000) {
-      next = { [`et${nText}`]: nNum };
+    const cNumber = BigInt(Object.values(current)[0]);
+    const nNumber = BigInt(Object.values(next)[0]);
+    let value;
+    if (nNumber == 100 || nNumber == 1000) {
+      next = { [`et${nText}`]: nNumber };
     }
-    if (cNum == 1) {
-      if (nNum < 1000000 || this.ordFlag) {
+    if (cNumber == 1) {
+      if (nNumber < 1_000_000 || this.ordFlag) {
         return next;
       }
       cText = 'en';
     }
-    if (nNum > cNum) {
-      if (nNum >= 1000000) {
+    if (nNumber > cNumber) {
+      if (nNumber >= 1_000_000) {
         cText += ' ';
       }
-      val = cNum * nNum;
+      value = cNumber * nNumber;
     } else {
-      if (cNum >= 100 && cNum < 1000) {
+      if (cNumber >= 100 && cNumber < 1000) {
         cText += ' og ';
-      } else if (cNum >= 1000 && cNum <= 100000) {
+      } else if (cNumber >= 1000 && cNumber <= 100_000) {
         cText += 'e og ';
       }
-      if ((nNum < 10) && (10 < cNum) && (cNum < 100)) {
-        if (nNum == 1) {
+      if ((nNumber < 10) && (10 < cNumber) && (cNumber < 100)) {
+        if (nNumber == 1) {
           nText = 'en';
         }
-        const temp = nText;
+        const temporary = nText;
         nText = cText;
-        cText = temp + 'og';
-      } else if (cNum >= 1000000) {
+        cText = temporary + 'og';
+      } else if (cNumber >= 1_000_000) {
         cText += ' ';
       }
-      val = cNum + nNum;
+      value = cNumber + nNumber;
     }
     const word = cText + nText;
-    return { [`${word}`]: val };
+    return { [`${word}`]: value };
   }
 }
 
@@ -102,9 +102,9 @@ export class N2WordsDK 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 N2WordsDK(options).floatToCardinal(value);
 }

package/lib/i18n/en.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;
 /**
  * This class is for converting numbers to english words.
  */
@@ -19,4 +19,4 @@ export class English extends BaseLanguage {
      */
     merge(lPair: object, rPair: object): object;
 }
-import BaseLanguage from '../classes/BaseLanguage.js';
+import BaseLanguage from '../classes/base-language.js';