stringzy 4.0.0 → 4.2.0

package/dist/formatting/percentage.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Converts a number into a percentage string with configurable decimal precision.
+ *
+ * Supports positive, negative, and whole numbers.
+ *
+ * Examples:
+ * 0.567 → "56.70%"
+ * 0.567 → "56.7%" (precision = 1)
+ * 0.5   → "50%"
+ * 1     → "100%"
+ * -0.25 → "-25%"
+ * 50    → "5000%"
+ *
+ * @param {number} num - The number to convert into a percentage.
+ * @param {number} [precision=2] - The number of decimal places to include.
+ * @returns {string} The formatted percentage string.
+ * @throws {TypeError} If the input is not a number or precision is not a number.
+ */
+export declare function formatPercentage(num: number, precision?: number): string;

package/dist/formatting/percentage.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatPercentage = formatPercentage;
+/**
+ * Converts a number into a percentage string with configurable decimal precision.
+ *
+ * Supports positive, negative, and whole numbers.
+ *
+ * Examples:
+ * 0.567 → "56.70%"
+ * 0.567 → "56.7%" (precision = 1)
+ * 0.5   → "50%"
+ * 1     → "100%"
+ * -0.25 → "-25%"
+ * 50    → "5000%"
+ *
+ * @param {number} num - The number to convert into a percentage.
+ * @param {number} [precision=2] - The number of decimal places to include.
+ * @returns {string} The formatted percentage string.
+ * @throws {TypeError} If the input is not a number or precision is not a number.
+ */
+function formatPercentage(num, precision = 2) {
+    if (typeof num !== 'number' || Number.isNaN(num)) {
+        throw new TypeError('Input must be a number');
+    }
+    if (typeof precision !== 'number' || Number.isNaN(precision) || precision < 0) {
+        throw new TypeError('Precision must be a non-negative number');
+    }
+    const percentage = num * 100;
+    return `${percentage.toFixed(precision)}%`;
+}

package/dist/formatting/romanNumerals.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Converts a positive integer into its Roman numeral representation.
+ *
+ * Supports numbers from 1 to 3999 using standard Roman numeral notation.
+ *
+ * Examples:
+ * 1     → "I"
+ * 4     → "IV"
+ * 9     → "IX"
+ * 58    → "LVIII"
+ * 1994  → "MCMXCIV"
+ * 2025  → "MMXXV"
+ * 3999  → "MMMCMXCIX"
+ *
+ * @param {number} num - The positive integer to convert (1–3999).
+ * @returns {string} The Roman numeral representation of the given number.
+ * @throws {RangeError} If the number is less than or equal to 0, or greater than 3999.
+ * @throws {TypeError} If the input is not a number.
+ */
+export declare function formatRomanNumeral(num: number): string;

package/dist/formatting/romanNumerals.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatRomanNumeral = formatRomanNumeral;
+/**
+ * Converts a positive integer into its Roman numeral representation.
+ *
+ * Supports numbers from 1 to 3999 using standard Roman numeral notation.
+ *
+ * Examples:
+ * 1     → "I"
+ * 4     → "IV"
+ * 9     → "IX"
+ * 58    → "LVIII"
+ * 1994  → "MCMXCIV"
+ * 2025  → "MMXXV"
+ * 3999  → "MMMCMXCIX"
+ *
+ * @param {number} num - The positive integer to convert (1–3999).
+ * @returns {string} The Roman numeral representation of the given number.
+ * @throws {RangeError} If the number is less than or equal to 0, or greater than 3999.
+ * @throws {TypeError} If the input is not a number.
+ */
+function formatRomanNumeral(num) {
+    if (typeof num !== 'number' || Number.isNaN(num)) {
+        throw new TypeError('Input must be a number');
+    }
+    if (num <= 0) {
+        throw new RangeError('Roman numerals are only defined for positive integers');
+    }
+    if (num > 3999) {
+        throw new RangeError('Roman numerals are supported only up to 3999');
+    }
+    const values = [
+        1000, 900, 500, 400,
+        100, 90, 50, 40,
+        10, 9, 5, 4, 1
+    ];
+    const symbols = [
+        'M', 'CM', 'D', 'CD',
+        'C', 'XC', 'L', 'XL',
+        'X', 'IX', 'V', 'IV', 'I'
+    ];
+    let result = '';
+    let i = 0;
+    while (num > 0) {
+        while (num >= values[i]) {
+            result += symbols[i];
+            num -= values[i];
+        }
+        i++;
+    }
+    return result;
+}

