stringzy 4.0.0 → 4.2.0

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/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,110 @@
+"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/);
+    });
+    (0, node_test_1.it)('respects limit parameter', () => {
+        const result = (0, stringPermutations_1.stringPermutations)('abcdef', 3);
+        node_assert_1.default.strictEqual(result.length, 3);
+        // All results should be valid permutations
+        for (const perm of result) {
+            node_assert_1.default.strictEqual(perm.length, 6);
+            node_assert_1.default.strictEqual([...perm].sort().join(''), 'abcdef');
+        }
+    });
+    (0, node_test_1.it)('throws error for negative limit', () => {
+        node_assert_1.default.throws(() => (0, stringPermutations_1.stringPermutations)('abc', -1), /Limit must be non-negative/);
+    });
+    (0, node_test_1.it)('handles limit of 0', () => {
+        const result = (0, stringPermutations_1.stringPermutations)('abc', 0);
+        node_assert_1.default.strictEqual(result.length, 0);
+    });
+    (0, node_test_1.it)('handles limit larger than total permutations', () => {
+        const result = (0, stringPermutations_1.stringPermutations)('abc', 100);
+        node_assert_1.default.strictEqual(result.length, 6); // 3! = 6
+    });
+});
+(0, node_test_1.describe)('stringPermutationsGenerator', () => {
+    (0, node_test_1.it)('yields correct permutations for small strings', () => {
+        const result = Array.from((0, stringPermutations_1.stringPermutationsGenerator)('ab')).sort();
+        node_assert_1.default.deepStrictEqual(result, ['ab', 'ba']);
+    });
+    (0, node_test_1.it)('yields all permutations for 3 unique characters', () => {
+        const result = Array.from((0, stringPermutations_1.stringPermutationsGenerator)('abc')).sort();
+        const expected = ['abc', 'acb', 'bac', 'bca', 'cab', 'cba'];
+        node_assert_1.default.deepStrictEqual(result, expected);
+    });
+    (0, node_test_1.it)('handles repeated characters correctly', () => {
+        const result = Array.from((0, stringPermutations_1.stringPermutationsGenerator)('aab')).sort();
+        const expected = ['aab', 'aba', 'baa'];
+        node_assert_1.default.deepStrictEqual(result, expected);
+    });
+    (0, node_test_1.it)('handles single character input', () => {
+        const result = Array.from((0, stringPermutations_1.stringPermutationsGenerator)('a'));
+        node_assert_1.default.deepStrictEqual(result, ['a']);
+    });
+    (0, node_test_1.it)('handles empty string input', () => {
+        const result = Array.from((0, stringPermutations_1.stringPermutationsGenerator)(''));
+        node_assert_1.default.deepStrictEqual(result, ['']);
+    });
+    (0, node_test_1.it)('is case-sensitive', () => {
+        const result = Array.from((0, stringPermutations_1.stringPermutationsGenerator)('Ab')).sort();
+        const expected = ['Ab', 'bA'];
+        node_assert_1.default.deepStrictEqual(result, expected);
+    });
+    (0, node_test_1.it)('handles special characters', () => {
+        const result = Array.from((0, stringPermutations_1.stringPermutationsGenerator)('!@')).sort();
+        const expected = ['!@', '@!'];
+        node_assert_1.default.deepStrictEqual(result, expected);
+    });
+    (0, node_test_1.it)('throws an error if input is not a string', () => {
+        // Generator functions throw when first consumed, not when created
+        const gen1 = (0, stringPermutations_1.stringPermutationsGenerator)(123);
+        node_assert_1.default.throws(() => gen1.next(), /Input must be a string/);
+        const gen2 = (0, stringPermutations_1.stringPermutationsGenerator)(null);
+        node_assert_1.default.throws(() => gen2.next(), /Input must be a string/);
+        const gen3 = (0, stringPermutations_1.stringPermutationsGenerator)(undefined);
+        node_assert_1.default.throws(() => gen3.next(), /Input must be a string/);
+    });
+    (0, node_test_1.it)('can be used with for...of loop', () => {
+        const results = [];
+        for (const perm of (0, stringPermutations_1.stringPermutationsGenerator)('abc')) {
+            results.push(perm);
+        }
+        node_assert_1.default.strictEqual(results.length, 6);
+    });
+});

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

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

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

