n2words 1.23.1 → 2.0.0

package/lib/i18n/no.d.ts

@@ -1,15 +0,0 @@
-/**
- * Converts a value to cardinal (written) form.
- * @param {number|string|bigint} value Number to be convert.
- * @param {object} [options] Options for class.
- * @returns {string} Value in cardinal (written) format.
- * @throws {Error} Value cannot be invalid.
- */
-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/base-language.js';

package/lib/i18n/no.js

@@ -1,77 +0,0 @@
-import BaseLanguage from '../classes/base-language.js';
-
-export class N2WordsNO extends BaseLanguage {
-  constructor(options) {
-    options = Object.assign({
-      negativeWord: 'minus',
-      separatorWord: 'komma',
-      zero: 'null'
-    }, options);
-
-    super(options, [
-      [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']
-    ]);
-  }
-
-  merge(lPair, rPair) { // {'one':1}, {'hundred':100}
-    const lText = Object.keys(lPair)[0];
-    const rText = Object.keys(rPair)[0];
-    const lNumber = BigInt(Object.values(lPair)[0]);
-    const rNumber = BigInt(Object.values(rPair)[0]);
-    if (lNumber == 1 && rNumber < 100) return { [rText]: rNumber };
-    else if (lNumber < 100 && lNumber > rNumber) return { [`${lText}-${rText}`]: lNumber + rNumber };
-    else if (lNumber >= 100 && rNumber < 100) return { [`${lText} og ${rText}`]: lNumber + rNumber };
-    else if (rNumber > lNumber) return { [`${lText} ${rText}`]: lNumber * rNumber };
-    return { [`${lText}, ${rText}`]: lNumber + rNumber };
-  }
-}
-
-/**
- * Converts a value to cardinal (written) form.
- * @param {number|string|bigint} value Number to be convert.
- * @param {object} [options] Options for class.
- * @returns {string} Value in cardinal (written) format.
- * @throws {Error} Value cannot be invalid.
- */
-export default function floatToCardinal (value, options = {}) {
-  return new N2WordsNO(options).floatToCardinal(value);
-}

package/lib/i18n/pl.js

@@ -1,126 +0,0 @@
-import { N2WordsRU } from './ru.js';
-
-export class N2WordsPL extends N2WordsRU {
-  ones = {
-    1: 'jeden',
-    2: 'dwa',
-    3: 'trzy',
-    4: 'cztery',
-    5: 'pięć',
-    6: 'sześć',
-    7: 'siedem',
-    8: 'osiem',
-    9: 'dziewięć'
-  };
-
-  tens = {
-    0: 'dziesięć',
-    1: 'jedenaście',
-    2: 'dwanaście',
-    3: 'trzynaście',
-    4: 'czternaście',
-    5: 'piętnaście',
-    6: 'szesnaście',
-    7: 'siedemnaście',
-    8: 'osiemnaście',
-    9: 'dziewiętnaście'
-  };
-
-  twenties = {
-    2: 'dwadzieścia',
-    3: 'trzydzieści',
-    4: 'czterdzieści',
-    5: 'pięćdziesiąt',
-    6: 'sześćdziesiąt',
-    7: 'siedemdziesiąt',
-    8: 'osiemdziesiąt',
-    9: 'dziewięćdzisiąt'
-  };
-
-  hundreds = {
-    1: 'sto',
-    2: 'dwieście',
-    3: 'trzysta',
-    4: 'czterysta',
-    5: 'pięćset',
-    6: 'sześćset',
-    7: 'siedemset',
-    8: 'osiemset',
-    9: 'dziewięćset'
-  };
-
-  thousands = {
-    1: ['tysiąc', 'tysiące', 'tysięcy'], // 10^ 3
-    2: ['milion', 'miliony', 'milionów'], // 10^ 6
-    3: ['miliard', 'miliardy', 'miliardów'], // 10^ 9
-    4: ['bilion', 'biliony', 'bilionów'], // 10^ 12
-    5: ['biliard', 'biliardy', 'biliardów'], // 10^ 15
-    6: ['trylion', 'tryliony', 'trylionów'], // 10^ 18
-    7: ['tryliard', 'tryliardy', 'tryliardów'], // 10^ 21
-    8: ['kwadrylion', 'kwadryliony', 'kwadrylionów'], // 10^ 24
-    9: ['kwaryliard', 'kwadryliardy', 'kwadryliardów'], // 10^ 27
-    10: ['kwintylion', 'kwintyliony', 'kwintylionów'], // 10^ 30
-  };
-
-  constructor(options) {
-    options = Object.assign({
-      negativeWord: 'minus',
-      separatorWord: 'przecinek',
-      zero: 'zero'
-    }, options);
-
-    super(options);
-  }
-
-  pluralize(n, forms) {
-    let form = 2;
-    if (n == 1) {
-      form = 0;
-    } else if ((n % 10n < 5n) && (n % 10n > 1n) && ((n % 100n < 10n) || (n % 100n > 20n))) {
-      form = 1;
-    }
-    return forms[form];
-  }
-
-  toCardinal(number) {
-    if (number == 0) {
-      return this.zero;
-    }
-    const words = [];
-    const chunks = this.splitByX(number.toString(), 3);
-    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) {
-        words.push(this.hundreds[n3]);
-      }
-      if (n2 > 1) {
-        words.push(this.twenties[n2]);
-      }
-      if (n2 == 1) {
-        words.push(this.tens[n1]);
-      } else if (n1 > 0 && !(index > 0 && x == 1)) {
-        words.push(this.ones[n1]);
-      }
-      if (index > 0) {
-        words.push(this.pluralize(x, this.thousands[index]));
-      }
-    }
-    return words.join(' ');
-  }
-}
-
-/**
- * Converts a value to cardinal (written) form.
- * @param {number|string|bigint} value Number to be convert.
- * @param {object} [options] Options for class.
- * @returns {string} Value in cardinal (written) format.
- * @throws {Error} Value cannot be invalid.
- */
-export default function floatToCardinal (value, options = {}) {
-  return new N2WordsPL(options).floatToCardinal(value);
-}

