stringzy 4.1.0 → 4.2.0

package/dist/tests/analyzing/lexicographicalRank.test.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const node_assert_1 = __importDefault(require("node:assert"));
+const lexicographicalRank_1 = require("../../analyzing/lexicographicalRank");
+(0, node_test_1.describe)('lexicographicalRank', () => {
+    (0, node_test_1.it)('returns correct rank for small strings', () => {
+        node_assert_1.default.strictEqual((0, lexicographicalRank_1.lexicographicalRank)('acb'), 2);
+        node_assert_1.default.strictEqual((0, lexicographicalRank_1.lexicographicalRank)('cba'), 6);
+        node_assert_1.default.strictEqual((0, lexicographicalRank_1.lexicographicalRank)('abc'), 1);
+    });
+    (0, node_test_1.it)('handles strings with repeated characters', () => {
+        node_assert_1.default.strictEqual((0, lexicographicalRank_1.lexicographicalRank)('aba'), 2);
+        node_assert_1.default.strictEqual((0, lexicographicalRank_1.lexicographicalRank)('aab'), 1);
+        node_assert_1.default.strictEqual((0, lexicographicalRank_1.lexicographicalRank)('baa'), 3);
+    });
+    (0, node_test_1.it)('returns 1 for single character string', () => {
+        node_assert_1.default.strictEqual((0, lexicographicalRank_1.lexicographicalRank)('a'), 1);
+        node_assert_1.default.strictEqual((0, lexicographicalRank_1.lexicographicalRank)('Z'), 1);
+    });
+    (0, node_test_1.it)('handles larger examples correctly', () => {
+        node_assert_1.default.strictEqual((0, lexicographicalRank_1.lexicographicalRank)('string'), 598);
+    });
+    (0, node_test_1.it)('handles empty string', () => {
+        node_assert_1.default.strictEqual((0, lexicographicalRank_1.lexicographicalRank)(''), 1);
+    });
+    (0, node_test_1.it)('is case-sensitive', () => {
+        node_assert_1.default.strictEqual((0, lexicographicalRank_1.lexicographicalRank)('Abc'), 1); // 'A' < 'b' < 'c'
+        node_assert_1.default.strictEqual((0, lexicographicalRank_1.lexicographicalRank)('bAc'), 3);
+    });
+    (0, node_test_1.it)('handles special characters', () => {
+        node_assert_1.default.strictEqual((0, lexicographicalRank_1.lexicographicalRank)('!ab'), 1); // '!' comes first
+        node_assert_1.default.strictEqual((0, lexicographicalRank_1.lexicographicalRank)('ab!'), 4); // correct rank is 4
+    });
+    (0, node_test_1.it)('throws an error if input is not a string', () => {
+        node_assert_1.default.throws(() => (0, lexicographicalRank_1.lexicographicalRank)(123), /Input must be a string/);
+        node_assert_1.default.throws(() => (0, lexicographicalRank_1.lexicographicalRank)(null), /Input must be a string/);
+        node_assert_1.default.throws(() => (0, lexicographicalRank_1.lexicographicalRank)(undefined), /Input must be a string/);
+    });
+});

