n2words 1.23.0 → 1.24.0

package/typings/languages/lt.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Converts a number to Lithuanian 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 Lithuanian 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.
+ */
+/**
+ * Lithuanian language converter.
+ *
+ * Implements Lithuanian number words using the Slavic language pattern:
+ * - Lithuanian number words (vienas/viena, du/dvi, trys, keturi...)
+ * - Gender-aware forms (masculine/feminine)
+ * - Baltic three-form pluralization (tūkstantis/tūkstančiai/tūkstančių)
+ * - Lithuanian-specific declension patterns
+ *
+ * Key Features:
+ * - Three-form pluralization system shared across Slavic/Baltic languages
+ *   * Form 1 (singular): 1 (e.g., "tūkstantis")
+ *   * Form 2 (few): 2-4, 22-24, 32-34... excluding teens (e.g., "tūkstančiai")
+ *   * Form 3 (many): all other numbers (e.g., "tūkstančių")
+ * - 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 (vienas/viena, du/dvi, keturi/keturios)
+ * - Complex declension patterns for large numbers
+ * - Baltic language characteristics
+ *
+ * Inherits from SlavicLanguage as Lithuanian uses similar pluralization.
+ */
+export class Lithuanian extends SlavicLanguage {
+    ones: {
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    onesFeminine: {
+        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: string[];
+    thousands: {
+        1: string[];
+        2: string[];
+        3: string[];
+        4: string[];
+        5: string[];
+        6: string[];
+        7: string[];
+        8: string[];
+        9: string[];
+        10: string[];
+    };
+    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/lv.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Converts a number to Latvian 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 Latvian 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.
+ */
+/**
+ * Latvian language converter.
+ *
+ * Implements Latvian number words using the Slavic language pattern:
+ * - Latvian number words (viens, divi, trīs, četri, pieci...)
+ * - Latvian-specific pluralization patterns
+ * - Baltic grammatical structure
+ * - Simplified gender handling compared to Lithuanian
+ *
+ * Key Features:
+ * - Three-form pluralization system shared across Slavic/Baltic languages
+ *   * Form 1 (singular): 1 (e.g., "tūkstotis")
+ *   * Form 2 (few): 2-4, 22-24, 32-34... excluding teens (e.g., "tūkstoši")
+ *   * Form 3 (many): all other numbers (e.g., "tūkstošu")
+ * - 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:
+ * - Latvian diacritical marks (ī, ā, ē, ū, etc.)
+ * - Three-form pluralization (adapted for Latvian)
+ * - Baltic number naming conventions
+ * - Compound number formation (divdesmit, trīsdesmit)
+ *
+ * Inherits from SlavicLanguage for pluralization algorithms.
+ */
+export class Latvian 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: string[];
+    thousands: {
+        1: string[];
+        2: string[];
+        3: string[];
+        4: string[];
+        5: string[];
+        6: string[];
+        7: string[];
+        8: string[];
+        9: string[];
+        10: string[];
+    };
+    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/mr.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Convert a number to Marathi words
+ *
+ * @param {number|string|bigint} value - The number to convert
+ * @param {Object} [options={}] - Conversion options
+ * @returns {string} The Marathi word representation
+ * @example
+ * convertToWords(42) // 'बेचाळीस'
+ * convertToWords(1000) // 'एक हजार'
+ * convertToWords(100000) // 'एक लाख'
+ */
+export default function convertToWords(value: number | string | bigint, options?: any): string;

package/typings/languages/ms.d.ts

@@ -0,0 +1,37 @@
+export default function convertToWords(value: any, options?: {}): string;
+/**
+ * Malay (Bahasa Melayu) language converter.
+ *
+ * Conventions:
+ * - Base-10 structure
+ * - "Se-" prefix for singular units (seratus, seribu, sejuta, sebilion, setrilion)
+ * - Space-separated components (no conjunction like "dan" for tens/ones)
+ * - Grouping by thousands (ribu, juta, bilion, trilion)
+ */
+export class Malay 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;
+    };
+    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';

package/typings/languages/nb.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Converts a number to Norwegian cardinal (written) form.
+ *
+ * @param {number|string|bigint} value The number to convert.
+ * @param {Object} [options] Conversion options (see Norwegian class options).
+ * @returns {string} The number expressed in Norwegian words.
+ * @throws {TypeError} If value is NaN or invalid type.
+ * @throws {Error} If value is an invalid number string.
+ *
+ * @example
+ * convertToWords(42); // 'førti-to'
+ * convertToWords('1.5'); // 'en komma fem'
+ */
+export default function convertToWords(value: number | string | bigint, options?: any): string;
+/**
+ * Norwegian language converter.
+ *
+ * GreedyScaleLanguage with inline Norwegian merge rules:
+ * - Hyphenation for compound numbers (e.g., "tjueen")
+ * - "og" (and) for hundreds combinations
+ * - Comma separation for non-magnitude additions
+ * - Implicit '1' before tens and magnitudes
+ * - Space separators for large numbers
+ */
+export class Norwegian extends GreedyScaleLanguage {
+}
+import GreedyScaleLanguage from '../classes/greedy-scale-language.js';

package/typings/languages/nl.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Converts a number to Dutch cardinal (written) form.
+ *
+ * @param {number|string|bigint} value The number to convert.
+ * @param {Object} [options] Conversion options (see Dutch class options).
+ * @param {boolean} [options.includeOptionalAnd=false] Include optional 'en' (and) separator.
+ * @param {boolean} [options.noHundredPairs=false] Don't combine hundreds with tens/units.
+ * @param {boolean} [options.accentOne=true] Use accented 'één' for standalone 1.
+ * @returns {string} The number expressed in Dutch words.
+ * @throws {TypeError} If value is NaN or invalid type.
+ * @throws {Error} If value is an invalid number string.
+ *
+ * @example
+ * convertToWords(1); // 'één' (default accent)
+ * convertToWords(1, { accentOne: false }); // 'een'
+ * convertToWords(21); // 'eenentwintig' (no accent in compounds)
+ * convertToWords(42); // 'tweeenveertig'
+ * convertToWords('1.5'); // 'één komma vijf'
+ */
+export default function convertToWords(value: number | string | bigint, options?: {
+    includeOptionalAnd?: boolean;
+    noHundredPairs?: boolean;
+    accentOne?: boolean;
+}): string;
+/**
+ * @typedef {Object} DutchOptions
+ * @property {boolean} [includeOptionalAnd=false] Include optional "en" separator.
+ * @property {boolean} [noHundredPairs=false] Disable comma before hundreds.
+ * @property {boolean} [accentOne=true] Use accented "één" for one.
+ */
+/**
+ * Dutch language converter.
+ *
+ * Features:
+ * - Optional "en" (and) separator for tens (includeOptionalAnd)
+ * - Optional comma before hundreds (noHundredPairs)
+ * - Compound word formation without hyphenation
+ */
+export class Dutch extends GreedyScaleLanguage {
+    /**
+     * Initializes the Dutch converter with language-specific options.
+     *
+     * @param {DutchOptions} [options={}] Configuration options.
+     */
+    constructor({ includeOptionalAnd, noHundredPairs, accentOne }?: DutchOptions);
+    includeOptionalAnd: boolean;
+    noHundredPairs: boolean;
+    accentOne: boolean;
+    convertWholePart(value: any): string;
+}
+export type DutchOptions = {
+    /**
+     * Include optional "en" separator.
+     */
+    includeOptionalAnd?: boolean;
+    /**
+     * Disable comma before hundreds.
+     */
+    noHundredPairs?: boolean;
+    /**
+     * Use accented "één" for one.
+     */
+    accentOne?: boolean;
+};
+import GreedyScaleLanguage from '../classes/greedy-scale-language.js';

package/typings/languages/pa-Guru.d.ts

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

package/typings/languages/pl.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Converts a number to Polish cardinal (written) form.
+ *
+ * @param {number|string|bigint} value The number to convert.
+ * @param {SlavicOptions} [options={}] Configuration options.
+ * @returns {string} The number expressed in Polish 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.
+ */
+/**
+ * Polish language converter.
+ *
+ * Implements Polish number words using the Slavic language pattern:
+ * - Polish number words (jeden, dwa, trzy, cztery, pięć...)
+ * - Complex Slavic three-form pluralization (tysiąc/tysiące/tysięcy)
+ * - Polish-specific declension patterns
+ * - Distinctive Polish phonology and orthography
+ *
+ * Key Features:
+ * - Three-form pluralization system shared across Slavic languages
+ *   * Form 1 (singular): 1 (e.g., "tysiąc")
+ *   * Form 2 (few): 2-4, 22-24, 32-34... excluding teens (e.g., "tysiące")
+ *   * Form 3 (many): all other numbers (e.g., "tysięcy")
+ * - 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:
+ * - Polish diacritical marks (ą, ć, ę, ł, ń, ś, ź, ż)
+ * - Gender and case agreement
+ * - Polish-specific number word endings
+ *
+ * Inherits from SlavicLanguage for complex pluralization algorithms.
+ */
+export class Polish 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[];
+    };
+    /**
+     * Implements Polish-specific three-form pluralization rules.
+     *
+     * Polish three-form system:
+     * - Form 1 (singular): exactly n=1 (e.g., "tysiąc")
+     * - Form 2 (few): n ends in 2-4, excluding teens (22-24, 32-34...) (e.g., "tysiące")
+     * - Form 3 (many): all other numbers (e.g., "tysięcy")
+     *
+     * @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/pt.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Converts a number to Portuguese cardinal (written) form.
+ *
+ * @param {number|string|bigint} value The number to convert.
+ * @param {Object} [options] Conversion options (see Portuguese class options).
+ * @returns {string} The number expressed in Portuguese words.
+ * @throws {TypeError} If value is NaN or invalid type.
+ * @throws {Error} If value is an invalid number string.
+ *
+ * @example
+ * convertToWords(42); // 'quarenta e dois'
+ * convertToWords('100.5'); // 'cem vírgula cinco'
+ */
+export default function convertToWords(value: number | string | bigint, options?: any): string;
+/**
+ * (European) Portuguese language converter.
+ *
+ * Features:
+ * - Gender-aware hundreds (hundredos, duzentos, etc.)
+ * - Million/Billion pluralization
+ * - "e" (and) conjunction for number combinations
+ * - Post-processing to normalize word flow
+ */
+export class Portuguese extends GreedyScaleLanguage {
+    static POSTCLEAN_REGEX: RegExp;
+    hundreds: {
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+        8: string;
+        9: string;
+    };
+    finalizeWords(words: any): any;
+}
+import GreedyScaleLanguage from '../classes/greedy-scale-language.js';