n2words 1.24.0 → 3.0.0

package/typings/languages/es.d.ts

@@ -1,43 +0,0 @@
-/**
- * Converts a number to Spanish cardinal (written) form.
- *
- * @param {number|string|bigint} value The number to convert.
- * @param {Object} [options] Conversion options (see ES class).
- * @returns {string} The number expressed in Spanish words.
- * @throws {TypeError} If value is NaN or invalid type.
- * @throws {Error} If value is an invalid number string.
- *
- * @example
- * convertToWords(42, { lang: 'es' }); // 'cuarenta y dos'
- * convertToWords(100, { lang: 'es' }); // 'cien'
- */
-export default function convertToWords(value: number | string | bigint, options?: any): string;
-/**
- * @typedef {Object} SpanishOptions
- * @property {string} [genderStem='o'] Masculine 'o' or feminine 'a' ending.
- */
-/**
- * Spanish language converter.
- *
- * Handles Spanish grammatical features:
- * - Gender agreement for numbers (masculine by default, feminine via `genderStem`)
- * - "y" (and) between tens and units (e.g., "veinte y uno")
- * - Special forms for hundreds (e.g., "cien", "ciento", "doscientos")
- * - Million pluralization
- */
-export class Spanish extends GreedyScaleLanguage {
-    /**
-     * Initializes the Spanish converter.
-     *
-     * @param {SpanishOptions} [options={}] Configuration options.
-     */
-    constructor({ genderStem }?: SpanishOptions);
-    genderStem: string;
-}
-export type SpanishOptions = {
-    /**
-     * Masculine 'o' or feminine 'a' ending.
-     */
-    genderStem?: string;
-};
-import GreedyScaleLanguage from '../classes/greedy-scale-language.js';

package/typings/languages/fa.d.ts

@@ -1,81 +0,0 @@
-/**
- * Converts a number to Persian cardinal (written) form.
- *
- * @param {number|string|bigint} value The number to convert.
- * @param {Object} [options={}] Configuration options.
- * @returns {string} The number expressed in Persian words.
- * @throws {TypeError} If value is NaN or invalid type.
- * @throws {Error} If value is an invalid number string.
- */
-export default function convertToWords(value: number | string | bigint, options?: any): string;
-/**
- * Persian (Farsi) language converter.
- *
- * Converts numbers to Persian words using Persian-Arabic numerals:
- * - Right-to-left script orientation
- * - Base-10 decimal system with Persian number words
- * - Conjunction "و" (va/and) for compound numbers
- * - Traditional Persian number naming conventions
- *
- * Key Features:
- * - Named number lookup table (namedNumbers) for direct mapping 0-999
- * - Group-based algorithm for numbers >= 1000:
- *   1. Split into groups of 3 digits
- *   2. Convert each group to words using named table or recursion
- *   3. Append magnitude word (هزار/میلیون/میلیارد)
- *   4. Join with "و" (and) conjunction
- * - Special compound forms (دویست for 200, سیصد for 300)
- * - Proper Persian grammatical structure
- * - Support for large numbers (thousands, millions, billions, trillions)
- *
- * Features:
- * - Native Persian digits and words
- * - Special compound forms (e.g., دویست for 200, سیصد for 300)
- * - Support for large numbers (thousands, millions)
- * - Proper Persian grammatical structure
- */
-export class Farsi extends AbstractLanguage {
-    namedNumbers: {
-        0: string;
-        1: string;
-        2: string;
-        3: string;
-        4: string;
-        5: string;
-        6: string;
-        7: string;
-        8: string;
-        9: string;
-        10: string;
-        11: string;
-        12: string;
-        13: string;
-        14: string;
-        15: string;
-        16: string;
-        17: string;
-        18: string;
-        19: string;
-        20: string;
-        30: string;
-        40: string;
-        50: string;
-        60: string;
-        70: string;
-        80: string;
-        90: string;
-        100: string;
-        200: string;
-        300: string;
-        400: string;
-        500: string;
-        600: string;
-        700: string;
-        800: string;
-        900: string;
-        1000: string;
-        1000000: string;
-    };
-    convertWholePart(number: any): any;
-}
-import AbstractLanguage from '../classes/abstract-language.js';

package/typings/languages/fil.d.ts