package/dist/tests/formatting/binary.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/formatting/binary.test.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const node_assert_1 = __importDefault(require("node:assert"));
+const binary_1 = require("../../formatting/binary");
+(0, node_test_1.describe)('formatToBinary', () => {
+    (0, node_test_1.it)('converts standard positive integers', () => {
+        node_assert_1.default.strictEqual((0, binary_1.formatToBinary)(5), '101');
+        node_assert_1.default.strictEqual((0, binary_1.formatToBinary)(10), '1010');
+        node_assert_1.default.strictEqual((0, binary_1.formatToBinary)(255), '11111111');
+        node_assert_1.default.strictEqual((0, binary_1.formatToBinary)(1), '1');
+        node_assert_1.default.strictEqual((0, binary_1.formatToBinary)(2), '10');
+    });
+    (0, node_test_1.it)('handles zero', () => {
+        node_assert_1.default.strictEqual((0, binary_1.formatToBinary)(0), '0');
+    });
+    (0, node_test_1.it)('prefixes negative numbers with a minus sign', () => {
+        node_assert_1.default.strictEqual((0, binary_1.formatToBinary)(-5), '-101');
+        node_assert_1.default.strictEqual((0, binary_1.formatToBinary)(-10), '-1010');
+    });
+    (0, node_test_1.it)('supports optional grouping from right to left (LSB first)', () => {
+        node_assert_1.default.strictEqual((0, binary_1.formatToBinary)(255, { group: 4 }), '1111 1111');
+        node_assert_1.default.strictEqual((0, binary_1.formatToBinary)(10, { group: 2 }), '10 10');
+        node_assert_1.default.strictEqual((0, binary_1.formatToBinary)(5, { group: 4 }), '101'); // no padding on the left
+        node_assert_1.default.strictEqual((0, binary_1.formatToBinary)(1023, { group: 4 }), '11 1111 1111');
+    });
+    (0, node_test_1.it)('applies grouping with negative numbers', () => {
+        node_assert_1.default.strictEqual((0, binary_1.formatToBinary)(-255, { group: 4 }), '-1111 1111');
+    });
+    (0, node_test_1.it)('handles large integers (MAX_SAFE_INTEGER)', () => {
+        const expected = Number.MAX_SAFE_INTEGER.toString(2);
+        node_assert_1.default.strictEqual((0, binary_1.formatToBinary)(Number.MAX_SAFE_INTEGER), expected);
+    });
+    (0, node_test_1.it)('throws TypeError for invalid inputs (type/NaN)', () => {
+        node_assert_1.default.throws(() => (0, binary_1.formatToBinary)('5'), /Input must be a number/);
+        node_assert_1.default.throws(() => (0, binary_1.formatToBinary)(null), /Input must be a number/);
+        node_assert_1.default.throws(() => (0, binary_1.formatToBinary)(undefined), /Input must be a number/);
+        node_assert_1.default.throws(() => (0, binary_1.formatToBinary)(NaN), /Input must be a number/);
+    });
+    (0, node_test_1.it)('throws TypeError for non-integer numbers', () => {
+        node_assert_1.default.throws(() => (0, binary_1.formatToBinary)(3.14), /Input must be an integer/);
+        node_assert_1.default.throws(() => (0, binary_1.formatToBinary)(-2.5), /Input must be an integer/);
+    });
+    (0, node_test_1.it)('throws TypeError for invalid group size', () => {
+        node_assert_1.default.throws(() => (0, binary_1.formatToBinary)(10, { group: 0 }), /Group size must be a positive integer/);
+        node_assert_1.default.throws(() => (0, binary_1.formatToBinary)(10, { group: -1 }), /Group size must be a positive integer/);
+        node_assert_1.default.throws(() => (0, binary_1.formatToBinary)(10, { group: 2.5 }), /Group size must be a positive integer/);
+        node_assert_1.default.throws(() => (0, binary_1.formatToBinary)(10, { group: '4' }), /Group size must be a positive integer/);
+    });
+});

package/dist/tests/formatting/creditCard.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/formatting/creditCard.test.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const node_assert_1 = __importDefault(require("node:assert"));
+const creditCard_1 = require("../../formatting/creditCard");
+(0, node_test_1.describe)('formatCreditCard', () => {
+    (0, node_test_1.it)('formats 16-digit card numbers correctly', () => {
+        node_assert_1.default.strictEqual((0, creditCard_1.formatCreditCard)('1234567812345678'), '1234 5678 1234 5678');
+        node_assert_1.default.strictEqual((0, creditCard_1.formatCreditCard)('4111111111111111'), '4111 1111 1111 1111');
+    });
+    (0, node_test_1.it)('formats 15-digit card numbers (AmEx) correctly', () => {
+        node_assert_1.default.strictEqual((0, creditCard_1.formatCreditCard)('378282246310005'), '3782 822463 10005');
+    });
+    (0, node_test_1.it)('removes non-digit characters before formatting', () => {
+        node_assert_1.default.strictEqual((0, creditCard_1.formatCreditCard)('4111-1111-1111-1111'), '4111 1111 1111 1111');
+        node_assert_1.default.strictEqual((0, creditCard_1.formatCreditCard)('3782 8224 6310 005'), '3782 822463 10005');
+    });
+    (0, node_test_1.it)('returns empty string for invalid lengths', () => {
+        node_assert_1.default.strictEqual((0, creditCard_1.formatCreditCard)('123'), '');
+        node_assert_1.default.strictEqual((0, creditCard_1.formatCreditCard)('11112222333344445555'), '');
+        node_assert_1.default.strictEqual((0, creditCard_1.formatCreditCard)(''), '');
+    });
+    (0, node_test_1.it)('throws an error if input is not a string', () => {
+        node_assert_1.default.throws(() => (0, creditCard_1.formatCreditCard)(1234567812345678), /Input must be a string/);
+        node_assert_1.default.throws(() => (0, creditCard_1.formatCreditCard)(null), /Input must be a string/);
+        node_assert_1.default.throws(() => (0, creditCard_1.formatCreditCard)(undefined), /Input must be a string/);
+    });
+});

