stringzy 3.0.0 → 4.1.0

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

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

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

@@ -0,0 +1,25 @@
+"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 vowelConsonantCount_1 = require("../../analyzing/vowelConsonantCount");
+(0, node_test_1.describe)('vowelConsonantCount', () => {
+    (0, node_test_1.it)('returns 0s for empty string', () => {
+        node_assert_1.default.deepStrictEqual((0, vowelConsonantCount_1.vowelConsonantCount)(''), { vowels: 0, consonants: 0 });
+    });
+    (0, node_test_1.it)('counts lowercase vowels and consonants', () => {
+        node_assert_1.default.deepStrictEqual((0, vowelConsonantCount_1.vowelConsonantCount)('hello'), { vowels: 2, consonants: 3 });
+    });
+    (0, node_test_1.it)('counts uppercase vowels and consonants', () => {
+        node_assert_1.default.deepStrictEqual((0, vowelConsonantCount_1.vowelConsonantCount)('HELLO'), { vowels: 2, consonants: 3 });
+    });
+    (0, node_test_1.it)('counts vowels and consonants ignoring special characters and whitespaces', () => {
+        node_assert_1.default.deepStrictEqual((0, vowelConsonantCount_1.vowelConsonantCount)('Hello, World!'), { vowels: 3, consonants: 7 });
+    });
+    (0, node_test_1.it)('throws if input is not a string', () => {
+        node_assert_1.default.throws(() => (0, vowelConsonantCount_1.vowelConsonantCount)(123), /Input must be a string/);
+    });
+});

package/dist/tests/transformations/numberToText.test.d.ts

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

package/dist/tests/transformations/numberToText.test.js

@@ -0,0 +1,60 @@
+"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 transformations_1 = require("../../transformations");
+(0, node_test_1.describe)("numberToText", () => {
+    (0, node_test_1.describe)("Param error handling", () => {
+        node_assert_1.default.throws(() => (0, transformations_1.numberToText)("aaaa"), /Num param should be number/i);
+        node_assert_1.default.throws(() => (0, transformations_1.numberToText)(1000000000001), RangeError);
+        node_assert_1.default.throws(() => (0, transformations_1.numberToText)(-1000000000001), RangeError);
+        const validLanguages = ['en', 'pl'];
+        const errorMessage = `Language must be one of: ${validLanguages.join(', ')}`;
+        node_assert_1.default.throws(() => (0, transformations_1.numberToText)(123, "invalid"), new RegExp(errorMessage, "i"));
+    });
+    (0, node_test_1.describe)("Conversion cases - en", () => {
+        node_assert_1.default.strictEqual((0, transformations_1.numberToText)(0), "zero");
+        node_assert_1.default.strictEqual((0, transformations_1.numberToText)(1), "one");
+        node_assert_1.default.strictEqual((0, transformations_1.numberToText)(5), "five");
+        node_assert_1.default.strictEqual((0, transformations_1.numberToText)(10), "ten");
+        node_assert_1.default.strictEqual((0, transformations_1.numberToText)(15), "fifteen");
+        node_assert_1.default.strictEqual((0, transformations_1.numberToText)(21), "twenty-one");
+        node_assert_1.default.strictEqual((0, transformations_1.numberToText)(99), "ninety-nine");
+        node_assert_1.default.strictEqual((0, transformations_1.numberToText)(100), "one hundred");
+        node_assert_1.default.strictEqual((0, transformations_1.numberToText)(101), "one hundred one");
+        node_assert_1.default.strictEqual((0, transformations_1.numberToText)(215), "two hundred fifteen");
+        node_assert_1.default.strictEqual((0, transformations_1.numberToText)(1000), "one thousand");
+        node_assert_1.default.strictEqual((0, transformations_1.numberToText)(2023), "two thousand twenty-three");
+        node_assert_1.default.strictEqual((0, transformations_1.numberToText)(1000000), "one million");
+        node_assert_1.default.strictEqual((0, transformations_1.numberToText)(1200000), "one million two hundred thousand");
+        node_assert_1.default.strictEqual((0, transformations_1.numberToText)(1000000000), "one billion");
+        node_assert_1.default.strictEqual((0, transformations_1.numberToText)(1000000000000), "one trillion");
+        node_assert_1.default.strictEqual((0, transformations_1.numberToText)(-1), "minus one");
+        node_assert_1.default.strictEqual((0, transformations_1.numberToText)(-215), "minus two hundred fifteen");
+        node_assert_1.default.strictEqual((0, transformations_1.numberToText)(-1000000), "minus one million");
+    });
+    (0, node_test_1.describe)("Conversion cases - pl", () => {
+        node_assert_1.default.strictEqual((0, transformations_1.numberToText)(0, 'pl'), "zero");
+        node_assert_1.default.strictEqual((0, transformations_1.numberToText)(1, 'pl'), "jeden");
+        node_assert_1.default.strictEqual((0, transformations_1.numberToText)(5, 'pl'), "pięć");
+        node_assert_1.default.strictEqual((0, transformations_1.numberToText)(10, 'pl'), "dziesięć");
+        node_assert_1.default.strictEqual((0, transformations_1.numberToText)(15, 'pl'), "piętnaście");
+        node_assert_1.default.strictEqual((0, transformations_1.numberToText)(21, 'pl'), "dwadzieścia jeden");
+        node_assert_1.default.strictEqual((0, transformations_1.numberToText)(99, 'pl'), "dziewięćdziesiąt dziewięć");
+        node_assert_1.default.strictEqual((0, transformations_1.numberToText)(100, 'pl'), "sto");
+        node_assert_1.default.strictEqual((0, transformations_1.numberToText)(101, 'pl'), "sto jeden");
+        node_assert_1.default.strictEqual((0, transformations_1.numberToText)(215, 'pl'), "dwieście piętnaście");
+        node_assert_1.default.strictEqual((0, transformations_1.numberToText)(1000, 'pl'), "tysiąc");
+        node_assert_1.default.strictEqual((0, transformations_1.numberToText)(2023, 'pl'), "dwa tysiące dwadzieścia trzy");
+        node_assert_1.default.strictEqual((0, transformations_1.numberToText)(1000000, 'pl'), "milion");
+        node_assert_1.default.strictEqual((0, transformations_1.numberToText)(1200000, 'pl'), "milion dwieście tysięcy");
+        node_assert_1.default.strictEqual((0, transformations_1.numberToText)(1000000000, 'pl'), "miliard");
+        node_assert_1.default.strictEqual((0, transformations_1.numberToText)(1000000000000, 'pl'), "bilion");
+        node_assert_1.default.strictEqual((0, transformations_1.numberToText)(-1, 'pl'), "minus jeden");
+        node_assert_1.default.strictEqual((0, transformations_1.numberToText)(-215, 'pl'), "minus dwieście piętnaście");
+        node_assert_1.default.strictEqual((0, transformations_1.numberToText)(-1000000, 'pl'), "minus milion");
+    });
+});