package/lib/i18n/pt.d.ts

@@ -1,26 +0,0 @@
-/**
- * Converts a value to cardinal (written) form.
- * @param {number|string|bigint} value Number to be convert.
- * @param {object} [options] Options for class.
- * @returns {string} Value in cardinal (written) format.
- * @throws {Error} Value cannot be invalid.
- */
-export default function floatToCardinal(value: number | string | bigint, options?: object): string;
-export class N2WordsPT extends BaseLanguage {
-    constructor(options: any);
-    hundreds: {
-        1: string;
-        2: string;
-        3: string;
-        4: string;
-        5: string;
-        6: string;
-        7: string;
-        8: string;
-        9: string;
-    };
-    merge(current: any, next: any): {
-        [x: string]: bigint;
-    };
-}
-import BaseLanguage from '../classes/base-language.js';

package/lib/i18n/pt.js

@@ -1,118 +0,0 @@
-import BaseLanguage from '../classes/base-language.js';
-
-export class N2WordsPT extends BaseLanguage {
-  hundreds = {
-    1: 'cento',
-    2: 'duzentos',
-    3: 'trezentos',
-    4: 'quatrocentos',
-    5: 'quinhentos',
-    6: 'seiscentos',
-    7: 'setecentos',
-    8: 'oitocentos',
-    9: 'novecentos'
-  };
-
-  constructor(options) {
-    options = Object.assign({
-      negativeWord: 'menos',
-      separatorWord: 'vírgula',
-      zero: 'zero'
-    }, options);
-
-    super(options, [
-      [1_000_000_000_000_000_000_000_000n, 'quatrilião'],
-      [1_000_000_000_000_000_000n, 'trilião'],
-      [1_000_000_000_000n, 'bilião'],
-      [1_000_000n, 'milião'],
-      [1000n, 'mil'],
-      [100n, 'cem'],
-      [90n, 'noventa'],
-      [80n, 'oitenta'],
-      [70n, 'setenta'],
-      [60n, 'sessenta'],
-      [50n, 'cinquenta'],
-      [40n, 'quarenta'],
-      [30n, 'trinta'],
-      [20n, 'vinte'],
-      [19n, 'dezanove'],
-      [18n, 'dezoito'],
-      [17n, 'dezassete'],
-      [16n, 'dezasseis'],
-      [15n, 'quinze'],
-      [14n, 'catorze'],
-      [13n, 'treze'],
-      [12n, 'doze'],
-      [11n, 'onze'],
-      [10n, 'dez'],
-      [9n, 'nove'],
-      [8n, 'oito'],
-      [7n, 'sete'],
-      [6n, 'seis'],
-      [5n, 'cinco'],
-      [4n, 'quatro'],
-      [3n, 'três'],
-      [2n, 'dois'],
-      [1n, 'um'],
-      [0n, 'zero']
-    ]);
-  }
-
-  postClean(words) {
-    const transforms = ['mil', 'milhão', 'milhões', 'mil milhões', 'bilião', 'biliões', 'mil biliões'];
-
-    for (const transform of transforms) {
-      if (new RegExp(`.*${transform} e \\w*entos? (?=.*e)`).test(words)) {
-        words = words.replaceAll(new RegExp(`${transform} e`, 'g'), `${transform}`);
-      }
-    }
-
-    return words;
-  }
-
-  merge(current, next) {
-    let cText = Object.keys(current)[0];
-    let nText = Object.keys(next)[0];
-    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 = 'um';
-    } else if (cNumber == 100 && nNumber % 1000n != 0) {
-      cText = 'cento';
-    }
-
-    if (nNumber < cNumber) {
-      // if (cNum < 100) {
-      //   return { [`${cText} e ${nText}`]: cNum + nNum }
-      // }
-      return { [`${cText} e ${nText}`]: cNumber + nNumber };
-    } else if (nNumber % 1_000_000_000n == 0 && cNumber > 1) {
-      nText = nText.slice(0, -4) + 'liões';
-    } else if (nNumber % 1_000_000n == 0 && cNumber > 1) {
-      nText = nText.slice(0, -4) + 'lhões';
-    }
-
-    if (nText == 'milião') nText = 'milhão';
-
-    if (nNumber == 100) {
-      cText = this.hundreds[cNumber];
-      nText = '';
-    } else {
-      nText = ' ' + nText;
-    }
-    return { [`${cText}${nText}`]: cNumber * nNumber };
-  }
-}
-
-/**
- * Converts a value to cardinal (written) form.
- * @param {number|string|bigint} value Number to be convert.
- * @param {object} [options] Options for class.
- * @returns {string} Value in cardinal (written) format.
- * @throws {Error} Value cannot be invalid.
- */
-export default function floatToCardinal (value, options = {}) {
-  return new N2WordsPT(options).floatToCardinal(value);
-}

