n2words 5.1.1 → 5.1.2

package/src/ur-PK.d.ts

@@ -1,12 +1,23 @@
-export const cardinalMax: bigint;
-export const ordinalMax: bigint;
-export const currencyMax: bigint;
+/**
+ * Urdu (Pakistan) language converter
+ *
+ * CLDR: ur-PK | Urdu as used in Pakistan
+ *
+ * Key features:
+ * - Indian numbering system (ہزار, لاکھ, کروڑ)
+ * - Urdu script (right-to-left)
+ * - 3-2-2 grouping pattern (last 3 digits, then groups of 2)
+ * - Complete word forms for 0-99
+ */
+export declare const cardinalMax: bigint;
+export declare const ordinalMax: bigint;
+export declare const currencyMax: bigint;
 /**
  * Converts a numeric value to Urdu words.
  * @param {number | string | bigint} value - The numeric value to convert
  * @returns {string} The number in Urdu words
  */
-export function toCardinal(value: number | string | bigint): string;
+declare function toCardinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Urdu ordinal words.
  * @param {number | string | bigint} value - The numeric value to convert (positive integer)
@@ -19,7 +30,7 @@ export function toCardinal(value: number | string | bigint): string;
  * toOrdinal(3)    // 'تیسرا'
  * toOrdinal(10)   // 'دسواں'
  */
-export function toOrdinal(value: number | string | bigint): string;
+declare function toOrdinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Urdu currency words (Pakistani Rupee).
  * @param {number | string | bigint} value - The currency amount to convert
@@ -31,4 +42,5 @@ export function toOrdinal(value: number | string | bigint): string;
  * toCurrency(1)      // 'ایک روپیہ'
  * toCurrency(0.01)   // 'ایک پیسہ'
  */
-export function toCurrency(value: number | string | bigint): string;
+declare function toCurrency(value: number | string | bigint): string;
+export { toCardinal, toOrdinal, toCurrency };

package/src/utils/check-max.d.ts

@@ -23,4 +23,4 @@
  *   currency forms omit it so long fractions stay valid.
  * @throws {RangeError} when the value is out of range
  */
-export function checkMax(value: bigint, max: bigint | null, fraction?: string): void;
+export declare function checkMax(value: bigint, max: bigint | null, fraction?: string): void;

package/src/utils/expand-scientific.d.ts

@@ -13,16 +13,16 @@
  * expandScientificNotation("1.5e3")   // "1500"
  * expandScientificNotation("1e-3")    // "0.001"
  */
-export function expandScientificNotation(str: string): string;
+export declare function expandScientificNotation(str: string): string;
 /**
  * Converts a number to decimal string, expanding scientific notation if needed.
  * @param {number} value - The number to convert
  * @returns {string} Decimal string representation
  */
-export function numberToString(value: number): string;
+export declare function numberToString(value: number): string;
 /**
  * Checks if a string contains scientific notation.
  * @param {string} str - String to check
  * @returns {boolean} True if string contains 'e' or 'E'
  */
-export function hasScientificNotation(str: string): boolean;
+export declare function hasScientificNotation(str: string): boolean;

package/src/utils/is-plain-object.d.ts

@@ -9,4 +9,4 @@
  * @param {unknown} value Value to check
  * @returns {value is object} True if value is a plain object
  */
-export function isPlainObject(value: unknown): value is object;
+export declare function isPlainObject(value: unknown): value is object;

package/src/utils/parse-cardinal.d.ts

@@ -1,3 +1,9 @@
+/**
+ * Cardinal value parsing utility.
+ * Transforms user input (number, string, or bigint) into normalized components.
+ * Handles negatives, decimals, and scientific notation.
+ * @module parse-cardinal
+ */
 /**
  * Parses a value for cardinal conversion.
  * Cardinals accept any numeric value: integers, decimals, negatives.
@@ -6,7 +12,7 @@
  * @throws {TypeError} If value is not number, string, or bigint
  * @throws {RangeError} If value is not finite
  */