@@ -0,0 +1,65 @@
+"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 isIPv6_1 = require("../../validations/isIPv6");
+(0, node_test_1.describe)('isIPv6', () => {
+    (0, node_test_1.it)('returns true for valid full IPv6 addresses', () => {
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('2001:0db8:85a3:0000:0000:8a2e:0370:7334'), true);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff'), true);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('0:0:0:0:0:0:0:1'), true);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('fe80:0000:0000:0000:0202:b3ff:fe1e:8329'), true);
+    });
+    (0, node_test_1.it)('returns true for valid shorthand IPv6 addresses', () => {
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('2001:db8:85a3::8a2e:370:7334'), true);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('::1'), true);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('fe80::1'), true);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('::'), true);
+    });
+    (0, node_test_1.it)('returns false for IPv6 addresses with too many groups', () => {
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('2001:0db8:85a3:0000:0000:8a2e:0370:7334:1234'), false);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('1:2:3:4:5:6:7:8:9'), false);
+    });
+    (0, node_test_1.it)('returns false for IPv6 addresses with too few groups without shorthand', () => {
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('2001:db8:85a3:8a2e:370:7334'), false);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('1:2:3:4:5:6:7'), false);
+    });
+    (0, node_test_1.it)('returns false for invalid use of shorthand (::)', () => {
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('2001:db8:::1'), false);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)(':::1'), false);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('2001::85a3::7334'), false);
+    });
+    (0, node_test_1.it)('returns false for groups longer than 4 hex digits', () => {
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('12345::abcd'), false);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('2001:db8:85a3:00000:0000:8a2e:0370:7334'), false);
+    });
+    (0, node_test_1.it)('returns false for invalid characters', () => {
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('2001:db8:85a3:z000:0000:8a2e:0370:7334'), false);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('2001:db8:85a3:0000:0000:8a2e:0370:g334'), false);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('abcd:efgh:ijkl:mnop:qrst:uvwx:yz12:3456'), false);
+    });
+    (0, node_test_1.it)('returns false for special characters and malformed strings', () => {
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('2001:db8:85a3:0000:0000:8a2e:0370:7334:'), false);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)(':2001:db8:85a3:0000:0000:8a2e:0370:7334'), false);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('2001:db8::85a3::7334'), false);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('2001:db8::85a3:7334:'), false);
+    });
+    (0, node_test_1.it)('returns false for empty strings and edge cases', () => {
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)(''), false);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)(':'), false);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)(':::'), false);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('::::'), false);
+    });
+    (0, node_test_1.it)('returns true for uppercase valid IPv6 addresses (case-insensitive)', () => {
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('2001:DB8:85A3::8A2E:370:7334'), true);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('FE80::1'), true);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF'), true);
+    });
+    (0, node_test_1.it)('returns false for IPv4-mapped IPv6 (unsupported by this validator)', () => {
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('::ffff:192.168.1.1'), false);
+        node_assert_1.default.strictEqual((0, isIPv6_1.isIPv6)('2001:db8::192.168.1.1'), false);
+    });
+});

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

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

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