@@ -1,12 +0,0 @@
-/**
- * Convert a number to Filipino words
- *
- * @param {number|string|bigint} value - The number to convert
- * @param {Object} [options={}] - Conversion options
- * @returns {string} The Filipino word representation
- * @example
- * convertToWords(42) // 'apatnapu dalawa'
- * convertToWords(1000) // 'isang libo'
- * convertToWords(123456) // 'isang daang dalawampung tatlong libong apat na daang limampung anim'
- */
-export default function convertToWords(value: number | string | bigint, options?: any): string;

package/typings/languages/fr-BE.d.ts

@@ -1,41 +0,0 @@
-/**
- * Converts a number to Belgian French cardinal (written) form.
- *
- * @param {number|string|bigint} value The number to convert.
- * @param {Object} [options={}] Configuration options.
- * @param {boolean} [options.withHyphenSeparator=false] Use hyphens (true) instead of spaces (false) in compounds.
- * @returns {string} The number expressed in Belgian French words.
- * @throws {TypeError} If value is NaN or invalid type.
- * @throws {Error} If value is an invalid number string.
- */
-export default function convertToWords(value: number | string | bigint, options?: {
-    withHyphenSeparator?: boolean;
-}): string;
-/**
- * @typedef {Object} BelgianFrenchOptions
- * @property {boolean} [withHyphenSeparator=false] Use hyphens (true) instead of spaces (false) in compounds.
- */
-/**
- * Belgian French language converter.
- *
- * Extends the French converter with Belgian French regional variant:
- * - Uses "septante" (70) instead of "soixante-dix"
- * - Uses "nonante" (90) instead of "quatre-vingt-dix"
- * - Maintains standard French "quatre-vingts" for 80
- * - More regular and logical number system than standard French
- *
- * Features:
- * - Regional number word variations (septante, nonante)
- * - Simplified tens naming (no complex arithmetic)
- * - Inherits all other French grammar rules from FR class
- * - Same pluralization and hyphenation patterns as standard French
- */
-export class BelgianFrench extends French {
-}
-export type BelgianFrenchOptions = {
-    /**
-     * Use hyphens (true) instead of spaces (false) in compounds.
-     */
-    withHyphenSeparator?: boolean;
-};
-import { French } from './fr.js';

package/typings/languages/fr.d.ts

@@ -1,43 +0,0 @@
-/**
- * Converts a number to French cardinal (written) form.
- *
- * @param {number|string|bigint} value The number to convert.
- * @param {Object} [options] Conversion options (see FR class).
- * @returns {string} The number expressed in French words.
- * @throws {TypeError} If value is NaN or invalid type.
- * @throws {Error} If value is an invalid number string.
- *
- * @example
- * convertToWords(42, { lang: 'fr' }); // 'quarante-deux'
- * convertToWords(81, { lang: 'fr' }); // 'quatre-vingt-un'
- */
-export default function convertToWords(value: number | string | bigint, options?: any): string;
-/**
- * @typedef {Object} FrenchOptions
- * @property {boolean} [withHyphenSeparator=false] Use hyphens (true) instead of spaces (false) in compounds.
- */
-/**
- * French language converter.
- *
- * Special handling:
- * - Pluralization of "cent" (hundred) and other words
- * - "et" (and) before odd numbers in tens place
- * - Hyphenation for compound numbers
- * - Regional number word variations
- */
-export class French extends GreedyScaleLanguage {
-    /**
-     * Initializes the French converter with language-specific options.
-     *
-     * @param {FrenchOptions} [options={}] Configuration options.
-     */
-    constructor({ withHyphenSeparator }?: FrenchOptions);
-    withHyphenSeparator: boolean;
-}
-export type FrenchOptions = {
-    /**
-     * Use hyphens (true) instead of spaces (false) in compounds.
-     */
-    withHyphenSeparator?: boolean;
-};
-import GreedyScaleLanguage from '../classes/greedy-scale-language.js';

package/typings/languages/gu.d.ts

@@ -1,12 +0,0 @@
-/**
- * Convert a number to Gujarati words
- *
- * @param {number|string|bigint} value - The number to convert
- * @param {Object} [options={}] - Conversion options
- * @returns {string} The Gujarati word representation
- * @example
- * convertToWords(42) // 'બેતાળીસ'
- * convertToWords(1000) // 'એક હજાર'
- * convertToWords(100000) // 'એક લાખ'
- */
-export default function convertToWords(value: number | string | bigint, options?: any): string;

