tanisa 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Rija Nifaliana
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,2 @@
+# tanisa
+An utility to convert Malagasy 🇲🇬 numbers, including decimals, into their word representations.

package/dist/src/converter.d.ts

@@ -0,0 +1,8 @@
+export declare class MalagasyNumberToWords {
+    toWords(number: number | string): string;
+    private convertInteger;
+    private formatLargeNumber;
+    private convertBelowThousand;
+    private convertBelowHundred;
+}
+//# sourceMappingURL=converter.d.ts.map

package/dist/src/converter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../src/converter.ts"],"names":[],"mappings":"AAEA,qBAAa,qBAAqB;IACzB,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM;IA6C/C,OAAO,CAAC,cAAc;IActB,OAAO,CAAC,iBAAiB;IAuBzB,OAAO,CAAC,oBAAoB;IAyB5B,OAAO,CAAC,mBAAmB;CAmB5B"}

package/dist/src/converter.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MalagasyNumberToWords = void 0;
+const _1 = require(".");
+class MalagasyNumberToWords {
+    toWords(number) {
+        const numStr = String(number);
+        const [integerPartStr, decimalPartStr] = numStr.split('.');
+        const integerPartNum = parseInt(integerPartStr || '0', 10);
+        if (isNaN(integerPartNum) ||
+            (decimalPartStr && isNaN(parseInt(decimalPartStr, 10)))) {
+            throw new TypeError(`Invalid number input: "${number}"`);
+        }
+        if (numStr.trim().startsWith('-') && integerPartNum !== 0) {
+            throw new RangeError('Negative numbers are not supported.');
+        }
+        if (integerPartNum >= _1.MalagasyNumerals.MAX_SUPPORTED_INTEGER ||
+            integerPartStr == _1.MalagasyNumerals.MAX_SUPPORTED_INTEGER.toString()) {
+            throw new RangeError(`Number ${integerPartNum} exceeds the maximum supported value (${_1.MalagasyNumerals.MAX_SUPPORTED_INTEGER}).`);
+        }
+        const integerWords = this.convertInteger(integerPartNum);
+        let decimalWords = '';
+        if (decimalPartStr && decimalPartStr.length > 0) {
+            for (let i = 0; i < decimalPartStr.length; i++) {
+                const digit = decimalPartStr[i];
+                if (digit === '0') {
+                    decimalWords += _1.MalagasyNumerals.GLUE_DECIMAL_ZERO;
+                }
+                else {
+                    const remainingDecimal = decimalPartStr.substring(i);
+                    decimalWords += this.convertInteger(parseInt(remainingDecimal, 10));
+                    break;
+                }
+            }
+            return integerWords + _1.MalagasyNumerals.GLUE_FAINGO + decimalWords;
+        }
+        else {
+            return integerWords;
+        }
+    }
+    convertInteger(num) {
+        if (num === 0) {
+            return _1.MalagasyNumerals.ZERO;
+        }
+        for (const unit of _1.MalagasyNumerals.LARGE_NUMBER_UNITS) {
+            if (num >= unit.threshold) {
+                return this.formatLargeNumber(num, unit);
+            }
+        }
+        return this.convertBelowThousand(num);
+    }
+    formatLargeNumber(num, unit) {
+        const multiple = Math.floor(num / unit.threshold);
+        const remainder = num % unit.threshold;
+        let prefix = '';
+        if (multiple > 1) {
+            prefix = this.convertInteger(multiple) + ' ';
+        }
+        else if (multiple === 1 && unit.threshold > 1000) {
+            prefix = _1.MalagasyNumerals.DIGITS[1] + ' ';
+        }
+        const basePart = prefix + unit.name;
+        if (remainder > 0) {
+            const remainderText = this.convertInteger(remainder);
+            return remainderText + _1.MalagasyNumerals.GLUE_SY + basePart;
+        }
+        else {
+            return basePart;
+        }
+    }
+    convertBelowThousand(num) {
+        if (num >= 100) {
+            const hundredMultiple = Math.floor(num / 100);
+            const remainder = num % 100;
+            const hundredWord = _1.MalagasyNumerals.HUNDREDS[hundredMultiple];
+            if (remainder === 0) {
+                return hundredWord;
+            }
+            else {
+                const remainderWords = this.convertBelowHundred(remainder);
+                let glue = _1.MalagasyNumerals.GLUE_AMBY;
+                if (hundredMultiple >= 2 && remainder >= 10) {
+                    glue = _1.MalagasyNumerals.GLUE_SY;
+                }
+                const finalRemainderWords = remainder === 1 ? _1.MalagasyNumerals.CUSTOM_ONE : remainderWords;
+                return finalRemainderWords + glue + hundredWord;
+            }
+        }
+        return this.convertBelowHundred(num);
+    }
+    convertBelowHundred(num) {
+        if (num >= 10) {
+            const tenMultiple = Math.floor(num / 10);
+            const remainder = num % 10;
+            const tenWord = _1.MalagasyNumerals.TENS[tenMultiple];
+            if (remainder === 0) {
+                return tenWord;
+            }
+            else {
+                const digitWord = remainder === 1
+                    ? _1.MalagasyNumerals.CUSTOM_ONE
+                    : _1.MalagasyNumerals.DIGITS[remainder];
+                return digitWord + _1.MalagasyNumerals.GLUE_AMBY + tenWord;
+            }
+        }
+        return _1.MalagasyNumerals.DIGITS[num];
+    }
+}
+exports.MalagasyNumberToWords = MalagasyNumberToWords;