@@ -0,0 +1,50 @@
+"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 strict_1 = __importDefault(require("node:assert/strict"));
+const isLowerCase_1 = require("../../validations/isLowerCase");
+(0, node_test_1.describe)('isLowerCase', () => {
+    (0, node_test_1.it)('returns true for all lowercase alphabetic strings', () => {
+        strict_1.default.strictEqual((0, isLowerCase_1.isLowerCase)('hello'), true);
+        strict_1.default.strictEqual((0, isLowerCase_1.isLowerCase)('world'), true);
+    });
+    (0, node_test_1.it)('returns true for strings with lowercase letters, spaces, digits, or special characters', () => {
+        strict_1.default.strictEqual((0, isLowerCase_1.isLowerCase)('hello world!'), true);
+        strict_1.default.strictEqual((0, isLowerCase_1.isLowerCase)('abc123'), true);
+        strict_1.default.strictEqual((0, isLowerCase_1.isLowerCase)('lower_case-only!!'), true);
+    });
+    (0, node_test_1.it)('returns false if any uppercase alphabetic character is present', () => {
+        strict_1.default.strictEqual((0, isLowerCase_1.isLowerCase)('Hello'), false);
+        strict_1.default.strictEqual((0, isLowerCase_1.isLowerCase)('worldWide'), false);
+        strict_1.default.strictEqual((0, isLowerCase_1.isLowerCase)('123ABC'), false);
+        strict_1.default.strictEqual((0, isLowerCase_1.isLowerCase)('@@Good@@'), false);
+    });
+    (0, node_test_1.it)('returns false for an empty string', () => {
+        strict_1.default.strictEqual((0, isLowerCase_1.isLowerCase)(''), false);
+    });
+    (0, node_test_1.it)('returns true for strings with only non-alphabetic characters (digits/symbols/spaces)', () => {
+        strict_1.default.strictEqual((0, isLowerCase_1.isLowerCase)('12345'), false); // no letters
+        strict_1.default.strictEqual((0, isLowerCase_1.isLowerCase)('!@#$%^&*()'), false);
+        strict_1.default.strictEqual((0, isLowerCase_1.isLowerCase)('   '), false); // spaces only
+    });
+    (0, node_test_1.it)('returns true for single lowercase letters', () => {
+        strict_1.default.strictEqual((0, isLowerCase_1.isLowerCase)('a'), true);
+        strict_1.default.strictEqual((0, isLowerCase_1.isLowerCase)('z'), true);
+    });
+    (0, node_test_1.it)('returns false for single uppercase letters', () => {
+        strict_1.default.strictEqual((0, isLowerCase_1.isLowerCase)('A'), false);
+        strict_1.default.strictEqual((0, isLowerCase_1.isLowerCase)('Z'), false);
+    });
+    (0, node_test_1.it)('handles mixed alphanumeric correctly', () => {
+        strict_1.default.strictEqual((0, isLowerCase_1.isLowerCase)('abc123xyz'), true);
+        strict_1.default.strictEqual((0, isLowerCase_1.isLowerCase)('abcXYZ123'), false);
+    });
+    (0, node_test_1.it)('throws an error if input is not a string', () => {
+        strict_1.default.throws(() => (0, isLowerCase_1.isLowerCase)(123), /Input must be a string/);
+        strict_1.default.throws(() => (0, isLowerCase_1.isLowerCase)(null), /Input must be a string/);
+        strict_1.default.throws(() => (0, isLowerCase_1.isLowerCase)(undefined), /Input must be a string/);
+    });
+});

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

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

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

