@gks101/numtowords 1.0.0

package/dist/locales/de.js

@@ -0,0 +1,98 @@
+import { registerLocale } from "../core/converter";
+// ─── Word tables ──────────────────────────────────────────────────────────────
+const ONES_DE = [
+    "", "ein", "zwei", "drei", "vier", "fünf",
+    "sechs", "sieben", "acht", "neun", "zehn",
+    "elf", "zwölf", "dreizehn", "vierzehn", "fünfzehn",
+    "sechzehn", "siebzehn", "achtzehn", "neunzehn",
+];
+const TENS_DE = [
+    "", "", "zwanzig", "dreißig", "vierzig", "fünfzig",
+    "sechzig", "siebzig", "achtzig", "neunzig",
+];
+/** German uses "und" between ones and tens: einundzwanzig */
+function upToNinetyNine(n) {
+    if (n === 0)
+        return "";
+    if (n < 20)
+        return ONES_DE[n];
+    const t = Math.floor(n / 10);
+    const o = n % 10;
+    if (o === 0)
+        return TENS_DE[t];
+    return `${ONES_DE[o]}und${TENS_DE[t]}`;
+}
+function hundredsDE(n) {
+    if (n === 0)
+        return "";
+    const h = Math.floor(n / 100);
+    const rem = n % 100;
+    const parts = [];
+    if (h === 1)
+        parts.push("einhundert");
+    else if (h > 1)
+        parts.push(`${ONES_DE[h]}hundert`);
+    if (rem > 0)
+        parts.push(upToNinetyNine(rem));
+    return parts.join("");
+}
+const SCALES_DE = [
+    "tausend",
+    "Million",
+    "Milliarde",
+    "Billion",
+    "Billiarde",
+    "Trillion",
+];
+/** Scales that are grammatically feminine in German (require "eine" not "ein") */
+const FEMININE_SCALES = new Set([1, 2, 4, 6]); // indices: Million, Milliarde, Billiarde, Trillion
+const SCALES_DE_PLURAL = [
+    "tausend",
+    "Millionen",
+    "Milliarden",
+    "Billionen",
+    "Billiarden",
+    "Trillionen",
+];
+// ─── Locale definition ────────────────────────────────────────────────────────
+const de = {
+    name: "German",
+    convert(n, _opts) {
+        if (n === 0n)
+            return "null";
+        const chunks = [];
+        let remaining = n;
+        let idx = 0;
+        while (remaining > 0n) {
+            chunks.unshift({ value: Number(remaining % 1000n), scale: idx });
+            remaining = remaining / 1000n;
+            idx++;
+        }
+        const parts = [];
+        for (const { value, scale } of chunks) {
+            if (value === 0)
+                continue;
+            const words = hundredsDE(value);
+            if (scale === 0) {
+                parts.push(words);
+            }
+            else if (scale === 1) {
+                // "tausend" compounds directly
+                parts.push(`${words}tausend`);
+            }
+            else {
+                const scaleIdx = scale - 1;
+                const isFeminine = FEMININE_SCALES.has(scaleIdx);
+                // Replace trailing "ein" with "eine" for feminine scales
+                const adjustedWords = value === 1 && isFeminine
+                    ? words.replace(/ein$/, "eine")
+                    : words;
+                const scaleName = value === 1 ? SCALES_DE[scaleIdx] : SCALES_DE_PLURAL[scaleIdx];
+                parts.push(`${adjustedWords} ${scaleName}`);
+            }
+        }
+        return parts.join(" ").trim();
+    },
+};
+registerLocale("de", de);
+export default de;

package/dist/locales/en.js