package/dist/tests/transformations/reverseString.test.d.ts

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

package/dist/tests/transformations/reverseString.test.js

@@ -0,0 +1,41 @@
+"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 reverseWordsInString_1 = require("../../transformations/reverseWordsInString ");
+(0, node_test_1.describe)('reverseWordsInString', () => {
+    (0, node_test_1.it)('reverses words while preserving multiple spaces between them', () => {
+        node_assert_1.default.strictEqual((0, reverseWordsInString_1.reverseWordsInString)('Hello   world  from   stringzy'), 'stringzy   from  world   Hello');
+    });
+    (0, node_test_1.it)('preserves the exact leading and trailing spaces', () => {
+        node_assert_1.default.strictEqual((0, reverseWordsInString_1.reverseWordsInString)('  leading and trailing  '), '  trailing and leading  ');
+        node_assert_1.default.strictEqual((0, reverseWordsInString_1.reverseWordsInString)('leading and trailing  '), 'trailing and leading  ');
+        node_assert_1.default.strictEqual((0, reverseWordsInString_1.reverseWordsInString)('  leading and trailing'), '  trailing and leading');
+    });
+    (0, node_test_1.it)('handles a complex mix of spacing correctly', () => {
+        node_assert_1.default.strictEqual((0, reverseWordsInString_1.reverseWordsInString)('  first   second  third '), '  third   second  first ');
+    });
+    (0, node_test_1.it)('handles a single word with or without spaces', () => {
+        node_assert_1.default.strictEqual((0, reverseWordsInString_1.reverseWordsInString)('singleword'), 'singleword');
+        node_assert_1.default.strictEqual((0, reverseWordsInString_1.reverseWordsInString)('  singleword  '), '  singleword  ');
+    });
+    (0, node_test_1.it)('returns the original string if it contains only whitespace', () => {
+        node_assert_1.default.strictEqual((0, reverseWordsInString_1.reverseWordsInString)('   '), '   ');
+        node_assert_1.default.strictEqual((0, reverseWordsInString_1.reverseWordsInString)('\t \n'), '\t \n');
+    });
+    (0, node_test_1.it)('returns an empty string for an empty input', () => {
+        node_assert_1.default.strictEqual((0, reverseWordsInString_1.reverseWordsInString)(''), '');
+    });
+    (0, node_test_1.it)('handles words with numbers and special characters correctly', () => {
+        node_assert_1.default.strictEqual((0, reverseWordsInString_1.reverseWordsInString)('word1!   word2@#$'), 'word2@#$   word1!');
+    });
+    (0, node_test_1.it)('throws a TypeError if the input is not a string', () => {
+        node_assert_1.default.throws(() => (0, reverseWordsInString_1.reverseWordsInString)(12345), /Input must be a string/);
+        node_assert_1.default.throws(() => (0, reverseWordsInString_1.reverseWordsInString)(null), /Input must be a string/);
+        node_assert_1.default.throws(() => (0, reverseWordsInString_1.reverseWordsInString)(undefined), /Input must be a string/);
+        node_assert_1.default.throws(() => (0, reverseWordsInString_1.reverseWordsInString)({}), /Input must be a string/);
+    });
+});