@@ -0,0 +1,72 @@
+"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 isMacAddress_1 = require("../../validations/isMacAddress");
+(0, node_test_1.describe)('isMacAddress', () => {
+    (0, node_test_1.it)('returns true for valid MAC addresses with colons', () => {
+        node_assert_1.default.strictEqual((0, isMacAddress_1.isMacAddress)('00:1A:2B:3C:4D:5E'), true);
+        node_assert_1.default.strictEqual((0, isMacAddress_1.isMacAddress)('aa:bb:cc:dd:ee:ff'), true);
+        node_assert_1.default.strictEqual((0, isMacAddress_1.isMacAddress)('FF:FF:FF:FF:FF:FF'), true);
+        node_assert_1.default.strictEqual((0, isMacAddress_1.isMacAddress)('01:23:45:67:89:AB'), true);
+    });
+    (0, node_test_1.it)('returns true for valid MAC addresses with hyphens', () => {
+        node_assert_1.default.strictEqual((0, isMacAddress_1.isMacAddress)('00-1A-2B-3C-4D-5E'), true);
+        node_assert_1.default.strictEqual((0, isMacAddress_1.isMacAddress)('aa-bb-cc-dd-ee-ff'), true);
+        node_assert_1.default.strictEqual((0, isMacAddress_1.isMacAddress)('FF-FF-FF-FF-FF-FF'), true);
+    });
+    (0, node_test_1.it)('returns false for MAC addresses with mixed separators', () => {
+        node_assert_1.default.strictEqual((0, isMacAddress_1.isMacAddress)('00:1A-2B:3C-4D:5E'), false);
+        node_assert_1.default.strictEqual((0, isMacAddress_1.isMacAddress)('AA-BB:CC-DD:EE-FF'), false);
+    });
+    (0, node_test_1.it)('returns false for MAC addresses with invalid hex digits', () => {
+        node_assert_1.default.strictEqual((0, isMacAddress_1.isMacAddress)('00:1G:2B:3C:4D:5E'), false);
+        node_assert_1.default.strictEqual((0, isMacAddress_1.isMacAddress)('ZZ:ZZ:ZZ:ZZ:ZZ:ZZ'), false);
+        node_assert_1.default.strictEqual((0, isMacAddress_1.isMacAddress)('GG-GG-GG-GG-GG-GG'), false);
+    });
+    (0, node_test_1.it)('returns false for MAC addresses with wrong length', () => {
+        node_assert_1.default.strictEqual((0, isMacAddress_1.isMacAddress)('00:1A:2B:3C:4D'), false); // only 5 pairs
+        node_assert_1.default.strictEqual((0, isMacAddress_1.isMacAddress)('00:1A:2B:3C:4D:5E:7F'), false); // 7 pairs
+        node_assert_1.default.strictEqual((0, isMacAddress_1.isMacAddress)('001A:2B:3C:4D:5E'), false); // first group too long
+    });
+    (0, node_test_1.it)('returns false for MAC addresses with leading/trailing spaces', () => {
+        node_assert_1.default.strictEqual((0, isMacAddress_1.isMacAddress)(' 00:1A:2B:3C:4D:5E'), false);
+        node_assert_1.default.strictEqual((0, isMacAddress_1.isMacAddress)('00:1A:2B:3C:4D:5E '), false);
+        node_assert_1.default.strictEqual((0, isMacAddress_1.isMacAddress)(' 00:1A:2B:3C:4D:5E '), false);
+    });
+    (0, node_test_1.it)('returns false for MAC addresses with spaces inside', () => {
+        node_assert_1.default.strictEqual((0, isMacAddress_1.isMacAddress)('00:1A:2B:3C:4D :5E'), false);
+        node_assert_1.default.strictEqual((0, isMacAddress_1.isMacAddress)('00 :1A:2B:3C:4D:5E'), false);
+        node_assert_1.default.strictEqual((0, isMacAddress_1.isMacAddress)('00:1A:2B:3C: 4D:5E'), false);
+    });
+    (0, node_test_1.it)('returns false for missing separators', () => {
+        node_assert_1.default.strictEqual((0, isMacAddress_1.isMacAddress)('001A2B3C4D5E'), false);
+        node_assert_1.default.strictEqual((0, isMacAddress_1.isMacAddress)('00:1A2B:3C4D:5E'), false);
+        node_assert_1.default.strictEqual((0, isMacAddress_1.isMacAddress)('00-1A2B-3C4D-5E'), false);
+    });
+    (0, node_test_1.it)('returns false for extra separators', () => {
+        node_assert_1.default.strictEqual((0, isMacAddress_1.isMacAddress)('00::1A:2B:3C:4D:5E'), false);
+        node_assert_1.default.strictEqual((0, isMacAddress_1.isMacAddress)('00-1A--2B-3C-4D-5E'), false);
+        node_assert_1.default.strictEqual((0, isMacAddress_1.isMacAddress)('00:1A:2B:3C:4D:5E:'), false);
+    });
+    (0, node_test_1.it)('returns false for empty strings and malformed inputs', () => {
+        node_assert_1.default.strictEqual((0, isMacAddress_1.isMacAddress)(''), false);
+        node_assert_1.default.strictEqual((0, isMacAddress_1.isMacAddress)('::::::'), false);
+        node_assert_1.default.strictEqual((0, isMacAddress_1.isMacAddress)('--:--:--:--:--:--'), false);
+        node_assert_1.default.strictEqual((0, isMacAddress_1.isMacAddress)('00:1A:2B:3C:4D:5E:'), false);
+        node_assert_1.default.strictEqual((0, isMacAddress_1.isMacAddress)(':00:1A:2B:3C:4D:5E'), false);
+    });
+    (0, node_test_1.it)('returns false for non-hex characters and invalid formats', () => {
+        node_assert_1.default.strictEqual((0, isMacAddress_1.isMacAddress)('00:1A:2B:3C:4D:GH'), false);
+        node_assert_1.default.strictEqual((0, isMacAddress_1.isMacAddress)('hello-world-mac'), false);
+        node_assert_1.default.strictEqual((0, isMacAddress_1.isMacAddress)('mac:address:test'), false);
+    });
+    (0, node_test_1.it)('accepts both uppercase and lowercase consistently', () => {
+        node_assert_1.default.strictEqual((0, isMacAddress_1.isMacAddress)('aa:bb:cc:dd:ee:ff'), true);
+        node_assert_1.default.strictEqual((0, isMacAddress_1.isMacAddress)('AA:BB:CC:DD:EE:FF'), true);
+        node_assert_1.default.strictEqual((0, isMacAddress_1.isMacAddress)('Aa:Bb:Cc:Dd:Ee:Ff'), true);
+    });
+});

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

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