package/typings/languages/he.d.ts

@@ -1,197 +0,0 @@
-/**
- * Converts a number to Hebrew cardinal (written) form.
- *
- * @param {number|string|bigint} value The number to convert.
- * @param {HebrewOptions} [options={}] Configuration options.
- * @returns {string} The number expressed in Hebrew words.
- * @throws {TypeError} If value is NaN or invalid type.
- * @throws {Error} If value is an invalid number string.
- */
-export default function convertToWords(value: number | string | bigint, options?: HebrewOptions): string;
-/**
- * @typedef {Object} HebrewOptions
- * @property {string} [and='ו'] Conjunction character (typically 'ו' for and).
- * @property {boolean} [biblical=false] Use biblical scale words instead of modern ones.
- * @property {boolean} [feminine=false] Use feminine forms for numbers.
- */
-/**
- * Hebrew language converter.
- *
- * Implements Hebrew number words using the Slavic language pattern:
- * - Hebrew alphabet and right-to-left text
- * - Hebrew number words (אחת, שתים, שלוש, ארבע...)
- * - Feminine number forms (default in Hebrew)
- * - Optional "ve" (ו, "and") conjunction between number groups
- *
- * Key Features:
- * - Three-form pluralization system shared across Slavic languages
- *   * Form 1 (singular): 1 (e.g., "אלף")
- *   * Form 2 (few): 2-4, 22-24, 32-34... excluding teens (e.g., "אלפים")
- *   * Form 3 (many): all other numbers (e.g., "אלף")
- * - Chunk-based decomposition (splits into groups of 3 digits: ones, thousands, millions, etc.)
- * - Large number handling via thousands[] array with indexed [singular, few, many] forms
- *
- * Features:
- * - Right-to-left text orientation
- * - Feminine grammatical gender for numbers
- * - Three-form pluralization (similar to Slavic pattern)
- * - Conjunction control via "and" option
- *
- * Inherits from SlavicLanguage for complex pluralization algorithms.
- */
-export class Hebrew extends SlavicLanguage {
-    /**
-     * Initializes the Hebrew converter with language-specific options.
-     *
-     * @param {HebrewOptions} [options={}] Configuration options.
-     */
-    constructor({ and, biblical, feminine }?: HebrewOptions);
-    ones: {
-        1: string;
-        2: string;
-        3: string;
-        4: string;
-        5: string;
-        6: string;
-        7: string;
-        8: string;
-        9: string;
-    };
-    tens: {
-        0: string;
-        1: string;
-        2: string;
-        3: string;
-        4: string;
-        5: string;
-        6: string;
-        7: string;
-        8: string;
-        9: string;
-    };
-    twenties: {
-        2: string;
-        3: string;
-        4: string;
-        5: string;
-        6: string;
-        7: string;
-        8: string;
-        9: string;
-    };
-    hundreds: {
-        1: string;
-        2: string;
-        3: string;
-    };
-    thousands: {
-        1: string;
-        2: string;
-        3: string;
-        4: string;
-        5: string;
-        6: string;
-        7: string;
-        8: string;
-        9: string;
-    };
-    scale: {
-        1: string;
-        2: string;
-        3: string;
-        4: string;
-        5: string;
-        6: string;
-    };
-    scalePlural: {
-        1: string;
-        2: string;
-        3: string;
-        4: string;
-        5: string;
-        6: string;
-    };
-    biblicalOnes: {
-        1: string;
-        2: string;
-        3: string;
-        4: string;
-        5: string;
-        6: string;
-        7: string;
-        8: string;
-        9: string;
-    };
-    biblicalTens: {
-        0: string;
-        1: string;
-        2: string;
-        3: string;
-        4: string;
-        5: string;
-        6: string;
-        7: string;
-        8: string;
-        9: string;
-    };
-    biblicalTwenties: {
-        2: string;
-        3: string;
-        4: string;
-        5: string;
-        6: string;
-        7: string;
-        8: string;
-        9: string;
-    };
-    biblicalHundreds: {
-        1: string;
-        2: string;
-        3: string;
-    };
-    biblicalThousands: {
-        1: string;
-        2: string;
-        3: string;
-        4: string;
-        5: string;
-        6: string;
-        7: string;
-        8: string;
-        9: string;
-    };
-    biblicalScale: {
-        1: string;
-        2: string;
-        3: string;
-        4: string;
-        5: string;
-        6: string;
-    };
-    biblicalScalePlural: {
-        1: string;
-        2: string;
-        3: string;
-        4: string;
-        5: string;
-        6: string;
-    };
-    and: string;
-    biblical: boolean;
-    convertWholePart(number: any): string;
-}
-export type HebrewOptions = {
-    /**
-     * Conjunction character (typically 'ו' for and).
-     */
-    and?: string;
-    /**
-     * Use biblical scale words instead of modern ones.
-     */
-    biblical?: boolean;
-    /**
-     * Use feminine forms for numbers.
-     */
-    feminine?: boolean;
-};
-import SlavicLanguage from '../classes/slavic-language.js';