package/dist/tests/formatting/decimal.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/formatting/decimal.test.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const node_assert_1 = __importDefault(require("node:assert"));
+const decimal_1 = require("../../formatting/decimal");
+(0, node_test_1.describe)('formatToDecimal', () => {
+    // Binary
+    (0, node_test_1.it)('converts binary strings (base 2) without prefix', () => {
+        node_assert_1.default.strictEqual((0, decimal_1.formatToDecimal)('1010', { base: 2 }), 10);
+        node_assert_1.default.strictEqual((0, decimal_1.formatToDecimal)('0', { base: 2 }), 0);
+        node_assert_1.default.strictEqual((0, decimal_1.formatToDecimal)('000101', { base: 2 }), 5);
+    });
+    (0, node_test_1.it)('converts binary strings (base 2) with 0b prefix', () => {
+        node_assert_1.default.strictEqual((0, decimal_1.formatToDecimal)('0b1010', { base: 2 }), 10);
+        node_assert_1.default.strictEqual((0, decimal_1.formatToDecimal)('0B111', { base: 2 }), 7);
+    });
+    // Octal
+    (0, node_test_1.it)('converts octal strings (base 8) without prefix', () => {
+        node_assert_1.default.strictEqual((0, decimal_1.formatToDecimal)('12', { base: 8 }), 10);
+        node_assert_1.default.strictEqual((0, decimal_1.formatToDecimal)('00012', { base: 8 }), 10);
+    });
+    (0, node_test_1.it)('converts octal strings (base 8) with 0o prefix', () => {
+        node_assert_1.default.strictEqual((0, decimal_1.formatToDecimal)('0o12', { base: 8 }), 10);
+        node_assert_1.default.strictEqual((0, decimal_1.formatToDecimal)('0O377', { base: 8 }), 255);
+    });
+    // Hexadecimal
+    (0, node_test_1.it)('converts hexadecimal strings (base 16) without prefix (uppercase/lowercase)', () => {
+        node_assert_1.default.strictEqual((0, decimal_1.formatToDecimal)('ff', { base: 16 }), 255);
+        node_assert_1.default.strictEqual((0, decimal_1.formatToDecimal)('FF', { base: 16 }), 255);
+        node_assert_1.default.strictEqual((0, decimal_1.formatToDecimal)('000a', { base: 16 }), 10);
+    });
+    (0, node_test_1.it)('converts hexadecimal strings (base 16) with 0x prefix', () => {
+        node_assert_1.default.strictEqual((0, decimal_1.formatToDecimal)('0xFF', { base: 16 }), 255);
+        node_assert_1.default.strictEqual((0, decimal_1.formatToDecimal)('0X10', { base: 16 }), 16);
+    });
+    // Whitespace and sign handling
+    (0, node_test_1.it)('trims whitespace and supports optional sign', () => {
+        node_assert_1.default.strictEqual((0, decimal_1.formatToDecimal)('  1010  ', { base: 2 }), 10);
+        node_assert_1.default.strictEqual((0, decimal_1.formatToDecimal)('+0xFF', { base: 16 }), 255);
+        node_assert_1.default.strictEqual((0, decimal_1.formatToDecimal)('-0b10', { base: 2 }), -2);
+    });
+    // Errors: unsupported base
+    (0, node_test_1.it)('throws for unsupported bases', () => {
+        node_assert_1.default.throws(() => (0, decimal_1.formatToDecimal)('10', { base: 10 }), /Base must be one of 2, 8, or 16/);
+    });
+    // Errors: invalid input type or empty string
+    (0, node_test_1.it)('throws TypeError for non-string inputs or empty strings', () => {
+        node_assert_1.default.throws(() => (0, decimal_1.formatToDecimal)(1010, { base: 2 }), /Input must be a string/);
+        node_assert_1.default.throws(() => (0, decimal_1.formatToDecimal)('   ', { base: 2 }), /non-empty/);
+    });
+    // Errors: malformed or invalid values
+    (0, node_test_1.it)('throws TypeError for malformed values', () => {
+        node_assert_1.default.throws(() => (0, decimal_1.formatToDecimal)('102', { base: 2 }), /invalid characters/);
+        node_assert_1.default.throws(() => (0, decimal_1.formatToDecimal)('89', { base: 8 }), /invalid characters/);
+        node_assert_1.default.throws(() => (0, decimal_1.formatToDecimal)('0xG1', { base: 16 }), /invalid characters/);
+        node_assert_1.default.throws(() => (0, decimal_1.formatToDecimal)('-', { base: 2 }), /Malformed/);
+        node_assert_1.default.throws(() => (0, decimal_1.formatToDecimal)('+', { base: 16 }), /Malformed/);
+    });
+});