package/dist/src/dictionary.d.ts

@@ -0,0 +1,63 @@
+export declare const MalagasyNumerals: {
+    readonly GLUE_SY: " sy ";
+    readonly GLUE_AMBY: " amby ";
+    readonly GLUE_FAINGO: " faingo ";
+    readonly GLUE_DECIMAL_ZERO: "aotra ";
+    readonly CUSTOM_ONE: "iraika";
+    readonly ZERO: "aotra";
+    readonly DIGITS: readonly ["", "iray", "roa", "telo", "efatra", "dimy", "enina", "fito", "valo", "sivy"];
+    readonly TENS: readonly ["", "folo", "roapolo", "telopolo", "efapolo", "dimampolo", "enimpolo", "fitopolo", "valopolo", "sivifolo"];
+    readonly HUNDREDS: readonly ["", "zato", "roanjato", "telonjato", "efajato", "dimanjato", "enin-jato", "fitonjato", "valonjato", "sivinjato"];
+    readonly LARGE_NUMBER_UNITS: readonly [{
+        readonly threshold: 1000000000000000000;
+        readonly name: "tsipesimpesinafaharoa";
+    }, {
+        readonly threshold: 100000000000000000;
+        readonly name: "alinkisafaharoa";
+    }, {
+        readonly threshold: 10000000000000000;
+        readonly name: "lavitrisafaharoa";
+    }, {
+        readonly threshold: 1000000000000000;
+        readonly name: "tsitamboisafaharoa";
+    }, {
+        readonly threshold: 100000000000000;
+        readonly name: "safatsiroafaharoa";
+    }, {
+        readonly threshold: 10000000000000;
+        readonly name: "tsitanoanoa";
+    }, {
+        readonly threshold: 1000000000000;
+        readonly name: "tsitokotsiforohana";
+    }, {
+        readonly threshold: 100000000000;
+        readonly name: "tsipesimpesina";
+    }, {
+        readonly threshold: 10000000000;
+        readonly name: "alinkisa";
+    }, {
+        readonly threshold: 1000000000;
+        readonly name: "lavitrisa";
+    }, {
+        readonly threshold: 100000000;
+        readonly name: "tsitamboisa";
+    }, {
+        readonly threshold: 10000000;
+        readonly name: "safatsiroa";
+    }, {
+        readonly threshold: 1000000;
+        readonly name: "tapitrisa";
+    }, {
+        readonly threshold: 100000;
+        readonly name: "hetsy";
+    }, {
+        readonly threshold: 10000;
+        readonly name: "alina";
+    }, {
+        readonly threshold: 1000;
+        readonly name: "arivo";
+    }];
+    readonly MAX_SUPPORTED_INTEGER: number;
+};
+export type LargeNumberUnit = (typeof MalagasyNumerals.LARGE_NUMBER_UNITS)[number];
+//# sourceMappingURL=dictionary.d.ts.map

package/dist/src/dictionary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dictionary.d.ts","sourceRoot":"","sources":["../../src/dictionary.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqEnB,CAAA;AAEV,MAAM,MAAM,eAAe,GACzB,CAAC,OAAO,gBAAgB,CAAC,kBAAkB,CAAC,CAAC,MAAM,CAAC,CAAA"}

