n2words 1.24.0 → 3.0.0

package/typings/classes/slavic-language.d.ts

@@ -1,145 +0,0 @@
-export default SlavicLanguage;
-/**
- * Array of three plural forms for Slavic languages:
- * - [0]: Singular form (for numbers ending in 1, except 11)
- * - [1]: Few form (for numbers ending in 2-4, except 12-14)
- * - [2]: Many form (for all other numbers: 0, 5-20, and numbers ending in 0, 5-9, 11-19)
- */
-export type SlavicPluralForms = string[];
-/**
- * Mapping from power indices to their plural forms.
- * Example: { '0': ['тысяча', 'тысячи', 'тысяч'], '1': ['миллион', 'миллиона', 'миллионов'] }
- */
-export type SlavicThousandsMap = {
-    [x: string]: SlavicPluralForms;
-};
-/**
- * @typedef {string[]} SlavicPluralForms
- * Array of three plural forms for Slavic languages:
- * - [0]: Singular form (for numbers ending in 1, except 11)
- * - [1]: Few form (for numbers ending in 2-4, except 12-14)
- * - [2]: Many form (for all other numbers: 0, 5-20, and numbers ending in 0, 5-9, 11-19)
- */
-/**
- * @typedef {Object.<string, SlavicPluralForms>} SlavicThousandsMap
- * Mapping from power indices to their plural forms.
- * Example: { '0': ['тысяча', 'тысячи', 'тысяч'], '1': ['миллион', 'миллиона', 'миллионов'] }
- */
-/**
- * Base class for Slavic and related languages with complex pluralization.
- *
- * This class provides a reusable implementation for languages that share:
- * - Three-form pluralization (singular/few/many)
- * - Gender-aware number forms (masculine/feminine for 1, 2)
- * - Hundreds, tens, ones decomposition
- * - Chunk-based large number handling (thousands, millions, etc.)
- * - Inherits decimal handling from AbstractLanguage (supports both grouped and
- *   per-digit modes via the `convertDecimalsPerDigit` class property).
- *
- * Used by: Russian, Czech, Polish, Ukrainian, Serbian, Croatian,
- * as well as Baltic (Lithuanian, Latvian) and Hebrew languages.
- *
- * Subclasses MUST define these properties with language-specific vocabulary:
- * - `ones` - Object mapping 1-9 to masculine forms
- * - `onesFeminine` - Object mapping 1-9 to feminine forms
- * - `tens` - Object mapping 0-9 to teen numbers (10-19)
- * - `twenties` - Object mapping 2-9 to tens (20-90)
- * - `hundreds` - Object mapping 1-9 to hundreds (100-900)
- * - `thousands` - Object mapping power indices to [singular, few, many] forms
- * - `feminine` - Boolean indicating if feminine forms should be used (optional)
- *
- * @abstract
- * @extends AbstractLanguage
- */
-declare class SlavicLanguage extends AbstractLanguage {
-    /**
-     * Initializes the Slavic language converter with language-specific options.
-     *
-     * @param {Object} [options={}] Configuration options.
-     * @param {boolean} [options.feminine=false] Use feminine forms for numbers (affects gender agreement).
-     */
-    constructor({ feminine }?: {
-        feminine?: boolean;
-    });
-    /**
-     * Masculine forms for digits 1-9.
-     *
-     * @type {object}
-     */
-    ones: object;
-    /**
-     * Feminine forms for digits 1-9.
-     *
-     * @type {object}
-     */
-    onesFeminine: object;
-    /**
-     * Words for tens (10, 20, 30, etc.).
-     *
-     * @type {object}
-     */
-    tens: object;
-    /**
-     * Special forms for 21-29 in some languages.
-     *
-     * @type {object}
-     */
-    twenties: object;
-    /**
-     * Words for hundreds (100, 200, 300, etc.).
-     *
-     * @type {object}
-     */
-    hundreds: object;
-    /**
-     * Scale words for thousands, millions, etc.
-     *
-     * @type {object}
-     */
-    thousands: object;
-    /**
-     * Use feminine forms for numbers (affects 1-9).
-     *
-     * @type {boolean}
-     */
-    feminine: boolean;
-    /**
-     * Splits a number string into chunks of X digits.
-     *
-     * Example: splitByX('1234567', 3) => [1n, 234n, 567n]
-     *
-     * @param {string} numberString The number as a string.
-     * @param {number} chunkSize Chunk size (typically 3 for thousands grouping).
-     * @returns {bigint[]} Array of BigInt chunks.
-     */
-    splitByX(numberString: string, chunkSize: number): bigint[];
-    /**
-     * Extracts individual digits from a number (units, tens, hundreds).
-     *
-     * Returns digits in reverse order: [ones, tens, hundreds]
-     * Example: 456 => [6n, 5n, 4n]
-     *
-     * @param {bigint} value The number to extract digits from (0-999).
-     * @returns {bigint[]} Array of [ones, tens, hundreds] as BigInts.
-     */
-    getDigits(value: bigint): bigint[];
-    /**
-     * Selects the correct plural form based on Slavic pluralization rules.
-     *
-     * Slavic languages use three forms:
-     * - Form 0 (singular): numbers ending in 1 (but not 11)
-     * - Form 1 (few): numbers ending in 2-4 (but not 12-14)
-     * - Form 2 (many): all other numbers (0, 5-20, 25-30, etc.)
-     *
-     * Examples (Russian):
-     * - 1, 21, 31... => тысяча (form 0)
-     * - 2-4, 22-24, 32-34... => тысячи (form 1)
-     * - 0, 5-20, 25-30... => тысяч (form 2)
-     *
-     * @param {bigint} n The number to check.
-     * @param {string[]} forms Array of [singular, few, many] forms.
-     * @returns {string} The appropriate form for the number.
-     */
-    pluralize(number: any, pluralForms: any): string;
-}
-import AbstractLanguage from './abstract-language.js';