package/dist/tests/transformations/splitChunks.test.d.ts

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

package/dist/tests/transformations/splitChunks.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 splitChunks_1 = require("../../transformations/splitChunks");
+(0, node_test_1.describe)('splitChunks', () => {
+    (0, node_test_1.it)('creates chunks of size 3', () => {
+        node_assert_1.default.deepStrictEqual((0, splitChunks_1.splitChunks)('hello world', 3), ['hel', 'lo ', 'wor', 'ld']);
+    });
+    (0, node_test_1.it)('creates chunks of size 2', () => {
+        node_assert_1.default.deepStrictEqual((0, splitChunks_1.splitChunks)('hello world', 2), ['he', 'll', 'o ', 'wo', 'rl', 'd']);
+    });
+    (0, node_test_1.it)('creates chunks of size 1', () => {
+        node_assert_1.default.deepStrictEqual((0, splitChunks_1.splitChunks)('hello world'), [
+            'h',
+            'e',
+            'l',
+            'l',
+            'o',
+            ' ',
+            'w',
+            'o',
+            'r',
+            'l',
+            'd',
+        ]);
+    });
+});

package/dist/tests/transformations/stringCombinations.test.d.ts

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

package/dist/tests/transformations/stringCombinations.test.js

@@ -0,0 +1,41 @@
+"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 stringCombinations_1 = require("../../transformations/stringCombinations");
+(0, node_test_1.describe)('stringCombinations', () => {
+    (0, node_test_1.it)('returns correct combinations for 2 characters', () => {
+        const expected = ['', 'a', 'b', 'ab'];
+        node_assert_1.default.deepStrictEqual((0, stringCombinations_1.stringCombinations)('ab').sort(), expected.sort());
+    });
+    (0, node_test_1.it)('returns correct combinations for 3 unique characters', () => {
+        const expected = ['', 'a', 'b', 'c', 'ab', 'ac', 'bc', 'abc'];
+        node_assert_1.default.deepStrictEqual((0, stringCombinations_1.stringCombinations)('abc').sort(), expected.sort());
+    });
+    (0, node_test_1.it)('handles repeated characters correctly', () => {
+        const expected = ['', 'a', 'b', 'aa', 'ab', 'aab'];
+        node_assert_1.default.deepStrictEqual((0, stringCombinations_1.stringCombinations)('aab').sort(), expected.sort());
+    });
+    (0, node_test_1.it)('returns only empty string for empty input', () => {
+        node_assert_1.default.deepStrictEqual((0, stringCombinations_1.stringCombinations)(''), ['']);
+    });
+    (0, node_test_1.it)('handles single character input', () => {
+        node_assert_1.default.deepStrictEqual((0, stringCombinations_1.stringCombinations)('a'), ['', 'a']);
+    });
+    (0, node_test_1.it)('is case-sensitive', () => {
+        const expected = ['', 'A', 'b', 'Ab'];
+        node_assert_1.default.deepStrictEqual((0, stringCombinations_1.stringCombinations)('Ab').sort(), expected.sort());
+    });
+    (0, node_test_1.it)('handles special characters correctly', () => {
+        const expected = ['', '!', '@', '!@'];
+        node_assert_1.default.deepStrictEqual((0, stringCombinations_1.stringCombinations)('!@').sort(), expected.sort());
+    });
+    (0, node_test_1.it)('throws an error if input is not a string', () => {
+        node_assert_1.default.throws(() => (0, stringCombinations_1.stringCombinations)(123), /Input must be a string/);
+        node_assert_1.default.throws(() => (0, stringCombinations_1.stringCombinations)(null), /Input must be a string/);
+        node_assert_1.default.throws(() => (0, stringCombinations_1.stringCombinations)(undefined), /Input must be a string/);
+    });
+});