@@ -0,0 +1,94 @@
+import { registerLocale } from "../core/converter";
+// ─── Word tables ──────────────────────────────────────────────────────────────
+const ONES = [
+    "", "one", "two", "three", "four", "five",
+    "six", "seven", "eight", "nine", "ten",
+    "eleven", "twelve", "thirteen", "fourteen", "fifteen",
+    "sixteen", "seventeen", "eighteen", "nineteen",
+];
+const TENS = [
+    "", "", "twenty", "thirty", "forty", "fifty",
+    "sixty", "seventy", "eighty", "ninety",
+];
+/**
+ * Scale names in the short (American/modern British) scale.
+ * Index 0 = thousands, 1 = millions, …
+ */
+const SCALES = [
+    "thousand",
+    "million",
+    "billion",
+    "trillion",
+    "quadrillion",
+    "quintillion",
+    "sextillion",
+    "septillion",
+    "octillion",
+    "nonillion",
+    "decillion",
+];
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+/** Convert 0–999 to words */
+function hundredsToWords(n, useAnd) {
+    if (n === 0)
+        return "";
+    const parts = [];
+    const h = Math.floor(n / 100);
+    const remainder = n % 100;
+    if (h > 0) {
+        parts.push(`${ONES[h]} hundred`);
+    }
+    if (remainder === 0) {
+        // nothing more
+    }
+    else {
+        if (h > 0 && useAnd)
+            parts.push("and");
+        if (remainder < 20) {
+            parts.push(ONES[remainder]);
+        }
+        else {
+            const t = Math.floor(remainder / 10);
+            const o = remainder % 10;
+            parts.push(o === 0 ? TENS[t] : `${TENS[t]}-${ONES[o]}`);
+        }
+    }
+    return parts.join(" ");
+}
+// ─── Locale definition ────────────────────────────────────────────────────────
+const en = {
+    name: "English",
+    convert(n, opts) {
+        if (n === 0n)
+            return "zero";
+        const useAnd = opts.useAnd;
+        const chunks = [];
+        // Split number into groups of 3 from the right
+        let remaining = n;
+        const divisor = 1000n;
+        // chunk index: 0 = units, 1 = thousands, 2 = millions, …
+        let idx = 0;
+        while (remaining > 0n) {
+            chunks.unshift({ value: Number(remaining % divisor), scale: idx });
+            remaining = remaining / divisor;
+            idx++;
+        }
+        const parts = [];
+        for (const { value, scale } of chunks) {
+            if (value === 0)
+                continue;
+            // useAnd within the hundreds group (e.g. "one hundred and five")
+            const words = hundredsToWords(value, useAnd);
+            if (scale === 0) {
+                parts.push(words);
+            }
+            else {
+                const scaleName = SCALES[scale - 1];
+                parts.push(`${words} ${scaleName}`);
+            }
+        }
+        return parts.join(" ");
+    },
+};
+registerLocale("en", en);
+export default en;

package/dist/locales/fr.js

@@ -0,0 +1,116 @@
+import { registerLocale } from "../core/converter";
+// ─── Word tables ──────────────────────────────────────────────────────────────
+const ONES_FR = [
+    "", "un", "deux", "trois", "quatre", "cinq",
+    "six", "sept", "huit", "neuf", "dix",
+    "onze", "douze", "treize", "quatorze", "quinze",
+    "seize", "dix-sept", "dix-huit", "dix-neuf",
+];
+const TENS_FR = [
+    "", "", "vingt", "trente", "quarante", "cinquante",
+    "soixante", "soixante", "quatre-vingt", "quatre-vingt",
+];
+/**
+ * French has irregular 70s (soixante-dix + 10–19) and 90s (quatre-vingt-dix + 10–19).
+ */
+function upToNinetyNine(n) {
+    if (n === 0)
+        return "";
+    if (n < 20)
+        return ONES_FR[n];
+    const t = Math.floor(n / 10);
+    const o = n % 10;
+    if (t === 7) {
+        // soixante + (10 + o)
+        return o === 0 ? "soixante-dix" : `soixante-${ONES_FR[10 + o]}`;
+    }
+    if (t === 8) {
+        // quatre-vingt(s) + o
+        if (o === 0)
+            return "quatre-vingts";
+        return `quatre-vingt-${ONES_FR[o]}`;
+    }
+    if (t === 9) {
+        // quatre-vingt-dix + (0 + o)
+        return o === 0 ? "quatre-vingt-dix" : `quatre-vingt-${ONES_FR[10 + o]}`;
+    }
+    if (o === 0)
+        return TENS_FR[t];
+    if (o === 1 && t !== 8)
+        return `${TENS_FR[t]}-et-${ONES_FR[o]}`;
+    return `${TENS_FR[t]}-${ONES_FR[o]}`;
+}
+function hundredsFR(n) {
+    if (n === 0)
+        return "";
+    const h = Math.floor(n / 100);
+    const rem = n % 100;
+    const parts = [];
+    if (h === 1) {
+        parts.push("cent");
+    }
+    else if (h > 1) {
+        parts.push(`${ONES_FR[h]} cents`);
+    }
+    if (rem > 0) {
+        // remove trailing 's' from "cents" if followed by more words
+        if (h > 1 && parts.length > 0) {
+            parts[0] = `${ONES_FR[h]} cent`;
+        }
+        parts.push(upToNinetyNine(rem));
+    }
+    return parts.join(" ");
+}
+const SCALES_FR = [
+    "mille",
+    "million",
+    "milliard",
+    "billion",
+    "billiard",
+    "trillion",
+];
+const SCALES_FR_PLURAL = [
+    "mille",
+    "millions",
+    "milliards",
+    "billions",
+    "billiards",
+    "trillions",
+];
+// ─── Locale definition ────────────────────────────────────────────────────────
+const fr = {
+    name: "French",
+    convert(n, _opts) {
+        if (n === 0n)
+            return "zéro";
+        const chunks = [];
+        let remaining = n;
+        let idx = 0;
+        while (remaining > 0n) {
+            chunks.unshift({ value: Number(remaining % 1000n), scale: idx });
+            remaining = remaining / 1000n;
+            idx++;
+        }
+        const parts = [];
+        for (const { value, scale } of chunks) {
+            if (value === 0)
+                continue;
+            const words = hundredsFR(value);
+            if (scale === 0) {
+                parts.push(words);
+            }
+            else if (scale === 1) {
+                // "mille" does not pluralise and drops "un" prefix
+                parts.push(value === 1 ? "mille" : `${words} mille`);
+            }
+            else {
+                const scaleIdx = scale - 1;
+                const scaleName = value === 1 ? SCALES_FR[scaleIdx] : SCALES_FR_PLURAL[scaleIdx];
+                parts.push(`${words} ${scaleName}`);
+            }
+        }
+        return parts.join(" ").trim();
+    },
+};
+registerLocale("fr", fr);
+export default fr;