package/typings/classes/south-asian-language.d.ts

@@ -1,101 +0,0 @@
-export default SouthAsianLanguage;
-/**
- * Array of scale words for the Indian numbering system, in ascending order.
- * - Index 0: Usually empty/unused (ones place)
- * - Index 1: Thousands (hazaar/হাজার/हजार)
- * - Index 2: Lakhs (lakh/লাখ/लाख)
- * - Index 3: Crores (crore/কোটি/करोड़)
- * - Index 4: Arabs (arab/আরব/अरब)
- * Each index i represents the scale word for groups at position i in the Indian system.
- */
-export type SouthAsianScaleWords = Array<string>;
-/**
- * Array of words for numbers 0-99, indexed directly.
- * belowHundred[0] = word for 0, belowHundred[42] = word for 42, etc.
- */
-export type SouthAsianBelowHundred = Array<string>;
-/**
- * @typedef {Array<string>} SouthAsianScaleWords
- * Array of scale words for the Indian numbering system, in ascending order.
- * - Index 0: Usually empty/unused (ones place)
- * - Index 1: Thousands (hazaar/হাজার/हजार)
- * - Index 2: Lakhs (lakh/লাখ/लाख)
- * - Index 3: Crores (crore/কোটি/करोड़)
- * - Index 4: Arabs (arab/আরব/अरब)
- * Each index i represents the scale word for groups at position i in the Indian system.
- */
-/**
- * @typedef {Array<string>} SouthAsianBelowHundred
- * Array of words for numbers 0-99, indexed directly.
- * belowHundred[0] = word for 0, belowHundred[42] = word for 42, etc.
- */
-/**
- * Base class for South Asian languages with shared grouping patterns.
- *
- * This class provides a reusable implementation for South Asian languages that share:
- * - Indian-style number grouping: last 3 digits, then 2-2 (1,23,45,67,89)
- * - Lakh (100,000), Crore (10,000,000), Arab (1,000,000,000) scale words
- * - Standard negative and decimal handling (inherits AbstractLanguage decimal logic,
- *   including `convertDecimalsPerDigit` support when set by subclasses)
- *
- * Used by: Hindi (hi), Bengali (bn), Urdu (ur), Punjabi (pa), Marathi (mr), Gujarati (gu), Kannada (kn)
- *
- * Subclasses MUST define language-specific vocabulary via class properties:
- * - `belowHundred` array with digit and teen words (0-99)
- * - `hundredWord` string used inside `convertBelowThousand`
- * - `scaleWords` array with grouping words (hazaar, lakh, crore, etc.) indexed by grouping level
- * - `negativeWord`, `decimalSeparatorWord`, `zeroWord`, `wordSeparator`
- *
- * @abstract
- * @extends AbstractLanguage
- */
-declare class SouthAsianLanguage extends AbstractLanguage {
-    /**
-     * Array of words for numbers 0-99 (digits and teens).
-     * Index directly: belowHundred[0] through belowHundred[99].
-     * @type {Array<string>}
-     */
-    belowHundred: Array<string>;
-    /**
-     * Word for "hundred" in the language (e.g., 'सौ' in Hindi, 'শত' in Bengali).
-     * Used to construct hundreds (e.g., "1 hundred", "2 hundred").
-     * @type {string}
-     */
-    hundredWord: string;
-    /**
-     * Array of scale words for Indian-style grouping (hazaar, lakh, crore, arab, etc.).
-     * Index 0 is typically unused (ones place, no scale word).
-     * Index 1 is for thousands, Index 2 for lakhs, Index 3 for crores, etc.
-     * @type {Array<string>}
-     */
-    scaleWords: Array<string>;
-    /**
-     * Split a number into Indian numbering system groups.
-     *
-     * The Indian system groups differently than Western (3-3-3) systems:
-     * - First group (rightmost): Up to 3 digits (ones, tens, hundreds)
-     * - Subsequent groups: Exactly 2 digits each (thousands, lakhs, crores, etc.)
-     *
-     * This creates the familiar Indian comma pattern: 1,23,45,67,890
-     *
-     * @protected
-     * @param {bigint} number The number to split into groups
-     * @returns {Array<number>} Array of groups from most significant to least significant
-     *
-     * @example
-     * // splitToGroups(1234567n) → [12, 34, 567]
-     * // Reads as: 12 lakhs, 34 thousands, 567 units
-     * // splitToGroups(98765432n) → [9, 87, 65, 432]
-     * // Reads as: 9 crores, 87 lakhs, 65 thousands, 432 units
-     */
-    protected splitToGroups(number: bigint): Array<number>;
-    /**
-     * Convert a number below 1000 to words (0-999).
-     *
-     * @protected
-     * @param {number} number Value between 0 and 999
-     * @returns {string} Language-specific word representation
-     */
-    protected convertBelowThousand(number: number): string;
-}
-import AbstractLanguage from './abstract-language.js';