package/dist/tests/transformations/stringPermutations.test.d.ts

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

package/dist/tests/transformations/stringPermutations.test.js

@@ -0,0 +1,40 @@
+"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 stringPermutations_1 = require("../../transformations/stringPermutations");
+(0, node_test_1.describe)('stringPermutations', () => {
+    (0, node_test_1.it)('returns correct permutations for small strings', () => {
+        node_assert_1.default.deepStrictEqual((0, stringPermutations_1.stringPermutations)('ab').sort(), ['ab', 'ba'].sort());
+    });
+    (0, node_test_1.it)('returns all permutations for 3 unique characters', () => {
+        const expected = ['abc', 'acb', 'bac', 'bca', 'cab', 'cba'];
+        node_assert_1.default.deepStrictEqual((0, stringPermutations_1.stringPermutations)('abc').sort(), expected.sort());
+    });
+    (0, node_test_1.it)('handles repeated characters correctly', () => {
+        const expected = ['aab', 'aba', 'baa'];
+        node_assert_1.default.deepStrictEqual((0, stringPermutations_1.stringPermutations)('aab').sort(), expected.sort());
+    });
+    (0, node_test_1.it)('handles single character input', () => {
+        node_assert_1.default.deepStrictEqual((0, stringPermutations_1.stringPermutations)('a'), ['a']);
+    });
+    (0, node_test_1.it)('handles empty string input', () => {
+        node_assert_1.default.deepStrictEqual((0, stringPermutations_1.stringPermutations)(''), ['']);
+    });
+    (0, node_test_1.it)('is case-sensitive', () => {
+        const expected = ['Ab', 'bA'];
+        node_assert_1.default.deepStrictEqual((0, stringPermutations_1.stringPermutations)('Ab').sort(), expected.sort());
+    });
+    (0, node_test_1.it)('handles special characters', () => {
+        const expected = ['!@', '@!'];
+        node_assert_1.default.deepStrictEqual((0, stringPermutations_1.stringPermutations)('!@').sort(), expected.sort());
+    });
+    (0, node_test_1.it)('throws an error if input is not a string', () => {
+        node_assert_1.default.throws(() => (0, stringPermutations_1.stringPermutations)(123), /Input must be a string/);
+        node_assert_1.default.throws(() => (0, stringPermutations_1.stringPermutations)(null), /Input must be a string/);
+        node_assert_1.default.throws(() => (0, stringPermutations_1.stringPermutations)(undefined), /Input must be a string/);
+    });
+});

package/dist/tests/validations/isAlphaNumeric.test.d.ts

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

package/dist/tests/validations/isAlphaNumeric.test.js