package/dist/tests/formatting/duration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/formatting/duration.test.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const node_assert_1 = __importDefault(require("node:assert"));
+const duration_1 = require("../../formatting/duration");
+(0, node_test_1.describe)('formatDuration', () => {
+    (0, node_test_1.describe)('basic functionality', () => {
+        (0, node_test_1.it)('formats exact minutes', () => {
+            node_assert_1.default.strictEqual((0, duration_1.formatDuration)(60), '1m');
+        });
+        (0, node_test_1.it)('formats minutes and seconds', () => {
+            node_assert_1.default.strictEqual((0, duration_1.formatDuration)(61), '1m 1s');
+        });
+        (0, node_test_1.it)('formats hours, minutes and seconds', () => {
+            node_assert_1.default.strictEqual((0, duration_1.formatDuration)(3661), '1h 1m 1s');
+        });
+        (0, node_test_1.it)('formats exact hours', () => {
+            node_assert_1.default.strictEqual((0, duration_1.formatDuration)(3600), '1h');
+        });
+        (0, node_test_1.it)('formats complex durations', () => {
+            node_assert_1.default.strictEqual((0, duration_1.formatDuration)(7325), '2h 2m 5s');
+        });
+        (0, node_test_1.it)('formats milliseconds when specified', () => {
+            node_assert_1.default.strictEqual((0, duration_1.formatDuration)(1234567, { unit: 'milliseconds', includeMs: true }), '20m 34s 567ms');
+        });
+        (0, node_test_1.it)('formats zero as zero seconds', () => {
+            node_assert_1.default.strictEqual((0, duration_1.formatDuration)(0), '0s');
+        });
+        (0, node_test_1.it)('handles large values', () => {
+            node_assert_1.default.strictEqual((0, duration_1.formatDuration)(86400), '24h');
+        });
+    });
+    (0, node_test_1.describe)('format options', () => {
+        (0, node_test_1.it)('formats with medium format', () => {
+            node_assert_1.default.strictEqual((0, duration_1.formatDuration)(3661, { format: 'medium' }), '1h 01m 01s');
+        });
+        (0, node_test_1.it)('formats with long format', () => {
+            node_assert_1.default.strictEqual((0, duration_1.formatDuration)(3661, { format: 'long' }), '1 hour 1 minute 1 second');
+        });
+        (0, node_test_1.it)('formats with custom delimiter', () => {
+            node_assert_1.default.strictEqual((0, duration_1.formatDuration)(3661, { delimiter: ':' }), '1h:1m:1s');
+        });
+    });
+    (0, node_test_1.describe)('error handling', () => {
+        (0, node_test_1.it)('throws on non-numeric input', () => {
+            node_assert_1.default.throws(() => (0, duration_1.formatDuration)('60'), {
+                name: 'TypeError',
+                message: 'Input must be a number'
+            });
+        });
+        (0, node_test_1.it)('throws on negative input', () => {
+            node_assert_1.default.throws(() => (0, duration_1.formatDuration)(-60), {
+                name: 'TypeError',
+                message: 'Input must be non-negative'
+            });
+        });
+    });
+});

package/dist/tests/formatting/fileSize.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/formatting/fileSize.test.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const node_assert_1 = __importDefault(require("node:assert"));
+const fileSize_1 = require("../../formatting/fileSize");
+(0, node_test_1.describe)('formatFileSize', () => {
+    (0, node_test_1.it)('formats basic sizes correctly', () => {
+        node_assert_1.default.strictEqual((0, fileSize_1.formatFileSize)(123), '123 B');
+        node_assert_1.default.strictEqual((0, fileSize_1.formatFileSize)(1024), '1 KB');
+        node_assert_1.default.strictEqual((0, fileSize_1.formatFileSize)(1048576), '1 MB');
+        node_assert_1.default.strictEqual((0, fileSize_1.formatFileSize)(1073741824), '1 GB');
+    });
+    (0, node_test_1.it)('handles fractional sizes with correct rounding', () => {
+        node_assert_1.default.strictEqual((0, fileSize_1.formatFileSize)(1572864), '1.5 MB'); // 1.5 MB
+        node_assert_1.default.strictEqual((0, fileSize_1.formatFileSize)(1536, 1), '1.5 KB'); // 1.5 KB
+    });
+    (0, node_test_1.it)('handles precision configuration', () => {
+        node_assert_1.default.strictEqual((0, fileSize_1.formatFileSize)(1500, 0), '1 KB'); // rounds down
+        node_assert_1.default.strictEqual((0, fileSize_1.formatFileSize)(1500, 3), '1.465 KB');
+    });
+    (0, node_test_1.it)('handles zero correctly', () => {
+        node_assert_1.default.strictEqual((0, fileSize_1.formatFileSize)(0), '0 B');
+    });
+    (0, node_test_1.it)('throws TypeError for invalid inputs', () => {
+        node_assert_1.default.throws(() => (0, fileSize_1.formatFileSize)('1024'), /Input must be a number/);
+        node_assert_1.default.throws(() => (0, fileSize_1.formatFileSize)(null), /Input must be a number/);
+        node_assert_1.default.throws(() => (0, fileSize_1.formatFileSize)(undefined), /Input must be a number/);
+    });
+    (0, node_test_1.it)('throws TypeError for invalid precision', () => {
+        node_assert_1.default.throws(() => (0, fileSize_1.formatFileSize)(1024, -1), /Precision must be a non-negative number/);
+        node_assert_1.default.throws(() => (0, fileSize_1.formatFileSize)(1024, '2'), /Precision must be a non-negative number/);
+    });
+    (0, node_test_1.it)('throws RangeError for negative byte values', () => {
+        node_assert_1.default.throws(() => (0, fileSize_1.formatFileSize)(-1024), /File size cannot be negative/);
+    });
+});