package/typings/classes/turkic-language.d.ts

@@ -1,42 +0,0 @@
-export default TurkicLanguage;
-export type TurkicWordPair = {
-    /**
-     * - The Turkic word or phrase
-     */
-    word: string;
-    /**
-     * - The numeric value represented by the word
-     */
-    value: bigint;
-};
-/**
- * @typedef {Object} TurkicWordPair
- * @property {string} word - The Turkic word or phrase
- * @property {bigint} value - The numeric value represented by the word
- */
-/**
- * Base class for Turkic languages with shared grammar patterns.
- *
- * This class provides a reusable implementation for Turkic languages that share:
- * - Space-separated number combinations
- * - Implicit 'bir' (one) before hundreds and thousands
- * - Simple multiplication/addition logic
- * - Consistent magnitude handling
- * - Inherits decimal handling from AbstractLanguage via GreedyScaleLanguage
- *   (supports both grouped and per-digit modes via the `convertDecimalsPerDigit` class property).
- *
- * Used by: Turkish (TR), Azerbaijani (AZ)
- *
- * Subclasses MUST define (from GreedyScaleLanguage requirements):
- * - `scaleWordPairs` array of [value, word] pairs as a class property (ordered descending by value).
- * Optionally, language-specific class properties (e.g., `negativeWord`, `zeroWord`, `decimalSeparatorWord`, `wordSeparator`).
- *
- * TurkicLanguage provides a default `mergeScales()` implementation; subclasses may override
- * if specialized merge logic is needed (unlikely for Turkic languages).
- *
- * @abstract
- * @extends GreedyScaleLanguage
- */
-declare class TurkicLanguage extends GreedyScaleLanguage {
-}
-import GreedyScaleLanguage from './greedy-scale-language.js';