package/dist/formatting/scientific.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Converts a number to scientific (exponential) notation.
+ *
+ * @param {number} num - The number to convert.
+ * @param {object} [options] - Optional formatting settings.
+ * @param {number} [options.precision=2] - Number of digits after the decimal point.
+ * @param {boolean} [options.uppercase=false] - Whether to use uppercase "E" in the notation.
+ * @returns {string} Scientific notation of the number.
+ * @throws {TypeError} If input is not a valid number.
+ */
+export declare function formatScientific(num: number, options?: {
+    precision?: number;
+    uppercase?: boolean;
+}): string;

package/dist/formatting/scientific.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatScientific = formatScientific;
+/**
+ * Converts a number to scientific (exponential) notation.
+ *
+ * @param {number} num - The number to convert.
+ * @param {object} [options] - Optional formatting settings.
+ * @param {number} [options.precision=2] - Number of digits after the decimal point.
+ * @param {boolean} [options.uppercase=false] - Whether to use uppercase "E" in the notation.
+ * @returns {string} Scientific notation of the number.
+ * @throws {TypeError} If input is not a valid number.
+ */
+function formatScientific(num, options) {
+    if (typeof num !== 'number' || isNaN(num)) {
+        throw new TypeError('Input must be a valid number');
+    }
+    const { precision = 2, uppercase = false } = options || {};
+    let scientific = num.toExponential(precision);
+    if (uppercase) {
+        scientific = scientific.replace('e', 'E');
+    }
+    return scientific;
+}

package/dist/formatting/temperature.d.ts

@@ -0,0 +1,6 @@
+declare function formatTemperature(value: number, options: {
+    from: string;
+    to: string;
+    precision?: number;
+}): string;
+export { formatTemperature };

package/dist/formatting/temperature.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatTemperature = formatTemperature;
+function formatTemperature(value, options) {
+    const { from, to, precision = 2 } = options;
+    const conversions = {
+        'C_F': (v) => (v * 9) / 5 + 32,
+        'C_K': (v) => v + 273.15,
+        'F_C': (v) => ((v - 32) * 5) / 9,
+        'F_K': (v) => ((v - 32) * 5) / 9 + 273.15,
+        'K_C': (v) => v - 273.15,
+        'K_F': (v) => ((v - 273.15) * 9) / 5 + 32
+    };
+    const conversionKey = `${from}_${to}`;
+    const convert = conversions[conversionKey];
+    if (!convert) {
+        throw new Error(`Invalid conversion from ${from} to ${to}.`);
+    }
+    if (typeof value !== 'number' || isNaN(value)) {
+        throw new Error('Invalid temperature value.');
+    }
+    const convertedValue = convert(value);
+    if (to === 'K') {
+        return `${convertedValue.toFixed(precision)}K`;
+    }
+    return `${convertedValue.toFixed(precision)}°${to}`;
+}

package/dist/formatting/trim.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Removes unnecessary whitespace from a string.
+ * This includes leading/trailing spaces, multiple consecutive spaces, tabs, and line breaks.
+ * The result is a clean, single-spaced string.
+ *
+ * @param {string} str - The input string to format.
+ * @returns {string} The trimmed and normalized string.
+ * @throws {TypeError} If the input is not a string.
+ */
+export declare function trim(str: string): string;