package/dist/tests/formatting/hexadecimal.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/formatting/hexadecimal.test.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const node_assert_1 = __importDefault(require("node:assert"));
+const hexadecimal_1 = require("../../formatting/hexadecimal");
+(0, node_test_1.describe)('formatToHexadecimal', () => {
+    (0, node_test_1.it)('converts decimal to hexadecimal (uppercase by default)', () => {
+        node_assert_1.default.strictEqual((0, hexadecimal_1.formatToHexadecimal)(10), 'A');
+        node_assert_1.default.strictEqual((0, hexadecimal_1.formatToHexadecimal)(15), 'F');
+        node_assert_1.default.strictEqual((0, hexadecimal_1.formatToHexadecimal)(255), 'FF');
+        node_assert_1.default.strictEqual((0, hexadecimal_1.formatToHexadecimal)(4095), 'FFF');
+    });
+    (0, node_test_1.it)('handles negative numbers', () => {
+        node_assert_1.default.strictEqual((0, hexadecimal_1.formatToHexadecimal)(-255), '-FF');
+        node_assert_1.default.strictEqual((0, hexadecimal_1.formatToHexadecimal)(-4095), '-FFF');
+    });
+    (0, node_test_1.it)('supports prefix option (0x)', () => {
+        node_assert_1.default.strictEqual((0, hexadecimal_1.formatToHexadecimal)(255, { prefix: true }), '0xFF');
+        node_assert_1.default.strictEqual((0, hexadecimal_1.formatToHexadecimal)(-255, { prefix: true }), '-0xFF');
+    });
+    (0, node_test_1.it)('supports lowercase option', () => {
+        node_assert_1.default.strictEqual((0, hexadecimal_1.formatToHexadecimal)(255, { lowercase: true }), 'ff');
+        node_assert_1.default.strictEqual((0, hexadecimal_1.formatToHexadecimal)(4095, { lowercase: true }), 'fff');
+    });
+    (0, node_test_1.it)('supports both prefix and lowercase together', () => {
+        node_assert_1.default.strictEqual((0, hexadecimal_1.formatToHexadecimal)(255, { prefix: true, lowercase: true }), '0xff');
+        node_assert_1.default.strictEqual((0, hexadecimal_1.formatToHexadecimal)(-255, { prefix: true, lowercase: true }), '-0xff');
+    });
+    (0, node_test_1.it)('throws an error for non-numeric inputs', () => {
+        node_assert_1.default.throws(() => (0, hexadecimal_1.formatToHexadecimal)('123'), /Input must be a valid number/);
+        node_assert_1.default.throws(() => (0, hexadecimal_1.formatToHexadecimal)(null), /Input must be a valid number/);
+        node_assert_1.default.throws(() => (0, hexadecimal_1.formatToHexadecimal)(undefined), /Input must be a valid number/);
+        node_assert_1.default.throws(() => (0, hexadecimal_1.formatToHexadecimal)(NaN), /Input must be a valid number/);
+    });
+});