package/typings/languages/ar.d.ts

@@ -1,93 +0,0 @@
-/**
- * Converts a number to Arabic cardinal (written) form.
- *
- * @param {number|string|bigint} value The number to convert.
- * @param {ArabicOptions} [options={}] Configuration options.
- * @returns {string} The number expressed in Arabic 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?: ArabicOptions): string;
-/**
- * @typedef {Object} ArabicOptions
- * @property {string} [negativeWord='ناقص'] Word for negative numbers (minus).
- * @property {boolean} [feminine=false] Use feminine forms for numbers.
- */
-/**
- * Arabic language converter.
- *
- * Converts numbers to Arabic words with full grammatical support:
- * - Gender agreement (masculine/feminine forms)
- * - Complex pluralization rules (singular, dual, plural forms)
- * - Special handling for hundreds, thousands, millions, etc.
- * - Right-to-left text orientation
- * - Traditional Arabic number naming conventions
- *
- * Key Features:
- * - Gender-aware number forms (واحد masculine vs واحدة feminine)
- * - Dual forms: اثنان/اثنتان (two masculine/feminine)
- * - Complex rule system for numbers 3-10 (requiring feminine when referring to countables)
- * - Group-based algorithm: splits number by powers of 1000 (ones, thousands, millions, billions)
- * - Tanween (nunation) for indefinite numbers
- * - Sophisticated pluralization with singular, dual, and plural forms
- *
- * Algorithm:
- * 1. Break number into groups of 3 digits (right to left)
- * 2. For each non-zero group, convert to words using gender and plural rules
- * 3. Append the appropriate magnitude word (ألف/مليون/مليار) with proper plural form
- * 4. Join all groups with spaces
- *
- * Features:
- * - Support for gender-aware number forms
- * - Proper handling of Arabic dual forms (اثنان/اثنتان)
- * - Complex group processing for large numbers
- * - Right-to-left text orientation
- * - Traditional Arabic number naming conventions
- */
-export class Arabic extends AbstractLanguage {
-    /**
-     * Initializes the Arabic converter with language-specific options.
-     *
-     * @param {ArabicOptions} [options={}] Configuration options.
-     */
-    constructor({ negativeWord, feminine }?: ArabicOptions);
-    arabicTens: string[];
-    arabicHundreds: string[];
-    arabicAppendedTwos: string[];
-    arabicTwos: string[];
-    arabicGroup: string[];
-    arabicAppendedGroup: string[];
-    arabicPluralGroups: string[];
-    ones: {
-        masculine: string[];
-        feminine: string[];
-    };
-    feminine: boolean;
-    selectedOnes: string[];
-    /**
-     * Returns the feminine status of a given digit (1-9).
-     *
-     * @param {number} digit - The digit to check (1-9).
-     * @returns {string} The word form of the digit based on feminine status.
-     */
-    digitFeminineStatus(digit: number): string;
-    /**
-     * Processes the Arabic group number and returns the corresponding Arabic representation.
-     * @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, fullNumber: any): string;
-}
-export type ArabicOptions = {
-    /**
-     * Word for negative numbers (minus).
-     */
-    negativeWord?: string;
-    /**
-     * Use feminine forms for numbers.
-     */
-    feminine?: boolean;
-};
-import AbstractLanguage from '../classes/abstract-language.js';

package/typings/languages/az.d.ts

@@ -1,25 +0,0 @@
-/**
- * Converts a number to Azerbaijani cardinal (written) form.
- *
- * @param {number|string|bigint} value The number to convert.
- * @param {Object} [options] Conversion options (see AZ class).
- * @returns {string} The number expressed in Azerbaijani words.
- * @throws {TypeError} If value is NaN or invalid type.
- * @throws {Error} If value is an invalid number string.
- *
- * @example
- * convertToWords(42, { lang: 'az' }); // 'qırx iki'
- * convertToWords(1000, { lang: 'az' }); // 'min'
- */
-export default function convertToWords(value: number | string | bigint, options?: any): string;
-/**
- * Azerbaijani language converter.
- *
- * Inherits from TurkicLanguage shared patterns:
- * - Space-separated number combinations
- * - Omits '1' before hundreds and thousands
- * - Supports flexible word spacing configuration
- */
-export class Azerbaijani extends TurkicLanguage {
-}
-import TurkicLanguage from '../classes/turkic-language.js';