package/dist/tests/validations/isPanagram.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 isPanagram_1 = require("../../validations/isPanagram");
+(0, node_test_1.describe)('isPanagram', () => {
+    (0, node_test_1.it)('returns true for a classic pangram sentence', () => {
+        node_assert_1.default.strictEqual((0, isPanagram_1.isPanagram)('The quick brown fox jumps over the lazy dog.'), true);
+    });
+    (0, node_test_1.it)('returns true for the alphabet with hyphens or separators', () => {
+        node_assert_1.default.strictEqual((0, isPanagram_1.isPanagram)('A-B-C-D-E-F-G-H-I-J-K-L-M-N-O-P-Q-R-S-T-U-V-W-X-Y-Z'), true);
+    });
+    (0, node_test_1.it)('returns true for alphabet without separators', () => {
+        node_assert_1.default.strictEqual((0, isPanagram_1.isPanagram)('Abcdefghijklmnopqrstuvwxyz'), true);
+    });
+    (0, node_test_1.it)('returns true for alphabet in mixed case', () => {
+        node_assert_1.default.strictEqual((0, isPanagram_1.isPanagram)('AbCdEfGhIjKlMnOpQrStUvWxYz'), true);
+    });
+    (0, node_test_1.it)('returns false for non-pangram sentences', () => {
+        node_assert_1.default.strictEqual((0, isPanagram_1.isPanagram)('This is not a pangram.'), false);
+        node_assert_1.default.strictEqual((0, isPanagram_1.isPanagram)('Hello world'), false);
+        node_assert_1.default.strictEqual((0, isPanagram_1.isPanagram)('Quick fox'), false);
+    });
+    (0, node_test_1.it)('returns false for empty strings', () => {
+        node_assert_1.default.strictEqual((0, isPanagram_1.isPanagram)(''), false);
+    });
+    (0, node_test_1.it)('ignores numbers and punctuation', () => {
+        node_assert_1.default.strictEqual((0, isPanagram_1.isPanagram)('The quick brown fox jumps over the lazy dog! 12345'), true);
+        node_assert_1.default.strictEqual((0, isPanagram_1.isPanagram)('1234567890 !!! ???'), false);
+    });
+    (0, node_test_1.it)('throws an error if input is not a string', () => {
+        node_assert_1.default.throws(() => (0, isPanagram_1.isPanagram)(123), /Input must be a string/);
+        node_assert_1.default.throws(() => (0, isPanagram_1.isPanagram)(null), /Input must be a string/);
+        node_assert_1.default.throws(() => (0, isPanagram_1.isPanagram)(undefined), /Input must be a string/);
+    });
+});

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

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

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