package/lib/i18n/ro.d.ts

@@ -1,109 +0,0 @@
-/**
- * Converts a value to cardinal (written) form.
- * @param {number|string|bigint} value Number to be convert.
- * @param {object} [options] Options for class.
- * @returns {string} Value in cardinal (written) format.
- */
-export default function floatToCardinal(value: number | string | bigint, options?: object): string;
-export class N2WordsRO extends AbstractLanguage {
-    constructor(options: any);
-    /** @type {boolean} */
-    feminine: boolean;
-    /** @type {object} */
-    ones: object;
-    /** @type {object} */
-    onesFeminine: object;
-    /** @type {object} */
-    tens: object;
-    /** @type {object} */
-    tensMasculine: object;
-    /** @type {object} */
-    twenties: object;
-    /** @type {object} */
-    hundreds: object;
-    /**
-     * Romanian big units.
-     * For each power group we keep: singular, plural, feminineUnits?, needsDe?
-     * - 10^3: mie/mii (feminine units in chunk; "de" for chunk >= 20)
-     * - 10^6: milion/milioane ("de" for chunk >= 20)
-     * - 10^9: miliard/miliarde ("de" for chunk >= 20)
-     */
-    thousands: {
-        1: {
-            singular: string;
-            plural: string;
-            feminine: boolean;
-            needsDe: boolean;
-        };
-        2: {
-            singular: string;
-            plural: string;
-            feminine: boolean;
-            needsDe: boolean;
-        };
-        3: {
-            singular: string;
-            plural: string;
-            feminine: boolean;
-            needsDe: boolean;
-        };
-        4: {
-            singular: string;
-            plural: string;
-            feminine: boolean;
-            needsDe: boolean;
-        };
-        5: {
-            singular: string;
-            plural: string;
-            feminine: boolean;
-            needsDe: boolean;
-        };
-        6: {
-            singular: string;
-            plural: string;
-            feminine: boolean;
-            needsDe: boolean;
-        };
-        7: {
-            singular: string;
-            plural: string;
-            feminine: boolean;
-            needsDe: boolean;
-        };
-        8: {
-            singular: string;
-            plural: string;
-            feminine: boolean;
-            needsDe: boolean;
-        };
-    };
-    toCardinal(number: any): any;
-    /**
-     * Split numeric string into BigInt groups of size x from left to right.
-     * @param {string} n - The numeric string to split
-     * @param {number} x - The size of each group
-     * @returns {bigint[]} Array of BigInt groups
-     */
-    splitByX(n: string, x: number): bigint[];
-    getDigits(value: any): any;
-    /**
-     * Romanian pluralization & "de" rule for big units.
-     * - 1 → singular with article ("o mie", "un milion", "un miliard", …)
-     * - otherwise → spell chunk + (optional "de") + plural
-     * "de" is inserted when chunk >= 20 (e.g., "douăzeci de mii/milioane/miliarde").
-     * @param {bigint} chunk - The chunk value
-     * @param {object} form - The form object with singular, plural, feminine, needsDe properties
-     * @returns {string} The pluralized form
-     */
-    romanianPluralize(chunk: bigint, form: object): string;
-    spellUnder100(n: any, feminineUnits?: boolean): any;
-    spellUnder1000(n: any, feminineUnits?: boolean): any;
-    /**
-     * Convert number to cardinal form using masculine units
-     * @param {bigint} number Number to convert
-     * @returns {string} Value in written format
-     */
-    toCardinalWithMasculine(number: bigint): string;
-}
-import AbstractLanguage from '../classes/abstract-language.js';