package/dist/locales/hi.js

@@ -0,0 +1,78 @@
+import { registerLocale } from "../core/converter";
+// ─── Word tables ──────────────────────────────────────────────────────────────
+/** 1–99 in Hindi */
+const HINDI_ONES = {
+    1: "एक", 2: "दो", 3: "तीन", 4: "चार", 5: "पाँच",
+    6: "छह", 7: "सात", 8: "आठ", 9: "नौ", 10: "दस",
+    11: "ग्यारह", 12: "बारह", 13: "तेरह", 14: "चौदह", 15: "पन्द्रह",
+    16: "सोलह", 17: "सत्रह", 18: "अट्ठारह", 19: "उन्नीस", 20: "बीस",
+    21: "इक्कीस", 22: "बाईस", 23: "तेईस", 24: "चौबीस", 25: "पच्चीस",
+    26: "छब्बीस", 27: "सत्ताईस", 28: "अट्ठाईस", 29: "उनतीस", 30: "तीस",
+    31: "इकतीस", 32: "बत्तीस", 33: "तैंतीस", 34: "चौंतीस", 35: "पैंतीस",
+    36: "छत्तीस", 37: "सैंतीस", 38: "अड़तीस", 39: "उनतालीस", 40: "चालीस",
+    41: "इकतालीस", 42: "बयालीस", 43: "तैंतालीस", 44: "चौवालीस", 45: "पैंतालीस",
+    46: "छियालीस", 47: "सैंतालीस", 48: "अड़तालीस", 49: "उनचास", 50: "पचास",
+    51: "इक्यावन", 52: "बावन", 53: "तिरपन", 54: "चौवन", 55: "पचपन",
+    56: "छप्पन", 57: "सत्तावन", 58: "अट्ठावन", 59: "उनसठ", 60: "साठ",
+    61: "इकसठ", 62: "बासठ", 63: "तिरसठ", 64: "चौंसठ", 65: "पैंसठ",
+    66: "छियासठ", 67: "सड़सठ", 68: "अड़सठ", 69: "उनहत्तर", 70: "सत्तर",
+    71: "इकहत्तर", 72: "बहत्तर", 73: "तिहत्तर", 74: "चौहत्तर", 75: "पचहत्तर",
+    76: "छिहत्तर", 77: "सत्तहत्तर", 78: "अठहत्तर", 79: "उन्यासी", 80: "अस्सी",
+    81: "इक्यासी", 82: "बयासी", 83: "तिरासी", 84: "चौरासी", 85: "पचासी",
+    86: "छियासी", 87: "सत्तासी", 88: "अट्ठासी", 89: "नवासी", 90: "नब्बे",
+    91: "इक्यानबे", 92: "बानवे", 93: "तिरानवे", 94: "चौरानवे", 95: "पचानवे",
+    96: "छियानवे", 97: "सत्तानवे", 98: "अट्ठानवे", 99: "निन्यानवे",
+};
+const HINDI_HUNDRED = "सौ";
+const INDIAN_SCALES_HI = [
+    [100000000000000000n, "शंख"], // 10^17
+    [1000000000000000n, "पद्म"], // 10^15
+    [10000000000000n, "नील"], // 10^13
+    [100000000000n, "खरब"], // 10^11
+    [1000000000n, "अरब"], // 10^9
+    [10000000n, "करोड़"], // 10^7
+    [100000n, "लाख"], // 10^5
+    [1000n, "हज़ार"], // 10^3
+];
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+function upToNinetyNine(n) {
+    return HINDI_ONES[n] ?? "";
+}
+function hundredsHindi(n) {
+    if (n === 0)
+        return "";
+    const h = Math.floor(n / 100);
+    const rem = n % 100;
+    const parts = [];
+    if (h > 0) {
+        // Always include the digit before 'सौ' (e.g., 'एक सौ', 'तीन सौ')
+        parts.push(`${upToNinetyNine(h)} ${HINDI_HUNDRED}`);
+    }
+    if (rem > 0)
+        parts.push(upToNinetyNine(rem));
+    return parts.join(" ");
+}
+// ─── Locale definition ────────────────────────────────────────────────────────
+const hi = {
+    name: "Hindi",
+    convert(n, _opts) {
+        if (n === 0n)
+            return "शून्य";
+        const parts = [];
+        let remaining = n;
+        for (const [scale, name] of INDIAN_SCALES_HI) {
+            if (remaining >= scale) {
+                const count = remaining / scale;
+                remaining = remaining % scale;
+                const countWords = hundredsHindi(Number(count));
+                parts.push(`${countWords} ${name}`);
+            }
+        }
+        if (remaining > 0n) {
+            parts.push(hundredsHindi(Number(remaining)));
+        }
+        return parts.join(" ");
+    },
+};
+registerLocale("hi", hi);
+export default hi;