package/dist/formatting/trim.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trim = trim;
+/**
+ * Removes unnecessary whitespace from a string.
+ * This includes leading/trailing spaces, multiple consecutive spaces, tabs, and line breaks.
+ * The result is a clean, single-spaced string.
+ *
+ * @param {string} str - The input string to format.
+ * @returns {string} The trimmed and normalized string.
+ * @throws {TypeError} If the input is not a string.
+ */
+function trim(str) {
+    if (typeof str !== 'string') {
+        throw new TypeError('Input must be a string');
+    }
+    // 1. Trim leading/trailing whitespace (including newlines/tabs)
+    // 2. Replace multiple internal whitespace chars (including \n, \t) with a single space
+    return str.trim().replace(/\s+/g, ' ');
+}

package/dist/index.d.ts

@@ -12,11 +12,29 @@ declare const _default: {
         stringSimilarity: typeof import("./analyzing").stringSimilarity;
         patternCount: typeof import("./analyzing").patternCount;
         vowelConsonantCount: typeof import("./analyzing").vowelConsonantCount;
+        checkMultiplePatterns: typeof import("./analyzing").checkMultiplePatterns;
+        checkSubsequence: typeof import("./analyzing").checkSubsequence;
+        checkStringRotations: typeof import("./analyzing").checkStringRotations;
+        lexicographicalRank: typeof import("./analyzing").lexicographicalRank;
     };
     formatting: {
         capitalize: typeof import("./formatting").capitalize;
         formatNumber: typeof import("./formatting").formatNumber;
         formatPhone: typeof import("./formatting").formatPhone;
+        formatDuration: typeof import("./formatting").formatDuration;
+        trim: typeof import("./formatting").trim;
+        formatRomanNumeral: typeof import("./formatting").formatRomanNumeral;
+        formatPercentage: typeof import("./formatting").formatPercentage;
+        formatFileSize: typeof import("./formatting").formatFileSize;
+        formatOrdinal: typeof import("./formatting").formatOrdinal;
+        formatList: typeof import("./formatting").formatList;
+        formatTemperature: typeof import("./formatting").formatTemperature;
+        formatScientific: typeof import("./formatting").formatScientific;
+        formatCreditCard: typeof import("./formatting").formatCreditCard;
+        formatToBinary: typeof import("./formatting").formatToBinary;
+        formatToHexadecimal: typeof import("./formatting").formatToHexadecimal;
+        formatToOctal: typeof import("./formatting").formatToOctal;
+        formatToDecimal: typeof import("./formatting").formatToDecimal;
     };
     transformations: {
         camelCase: typeof import("./transformations").camelCase;
@@ -36,6 +54,10 @@ declare const _default: {
         maskSegment: typeof import("./transformations").maskSegment;
         deburr: typeof import("./transformations/deburr").deburr;
         numberToText: typeof import("./transformations").numberToText;
+        reverseWordsInString: typeof import("./transformations").reverseWordsInString;
+        stringPermutations: typeof import("./transformations").stringPermutations;
+        stringPermutationsGenerator: typeof import("./transformations").stringPermutationsGenerator;
+        stringCombinations: typeof import("./transformations").stringCombinations;
     };
     validations: {
         isCoordinates: typeof import("./validations").isCoordinates;
@@ -45,8 +67,16 @@ declare const _default: {
         isSlug: typeof import("./validations").isSlug;
         isURL: typeof import("./validations").isURL;
         isIPv4: typeof import("./validations").isIPv4;
+        isIPv6: typeof import("./validations").isIPv6;
         isHexColor: typeof import("./validations").isHexColor;
         isPalindrome: typeof import("./validations").isPalindrome;
+        isLowerCase: typeof import("./validations").isLowerCase;
+        isUpperCase: typeof import("./validations").isUpperCase;
+        isAlphabetic: typeof import("./validations").isAlphabetic;
+        isAlphaNumeric: typeof import("./validations").isAlphaNumeric;
+        isAnagram: typeof import("./validations").isAnagram;
+        isPanagram: typeof import("./validations").isPanagram;
+        isMacAddress: typeof import("./validations").isMacAddress;
     };
 };
 export default _default;

package/dist/tests/analyzing/checkMultiplePatterns.test.d.ts

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

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

@@ -0,0 +1,81 @@
+"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 checkMultiplePatterns_1 = require("../../analyzing/checkMultiplePatterns");
+(0, node_test_1.describe)('checkMultiplePatterns', () => {
+    (0, node_test_1.it)('finds multiple valid matches', () => {
+        const text = 'abracadabra';
+        const patterns = ['abra', 'cad'];
+        const result = (0, checkMultiplePatterns_1.checkMultiplePatterns)(text, patterns);
+        // "abra" occurs at index 0: "abra...cadabra"
+        // and again at index 7: "abracad...abra"
+        node_assert_1.default.deepStrictEqual(result['abra'], [0, 7]);
+        // "cad" occurs once starting at index 4: "abraCADabra"
+        node_assert_1.default.deepStrictEqual(result['cad'], [4]);
+    });
+    (0, node_test_1.it)('handles overlapping patterns', () => {
+        const text = 'aaaa';
+        const patterns = ['aa', 'aaa'];
+        const result = (0, checkMultiplePatterns_1.checkMultiplePatterns)(text, patterns);
+        // "aa" occurs at indices 0 ("aa.."), 1 (".aa."), 2 ("..aa")
+        node_assert_1.default.deepStrictEqual(result['aa'], [0, 1, 2]);
+        // "aaa" occurs at indices 0 ("aaa.") and 1 (".aaa")
+        node_assert_1.default.deepStrictEqual(result['aaa'], [0, 1]);
+    });
+    (0, node_test_1.it)('returns empty arrays when no matches found', () => {
+        const text = 'hello world';
+        const patterns = ['xyz', '123'];
+        const result = (0, checkMultiplePatterns_1.checkMultiplePatterns)(text, patterns);
+        // Neither "xyz" nor "123" exist in "hello world"
+        node_assert_1.default.deepStrictEqual(result['xyz'], []);
+        node_assert_1.default.deepStrictEqual(result['123'], []);
+    });
+    (0, node_test_1.it)('returns empty object when text is empty', () => {
+        // No text to search → nothing to return
+        const result = (0, checkMultiplePatterns_1.checkMultiplePatterns)('', ['a', 'b']);
+        node_assert_1.default.deepStrictEqual(result, {});
+    });
+    (0, node_test_1.it)('returns empty object when patterns array is empty', () => {
+        // No patterns given → nothing to search for
+        const result = (0, checkMultiplePatterns_1.checkMultiplePatterns)('hello', []);
+        node_assert_1.default.deepStrictEqual(result, {});
+    });
+    (0, node_test_1.it)('skips patterns longer than the text', () => {
+        const result = (0, checkMultiplePatterns_1.checkMultiplePatterns)('hi', ['longpattern']);
+        // pattern is longer than text → no match possible
+        node_assert_1.default.deepStrictEqual(result['longpattern'], []);
+    });
+    (0, node_test_1.it)('is case-sensitive by default', () => {
+        const text = 'Hello hello';
+        const patterns = ['Hello', 'hello'];
+        const result = (0, checkMultiplePatterns_1.checkMultiplePatterns)(text, patterns);
+        node_assert_1.default.deepStrictEqual(result['Hello'], [0]);
+        node_assert_1.default.deepStrictEqual(result['hello'], [6]);
+    });
+    (0, node_test_1.it)('handles spaces and special characters as part of patterns', () => {
+        const text = 'hi there!';
+        const patterns = [' ', '!'];
+        const result = (0, checkMultiplePatterns_1.checkMultiplePatterns)(text, patterns);
+        // space occurs at index 2, "!" occurs at the end
+        node_assert_1.default.deepStrictEqual(result[' '], [2]);
+        node_assert_1.default.deepStrictEqual(result['!'], [8]);
+    });
+    (0, node_test_1.it)('does not match mixed case unless exact', () => {
+        const text = 'RabinKarp';
+        const patterns = ['rabinkarp'];
+        const result = (0, checkMultiplePatterns_1.checkMultiplePatterns)(text, patterns);
+        // "rabinkarp" does not match "RabinKarp" because of case
+        node_assert_1.default.deepStrictEqual(result['rabinkarp'], []);
+    });
+    (0, node_test_1.it)('throws if text is not a string', () => {
+        node_assert_1.default.throws(() => (0, checkMultiplePatterns_1.checkMultiplePatterns)(123, ['a']), /Text must be a string/);
+    });
+    (0, node_test_1.it)('throws if patterns is not an array of strings', () => {
+        node_assert_1.default.throws(() => (0, checkMultiplePatterns_1.checkMultiplePatterns)('abc', 'a'), /Patterns must be an array of strings/);
+        node_assert_1.default.throws(() => (0, checkMultiplePatterns_1.checkMultiplePatterns)('abc', [123]), /Patterns must be an array of strings/);
+    });
+});

package/dist/tests/analyzing/checkSubsequence.test.d.ts

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

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

@@ -0,0 +1,34 @@
+"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 checkSubsequence_1 = require("../../analyzing/checkSubsequence");
+(0, node_test_1.describe)('checkSubsequence', () => {
+    (0, node_test_1.it)('returns true for valid subsequences', () => {
+        node_assert_1.default.strictEqual((0, checkSubsequence_1.checkSubsequence)('abcde', 'ace'), true);
+        node_assert_1.default.strictEqual((0, checkSubsequence_1.checkSubsequence)('abracadabra', 'aaa'), true);
+        node_assert_1.default.strictEqual((0, checkSubsequence_1.checkSubsequence)('hello world', 'hlo'), true);
+    });
+    (0, node_test_1.it)('returns false when order is broken', () => {
+        node_assert_1.default.strictEqual((0, checkSubsequence_1.checkSubsequence)('abcde', 'aec'), false);
+        node_assert_1.default.strictEqual((0, checkSubsequence_1.checkSubsequence)('abcdef', 'z'), false);
+    });
+    (0, node_test_1.it)('handles empty subsequence', () => {
+        node_assert_1.default.strictEqual((0, checkSubsequence_1.checkSubsequence)('anything', ''), true);
+    });
+    (0, node_test_1.it)('is case-sensitive', () => {
+        node_assert_1.default.strictEqual((0, checkSubsequence_1.checkSubsequence)('abc', 'A'), false);
+        node_assert_1.default.strictEqual((0, checkSubsequence_1.checkSubsequence)('AbC', 'AC'), true);
+    });
+    (0, node_test_1.it)('handles spaces as normal characters', () => {
+        node_assert_1.default.strictEqual((0, checkSubsequence_1.checkSubsequence)('a b c', 'abc'), true);
+        node_assert_1.default.strictEqual((0, checkSubsequence_1.checkSubsequence)('a b c', 'a c'), true);
+    });
+    (0, node_test_1.it)('throws if inputs are not strings', () => {
+        node_assert_1.default.throws(() => (0, checkSubsequence_1.checkSubsequence)(123, 'abc'), /Both inputs must be strings/);
+        node_assert_1.default.throws(() => (0, checkSubsequence_1.checkSubsequence)('abc', null), /Both inputs must be strings/);
+    });
+});

package/dist/tests/analyzing/contentWordCount.test.d.ts

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

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

@@ -0,0 +1,20 @@
+"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 = __importDefault(require("node:test"));
+const strict_1 = __importDefault(require("node:assert/strict"));
+const contentWordCount_js_1 = require("../../analyzing/contentWordCount.js");
+(0, node_test_1.default)("counts content words in a normal sentence", () => {
+    strict_1.default.equal((0, contentWordCount_js_1.contentWordCount)("This is a test of the system"), 2);
+});
+(0, node_test_1.default)("returns 0 when there are no content words", () => {
+    strict_1.default.equal((0, contentWordCount_js_1.contentWordCount)("is the at of"), 0);
+});
+(0, node_test_1.default)("ignores case and punctuation", () => {
+    strict_1.default.equal((0, contentWordCount_js_1.contentWordCount)("Elephants, ELEPHANTS, elephants!"), 3);
+});
+(0, node_test_1.default)("returns 0 for empty string", () => {
+    strict_1.default.equal((0, contentWordCount_js_1.contentWordCount)(""), 0);
+});

package/dist/tests/analyzing/functionWordCount.test.d.ts

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

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

@@ -0,0 +1,20 @@
+"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 = __importDefault(require("node:test"));
+const strict_1 = __importDefault(require("node:assert/strict"));
+const functionWordCount_js_1 = require("../../analyzing/functionWordCount.js");
+(0, node_test_1.default)("counts function words in a normal sentence", () => {
+    strict_1.default.equal((0, functionWordCount_js_1.functionWordCount)("This is a test of the system"), 5);
+});
+(0, node_test_1.default)("returns 0 when there are no function words", () => {
+    strict_1.default.equal((0, functionWordCount_js_1.functionWordCount)("Elephants run fast"), 0);
+});
+(0, node_test_1.default)("ignores case and punctuation", () => {
+    strict_1.default.equal((0, functionWordCount_js_1.functionWordCount)("The, THE, the!"), 3);
+});
+(0, node_test_1.default)("returns 0 for empty string", () => {
+    strict_1.default.equal((0, functionWordCount_js_1.functionWordCount)(""), 0);
+});

package/dist/tests/analyzing/lexicographicalRank.test.d.ts

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

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/analyzing/stringRotation.test.d.ts

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

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

@@ -0,0 +1,42 @@
+"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 stringRotation_1 = require("../../analyzing/stringRotation");
+(0, node_test_1.describe)('checkStringRotations', () => {
+    (0, node_test_1.it)('returns true for valid rotations', () => {
+        node_assert_1.default.strictEqual((0, stringRotation_1.checkStringRotations)('abcd', 'cdab'), true);
+        node_assert_1.default.strictEqual((0, stringRotation_1.checkStringRotations)('hello', 'ohell'), true);
+        node_assert_1.default.strictEqual((0, stringRotation_1.checkStringRotations)('12345', '45123'), true);
+        node_assert_1.default.strictEqual((0, stringRotation_1.checkStringRotations)('!@#$', '#$!@'), true);
+    });
+    (0, node_test_1.it)('returns false for invalid rotations', () => {
+        node_assert_1.default.strictEqual((0, stringRotation_1.checkStringRotations)('abc', 'acb'), false);
+        node_assert_1.default.strictEqual((0, stringRotation_1.checkStringRotations)('hello', 'helol'), false);
+        node_assert_1.default.strictEqual((0, stringRotation_1.checkStringRotations)('12345', '54321'), false);
+    });
+    (0, node_test_1.it)('is case-sensitive', () => {
+        node_assert_1.default.strictEqual((0, stringRotation_1.checkStringRotations)('ArB', 'Bar'), false);
+        node_assert_1.default.strictEqual((0, stringRotation_1.checkStringRotations)('Case', 'case'), false);
+        node_assert_1.default.strictEqual((0, stringRotation_1.checkStringRotations)('XYZ', 'yzx'), false);
+    });
+    (0, node_test_1.it)('returns true for empty strings', () => {
+        node_assert_1.default.strictEqual((0, stringRotation_1.checkStringRotations)('', ''), true);
+    });
+    (0, node_test_1.it)('returns false for strings of different lengths', () => {
+        node_assert_1.default.strictEqual((0, stringRotation_1.checkStringRotations)('abc', 'ab'), false);
+        node_assert_1.default.strictEqual((0, stringRotation_1.checkStringRotations)('abcd', ''), false);
+    });
+    (0, node_test_1.it)('handles special characters correctly', () => {
+        node_assert_1.default.strictEqual((0, stringRotation_1.checkStringRotations)('a@b$c', 'b$ca@'), true);
+        node_assert_1.default.strictEqual((0, stringRotation_1.checkStringRotations)('a@b$c', 'c$a@b'), false);
+    });
+    (0, node_test_1.it)('throws an error if inputs are not strings', () => {
+        node_assert_1.default.throws(() => (0, stringRotation_1.checkStringRotations)(123, '123'), /Both inputs must be strings/);
+        node_assert_1.default.throws(() => (0, stringRotation_1.checkStringRotations)('abc', null), /Both inputs must be strings/);
+        node_assert_1.default.throws(() => (0, stringRotation_1.checkStringRotations)(undefined, 'abc'), /Both inputs must be strings/);
+    });
+});

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 {};