@@ -0,0 +1,30 @@
+"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 isAlphaNumeric_1 = require("../../validations/isAlphaNumeric");
+(0, node_test_1.describe)('isAlphaNumeric', () => {
+    (0, node_test_1.it)('returns true for alphanumeric strings', () => {
+        node_assert_1.default.strictEqual((0, isAlphaNumeric_1.isAlphaNumeric)('abc123'), true);
+        node_assert_1.default.strictEqual((0, isAlphaNumeric_1.isAlphaNumeric)('A1B2C3'), true);
+        node_assert_1.default.strictEqual((0, isAlphaNumeric_1.isAlphaNumeric)('123'), true);
+        node_assert_1.default.strictEqual((0, isAlphaNumeric_1.isAlphaNumeric)('abc'), true);
+    });
+    (0, node_test_1.it)('returns false for strings with special characters or spaces', () => {
+        node_assert_1.default.strictEqual((0, isAlphaNumeric_1.isAlphaNumeric)('abc!123'), false);
+        node_assert_1.default.strictEqual((0, isAlphaNumeric_1.isAlphaNumeric)('hello world'), false);
+        node_assert_1.default.strictEqual((0, isAlphaNumeric_1.isAlphaNumeric)('test@'), false);
+    });
+    (0, node_test_1.it)('returns false for empty string', () => {
+        node_assert_1.default.strictEqual((0, isAlphaNumeric_1.isAlphaNumeric)(''), false);
+    });
+    (0, node_test_1.it)('throws an error if input is not a string', () => {
+        node_assert_1.default.throws(() => (0, isAlphaNumeric_1.isAlphaNumeric)(123), /Input must be a string/);
+        node_assert_1.default.throws(() => (0, isAlphaNumeric_1.isAlphaNumeric)(null), /Input must be a string/);
+        node_assert_1.default.throws(() => (0, isAlphaNumeric_1.isAlphaNumeric)(undefined), /Input must be a string/);
+        node_assert_1.default.throws(() => (0, isAlphaNumeric_1.isAlphaNumeric)({}), /Input must be a string/);
+    });
+});

package/dist/tests/validations/isAlphabetic.test.d.ts

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

package/dist/tests/validations/isAlphabetic.test.js

@@ -0,0 +1,32 @@
+"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 isAlphabetic_1 = require("../../validations/isAlphabetic");
+(0, node_test_1.describe)('isAlphabetic', () => {
+    (0, node_test_1.it)('returns true for purely alphabetic strings', () => {
+        node_assert_1.default.strictEqual((0, isAlphabetic_1.isAlphabetic)('hello'), true);
+        node_assert_1.default.strictEqual((0, isAlphabetic_1.isAlphabetic)('World'), true);
+        node_assert_1.default.strictEqual((0, isAlphabetic_1.isAlphabetic)('TestCase'), true);
+    });
+    (0, node_test_1.it)('returns false for strings with numbers', () => {
+        node_assert_1.default.strictEqual((0, isAlphabetic_1.isAlphabetic)('hello123'), false);
+        node_assert_1.default.strictEqual((0, isAlphabetic_1.isAlphabetic)('Test1'), false);
+    });
+    (0, node_test_1.it)('returns false for strings with special characters or spaces', () => {
+        node_assert_1.default.strictEqual((0, isAlphabetic_1.isAlphabetic)('hello!'), false);
+        node_assert_1.default.strictEqual((0, isAlphabetic_1.isAlphabetic)('hello world'), false);
+        node_assert_1.default.strictEqual((0, isAlphabetic_1.isAlphabetic)('Hi-There'), false);
+    });
+    (0, node_test_1.it)('returns false for empty strings', () => {
+        node_assert_1.default.strictEqual((0, isAlphabetic_1.isAlphabetic)(''), false);
+    });
+    (0, node_test_1.it)('throws an error if input is not a string', () => {
+        node_assert_1.default.throws(() => (0, isAlphabetic_1.isAlphabetic)(123), /Input must be a string/);
+        node_assert_1.default.throws(() => (0, isAlphabetic_1.isAlphabetic)(null), /Input must be a string/);
+        node_assert_1.default.throws(() => (0, isAlphabetic_1.isAlphabetic)(undefined), /Input must be a string/);
+    });
+});

package/dist/tests/validations/isAnagram.test.d.ts

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

package/dist/tests/validations/isAnagram.test.js