package/dist/src/dictionary.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MalagasyNumerals = void 0;
+exports.MalagasyNumerals = {
+    GLUE_SY: ' sy ',
+    GLUE_AMBY: ' amby ',
+    GLUE_FAINGO: ' faingo ',
+    GLUE_DECIMAL_ZERO: 'aotra ',
+    CUSTOM_ONE: 'iraika',
+    ZERO: 'aotra',
+    DIGITS: [
+        '',
+        'iray',
+        'roa',
+        'telo',
+        'efatra',
+        'dimy',
+        'enina',
+        'fito',
+        'valo',
+        'sivy',
+    ],
+    TENS: [
+        '',
+        'folo',
+        'roapolo',
+        'telopolo',
+        'efapolo',
+        'dimampolo',
+        'enimpolo',
+        'fitopolo',
+        'valopolo',
+        'sivifolo',
+    ],
+    HUNDREDS: [
+        '',
+        'zato',
+        'roanjato',
+        'telonjato',
+        'efajato',
+        'dimanjato',
+        'enin-jato',
+        'fitonjato',
+        'valonjato',
+        'sivinjato',
+    ],
+    LARGE_NUMBER_UNITS: [
+        { threshold: 1000000000000000000, name: 'tsipesimpesinafaharoa' },
+        { threshold: 100000000000000000, name: 'alinkisafaharoa' },
+        { threshold: 10000000000000000, name: 'lavitrisafaharoa' },
+        { threshold: 1000000000000000, name: 'tsitamboisafaharoa' },
+        { threshold: 100000000000000, name: 'safatsiroafaharoa' },
+        { threshold: 10000000000000, name: 'tsitanoanoa' },
+        { threshold: 1000000000000, name: 'tsitokotsiforohana' },
+        { threshold: 100000000000, name: 'tsipesimpesina' },
+        { threshold: 10000000000, name: 'alinkisa' },
+        { threshold: 1000000000, name: 'lavitrisa' },
+        { threshold: 100000000, name: 'tsitamboisa' },
+        { threshold: 10000000, name: 'safatsiroa' },
+        { threshold: 1000000, name: 'tapitrisa' },
+        { threshold: 100000, name: 'hetsy' },
+        { threshold: 10000, name: 'alina' },
+        { threshold: 1000, name: 'arivo' },
+    ],
+    MAX_SUPPORTED_INTEGER: 1000000000000000000 * 1000,
+};

package/dist/src/index.d.ts

@@ -0,0 +1,3 @@
+export { MalagasyNumberToWords } from './converter';
+export { MalagasyNumerals, LargeNumberUnit } from './dictionary';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AACnD,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA"}

package/dist/src/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MalagasyNumerals = exports.MalagasyNumberToWords = void 0;
+var converter_1 = require("./converter");
+Object.defineProperty(exports, "MalagasyNumberToWords", { enumerable: true, get: function () { return converter_1.MalagasyNumberToWords; } });
+var dictionary_1 = require("./dictionary");
+Object.defineProperty(exports, "MalagasyNumerals", { enumerable: true, get: function () { return dictionary_1.MalagasyNumerals; } });