package/typings/languages/hi.d.ts

@@ -1 +0,0 @@
-export default function convertToWords(value: any, options?: {}): string;

package/typings/languages/hr.d.ts

@@ -1,110 +0,0 @@
-/**
- * Converts a number to Croatian cardinal (written) form.
- *
- * @param {number|string|bigint} value The number to convert.
- * @param {Object} [options={}] Configuration options.
- * @param {boolean} [options.feminine=false] Use feminine forms for numbers.
- * @returns {string} The number expressed in Croatian words.
- * @throws {TypeError} If value is NaN or invalid type.
- * @throws {Error} If value is an invalid number string.
- */
-export default function convertToWords(value: number | string | bigint, options?: {
-    feminine?: boolean;
-}): string;
-/**
- * @typedef {Object} SlavicOptions
- * @property {boolean} [feminine=false] Use feminine forms for numbers.
- */
-/**
- * Croatian language converter.
- *
- * Implements Croatian number words using the Slavic language pattern:
- * - Croatian number words (jedan/jedna, dva/dvije, tri, četiri...)
- * - Gender-aware forms (masculine/feminine)
- * - Slavic three-form pluralization (tisuća/tisuće/tisuća)
- * - Croatian-specific declension endings
- *
- * Key Features:
- * - Three-form pluralization system shared across Slavic languages
- *   * Form 1 (singular): 1 (e.g., "tisuća")
- *   * Form 2 (few): 2-4, 22-24, 32-34... excluding teens (e.g., "tisuće")
- *   * Form 3 (many): all other numbers (e.g., "tisuća")
- * - Chunk-based decomposition (splits into groups of 3 digits: ones, thousands, millions, etc.)
- * - Large number handling via thousands[] array with indexed [singular, few, many] forms
- * - Gender-specific number forms for 1 and 2 (masculine/feminine dual forms)
- *
- * Features:
- * - Dual gender forms for 1 and 2 (jedan/jedna, dva/dvije)
- * - Latin script orthography
- * - Similar structure to Serbian
- *
- * Inherits from SlavicLanguage for complex pluralization algorithms.
- */
-export class Croatian extends SlavicLanguage {
-    ones: {
-        1: string[];
-        2: string[];
-        3: string[];
-        4: string[];
-        5: string[];
-        6: string[];
-        7: string[];
-        8: string[];
-        9: string[];
-    };
-    tens: {
-        0: string;
-        1: string;
-        2: string;
-        3: string;
-        4: string;
-        5: string;
-        6: string;
-        7: string;
-        8: string;
-        9: string;
-    };
-    twenties: {
-        2: string;
-        3: string;
-        4: string;
-        5: string;
-        6: string;
-        7: string;
-        8: string;
-        9: string;
-    };
-    hundreds: {
-        1: string;
-        2: string;
-        3: string;
-        4: string;
-        5: string;
-        6: string;
-        7: string;
-        8: string;
-        9: string;
-    };
-    SCALE: {
-        0: (string | boolean)[];
-        1: (string | boolean)[];
-        2: (string | boolean)[];
-        3: (string | boolean)[];
-        4: (string | boolean)[];
-        5: (string | boolean)[];
-        6: (string | boolean)[];
-        7: (string | boolean)[];
-        8: (string | boolean)[];
-        9: (string | boolean)[];
-        10: (string | boolean)[];
-    };
-    pluralize(n: any, forms: any): any;
-    convertWholePart(number: any): string;
-}
-export type SlavicOptions = {
-    /**
-     * Use feminine forms for numbers.
-     */
-    feminine?: boolean;
-};
-import SlavicLanguage from '../classes/slavic-language.js';