package/dist/tests/formatting/listToString.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/formatting/listToString.test.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const node_assert_1 = __importDefault(require("node:assert"));
+const listToString_1 = require("../../formatting/listToString");
+(0, node_test_1.describe)('formatList', () => {
+    (0, node_test_1.it)('formats empty arrays correctly', () => {
+        node_assert_1.default.strictEqual((0, listToString_1.formatList)([]), '');
+    });
+    (0, node_test_1.it)('formats single-item arrays correctly', () => {
+        node_assert_1.default.strictEqual((0, listToString_1.formatList)(['apple']), 'apple');
+    });
+    (0, node_test_1.it)('formats two-item arrays correctly', () => {
+        node_assert_1.default.strictEqual((0, listToString_1.formatList)(['apples', 'bananas']), 'apples and bananas');
+    });
+    (0, node_test_1.it)('formats three or more items with Oxford comma', () => {
+        node_assert_1.default.strictEqual((0, listToString_1.formatList)(['apples', 'bananas', 'cherries']), 'apples, bananas, and cherries');
+        node_assert_1.default.strictEqual((0, listToString_1.formatList)(['red', 'blue', 'green', 'yellow']), 'red, blue, green, and yellow');
+    });
+    (0, node_test_1.it)('throws TypeError for non-array inputs', () => {
+        node_assert_1.default.throws(() => (0, listToString_1.formatList)('apple'), /Input must be an array/);
+        node_assert_1.default.throws(() => (0, listToString_1.formatList)(123), /Input must be an array/);
+    });
+    (0, node_test_1.it)('throws TypeError for non-string elements in array', () => {
+        node_assert_1.default.throws(() => (0, listToString_1.formatList)(['apple', 123]), /All elements in the array must be strings/);
+        node_assert_1.default.throws(() => (0, listToString_1.formatList)(['apple', null]), /All elements in the array must be strings/);
+    });
+    (0, node_test_1.it)('throws TypeError for mixed arrays (strings + other types)', () => {
+        node_assert_1.default.throws(() => (0, listToString_1.formatList)(['apple', 42, 'banana']), /All elements in the array must be strings/);
+        node_assert_1.default.throws(() => (0, listToString_1.formatList)(['apple', true, 'banana']), /All elements in the array must be strings/);
+        node_assert_1.default.throws(() => (0, listToString_1.formatList)(['apple', undefined, 'banana']), /All elements in the array must be strings/);
+        node_assert_1.default.throws(() => (0, listToString_1.formatList)(['apple', {}, 'banana']), /All elements in the array must be strings/);
+    });
+});

package/dist/tests/formatting/octal.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/formatting/octal.test.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const node_assert_1 = __importDefault(require("node:assert"));
+const octal_1 = require("../../formatting/octal");
+(0, node_test_1.describe)('formatToOctal', () => {
+    (0, node_test_1.it)('converts standard positive numbers', () => {
+        node_assert_1.default.strictEqual((0, octal_1.formatToOctal)(8), '10');
+        node_assert_1.default.strictEqual((0, octal_1.formatToOctal)(10), '12');
+        node_assert_1.default.strictEqual((0, octal_1.formatToOctal)(255), '377');
+        node_assert_1.default.strictEqual((0, octal_1.formatToOctal)(0), '0');
+    });
+    (0, node_test_1.it)('handles negative numbers', () => {
+        node_assert_1.default.strictEqual((0, octal_1.formatToOctal)(-8), '-10');
+        node_assert_1.default.strictEqual((0, octal_1.formatToOctal)(-255), '-377');
+    });
+    (0, node_test_1.it)('adds prefix when specified', () => {
+        node_assert_1.default.strictEqual((0, octal_1.formatToOctal)(255, { prefix: true }), '0o377');
+        node_assert_1.default.strictEqual((0, octal_1.formatToOctal)(-255, { prefix: true }), '-0o377');
+        node_assert_1.default.strictEqual((0, octal_1.formatToOctal)(0, { prefix: true }), '0o0');
+    });
+    (0, node_test_1.it)('handles large integers', () => {
+        const value = Number.MAX_SAFE_INTEGER;
+        const expected = value.toString(8);
+        node_assert_1.default.strictEqual((0, octal_1.formatToOctal)(value), expected);
+    });
+    (0, node_test_1.it)('throws TypeError for invalid inputs', () => {
+        node_assert_1.default.throws(() => (0, octal_1.formatToOctal)('10'), /Input must be a number/);
+        node_assert_1.default.throws(() => (0, octal_1.formatToOctal)(null), /Input must be a number/);
+        node_assert_1.default.throws(() => (0, octal_1.formatToOctal)(undefined), /Input must be a number/);
+        node_assert_1.default.throws(() => (0, octal_1.formatToOctal)(NaN), /Input must be a number/);
+    });
+});