package/dist/test/converter.test.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const src_1 = require("../src");
+(0, vitest_1.describe)('MalagasyNumberToWords', () => {
+    let converter;
+    (0, vitest_1.beforeEach)(() => {
+        converter = new src_1.MalagasyNumberToWords();
+    });
+    const testCases = [
+        [0, 'aotra'],
+        [1, 'iray'],
+        [5, 'dimy'],
+        [9, 'sivy'],
+        [10, 'folo'],
+        [11, 'iraika amby folo'],
+        [15, 'dimy amby folo'],
+        [20, 'roapolo'],
+        [21, 'iraika amby roapolo'],
+        [35, 'dimy amby telopolo'],
+        [99, 'sivy amby sivifolo'],
+        [100, 'zato'],
+        [101, 'iraika amby zato'],
+        [110, 'folo amby zato'],
+        [111, 'iraika amby folo amby zato'],
+        [121, 'iraika amby roapolo amby zato'],
+        [200, 'roanjato'],
+        [201, 'iraika amby roanjato'],
+        [210, 'folo sy roanjato'],
+        [225, 'dimy amby roapolo sy roanjato'],
+        [600, 'enin-jato'],
+        [999, 'sivy amby sivifolo sy sivinjato'],
+        [1000, 'arivo'],
+        [1001, 'iray sy arivo'],
+        [1010, 'folo sy arivo'],
+        [1011, 'iraika amby folo sy arivo'],
+        [1378, 'valo amby fitopolo sy telonjato sy arivo'],
+        [2000, 'roa arivo'],
+        [2023, 'telo amby roapolo sy roa arivo'],
+        [10000, 'iray alina'],
+        [15000, 'dimy arivo sy iray alina'],
+        [20000, 'roa alina'],
+        [98765, 'dimy amby enimpolo sy fitonjato sy valo arivo sy sivy alina'],
+        [100000, 'iray hetsy'],
+        [
+            123456,
+            'enina amby dimampolo sy efajato sy telo arivo sy roa alina sy iray hetsy',
+        ],
+        [500000, 'dimy hetsy'],
+        [
+            654321,
+            'iraika amby roapolo sy telonjato sy efatra arivo sy dimy alina sy enina hetsy',
+        ],
+        [1000000, 'iray tapitrisa'],
+        [1000001, 'iray sy iray tapitrisa'],
+        [2500000, 'dimy hetsy sy roa tapitrisa'],
+        [
+            9876543,
+            'telo amby efapolo sy dimanjato sy enina arivo sy fito alina sy valo hetsy sy sivy tapitrisa',
+        ],
+        [10000000, 'iray safatsiroa'],
+        [100000000, 'iray tsitamboisa'],
+        [1000000000, 'iray lavitrisa'],
+        [
+            12345678901,
+            'iraika amby sivinjato sy valo arivo sy fito alina sy enina hetsy sy dimy tapitrisa sy efatra safatsiroa sy telo tsitamboisa sy roa lavitrisa sy iray alinkisa',
+        ],
+        [1100000000000, 'iray tsipesimpesina sy iray tsitokotsiforohana'],
+        [0.5, 'aotra faingo dimy'],
+        [0.1, 'aotra faingo iray'],
+        ['2.00100', 'roa faingo aotra aotra zato'],
+        [
+            1378.23,
+            'valo amby fitopolo sy telonjato sy arivo faingo telo amby roapolo',
+        ],
+        [100.01, 'zato faingo aotra iray'],
+        [0.005, 'aotra faingo aotra aotra dimy'],
+    ];
+    vitest_1.it.each(testCases)('should convert %s to "%s"', (input, expected) => {
+        (0, vitest_1.expect)(converter.toWords(input)).toBe(expected);
+    });
+    (0, vitest_1.describe)('Error Handling', () => {
+        (0, vitest_1.it)('should throw TypeError for invalid input', () => {
+            (0, vitest_1.expect)(() => converter.toWords('not a number')).toThrow(TypeError);
+            (0, vitest_1.expect)(() => converter.toWords('123.abc')).toThrow(TypeError);
+            (0, vitest_1.expect)(() => converter.toWords(NaN)).toThrow(TypeError);
+        });
+        (0, vitest_1.it)('should throw RangeError for negative numbers', () => {
+            (0, vitest_1.expect)(() => converter.toWords(-1)).toThrow(RangeError);
+            (0, vitest_1.expect)(() => converter.toWords(-100.5)).toThrow(RangeError);
+            (0, vitest_1.expect)(() => converter.toWords('-0')).not.toThrow(RangeError);
+            (0, vitest_1.expect)(converter.toWords('-0')).toBe('aotra');
+        });
+        (0, vitest_1.it)('should throw RangeError for numbers exceeding the limit', () => {
+            const limit = src_1.MalagasyNumerals.MAX_SUPPORTED_INTEGER;
+            const largeNumber = BigInt(limit) + BigInt(1);
+            (0, vitest_1.expect)(() => converter.toWords(limit)).toThrow(RangeError);
+            (0, vitest_1.expect)(() => converter.toWords(largeNumber.toString())).toThrow(RangeError);
+        });
+        (0, vitest_1.it)('should handle string input correctly', () => {
+            (0, vitest_1.expect)(converter.toWords('123')).toBe('telo amby roapolo amby zato');
+            (0, vitest_1.expect)(converter.toWords('1000.5')).toBe('arivo faingo dimy');
+        });
+        (0, vitest_1.it)('should handle number input with maximum safe integer', () => {
+            const safeInt = Number.MAX_SAFE_INTEGER;
+            (0, vitest_1.expect)(() => converter.toWords(safeInt)).not.toThrow();
+        });
+    });
+});