@@ -0,0 +1,44 @@
+"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 isAnagram_1 = require("../../validations/isAnagram");
+(0, node_test_1.describe)('isAnagram', () => {
+    (0, node_test_1.it)('returns true for valid anagrams (simple lowercase words)', () => {
+        node_assert_1.default.strictEqual((0, isAnagram_1.isAnagram)('listen', 'silent'), true);
+        node_assert_1.default.strictEqual((0, isAnagram_1.isAnagram)('evil', 'vile'), true);
+    });
+    (0, node_test_1.it)('returns true for case-insensitive matches', () => {
+        node_assert_1.default.strictEqual((0, isAnagram_1.isAnagram)('Listen', 'Silent'), true);
+        node_assert_1.default.strictEqual((0, isAnagram_1.isAnagram)('Debit Card', 'Bad Credit'), true);
+    });
+    (0, node_test_1.it)('returns true when ignoring spaces and punctuation', () => {
+        node_assert_1.default.strictEqual((0, isAnagram_1.isAnagram)('Astronomer', 'Moon starer'), true);
+        node_assert_1.default.strictEqual((0, isAnagram_1.isAnagram)('The eyes!!', 'They see'), true);
+    });
+    (0, node_test_1.it)('returns false for non-anagrams', () => {
+        node_assert_1.default.strictEqual((0, isAnagram_1.isAnagram)('hello', 'world'), false);
+        node_assert_1.default.strictEqual((0, isAnagram_1.isAnagram)('abc', 'abcd'), false);
+    });
+    (0, node_test_1.it)('returns true for single character anagrams', () => {
+        node_assert_1.default.strictEqual((0, isAnagram_1.isAnagram)('a', 'a'), true);
+    });
+    (0, node_test_1.it)('returns false for different single characters', () => {
+        node_assert_1.default.strictEqual((0, isAnagram_1.isAnagram)('a', 'b'), false);
+    });
+    (0, node_test_1.it)('returns true for empty strings (both empty)', () => {
+        node_assert_1.default.strictEqual((0, isAnagram_1.isAnagram)('', ''), true);
+    });
+    (0, node_test_1.it)('returns false when only one string is empty', () => {
+        node_assert_1.default.strictEqual((0, isAnagram_1.isAnagram)('', 'a'), false);
+        node_assert_1.default.strictEqual((0, isAnagram_1.isAnagram)('a', ''), false);
+    });
+    (0, node_test_1.it)('throws an error if inputs are not strings', () => {
+        node_assert_1.default.throws(() => (0, isAnagram_1.isAnagram)(123, 'abc'), /Both inputs must be strings/);
+        node_assert_1.default.throws(() => (0, isAnagram_1.isAnagram)(null, 'abc'), /Both inputs must be strings/);
+        node_assert_1.default.throws(() => (0, isAnagram_1.isAnagram)(undefined, 'abc'), /Both inputs must be strings/);
+    });
+});

package/dist/tests/validations/isCoordinates.test.d.ts

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

package/dist/tests/validations/isCoordinates.test.js

@@ -0,0 +1,18 @@
+"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 isCoordinates_1 = require("../../validations/isCoordinates");
+(0, node_test_1.describe)('isCoordinates', () => {
+    (0, node_test_1.it)('returns true for valid coordinates', () => {
+        node_assert_1.default.strictEqual((0, isCoordinates_1.isCoordinates)(48.8582, 2.2945), true);
+        node_assert_1.default.strictEqual((0, isCoordinates_1.isCoordinates)(40.748817, -73.985428), true);
+    });
+    (0, node_test_1.it)('returns false for invalid coordinates', () => {
+        node_assert_1.default.strictEqual((0, isCoordinates_1.isCoordinates)(200, 200), false);
+        node_assert_1.default.strictEqual((0, isCoordinates_1.isCoordinates)(-200, -200), false);
+    });
+});

package/dist/tests/validations/isEmail.smtpUTF8.test.d.ts

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

package/dist/tests/validations/isEmail.smtpUTF8.test.js

@@ -0,0 +1,16 @@
+"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 isEmail_1 = require("../../validations/isEmail");
+(0, node_test_1.describe)('isEmail (SMTPUTF8)', () => {
+    (0, node_test_1.it)('accepts emoji in local-part by default', () => {
+        node_assert_1.default.strictEqual((0, isEmail_1.isEmail)('I❤️CHOCOLATE@example.com'), true);
+    });
+    (0, node_test_1.it)('rejects emoji in local-part when smtpUTF8 is explicitly disabled', () => {
+        node_assert_1.default.strictEqual((0, isEmail_1.isEmail)('I❤️CHOCOLATE@example.com', { smtpUTF8: false }), false);
+    });
+});

package/dist/tests/validations/isEmail.test.js

@@ -6,12 +6,62 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const node_test_1 = require("node:test");
 const node_assert_1 = __importDefault(require("node:assert"));
 const isEmail_1 = require("../../validations/isEmail");