package/dist/tests/formatting/ordinal.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/formatting/ordinal.test.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const node_assert_1 = __importDefault(require("node:assert"));
+const ordinal_1 = require("../../formatting/ordinal");
+(0, node_test_1.describe)('formatOrdinal', () => {
+    (0, node_test_1.it)('formats basic ordinals correctly', () => {
+        node_assert_1.default.strictEqual((0, ordinal_1.formatOrdinal)(1), '1st');
+        node_assert_1.default.strictEqual((0, ordinal_1.formatOrdinal)(2), '2nd');
+        node_assert_1.default.strictEqual((0, ordinal_1.formatOrdinal)(3), '3rd');
+        node_assert_1.default.strictEqual((0, ordinal_1.formatOrdinal)(4), '4th');
+        node_assert_1.default.strictEqual((0, ordinal_1.formatOrdinal)(10), '10th');
+    });
+    (0, node_test_1.it)('handles special teen cases (11, 12, 13)', () => {
+        node_assert_1.default.strictEqual((0, ordinal_1.formatOrdinal)(11), '11th');
+        node_assert_1.default.strictEqual((0, ordinal_1.formatOrdinal)(12), '12th');
+        node_assert_1.default.strictEqual((0, ordinal_1.formatOrdinal)(13), '13th');
+    });
+    (0, node_test_1.it)('handles large numbers correctly', () => {
+        node_assert_1.default.strictEqual((0, ordinal_1.formatOrdinal)(21), '21st');
+        node_assert_1.default.strictEqual((0, ordinal_1.formatOrdinal)(22), '22nd');
+        node_assert_1.default.strictEqual((0, ordinal_1.formatOrdinal)(23), '23rd');
+        node_assert_1.default.strictEqual((0, ordinal_1.formatOrdinal)(24), '24th');
+        node_assert_1.default.strictEqual((0, ordinal_1.formatOrdinal)(101), '101st');
+        node_assert_1.default.strictEqual((0, ordinal_1.formatOrdinal)(111), '111th');
+        node_assert_1.default.strictEqual((0, ordinal_1.formatOrdinal)(112), '112th');
+        node_assert_1.default.strictEqual((0, ordinal_1.formatOrdinal)(113), '113th');
+    });
+    (0, node_test_1.it)('throws TypeError for invalid inputs', () => {
+        node_assert_1.default.throws(() => (0, ordinal_1.formatOrdinal)('21'), /Input must be a number/);
+        node_assert_1.default.throws(() => (0, ordinal_1.formatOrdinal)(null), /Input must be a number/);
+        node_assert_1.default.throws(() => (0, ordinal_1.formatOrdinal)(undefined), /Input must be a number/);
+    });
+});

package/dist/tests/formatting/percentage.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/formatting/percentage.test.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const node_assert_1 = __importDefault(require("node:assert"));
+const percentage_1 = require("../../formatting/percentage");
+(0, node_test_1.describe)('formatPercentage', () => {
+    (0, node_test_1.it)('formats numbers correctly with default precision', () => {
+        node_assert_1.default.strictEqual((0, percentage_1.formatPercentage)(0.567), '56.70%');
+        node_assert_1.default.strictEqual((0, percentage_1.formatPercentage)(0.5), '50.00%');
+        node_assert_1.default.strictEqual((0, percentage_1.formatPercentage)(1), '100.00%');
+    });
+    (0, node_test_1.it)('formats numbers correctly with custom precision', () => {
+        node_assert_1.default.strictEqual((0, percentage_1.formatPercentage)(0.567, 1), '56.7%');
+        node_assert_1.default.strictEqual((0, percentage_1.formatPercentage)(0.5, 0), '50%');
+    });
+    (0, node_test_1.it)('supports negative numbers', () => {
+        node_assert_1.default.strictEqual((0, percentage_1.formatPercentage)(-0.25, 0), '-25%');
+        node_assert_1.default.strictEqual((0, percentage_1.formatPercentage)(-0.1234, 2), '-12.34%');
+    });
+    (0, node_test_1.it)('works with whole numbers (scales by 100)', () => {
+        node_assert_1.default.strictEqual((0, percentage_1.formatPercentage)(50, 0), '5000%');
+    });
+    (0, node_test_1.it)('handles zero correctly', () => {
+        node_assert_1.default.strictEqual((0, percentage_1.formatPercentage)(0), '0.00%');
+    });
+    (0, node_test_1.it)('throws TypeError for invalid inputs', () => {
+        node_assert_1.default.throws(() => (0, percentage_1.formatPercentage)('0.5'), /Input must be a number/);
+        node_assert_1.default.throws(() => (0, percentage_1.formatPercentage)(null), /Input must be a number/);
+        node_assert_1.default.throws(() => (0, percentage_1.formatPercentage)(undefined), /Input must be a number/);
+    });
+    (0, node_test_1.it)('throws TypeError for invalid precision', () => {
+        node_assert_1.default.throws(() => (0, percentage_1.formatPercentage)(0.5, -1), /Precision must be a non-negative number/);
+        node_assert_1.default.throws(() => (0, percentage_1.formatPercentage)(0.5, '2'), /Precision must be a non-negative number/);
+    });
+});