package/dist/locales/in.js

@@ -0,0 +1,80 @@
+import { registerLocale } from "../core/converter";
+// ─── Word tables ──────────────────────────────────────────────────────────────
+const ONES = [
+    "", "one", "two", "three", "four", "five",
+    "six", "seven", "eight", "nine", "ten",
+    "eleven", "twelve", "thirteen", "fourteen", "fifteen",
+    "sixteen", "seventeen", "eighteen", "nineteen",
+];
+const TENS = [
+    "", "", "twenty", "thirty", "forty", "fifty",
+    "sixty", "seventy", "eighty", "ninety",
+];
+/**
+ * Indian scale names (each 100× the previous after thousand):
+ *   1,000         = thousand
+ *   1,00,000      = lakh
+ *   1,00,00,000   = crore
+ *   1,00,00,00,000 = arab (not commonly used in English but included)
+ *   …
+ */
+const INDIAN_SCALES = [
+    [100000000000000000n, "shankh"], // 10^17
+    [1000000000000000n, "padma"], // 10^15
+    [10000000000000n, "neel"], // 10^13
+    [100000000000n, "kharab"], // 10^11
+    [1000000000n, "arab"], // 10^9
+    [10000000n, "crore"], // 10^7
+    [100000n, "lakh"], // 10^5
+    [1000n, "thousand"],
+];
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+function twoDigits(n) {
+    if (n === 0)
+        return "";
+    if (n < 20)
+        return ONES[n];
+    const t = Math.floor(n / 10);
+    const o = n % 10;
+    return o === 0 ? TENS[t] : `${TENS[t]}-${ONES[o]}`;
+}
+function hundredsToWords(n) {
+    if (n === 0)
+        return "";
+    const h = Math.floor(n / 100);
+    const rem = n % 100;
+    const parts = [];
+    if (h > 0)
+        parts.push(`${ONES[h]} hundred`);
+    const two = twoDigits(rem);
+    if (two)
+        parts.push(two);
+    return parts.join(" ");
+}
+// ─── Locale definition ────────────────────────────────────────────────────────
+const indian = {
+    name: "Indian",
+    convert(n, _opts) {
+        if (n === 0n)
+            return "zero";
+        const parts = [];
+        let remaining = n;
+        for (const [scale, name] of INDIAN_SCALES) {
+            if (remaining >= scale) {
+                const count = remaining / scale;
+                remaining = remaining % scale;
+                // The count itself may need Indian-style words
+                // For counts < 1000 we use simple English words
+                const countWords = hundredsToWords(Number(count));
+                parts.push(`${countWords} ${name}`);
+            }
+        }
+        // Anything left is < 1000
+        if (remaining > 0n) {
+            parts.push(hundredsToWords(Number(remaining)));
+        }
+        return parts.join(" ");
+    },
+};
+registerLocale("in", indian);
+export default indian;

package/dist/types/core/converter.d.ts