package/dist/tests/converter.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=converter.test.d.ts.map

package/dist/tests/converter.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"converter.test.d.ts","sourceRoot":"","sources":["../../tests/converter.test.ts"],"names":[],"mappings":""}

package/dist/tests/converter.test.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const src_1 = require("../src");
+(0, vitest_1.describe)('MalagasyNumberToWords', () => {
+    let converter;
+    (0, vitest_1.beforeEach)(() => {
+        converter = new src_1.MalagasyNumberToWords();
+    });
+    const testCases = [
+        [0, 'aotra'],
+        [1, 'iray'],
+        [5, 'dimy'],
+        [9, 'sivy'],
+        [10, 'folo'],
+        [11, 'iraika amby folo'],
+        [15, 'dimy amby folo'],
+        [20, 'roapolo'],
+        [21, 'iraika amby roapolo'],
+        [35, 'dimy amby telopolo'],
+        [99, 'sivy amby sivifolo'],
+        [100, 'zato'],
+        [101, 'iraika amby zato'],
+        [110, 'folo amby zato'],
+        [111, 'iraika amby folo amby zato'],
+        [121, 'iraika amby roapolo amby zato'],
+        [200, 'roanjato'],
+        [201, 'iraika amby roanjato'],
+        [210, 'folo sy roanjato'],
+        [225, 'dimy amby roapolo sy roanjato'],
+        [600, 'enin-jato'],
+        [999, 'sivy amby sivifolo sy sivinjato'],
+        [1000, 'arivo'],
+        [1001, 'iray sy arivo'],
+        [1010, 'folo sy arivo'],
+        [1011, 'iraika amby folo sy arivo'],
+        [1378, 'valo amby fitopolo sy telonjato sy arivo'],
+        [2000, 'roa arivo'],
+        [2023, 'telo amby roapolo sy roa arivo'],
+        [10000, 'iray alina'],
+        [15000, 'dimy arivo sy iray alina'],
+        [20000, 'roa alina'],
+        [98765, 'dimy amby enimpolo sy fitonjato sy valo arivo sy sivy alina'],
+        [100000, 'iray hetsy'],
+        [
+            123456,
+            'enina amby dimampolo sy efajato sy telo arivo sy roa alina sy iray hetsy',
+        ],
+        [500000, 'dimy hetsy'],
+        [
+            654321,
+            'iraika amby roapolo sy telonjato sy efatra arivo sy dimy alina sy enina hetsy',
+        ],
+        [1000000, 'iray tapitrisa'],
+        [1000001, 'iray sy iray tapitrisa'],
+        [2500000, 'dimy hetsy sy roa tapitrisa'],
+        [
+            9876543,
+            'telo amby efapolo sy dimanjato sy enina arivo sy fito alina sy valo hetsy sy sivy tapitrisa',
+        ],
+        [10000000, 'iray safatsiroa'],
+        [100000000, 'iray tsitamboisa'],
+        [1000000000, 'iray lavitrisa'],
+        [
+            12345678901,
+            'iraika amby sivinjato sy valo arivo sy fito alina sy enina hetsy sy dimy tapitrisa sy efatra safatsiroa sy telo tsitamboisa sy roa lavitrisa sy iray alinkisa',
+        ],
+        [1100000000000, 'iray tsipesimpesina sy iray tsitokotsiforohana'],
+        [0.5, 'aotra faingo dimy'],
+        [0.1, 'aotra faingo iray'],
+        ['2.00100', 'roa faingo aotra aotra zato'],
+        [
+            1378.23,
+            'valo amby fitopolo sy telonjato sy arivo faingo telo amby roapolo',
+        ],
+        [100.01, 'zato faingo aotra iray'],
+        [0.005, 'aotra faingo aotra aotra dimy'],
+    ];
+    vitest_1.it.each(testCases)('should convert %s to "%s"', (input, expected) => {
+        (0, vitest_1.expect)(converter.toWords(input)).toBe(expected);
+    });
+    (0, vitest_1.describe)('Error Handling', () => {
+        (0, vitest_1.it)('should throw TypeError for invalid input', () => {
+            (0, vitest_1.expect)(() => converter.toWords('not a number')).toThrow(TypeError);
+            (0, vitest_1.expect)(() => converter.toWords('123.abc')).toThrow(TypeError);
+            (0, vitest_1.expect)(() => converter.toWords(NaN)).toThrow(TypeError);
+        });
+        (0, vitest_1.it)('should throw RangeError for negative numbers', () => {
+            (0, vitest_1.expect)(() => converter.toWords(-1)).toThrow(RangeError);
+            (0, vitest_1.expect)(() => converter.toWords(-100.5)).toThrow(RangeError);
+            (0, vitest_1.expect)(() => converter.toWords('-0')).not.toThrow(RangeError);
+            (0, vitest_1.expect)(converter.toWords('-0')).toBe('aotra');
+        });
+        (0, vitest_1.it)('should throw RangeError for numbers exceeding the limit', () => {
+            const limit = src_1.MalagasyNumerals.MAX_SUPPORTED_INTEGER;
+            const largeNumber = BigInt(limit) + BigInt(1);
+            (0, vitest_1.expect)(() => converter.toWords(limit)).toThrow(RangeError);
+            (0, vitest_1.expect)(() => converter.toWords(largeNumber.toString())).toThrow(RangeError);
+        });
+        (0, vitest_1.it)('should handle string input correctly', () => {
+            (0, vitest_1.expect)(converter.toWords('123')).toBe('telo amby roapolo amby zato');
+            (0, vitest_1.expect)(converter.toWords('1000.5')).toBe('arivo faingo dimy');
+        });
+        (0, vitest_1.it)('should handle number input with maximum safe integer', () => {
+            const safeInt = Number.MAX_SAFE_INTEGER;
+            (0, vitest_1.expect)(() => converter.toWords(safeInt)).not.toThrow();
+        });
+    });
+});