-(0, node_test_1.describe)('isEmail', () => {
-    (0, node_test_1.it)('returns true for valid emails', () => {
-        node_assert_1.default.strictEqual((0, isEmail_1.isEmail)('foo@bar.com'), true);
+(0, node_test_1.describe)("isEmail", () => {
+    //
+    // ✅ Basic valid emails
+    //
+    (0, node_test_1.it)("returns true for basic valid emails", () => {
+        node_assert_1.default.strictEqual((0, isEmail_1.isEmail)("foo@bar.com"), true);
+        node_assert_1.default.strictEqual((0, isEmail_1.isEmail)("test@example.org"), true);
+        node_assert_1.default.strictEqual((0, isEmail_1.isEmail)("very.common@example.com"), true);
+        node_assert_1.default.strictEqual((0, isEmail_1.isEmail)("long.email-address-with-hyphens@and.subdomains.example.com"), true);
     });
-    (0, node_test_1.it)('returns false for invalid emails', () => {
-        node_assert_1.default.strictEqual((0, isEmail_1.isEmail)('foo@bar'), false);
-        node_assert_1.default.strictEqual((0, isEmail_1.isEmail)(''), false);
+    //
+    // ✅ Special characters in local-part
+    //
+    (0, node_test_1.it)("returns true for special characters", () => {
+        node_assert_1.default.strictEqual((0, isEmail_1.isEmail)("test+tag@example.com"), true);
+        node_assert_1.default.strictEqual((0, isEmail_1.isEmail)("user.name+tag+sorting@example.com"), true);
+        node_assert_1.default.strictEqual((0, isEmail_1.isEmail)("test/test@example.com"), true);
+    });
+    //
+    // ✅ IPv4 address literal
+    //
+    (0, node_test_1.it)("returns true for IPv4 address literal", () => {
+        node_assert_1.default.strictEqual((0, isEmail_1.isEmail)("user@[192.168.1.1]"), true);
+    });
+    //
+    // ✅ Quoted local-parts (RFC 5322)
+    //
+    (0, node_test_1.it)("returns true for quoted local-parts", () => {
+        node_assert_1.default.strictEqual((0, isEmail_1.isEmail)('"much.more unusual"@example.com'), true);
+        node_assert_1.default.strictEqual((0, isEmail_1.isEmail)('"very.unusual.@.unusual.com"@example.com'), true);
+        node_assert_1.default.strictEqual((0, isEmail_1.isEmail)('"very.(),:;<>[]".VERY."very@\\ "very".unusual"@strange.example.com'), true);
+    });
+    //
+    // ✅ IPv6 domain literal
+    //
+    (0, node_test_1.it)("returns true for IPv6 domain literals", () => {
+        node_assert_1.default.strictEqual((0, isEmail_1.isEmail)("user@[IPv6:2001:db8::1]"), true);
+    });
+    //
+    // ❌ Invalid emails
+    //
+    (0, node_test_1.it)("returns false for invalid emails", () => {
+        node_assert_1.default.strictEqual((0, isEmail_1.isEmail)(""), false);
+        node_assert_1.default.strictEqual((0, isEmail_1.isEmail)("@example.com"), false);
+        node_assert_1.default.strictEqual((0, isEmail_1.isEmail)("test@"), false);
+        node_assert_1.default.strictEqual((0, isEmail_1.isEmail)("test"), false);
+        node_assert_1.default.strictEqual((0, isEmail_1.isEmail)("test@.com"), false);
+        node_assert_1.default.strictEqual((0, isEmail_1.isEmail)("test..test@example.com"), false);
+        node_assert_1.default.strictEqual((0, isEmail_1.isEmail)(".test@example.com"), false);
+        node_assert_1.default.strictEqual((0, isEmail_1.isEmail)("test.@example.com"), false);
+    });
+    //
+    // ❌ Invalid quoted emails
+    //
+    (0, node_test_1.it)("returns false for invalid quoted local-parts", () => {
+        node_assert_1.default.strictEqual((0, isEmail_1.isEmail)('"unclosed-quote@example.com'), false);
+        node_assert_1.default.strictEqual((0, isEmail_1.isEmail)('"missing"quotes@@example.com'), false);
     });
 });

package/dist/tests/validations/isHexColor.test.js

@@ -6,27 +6,27 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const node_test_1 = require("node:test");
 const node_assert_1 = __importDefault(require("node:assert"));
 const isHexColor_1 = require("../../validations/isHexColor");
-(0, node_test_1.describe)("isHexColor", () => {
-    (0, node_test_1.it)("returns true for valid hex colors", () => {
-        node_assert_1.default.strictEqual((0, isHexColor_1.isHexColor)("#abc"), true);
-        node_assert_1.default.strictEqual((0, isHexColor_1.isHexColor)("abc"), true);
-        node_assert_1.default.strictEqual((0, isHexColor_1.isHexColor)("#a1b2c3"), true);
-        node_assert_1.default.strictEqual((0, isHexColor_1.isHexColor)("a1b2c3"), true);
-        node_assert_1.default.strictEqual((0, isHexColor_1.isHexColor)("#A1B2C3"), true);
-        node_assert_1.default.strictEqual((0, isHexColor_1.isHexColor)("   #fff   "), true);
+(0, node_test_1.describe)('isHexColor', () => {
+    (0, node_test_1.it)('returns true for valid hex colors', () => {
+        node_assert_1.default.strictEqual((0, isHexColor_1.isHexColor)('#abc'), true);
+        node_assert_1.default.strictEqual((0, isHexColor_1.isHexColor)('abc'), true);
+        node_assert_1.default.strictEqual((0, isHexColor_1.isHexColor)('#a1b2c3'), true);
+        node_assert_1.default.strictEqual((0, isHexColor_1.isHexColor)('a1b2c3'), true);
+        node_assert_1.default.strictEqual((0, isHexColor_1.isHexColor)('#A1B2C3'), true);
+        node_assert_1.default.strictEqual((0, isHexColor_1.isHexColor)('   #fff   '), true);
     });
-    (0, node_test_1.it)("returns false for invalid hex colors", () => {
-        node_assert_1.default.strictEqual((0, isHexColor_1.isHexColor)("#12G"), false);
-        node_assert_1.default.strictEqual((0, isHexColor_1.isHexColor)("xyz"), false);
-        node_assert_1.default.strictEqual((0, isHexColor_1.isHexColor)("#ab"), false);
-        node_assert_1.default.strictEqual((0, isHexColor_1.isHexColor)("#12345"), false);
-        node_assert_1.default.strictEqual((0, isHexColor_1.isHexColor)("12345"), false);
-        node_assert_1.default.strictEqual((0, isHexColor_1.isHexColor)("#1234567"), false);
-        node_assert_1.default.strictEqual((0, isHexColor_1.isHexColor)("1234567"), false);
-        node_assert_1.default.strictEqual((0, isHexColor_1.isHexColor)("#1234g6"), false);
-        node_assert_1.default.strictEqual((0, isHexColor_1.isHexColor)("1234g6"), false);
-        node_assert_1.default.strictEqual((0, isHexColor_1.isHexColor)(""), false);
-        node_assert_1.default.strictEqual((0, isHexColor_1.isHexColor)("   "), false);
-        node_assert_1.default.strictEqual((0, isHexColor_1.isHexColor)("blue"), false);
+    (0, node_test_1.it)('returns false for invalid hex colors', () => {
+        node_assert_1.default.strictEqual((0, isHexColor_1.isHexColor)('#12G'), false);
+        node_assert_1.default.strictEqual((0, isHexColor_1.isHexColor)('xyz'), false);
+        node_assert_1.default.strictEqual((0, isHexColor_1.isHexColor)('#ab'), false);
+        node_assert_1.default.strictEqual((0, isHexColor_1.isHexColor)('#12345'), false);
+        node_assert_1.default.strictEqual((0, isHexColor_1.isHexColor)('12345'), false);
+        node_assert_1.default.strictEqual((0, isHexColor_1.isHexColor)('#1234567'), false);
+        node_assert_1.default.strictEqual((0, isHexColor_1.isHexColor)('1234567'), false);
+        node_assert_1.default.strictEqual((0, isHexColor_1.isHexColor)('#1234g6'), false);
+        node_assert_1.default.strictEqual((0, isHexColor_1.isHexColor)('1234g6'), false);
+        node_assert_1.default.strictEqual((0, isHexColor_1.isHexColor)(''), false);
+        node_assert_1.default.strictEqual((0, isHexColor_1.isHexColor)('   '), false);
+        node_assert_1.default.strictEqual((0, isHexColor_1.isHexColor)('blue'), false);
     });
 });

package/dist/tests/validations/isLowerCase.test.d.ts

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