@@ -0,0 +1,21 @@
+import { ConvertOptions, Locale, LocaleDefinition } from "./types";
+/**
+ * Register a locale definition.
+ * Called internally by each locale module.
+ */
+export declare function registerLocale(id: Locale, def: LocaleDefinition): void;
+/**
+ * Retrieve a locale definition or throw.
+ */
+export declare function getLocale(id: Locale): LocaleDefinition;
+/** List all registered locale IDs */
+export declare function availableLocales(): Locale[];
+/**
+ * Convert a number (integer or string) to its word representation.
+ *
+ * @example
+ * convert(1000124)              // "One Million One Hundred Twenty Four"
+ * convert(1000124, { locale: "in" })  // "Ten Lakh One Hundred Twenty Four"
+ * convert(1000124, { locale: "hi" })  // "दस लाख एक सौ चौबीस"
+ */
+export declare function convert(input: number | bigint | string, options?: ConvertOptions): string;

package/dist/types/core/types.d.ts

@@ -0,0 +1,31 @@
+/** Supported locale identifiers */
+export type Locale = "en" | "in" | "hi" | "de" | "fr" | (string & {});
+/** Options passed to convert() */
+export interface ConvertOptions {
+    /**
+     * Target locale / numeral system.
+     * - `"en"` — English (International):  1,000,000 = One Million
+     * - `"in"` — Indian numbering system:  10,00,000 = Ten Lakh
+     * - `"hi"` — Hindi words (Indian system): दस लाख
+     * - `"de"` — German
+     * - `"fr"` — French
+     * @default "en"
+     */
+    locale?: Locale;
+    /** Capitalise the first letter of the result. @default true */
+    capitalize?: boolean;
+    /** Include "and" connector where applicable (English only). @default true */
+    useAnd?: boolean;
+    /**
+     * Currency mode — append currency labels.
+     * e.g. { currency: "USD" } → "One Million Dollars"
+     */
+    currency?: string;
+}
+/** Internal locale definition contract */
+export interface LocaleDefinition {
+    /** Human-readable name */
+    name: string;
+    /** Convert an integer ≥ 0 to words */
+    convert(n: bigint, opts: Required<ConvertOptions>): string;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,7 @@
+import "./locales/en";
+import "./locales/in";
+import "./locales/hi";
+import "./locales/de";
+import "./locales/fr";
+export { convert, registerLocale, getLocale, availableLocales } from "./core/converter";
+export type { Locale, ConvertOptions, LocaleDefinition } from "./core/types";

package/dist/types/locales/de.d.ts

@@ -0,0 +1,3 @@
+import { LocaleDefinition } from "../core/types";
+declare const de: LocaleDefinition;
+export default de;

package/dist/types/locales/en.d.ts

@@ -0,0 +1,3 @@
+import { LocaleDefinition } from "../core/types";
+declare const en: LocaleDefinition;
+export default en;

package/dist/types/locales/fr.d.ts

@@ -0,0 +1,3 @@
+import { LocaleDefinition } from "../core/types";
+declare const fr: LocaleDefinition;
+export default fr;

package/dist/types/locales/hi.d.ts

@@ -0,0 +1,3 @@
+import { LocaleDefinition } from "../core/types";
+declare const hi: LocaleDefinition;
+export default hi;

package/dist/types/locales/in.d.ts

@@ -0,0 +1,3 @@
+import { LocaleDefinition } from "../core/types";
+declare const indian: LocaleDefinition;
+export default indian;

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@gks101/numtowords",
+  "version": "1.0.0",
+  "description": "Convert numbers to words in multiple languages and numeral systems (English, Indian, etc.)",
+  "main": "dist/index.cjs.js",
+  "module": "dist/index.esm.js",
+  "browser": "dist/index.umd.js",
+  "types": "dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.esm.js",
+      "require": "./dist/index.cjs.js",
+      "types": "./dist/types/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "rm -rf dist && rollup -c rollup.config.mjs && tsc --target ES2020 --module ES2020 --downlevelIteration --skipLibCheck --noEmitOnError false --outDir dist --rootDir src src/locales/*.ts",
+    "test": "jest",
+    "lint": "tsc --noEmit",
+    "prepack": "npm run build",
+    "prepare": "npm run build"
+  },
+  "keywords": [
+    "number-to-words",
+    "multilingual",
+    "indian-numbering",
+    "english",
+    "hindi",
+    "number-converter",
+    "number-to-word-converter",
+    "i18n"
+  ],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@rollup/plugin-node-resolve": "^15.2.3",
+    "@rollup/plugin-typescript": "^11.1.6",
+    "rollup": "^4.18.0",
+    "rollup-plugin-dts": "^6.1.1",
+    "tslib": "^2.6.3",
+    "typescript": "^5.5.3",
+    "jest": "^29.7.0",
+    "@types/jest": "^29.5.12",
+    "ts-jest": "^29.2.2"
+  }
+}