package/dist/vitest.config.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("vite").UserConfig;
+export default _default;
+//# sourceMappingURL=vitest.config.d.ts.map

package/dist/vitest.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vitest.config.d.ts","sourceRoot":"","sources":["../vitest.config.ts"],"names":[],"mappings":";AAEA,wBAIE"}

package/dist/vitest.config.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vite_1 = require("vite");
+exports.default = (0, vite_1.defineConfig)({
+    test: {
+        exclude: ['./dist', './node_modules'],
+    },
+});

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "tanisa",
+  "version": "1.0.0",
+  "main": "src/converter.ts",
+  "description": "An utility to convert Malagasy 🇲🇬 numbers, including decimals, into their word representations.",
+  "license": "MIT",
+  "author": {
+    "name": "Rija Nifaliana",
+    "email": "rija.nifaliana@gmail.com"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "format": "prettier . --write",
+    "lint": "eslint",
+    "lint:fix": "eslint . --fix",
+    "build": "tsc",
+    "_postinstall": "husky",
+    "prepack": "pinst --disable",
+    "postpack": "pinst --enable",
+    "prepare": "husky"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.24.0",
+    "@types/node": "^22.14.1",
+    "eslint": "^9.24.0",
+    "globals": "^16.0.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^15.5.1",
+    "pinst": "^3.0.0",
+    "prettier": "^3.5.3",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.30.1",
+    "vitest": "^3.1.1"
+  },
+  "dependencies": {
+    "husky-init": "^8.0.0"
+  },
+  "keywords": [
+    "malagasy",
+    "number",
+    "words",
+    "converter",
+    "i18n",
+    "l10n",
+    "toWords",
+    "fanisana",
+    "typescript",
+    "javascript"
+  ]
+}

package/src/converter.ts

