stringzy 4.0.0 → 4.1.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,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/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/);
+    });
+});

package/dist/transformations/index.d.ts

@@ -14,6 +14,9 @@ export { truncateText } from './truncateText';
 export { escapeHtml } from './escapeHTML';
 export { maskSegment } from './maskSegment';
 export { numberToText } from './numberToText/main';
+export { reverseWordsInString } from './reverseWordsInString ';
+export { stringPermutations } from './stringPermutations';
+export { stringCombinations } from './stringCombinations';
 import { camelCase } from './camelCase';
 import { capitalizeWords } from './capitalizeWords';
 import { constantCase } from './constantCase';
@@ -31,6 +34,9 @@ import { escapeHtml } from './escapeHTML';
 import { maskSegment } from './maskSegment';
 import { deburr } from './deburr';
 import { numberToText } from './numberToText/main';
+import { reverseWordsInString } from './reverseWordsInString ';
+import { stringPermutations } from './stringPermutations';
+import { stringCombinations } from './stringCombinations';
 export declare const transformations: {
     camelCase: typeof camelCase;
     capitalizeWords: typeof capitalizeWords;
@@ -49,4 +55,7 @@ export declare const transformations: {
     maskSegment: typeof maskSegment;
     deburr: typeof deburr;
     numberToText: typeof numberToText;
+    reverseWordsInString: typeof reverseWordsInString;
+    stringPermutations: typeof stringPermutations;
+    stringCombinations: typeof stringCombinations;
 };

package/dist/transformations/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformations = exports.numberToText = exports.maskSegment = exports.escapeHtml = exports.truncateText = exports.toSlug = exports.titleCase = exports.snakeCase = exports.removeWords = exports.removeSpecialChars = exports.removeDuplicates = exports.pascalCase = exports.kebabCase = exports.initials = exports.constantCase = exports.capitalizeWords = exports.camelCase = void 0;
+exports.transformations = exports.stringCombinations = exports.stringPermutations = exports.reverseWordsInString = exports.numberToText = exports.maskSegment = exports.escapeHtml = exports.truncateText = exports.toSlug = exports.titleCase = exports.snakeCase = exports.removeWords = exports.removeSpecialChars = exports.removeDuplicates = exports.pascalCase = exports.kebabCase = exports.initials = exports.constantCase = exports.capitalizeWords = exports.camelCase = void 0;
 var camelCase_1 = require("./camelCase");
 Object.defineProperty(exports, "camelCase", { enumerable: true, get: function () { return camelCase_1.camelCase; } });
 var capitalizeWords_1 = require("./capitalizeWords");
@@ -33,6 +33,12 @@ var maskSegment_1 = require("./maskSegment");
 Object.defineProperty(exports, "maskSegment", { enumerable: true, get: function () { return maskSegment_1.maskSegment; } });
 var main_1 = require("./numberToText/main");
 Object.defineProperty(exports, "numberToText", { enumerable: true, get: function () { return main_1.numberToText; } });
+var reverseWordsInString_1 = require("./reverseWordsInString ");
+Object.defineProperty(exports, "reverseWordsInString", { enumerable: true, get: function () { return reverseWordsInString_1.reverseWordsInString; } });
+var stringPermutations_1 = require("./stringPermutations");
+Object.defineProperty(exports, "stringPermutations", { enumerable: true, get: function () { return stringPermutations_1.stringPermutations; } });
+var stringCombinations_1 = require("./stringCombinations");
+Object.defineProperty(exports, "stringCombinations", { enumerable: true, get: function () { return stringCombinations_1.stringCombinations; } });
 const camelCase_2 = require("./camelCase");
 const capitalizeWords_2 = require("./capitalizeWords");
 const constantCase_2 = require("./constantCase");
@@ -50,6 +56,9 @@ const escapeHTML_2 = require("./escapeHTML");
 const maskSegment_2 = require("./maskSegment");
 const deburr_1 = require("./deburr");
 const main_2 = require("./numberToText/main");
+const reverseWordsInString_2 = require("./reverseWordsInString ");
+const stringPermutations_2 = require("./stringPermutations");
+const stringCombinations_2 = require("./stringCombinations");
 exports.transformations = {
     camelCase: camelCase_2.camelCase,
     capitalizeWords: capitalizeWords_2.capitalizeWords,
@@ -67,5 +76,8 @@ exports.transformations = {
     escapeHtml: escapeHTML_2.escapeHtml,
     maskSegment: maskSegment_2.maskSegment,
     deburr: deburr_1.deburr,
-    numberToText: main_2.numberToText
+    numberToText: main_2.numberToText,
+    reverseWordsInString: reverseWordsInString_2.reverseWordsInString,
+    stringPermutations: stringPermutations_2.stringPermutations,
+    stringCombinations: stringCombinations_2.stringCombinations
 };

package/dist/transformations/reverseWordsInString .d.ts

@@ -0,0 +1,9 @@
+/**
+ * Reverses the order of words in a given string while preserving the
+ * exact spacing (including multiple spaces) between them.
+ *
+ * @param {string} str - The input string whose words are to be reversed.
+ * @returns {string} The string with the order of words reversed and all original spacing intact.
+ * @throws {TypeError} If the input is not a string.
+ */
+export declare function reverseWordsInString(str: string): string;

package/dist/transformations/reverseWordsInString .js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reverseWordsInString = reverseWordsInString;
+/**
+ * Reverses the order of words in a given string while preserving the
+ * exact spacing (including multiple spaces) between them.
+ *
+ * @param {string} str - The input string whose words are to be reversed.
+ * @returns {string} The string with the order of words reversed and all original spacing intact.
+ * @throws {TypeError} If the input is not a string.
+ */
+function reverseWordsInString(str) {
+    if (typeof str !== 'string') {
+        throw new TypeError('Input must be a string');
+    }
+    // 1. Extract all blocks of non-whitespace characters (the words).
+    const words = str.match(/\S+/g) || [];
+    // 2. If there are no words (e.g., empty or whitespace-only string), return the original string.
+    if (words.length === 0) {
+        return str;
+    }
+    // 3. Extract all blocks of whitespace.
+    const spaces = str.match(/\s+/g) || [];
+    // 4. Reverse ONLY the array of words.
+    const reversedWords = words.reverse();
+    // 5. Stitch the reversed words and original spaces back together.
+    let result = '';
+    const startsWithSpace = /^\s/.test(str);
+    if (startsWithSpace) {
+        // If the string starts with a space, the pattern is: space, word, space, word...
+        for (let i = 0; i < reversedWords.length; i++) {
+            result += spaces[i] + reversedWords[i];
+        }
+        // Append any final trailing space block.
+        if (spaces.length > reversedWords.length) {
+            result += spaces[spaces.length - 1];
+        }
+    }
+    else {
+        // If the string starts with a word, the pattern is: word, space, word, space...
+        for (let i = 0; i < reversedWords.length; i++) {
+            result += reversedWords[i];
+            if (spaces[i]) {
+                result += spaces[i];
+            }
+        }
+    }
+    return result;
+}