package/typings/languages/bn.d.ts

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

package/typings/languages/cs.d.ts

@@ -1,120 +0,0 @@
-/**
- * Converts a number to Czech cardinal (written) form.
- *
- * @param {number|string|bigint} value The number to convert.
- * @param {SlavicOptions} [options={}] Configuration options.
- * @returns {string} The number expressed in Czech 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?: SlavicOptions): string;
-/**
- * @typedef {Object} SlavicOptions
- * @property {boolean} [feminine=false] Use feminine forms for numbers.
- */
-/**
- * Czech language converter.
- *
- * Implements Czech number words using the Slavic language pattern:
- * - Czech number words (jedna, dva, tři, čtyři, pět...)
- * - Slavic three-form pluralization (tisíc/tisíce/tisíc)
- * - Gender agreement for numbers 1-2
- * - Czech-specific number word endings
- *
- * Key Features:
- * - Three-form pluralization system shared across Slavic languages
- *   * Form 1 (singular): 1 (e.g., "tisíc")
- *   * Form 2 (few): 2-4, 22-24, 32-34... excluding teens (e.g., "tisíce")
- *   * Form 3 (many): all other numbers (e.g., "tisíc")
- * - 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
- *
- * Inherits from SlavicLanguage:
- * - Complex pluralization rules (one/few/many forms)
- * - Group-based large number handling (chunk decomposition via splitByX())
- * - Proper declension patterns via pluralize() method
- */
-export class Czech 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;
-    };
-    thousands: {
-        1: string[];
-        2: string[];
-        3: string[];
-        4: string[];
-        5: string[];
-        6: string[];
-        7: string[];
-        8: string[];
-        9: string[];
-        10: string[];
-    };
-    /**
-     * Returns the Czech word for the decimal separator based on the whole number.
-     *
-     * @returns {string} The Czech word for the decimal separator.
-     */
-    get decimalSeparatorWord(): string;
-    /**
-     * Implements Czech-specific three-form pluralization rules.
-     *
-     * Czech three-form system:
-     * - Form 1 (singular): exactly n=1 (e.g., "tisíc")
-     * - Form 2 (few): n ends in 2-4, excluding teens (22-24, 32-34...) (e.g., "tisíce")
-     * - Form 3 (many): all other numbers (e.g., "tisíc" for 0, 5+)
-     *
-     * @param {bigint} n The number to classify.
-     * @param {Array<string>} forms Array of [singular, few, many] word forms.
-     * @returns {string} The appropriate form for the number n.
-     */
-    pluralize(n: bigint, forms: Array<string>): string;
-}
-export type SlavicOptions = {
-    /**
-     * Use feminine forms for numbers.
-     */
-    feminine?: boolean;
-};
-import SlavicLanguage from '../classes/slavic-language.js';

package/typings/languages/da.d.ts