@@ -0,0 +1,50 @@
+"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 strict_1 = __importDefault(require("node:assert/strict"));
+const isUpperCase_1 = require("../../validations/isUpperCase");
+(0, node_test_1.describe)('isUpperCase', () => {
+    (0, node_test_1.it)('returns true for all uppercase alphabetic strings', () => {
+        strict_1.default.strictEqual((0, isUpperCase_1.isUpperCase)('HELLO'), true);
+        strict_1.default.strictEqual((0, isUpperCase_1.isUpperCase)('WORLD'), true);
+    });
+    (0, node_test_1.it)('returns true for strings with uppercase letters, spaces, digits, or special characters', () => {
+        strict_1.default.strictEqual((0, isUpperCase_1.isUpperCase)('HELLO WORLD!'), true);
+        strict_1.default.strictEqual((0, isUpperCase_1.isUpperCase)('ABC123'), true);
+        strict_1.default.strictEqual((0, isUpperCase_1.isUpperCase)('UPPER_CASE-ONLY!!'), true);
+    });
+    (0, node_test_1.it)('returns false if any lowercase alphabetic character is present', () => {
+        strict_1.default.strictEqual((0, isUpperCase_1.isUpperCase)('Hello'), false);
+        strict_1.default.strictEqual((0, isUpperCase_1.isUpperCase)('WORLDwide'), false);
+        strict_1.default.strictEqual((0, isUpperCase_1.isUpperCase)('123abc'), false);
+        strict_1.default.strictEqual((0, isUpperCase_1.isUpperCase)('@@good@@'), false);
+    });
+    (0, node_test_1.it)('returns false for an empty string', () => {
+        strict_1.default.strictEqual((0, isUpperCase_1.isUpperCase)(''), false);
+    });
+    (0, node_test_1.it)('returns false for strings with only non-alphabetic characters (digits/symbols/spaces)', () => {
+        strict_1.default.strictEqual((0, isUpperCase_1.isUpperCase)('12345'), false); // no letters
+        strict_1.default.strictEqual((0, isUpperCase_1.isUpperCase)('!@#$%^&*()'), false);
+        strict_1.default.strictEqual((0, isUpperCase_1.isUpperCase)('   '), false); // spaces only
+    });
+    (0, node_test_1.it)('returns true for single uppercase letters', () => {
+        strict_1.default.strictEqual((0, isUpperCase_1.isUpperCase)('A'), true);
+        strict_1.default.strictEqual((0, isUpperCase_1.isUpperCase)('Z'), true);
+    });
+    (0, node_test_1.it)('returns false for single lowercase letters', () => {
+        strict_1.default.strictEqual((0, isUpperCase_1.isUpperCase)('a'), false);
+        strict_1.default.strictEqual((0, isUpperCase_1.isUpperCase)('z'), false);
+    });
+    (0, node_test_1.it)('handles mixed alphanumeric correctly', () => {
+        strict_1.default.strictEqual((0, isUpperCase_1.isUpperCase)('ABC123XYZ'), true);
+        strict_1.default.strictEqual((0, isUpperCase_1.isUpperCase)('ABCxyz123'), false);
+    });
+    (0, node_test_1.it)('throws an error if input is not a string', () => {
+        strict_1.default.throws(() => (0, isUpperCase_1.isUpperCase)(123), /Input must be a string/);
+        strict_1.default.throws(() => (0, isUpperCase_1.isUpperCase)(null), /Input must be a string/);
+        strict_1.default.throws(() => (0, isUpperCase_1.isUpperCase)(undefined), /Input must be a string/);
+    });
+});