package/dist/tests/formatting/romanNumerals.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/formatting/romanNumerals.test.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const node_assert_1 = __importDefault(require("node:assert"));
+const romanNumerals_1 = require("../../formatting/romanNumerals");
+(0, node_test_1.describe)('formatRomanNumeral', () => {
+    (0, node_test_1.it)('correctly converts basic numerals', () => {
+        node_assert_1.default.strictEqual((0, romanNumerals_1.formatRomanNumeral)(1), 'I');
+        node_assert_1.default.strictEqual((0, romanNumerals_1.formatRomanNumeral)(4), 'IV');
+        node_assert_1.default.strictEqual((0, romanNumerals_1.formatRomanNumeral)(9), 'IX');
+    });
+    (0, node_test_1.it)('correctly converts mid-range numbers', () => {
+        node_assert_1.default.strictEqual((0, romanNumerals_1.formatRomanNumeral)(58), 'LVIII'); // 50 + 5 + 3
+        node_assert_1.default.strictEqual((0, romanNumerals_1.formatRomanNumeral)(1994), 'MCMXCIV'); // 1000 + 900 + 90 + 4
+        node_assert_1.default.strictEqual((0, romanNumerals_1.formatRomanNumeral)(2025), 'MMXXV');
+    });
+    (0, node_test_1.it)('correctly converts upper limit', () => {
+        node_assert_1.default.strictEqual((0, romanNumerals_1.formatRomanNumeral)(3999), 'MMMCMXCIX');
+    });
+    (0, node_test_1.it)('throws error for 0 and negative numbers', () => {
+        node_assert_1.default.throws(() => (0, romanNumerals_1.formatRomanNumeral)(0), /Roman numerals are only defined for positive integers/);
+        node_assert_1.default.throws(() => (0, romanNumerals_1.formatRomanNumeral)(-5), /Roman numerals are only defined for positive integers/);
+    });
+    (0, node_test_1.it)('throws error for numbers above 3999', () => {
+        node_assert_1.default.throws(() => (0, romanNumerals_1.formatRomanNumeral)(4000), /Roman numerals are supported only up to 3999/);
+    });
+    (0, node_test_1.it)('throws TypeError for non-number inputs', () => {
+        node_assert_1.default.throws(() => (0, romanNumerals_1.formatRomanNumeral)('123'), /Input must be a number/);
+        node_assert_1.default.throws(() => (0, romanNumerals_1.formatRomanNumeral)(null), /Input must be a number/);
+        node_assert_1.default.throws(() => (0, romanNumerals_1.formatRomanNumeral)(undefined), /Input must be a number/);
+    });
+});

package/dist/tests/formatting/scientific.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/formatting/scientific.test.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const node_assert_1 = __importDefault(require("node:assert"));
+const scientific_1 = require("../../formatting/scientific");
+(0, node_test_1.describe)('formatScientific', () => {
+    (0, node_test_1.it)('converts numbers to scientific notation with default precision (2)', () => {
+        node_assert_1.default.strictEqual((0, scientific_1.formatScientific)(12345), '1.23e+4');
+        node_assert_1.default.strictEqual((0, scientific_1.formatScientific)(0.000123), '1.23e-4');
+    });
+    (0, node_test_1.it)('handles negative numbers correctly', () => {
+        node_assert_1.default.strictEqual((0, scientific_1.formatScientific)(-12345), '-1.23e+4');
+        node_assert_1.default.strictEqual((0, scientific_1.formatScientific)(-0.000987), '-9.87e-4');
+    });
+    (0, node_test_1.it)('applies custom precision', () => {
+        node_assert_1.default.strictEqual((0, scientific_1.formatScientific)(1000000, { precision: 4 }), '1.0000e+6');
+        node_assert_1.default.strictEqual((0, scientific_1.formatScientific)(98765, { precision: 3 }), '9.877e+4');
+    });
+    (0, node_test_1.it)('uses uppercase E when specified', () => {
+        node_assert_1.default.strictEqual((0, scientific_1.formatScientific)(98765, { uppercase: true }), '9.88E+4');
+        node_assert_1.default.strictEqual((0, scientific_1.formatScientific)(0.000123, { uppercase: true }), '1.23E-4');
+    });
+    (0, node_test_1.it)('combines precision and uppercase options', () => {
+        node_assert_1.default.strictEqual((0, scientific_1.formatScientific)(12345, { precision: 5, uppercase: true }), '1.23450E+4');
+    });
+    (0, node_test_1.it)('throws an error for invalid inputs', () => {
+        node_assert_1.default.throws(() => (0, scientific_1.formatScientific)('12345'), /Input must be a valid number/);
+        node_assert_1.default.throws(() => (0, scientific_1.formatScientific)(null), /Input must be a valid number/);
+        node_assert_1.default.throws(() => (0, scientific_1.formatScientific)(undefined), /Input must be a valid number/);
+        node_assert_1.default.throws(() => (0, scientific_1.formatScientific)(NaN), /Input must be a valid number/);
+    });
+});

package/dist/tests/formatting/temperature.test.d.ts

@@ -0,0 +1 @@
+export {};