package/typings/languages/hu.d.ts

@@ -1,37 +0,0 @@
-/**
- * Converts a number to Hungarian cardinal (written) form.
- *
- * @param {number|string|bigint} value The number to convert.
- * @param {Object} [options] Conversion options (see Hungarian class options).
- * @returns {string} The number expressed in Hungarian words.
- * @throws {TypeError} If value is NaN or invalid type.
- * @throws {Error} If value is an invalid number string.
- *
- * @example
- * convertToWords(42); // 'negyvenkettő'
- * convertToWords(21); // 'huszonegy'
- */
-export default function convertToWords(value: number | string | bigint, options?: any): string;
-/**
- * Hungarian language converter.
- *
- * Converts numbers to Hungarian words following Hungarian conventions:
- * - Agglutinative structure for compound numbers
- * - No spaces between tens and units (e.g., "huszonegy" = twenty-one)
- * - Special handling for "egy" (one) - often omitted as multiplier
- * - Vowel harmony in compound words
- *
- * Features:
- * - Compact number representations (húsz, harminc, negyven)
- * - Pre-composed twenties (huszonegy through huszonkilenc)
- * - "egész" as decimal separator (meaning "whole")
- * - Support for very large numbers (up to quadrilliards)
- */
-export class Hungarian extends GreedyScaleLanguage {
-    tensToCardinal(number: any): string;
-    hundredsToCardinal(number: any): string;
-    thousandsToCardinal(number: any): string;
-    bigNumberToCardinal(number: any): string;
-    convertWholePart(number: any, zeroWord?: string): string;
-}
-import GreedyScaleLanguage from '../classes/greedy-scale-language.js';

package/typings/languages/id.d.ts

@@ -1,69 +0,0 @@
-/**
- * Converts a number to Indonesian cardinal (written) form.
- *
- * @param {number|string|bigint} value The number to convert.
- * @param {Object} [options={}] Configuration options.
- * @returns {string} The number expressed in Indonesian words.
- * @throws {TypeError} If value is NaN or invalid type.
- * @throws {Error} If value is an invalid number string.
- */
-export default function convertToWords(value: number | string | bigint, options?: any): string;
-/**
- * Indonesian language converter.
- *
- * Converts numbers to Indonesian words following Indonesian conventions:
- * - Simple base-10 structure
- * - "Se-" prefix for one (e.g., "seratus" = one hundred, "seribu" = one thousand)
- * - Space-separated number components
- * - Straightforward grouping by thousands
- *
- * Key Features:
- * - Base number mapping (base) for single digits 0-9
- * - Magnitude scale (thousands) mapping powers of 10 to Indonesian words
- * - Group-based algorithm:
- *   1. Split number into groups of 3 digits
- *   2. For each group, convert ones/tens/hundreds using base and naming rules
- *   3. Apply "se-" prefix for 1 (seratus, seribu, sejuta)
- *   4. Combine with magnitude words
- *   5. Join all parts with spaces
- * - Regular patterns (puluh for tens, ratus for hundreds, ribu for thousands)
- * - Clear grouping: ribu (10³), juta (10⁶), miliar (10⁹), triliun (10¹²)
- *
- * Features:
- * - "Se-" prefix usage for singular units
- * - Support for very large numbers (up to decillions)
- */
-export class Indonesian extends AbstractLanguage {
-    base: {
-        0: any[];
-        1: string[];
-        2: string[];
-        3: string[];
-        4: string[];
-        5: string[];
-        6: string[];
-        7: string[];
-        8: string[];
-        9: string[];
-    };
-    thousands: {
-        3: string;
-        6: string;
-        9: string;
-        12: string;
-        15: string;
-        18: string;
-        21: string;
-        24: string;
-        27: string;
-        30: string;
-        33: string;
-    };
-    splitBy3(number: any): any[][];
-    spell(blocks: any): any[];
-    getHundreds(number: any): any[];
-    getTens(number: any): any;
-    join(wordBlocks: any): string;
-    convertWholePart(number: any): string;
-}
-import AbstractLanguage from '../classes/abstract-language.js';