@@ -1,53 +0,0 @@
-/**
- * Converts a number to Danish cardinal (written) form.
- *
- * @param {number|string|bigint} value The number to convert.
- * @param {Object} [options] Conversion options (see Danish class options).
- * @param {boolean} [options.ordFlag=false] Enable ordinal number conversion.
- * @returns {string} The number expressed in Danish words.
- * @throws {TypeError} If value is NaN or invalid type.
- * @throws {Error} If value is an invalid number string.
- *
- * @example
- * convertToWords(25); // 'femogtyve' (five-and-twenty)
- * convertToWords(50); // 'halvtreds' (half-third-times-twenty)
- */
-export default function convertToWords(value: number | string | bigint, options?: {
-    ordFlag?: boolean;
-}): string;
-/**
- * @typedef {Object} DanishOptions
- * @property {boolean} [ordFlag=false] Enable ordinal number conversion.
- */
-/**
- * Danish language converter.
- *
- * GreedyScaleLanguage with Danish-specific extensions:
- * - Unique vigesimal (base-20) number system for 50-90
- * - Special composition rules ("og" for "and" between units and tens)
- * - Reverse digit order (e.g., "fem-og-tyve" = five-and-twenty = 25)
- * - Support for ordinal numbers via ordFlag option
- *
- * Key Features:
- * - Vigesimal tens: halvtreds (50), treds (60), halvfjerds (70), firs (80), halvfems (90)
- * - Units-before-tens pattern (e.g., "tre-og-tyve" = 23)
- * - "et" prefix for hundreds/thousands (not "en")
- * - Optional ordinal number conversion via ordFlag option
- * - Inline merge logic tailored for Danish ordering
- */
-export class Danish extends GreedyScaleLanguage {
-    /**
-     * Initializes the Danish converter with language-specific options.
-     *
-     * @param {DanishOptions} [options={}] Configuration options.
-     */
-    constructor({ ordFlag }?: DanishOptions);
-    ordFlag: boolean;
-}
-export type DanishOptions = {
-    /**
-     * Enable ordinal number conversion.
-     */
-    ordFlag?: boolean;
-};
-import GreedyScaleLanguage from '../classes/greedy-scale-language.js';

package/typings/languages/de.d.ts

@@ -1,26 +0,0 @@
-/**
- * Converts a number to German cardinal (written) form.
- *
- * @param {number|string|bigint} value The number to convert.
- * @param {Object} [options] Conversion options (see German class options).
- * @returns {string} The number expressed in German words.
- * @throws {TypeError} If value is NaN or invalid type.
- * @throws {Error} If value is an invalid number string.
- *
- * @example
- * convertToWords(42); // 'zweiundvierzig'
- * convertToWords('1.5'); // 'eins komma fünf'
- */
-export default function convertToWords(value: number | string | bigint, options?: any): string;
-/**
- * German language converter.
- *
- * Handles German grammatical features:
- * - "eins" vs "ein" and "eine" forms for 1
- * - Compound words without separators (e.g., "einundzwanzig" = 21)
- * - Million/Billion pluralization
- * - Special characters (e.g., "ü", "ö", "ß")
- */
-export class German extends GreedyScaleLanguage {
-}
-import GreedyScaleLanguage from '../classes/greedy-scale-language.js';

package/typings/languages/el.d.ts

@@ -1,11 +0,0 @@
-/**
- * Converts a number to its word representation in Greek.
- * @param {number|string|bigint} value - The number to convert
- * @param {Object} [options={}] - Conversion options
- * @returns {string} The word representation of the number
- * @example
- * convertToWords(42) // 'σαράντα δύο'
- * convertToWords(1000) // 'χίλια'
- * convertToWords(2000) // 'δύο χίλια'
- */
-export default function convertToWords(value: number | string | bigint, options?: any): string;

package/typings/languages/en.d.ts

@@ -1,30 +0,0 @@
-/**
- * Converts a number to English cardinal (written) form.
- *
- * @param {number|string|bigint} value The number to convert.
- * @param {Object} [options] Conversion options (see English class options).
- * @returns {string} The number expressed in English words.
- * @throws {TypeError} If value is NaN or invalid type.
- * @throws {Error} If value is an invalid number string.
- *
- * @example
- * convertToWords(42); // 'forty-two'
- * convertToWords('1.5'); // 'one point five'
- */
-export default function convertToWords(value: number | string | bigint, options?: any): string;
-/**
- * English language converter.
- *
- * Converts numbers to English words, supporting:
- * - Negative numbers (prepended with "minus")
- * - Decimal numbers (word "point" between whole and fractional parts)
- * - Numbers up to octillions
- *
- * Merge rules:
- * - Hyphenated for compound tens (e.g., "twenty-three")
- * - "and" after hundreds (e.g., "one hundred and one")
- * - Space-separated for larger composites (e.g., "one thousand twenty-three")
- */
-export class English extends GreedyScaleLanguage {
-}
-import GreedyScaleLanguage from '../classes/greedy-scale-language.js';