-export function parseCardinalValue(value: number | string | bigint): {
+export declare function parseCardinalValue(value: number | string | bigint): {
     isNegative: boolean;
     integerPart: bigint;
     decimalPart?: string;

package/src/utils/parse-currency.d.ts

@@ -1,3 +1,8 @@
+/**
+ * Currency value parsing utility.
+ * Optimized parser for currency conversion - extracts dollars and cents.
+ * @module parse-currency
+ */
 /**
  * Parses a value for currency conversion.
  * Returns dollars and cents as separate bigints, plus negative flag.
@@ -6,7 +11,7 @@
  * @throws {TypeError} If value is not number, string, or bigint
  * @throws {RangeError} If value is not finite
  */
-export function parseCurrencyValue(value: number | string | bigint): {
+export declare function parseCurrencyValue(value: number | string | bigint): {
     isNegative: boolean;
     dollars: bigint;
     cents: bigint;

package/src/utils/parse-ordinal.d.ts

@@ -1,3 +1,8 @@
+/**
+ * Ordinal value parsing utility.
+ * Optimized parser for ordinal conversion - accepts only positive integers.
+ * @module parse-ordinal
+ */
 /**
  * Parses a value for ordinal conversion.
  * Ordinals require positive integers only (no zero, negatives, or decimals).
@@ -6,4 +11,4 @@
  * @throws {TypeError} If value is not number, string, or bigint
  * @throws {RangeError} If value is zero, negative, or has a decimal part
  */
-export function parseOrdinalValue(value: number | string | bigint): bigint;
+export declare function parseOrdinalValue(value: number | string | bigint): bigint;

package/src/utils/resolve-options.d.ts

@@ -14,4 +14,4 @@
  * @param {Partial<Record<keyof T & string, readonly unknown[]>>} [values] - Allowed set per enum-valued option
  * @returns {Required<T>} The options with every default applied
  */
-export function resolveOptions<T extends object>(options: T | undefined, defaults: Required<T>, values?: Partial<Record<keyof T & string, readonly unknown[]>>): Required<T>;
+export declare function resolveOptions<T extends object>(options: T | undefined, defaults: Required<T>, values?: Partial<Record<keyof T & string, readonly unknown[]>>): Required<T>;

package/src/utils/scale.d.ts

@@ -1,49 +1,49 @@
+/**
+ * Scale-range helpers — pure.
+ *
+ * Each form declares its maximum supported value as a bigint export
+ * (`cardinalMax`, `ordinalMax`, `currencyMax`): the smallest value the form
+ * refuses, so the largest it converts is that minus one. `UNBOUNDED` (null)
+ * means no fixed limit.
+ *
+ * These helpers derive that bigint from a language's own scale-table size, so
+ * the ceiling tracks the vocabulary and can't drift. A language whose shape
+ * fits none of them declares the value directly (`bounded(n)` or a literal
+ * bigint). They only *produce* a max — the range check that consumes one
+ * (`checkMax`) lives in check-max.js, and the verification checks (boundary,
+ * gaps, injectivity) live in the gate. Nothing here throws.
+ */
+/** No fixed ceiling — recursive/compounding spellers (th-TH, fa-IR, …). */
+export declare const UNBOUNDED: null;
 /**
  * 3-digit grouping, scale array starting at "thousand" (en-US, de-DE, ru-RU, …).
  * @param {number} scaleCount Number of scale words in the table
  * @returns {bigint} The first unsupported value (10^((scaleCount + 1) * 3))
  */
-export function western(scaleCount: number): bigint;
+export declare function western(scaleCount: number): bigint;
 /**
  * Myriad (4-digit) grouping — one scale word per power of 10,000 (ja-JP, ko-KR).
  * @param {number} scaleCount Number of scale words in the table
  * @returns {bigint} The first unsupported value
  */
-export function myriad(scaleCount: number): bigint;
+export declare function myriad(scaleCount: number): bigint;
 /**
  * South Asian 3-2-2 grouping: a 3-digit base segment then 2 digits per scale
  * word, with the table's index 0 reserved for the (empty) units slot.
  * @param {number} wordCount Length of the scale-word table (including the units slot)
  * @returns {bigint} The first unsupported value
  */
-export function indian(wordCount: number): bigint;
+export declare function indian(wordCount: number): bigint;
 /**
  * Long scale — each unit (a base scale word, or a prefix) yields two levels
  * (-illion / -illiard), spanning 6 powers of ten. es-*, fr-*, it-IT.
  * @param {number} unitCount Number of base scale words or prefixes
  * @returns {bigint} The first unsupported value (10^(6 * (unitCount + 1)))
  */
-export function longScale(unitCount: number): bigint;
+export declare function longScale(unitCount: number): bigint;
 /**
  * Escape hatch: a structural bound given as its base-10 exponent (zh: `bounded(16)`).
  * @param {number} exponent The base-10 exponent of the ceiling
  * @returns {bigint} 10^exponent
  */
-export function bounded(exponent: number): bigint;
-/**
- * Scale-range helpers — pure.
- *
- * Each form declares its maximum supported value as a bigint export
- * (`cardinalMax`, `ordinalMax`, `currencyMax`): the smallest value the form
- * refuses, so the largest it converts is that minus one. `UNBOUNDED` (null)
- * means no fixed limit.
- *
- * These helpers derive that bigint from a language's own scale-table size, so
- * the ceiling tracks the vocabulary and can't drift. A language whose shape
- * fits none of them declares the value directly (`bounded(n)` or a literal
- * bigint). They only *produce* a max — the range check that consumes one
- * (`checkMax`) lives in check-max.js, and the verification checks (boundary,
- * gaps, injectivity) live in the gate. Nothing here throws.
- */
-/** No fixed ceiling — recursive/compounding spellers (th-TH, fa-IR, …). */
-export const UNBOUNDED: null;
+export declare function bounded(exponent: number): bigint;

package/src/vi-VN.d.ts

@@ -1,6 +1,16 @@
-export const cardinalMax: bigint;
-export const ordinalMax: bigint;
-export const currencyMax: bigint;
+/**
+ * Vietnamese (Vietnam) language converter
+ *
+ * CLDR: vi-VN | Vietnamese as used in Vietnam
+ *
+ * Vietnamese-specific rules:
+ * - Special pronunciation: "lăm" for 5 in tens position, "mốt" for final 1
+ * - "Lẻ" (odd/extra) marker when tens place is zero after hundreds/scales
+ * - Short scale system with Vietnamese words (nghìn, triệu, tỷ)
+ */
+export declare const cardinalMax: bigint;
+export declare const ordinalMax: bigint;
+export declare const currencyMax: bigint;
 /**
  * Converts a numeric value to Vietnamese words.
  *
@@ -15,7 +25,7 @@ export const currencyMax: bigint;
  * toCardinal(101)          // 'một trăm lẻ một'
  * toCardinal(1000000)      // 'một triệu'
  */
-export function toCardinal(value: number | string | bigint): string;
+declare function toCardinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Vietnamese ordinal words.
  * @param {number | string | bigint} value - The numeric value to convert (positive integer)
@@ -27,7 +37,7 @@ export function toCardinal(value: number | string | bigint): string;
  * toOrdinal(2)    // 'thứ hai'
  * toOrdinal(10)   // 'thứ mười'
  */
-export function toOrdinal(value: number | string | bigint): string;
+declare function toOrdinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Vietnamese currency words (Dong).
  *
@@ -42,4 +52,5 @@ export function toOrdinal(value: number | string | bigint): string;
  * toCurrency(1000)   // 'một nghìn đồng'
  * toCurrency(-5)     // 'âm năm đồng'
  */
-export function toCurrency(value: number | string | bigint): string;
+declare function toCurrency(value: number | string | bigint): string;
+export { toCardinal, toOrdinal, toCurrency };

package/src/yo-NG.d.ts

@@ -1,12 +1,29 @@
-export const cardinalMax: null;
-export const ordinalMax: null;
-export const currencyMax: null;
+/**
+ * Yoruba (Nigeria) language converter
+ *
+ * CLDR: yo-NG | Yoruba as used in Nigeria
+ *
+ * Yoruba uses a complex vigesimal (base-20) system with:
+ * - Additive patterns: 1-4 added to decade (lé = "plus")
+ * - Subtractive patterns: 5-9 subtracted from next decade (dín = "minus")
+ * - Odd decades (30,50,70,90) formed by subtracting 10 from next even decade
+ * - Even decades (20,40,60,80,100) are multiples of 20
+ *
+ * Examples:
+ * - 21 = ọ̀kan lé lógún (1 + 20)
+ * - 15 = àrùndínlógún (20 - 5)
+ * - 50 = àádọ́ta (60 - 10)
+ * - 45 = àrùndínláàádọ́ta (50 - 5)
+ */
+export declare const cardinalMax: null;
+export declare const ordinalMax: null;
+export declare const currencyMax: null;
 /**
  * Converts a numeric value to Yoruba words.
  * @param {number | string | bigint} value - The numeric value to convert
  * @returns {string} The number in Yoruba words
  */
-export function toCardinal(value: number | string | bigint): string;
+declare function toCardinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Yoruba ordinal words.
  * @param {number | string | bigint} value - The numeric value to convert (positive integer)
@@ -18,7 +35,7 @@ export function toCardinal(value: number | string | bigint): string;
  * toOrdinal(2)    // 'ìkejì'
  * toOrdinal(3)    // 'ìkẹẹ̀ta'
  */
-export function toOrdinal(value: number | string | bigint): string;
+declare function toOrdinal(value: number | string | bigint): string;
 /**
  * Converts a numeric value to Yoruba currency words (Nigerian Naira).
  *
@@ -32,4 +49,5 @@ export function toOrdinal(value: number | string | bigint): string;
  * toCurrency(1.50)   // 'ọ̀kan náírà àti àádọ́ta kọ́bọ̀'
  * toCurrency(-5)     // 'àìní àrùn náírà'
  */
-export function toCurrency(value: number | string | bigint): string;
+declare function toCurrency(value: number | string | bigint): string;
+export { toCardinal, toOrdinal, toCurrency };

package/src/zh-Hans-CN.d.ts

@@ -1,49 +1,48 @@
-export const cardinalMax: bigint;
-export const ordinalMax: bigint;
-export const currencyMax: bigint;
 /**
- * @typedef {object} CardinalOptions
- * @property {boolean} [formal] - Use formal/financial numerals
- */
-/** @type {Required<CardinalOptions>} */
-export const cardinalDefaults: Required<CardinalOptions>;
-/**
- * @typedef {object} OrdinalOptions
- * @property {boolean} [formal] - Use formal/financial numerals
- */
-/** @type {Required<OrdinalOptions>} */
-export const ordinalDefaults: Required<OrdinalOptions>;
-/**
- * @typedef {object} CurrencyOptions
- * @property {boolean} [formal] - Use formal/financial numerals
+ * Simplified Chinese (China) language converter
+ *
+ * CLDR: zh-Hans-CN | Simplified Chinese as used in China
+ *
+ * Key features:
+ * - Myriad-based (万, 亿) grouping - 4 digits
+ * - Formal (financial) vs common numerals
+ * - Zero insertion for skipped positions
+ * - No word separators (concatenated format)
  */
-/** @type {Required<CurrencyOptions>} */
-export const currencyDefaults: Required<CurrencyOptions>;
+export declare const cardinalMax: bigint;
+export declare const ordinalMax: bigint;
+export declare const currencyMax: bigint;
 export type CardinalOptions = {
     /**
      * - Use formal/financial numerals
      */
-    formal?: boolean | undefined;
+    formal?: boolean;
 };
+/**
+ * @typedef {object} CardinalOptions
+ * @property {boolean} [formal] - Use formal/financial numerals
+ */
+/** @type {Required<CardinalOptions>} */
+export declare const cardinalDefaults: Required<CardinalOptions>;
+/**
+ * Converts a numeric value to Simplified Chinese words.
+ * @param {number | string | bigint} value - The numeric value to convert
+ * @param {CardinalOptions} [options] - Optional configuration
+ * @returns {string} The number in Simplified Chinese words
+ */
+declare function toCardinal(value: number | string | bigint, options?: CardinalOptions): string;
 export type OrdinalOptions = {
     /**
      * - Use formal/financial numerals
      */
-    formal?: boolean | undefined;
-};
-export type CurrencyOptions = {
-    /**
-     * - Use formal/financial numerals
-     */
-    formal?: boolean | undefined;
+    formal?: boolean;
 };
 /**
- * Converts a numeric value to Simplified Chinese words.
- * @param {number | string | bigint} value - The numeric value to convert
- * @param {CardinalOptions} [options] - Optional configuration
- * @returns {string} The number in Simplified Chinese words
+ * @typedef {object} OrdinalOptions
+ * @property {boolean} [formal] - Use formal/financial numerals
  */
-export function toCardinal(value: number | string | bigint, options?: CardinalOptions): string;
+/** @type {Required<OrdinalOptions>} */
+export declare const ordinalDefaults: Required<OrdinalOptions>;
 /**
  * Converts a numeric value to Simplified Chinese ordinal words.
  * @param {number | string | bigint} value - The numeric value to convert (positive integer)
@@ -56,7 +55,19 @@ export function toCardinal(value: number | string | bigint, options?: CardinalOp
  * toOrdinal(1, { formal: false }) // '第一'
  * toOrdinal(10)                   // '第壹拾'
  */
-export function toOrdinal(value: number | string | bigint, options?: OrdinalOptions): string;
+declare function toOrdinal(value: number | string | bigint, options?: OrdinalOptions): string;
+export type CurrencyOptions = {
+    /**
+     * - Use formal/financial numerals
+     */
+    formal?: boolean;
+};
+/**
+ * @typedef {object} CurrencyOptions
+ * @property {boolean} [formal] - Use formal/financial numerals
+ */
+/** @type {Required<CurrencyOptions>} */
+export declare const currencyDefaults: Required<CurrencyOptions>;
 /**
  * Converts a numeric value to Simplified Chinese currency words (Yuan/Renminbi).
  * @param {number | string | bigint} value - The currency amount to convert
@@ -70,4 +81,5 @@ export function toOrdinal(value: number | string | bigint, options?: OrdinalOpti
  * toCurrency(0.05)                     // '伍分'
  * toCurrency(42.50, { formal: false }) // '四十二元五角整'
  */
-export function toCurrency(value: number | string | bigint, options?: CurrencyOptions): string;
+declare function toCurrency(value: number | string | bigint, options?: CurrencyOptions): string;
+export { toCardinal, toOrdinal, toCurrency };

package/src/zh-Hant-TW.d.ts

@@ -1,49 +1,52 @@
-export const cardinalMax: bigint;
-export const ordinalMax: bigint;
-export const currencyMax: bigint;
 /**
- * @typedef {object} CardinalOptions
- * @property {boolean} [formal] - Use formal/financial numerals
- */
-/** @type {Required<CardinalOptions>} */
-export const cardinalDefaults: Required<CardinalOptions>;
-/**
- * @typedef {object} OrdinalOptions
- * @property {boolean} [formal] - Use formal/financial numerals
- */
-/** @type {Required<OrdinalOptions>} */
-export const ordinalDefaults: Required<OrdinalOptions>;
-/**
- * @typedef {object} CurrencyOptions
- * @property {boolean} [formal] - Use formal/financial numerals
+ * Traditional Chinese (Taiwan) language converter
+ *
+ * CLDR: zh-Hant-TW | Traditional Chinese as used in Taiwan
+ *
+ * Key features:
+ * - Myriad-based (萬, 億) grouping - 4 digits
+ * - Formal (financial) vs common numerals
+ * - Zero insertion for skipped positions
+ * - No word separators (concatenated format)
+ *
+ * Differences from Simplified:
+ * - Different character forms (e.g., 負/负, 點/点, 億/亿, 萬/万)
+ * - Some formal numerals differ (參/叁, 貳/贰, 陸/陆)
  */
-/** @type {Required<CurrencyOptions>} */
-export const currencyDefaults: Required<CurrencyOptions>;
+export declare const cardinalMax: bigint;
+export declare const ordinalMax: bigint;
+export declare const currencyMax: bigint;
 export type CardinalOptions = {
     /**
      * - Use formal/financial numerals
      */
-    formal?: boolean | undefined;
+    formal?: boolean;
 };
+/**
+ * @typedef {object} CardinalOptions
+ * @property {boolean} [formal] - Use formal/financial numerals
+ */
+/** @type {Required<CardinalOptions>} */
+export declare const cardinalDefaults: Required<CardinalOptions>;
+/**
+ * Converts a numeric value to Traditional Chinese words.
+ * @param {number | string | bigint} value - The numeric value to convert
+ * @param {CardinalOptions} [options] - Optional configuration
+ * @returns {string} The number in Traditional Chinese words
+ */
+declare function toCardinal(value: number | string | bigint, options?: CardinalOptions): string;
 export type OrdinalOptions = {
     /**
      * - Use formal/financial numerals
      */
-    formal?: boolean | undefined;
-};
-export type CurrencyOptions = {
-    /**
-     * - Use formal/financial numerals
-     */
-    formal?: boolean | undefined;
+    formal?: boolean;
 };
 /**
- * Converts a numeric value to Traditional Chinese words.
- * @param {number | string | bigint} value - The numeric value to convert
- * @param {CardinalOptions} [options] - Optional configuration
- * @returns {string} The number in Traditional Chinese words
+ * @typedef {object} OrdinalOptions
+ * @property {boolean} [formal] - Use formal/financial numerals
  */
-export function toCardinal(value: number | string | bigint, options?: CardinalOptions): string;
+/** @type {Required<OrdinalOptions>} */
+export declare const ordinalDefaults: Required<OrdinalOptions>;
 /**
  * Converts a numeric value to Traditional Chinese ordinal words.
  * @param {number | string | bigint} value - The numeric value to convert (positive integer)
@@ -56,7 +59,19 @@ export function toCardinal(value: number | string | bigint, options?: CardinalOp
  * toOrdinal(2)                    // '第貳'
  * toOrdinal(1, { formal: false }) // '第一'
  */
-export function toOrdinal(value: number | string | bigint, options?: OrdinalOptions): string;
+declare function toOrdinal(value: number | string | bigint, options?: OrdinalOptions): string;
+export type CurrencyOptions = {
+    /**
+     * - Use formal/financial numerals
+     */
+    formal?: boolean;
+};
+/**
+ * @typedef {object} CurrencyOptions
+ * @property {boolean} [formal] - Use formal/financial numerals
+ */
+/** @type {Required<CurrencyOptions>} */
+export declare const currencyDefaults: Required<CurrencyOptions>;
 /**
  * Converts a numeric value to Traditional Chinese currency words (New Taiwan Dollar).
  *
@@ -72,4 +87,5 @@ export function toOrdinal(value: number | string | bigint, options?: OrdinalOpti
  * toCurrency(1.50)                  // '壹圓伍角整'
  * toCurrency(42, { formal: false }) // '四十二元整'
  */
-export function toCurrency(value: number | string | bigint, options?: CurrencyOptions): string;
+declare function toCurrency(value: number | string | bigint, options?: CurrencyOptions): string;
+export { toCardinal, toOrdinal, toCurrency };