@@ -0,0 +1,130 @@
+import { LargeNumberUnit, MalagasyNumerals } from '.'
+
+export class MalagasyNumberToWords {
+  public toWords(number: number | string): string {
+    const numStr = String(number)
+    const [integerPartStr, decimalPartStr] = numStr.split('.')
+    const integerPartNum = parseInt(integerPartStr || '0', 10)
+
+    if (
+      isNaN(integerPartNum) ||
+      (decimalPartStr && isNaN(parseInt(decimalPartStr, 10)))
+    ) {
+      throw new TypeError(`Invalid number input: "${number}"`)
+    }
+
+    if (numStr.trim().startsWith('-') && integerPartNum !== 0) {
+      throw new RangeError('Negative numbers are not supported.')
+    }
+
+    if (
+      integerPartNum >= MalagasyNumerals.MAX_SUPPORTED_INTEGER ||
+      integerPartStr == MalagasyNumerals.MAX_SUPPORTED_INTEGER.toString()
+    ) {
+      throw new RangeError(
+        `Number ${integerPartNum} exceeds the maximum supported value (${MalagasyNumerals.MAX_SUPPORTED_INTEGER}).`
+      )
+    }
+
+    const integerWords = this.convertInteger(integerPartNum)
+
+    let decimalWords = ''
+    if (decimalPartStr && decimalPartStr.length > 0) {
+      for (let i = 0; i < decimalPartStr.length; i++) {
+        const digit = decimalPartStr[i]
+        if (digit === '0') {
+          decimalWords += MalagasyNumerals.GLUE_DECIMAL_ZERO
+        } else {
+          const remainingDecimal = decimalPartStr.substring(i)
+          decimalWords += this.convertInteger(parseInt(remainingDecimal, 10))
+          break
+        }
+      }
+      return integerWords + MalagasyNumerals.GLUE_FAINGO + decimalWords
+    } else {
+      return integerWords
+    }
+  }
+
+  private convertInteger(num: number): string {
+    if (num === 0) {
+      return MalagasyNumerals.ZERO
+    }
+
+    for (const unit of MalagasyNumerals.LARGE_NUMBER_UNITS) {
+      if (num >= unit.threshold) {
+        return this.formatLargeNumber(num, unit)
+      }
+    }
+
+    return this.convertBelowThousand(num)
+  }
+
+  private formatLargeNumber(num: number, unit: LargeNumberUnit): string {
+    const multiple = Math.floor(num / unit.threshold)
+    const remainder = num % unit.threshold
+
+    let prefix = ''
+    // Use prefix only if multiple is greater than 1 OR
+    // if multiple is 1 AND the unit is larger than 'arivo' (1000)
+    if (multiple > 1) {
+      prefix = this.convertInteger(multiple) + ' '
+    } else if (multiple === 1 && unit.threshold > 1000) {
+      prefix = MalagasyNumerals.DIGITS[1] + ' '
+    }
+    // If multiple is 1 and unit is 'arivo', no prefix is needed ("arivo", not "iray arivo")
+    const basePart = prefix + unit.name
+
+    if (remainder > 0) {
+      const remainderText = this.convertInteger(remainder)
+      return remainderText + MalagasyNumerals.GLUE_SY + basePart
+    } else {
+      return basePart
+    }
+  }
+
+  private convertBelowThousand(num: number): string {
+    // Assumes 0 < num < 1000
+    if (num >= 100) {
+      const hundredMultiple = Math.floor(num / 100)
+      const remainder = num % 100
+      const hundredWord = MalagasyNumerals.HUNDREDS[hundredMultiple]
+
+      if (remainder === 0) {
+        return hundredWord
+      } else {
+        const remainderWords = this.convertBelowHundred(remainder)
+        let glue = MalagasyNumerals.GLUE_AMBY as string
+        // Special rule: Use "sy" if hundred base >= 200 AND remainder >= 10
+        if (hundredMultiple >= 2 && remainder >= 10) {
+          glue = MalagasyNumerals.GLUE_SY
+        }
+        // Use "iraika" for remainder 1 when connecting
+        const finalRemainderWords =
+          remainder === 1 ? MalagasyNumerals.CUSTOM_ONE : remainderWords
+        return finalRemainderWords + glue + hundredWord
+      }
+    }
+    return this.convertBelowHundred(num)
+  }
+
+  private convertBelowHundred(num: number): string {
+    if (num >= 10) {
+      const tenMultiple = Math.floor(num / 10)
+      const remainder = num % 10
+      const tenWord = MalagasyNumerals.TENS[tenMultiple]
+
+      if (remainder === 0) {
+        return tenWord
+      } else {
+        // Always use "amby" for tens+digits
+        const digitWord =
+          remainder === 1
+            ? MalagasyNumerals.CUSTOM_ONE
+            : MalagasyNumerals.DIGITS[remainder]
+        return digitWord + MalagasyNumerals.GLUE_AMBY + tenWord
+      }
+    }
+    return MalagasyNumerals.DIGITS[num]
+  }
+}