stringzy 4.0.0 → 4.2.0

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, stringPermutationsGenerator } 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, stringPermutationsGenerator } from './stringPermutations';
+import { stringCombinations } from './stringCombinations';
 export declare const transformations: {
     camelCase: typeof camelCase;
     capitalizeWords: typeof capitalizeWords;
@@ -49,4 +55,8 @@ export declare const transformations: {
     maskSegment: typeof maskSegment;
     deburr: typeof deburr;
     numberToText: typeof numberToText;
+    reverseWordsInString: typeof reverseWordsInString;
+    stringPermutations: typeof stringPermutations;
+    stringPermutationsGenerator: typeof stringPermutationsGenerator;
+    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.stringPermutationsGenerator = 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,13 @@ 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; } });
+Object.defineProperty(exports, "stringPermutationsGenerator", { enumerable: true, get: function () { return stringPermutations_1.stringPermutationsGenerator; } });
+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 +57,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 +77,9 @@ 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,
+    stringPermutationsGenerator: stringPermutations_2.stringPermutationsGenerator,
+    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;
+}

package/dist/transformations/stringCombinations.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Generates all unique combinations (subsequences) of a given string,
+ * including the empty string.
+ *
+ * Handles duplicate characters by ensuring only unique combinations are returned.
+ * The order of combinations in the output array is not guaranteed.
+ *
+ * @param {string} str - The input string to generate combinations from.
+ * @returns {string[]} An array containing all unique combinations of the string.
+ * @throws {TypeError} If the input is not a string.
+ *
+ * @example
+ * stringCombinations("ab");
+ * // ["", "a", "b", "ab"]
+ *
+ * @example
+ * stringCombinations("abc");
+ * // ["", "a", "b", "c", "ab", "ac", "bc", "abc"]
+ *
+ * @example
+ * stringCombinations("aab");
+ * // ["", "a", "b", "aa", "ab", "aab"]
+ *
+ * @example
+ * stringCombinations("");
+ * // [""]
+ */
+export declare function stringCombinations(str: string): string[];

package/dist/transformations/stringCombinations.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringCombinations = stringCombinations;
+/**
+ * Generates all unique combinations (subsequences) of a given string,
+ * including the empty string.
+ *
+ * Handles duplicate characters by ensuring only unique combinations are returned.
+ * The order of combinations in the output array is not guaranteed.
+ *
+ * @param {string} str - The input string to generate combinations from.
+ * @returns {string[]} An array containing all unique combinations of the string.
+ * @throws {TypeError} If the input is not a string.
+ *
+ * @example
+ * stringCombinations("ab");
+ * // ["", "a", "b", "ab"]
+ *
+ * @example
+ * stringCombinations("abc");
+ * // ["", "a", "b", "c", "ab", "ac", "bc", "abc"]
+ *
+ * @example
+ * stringCombinations("aab");
+ * // ["", "a", "b", "aa", "ab", "aab"]
+ *
+ * @example
+ * stringCombinations("");
+ * // [""]
+ */
+function stringCombinations(str) {
+    if (typeof str !== 'string') {
+        throw new TypeError('Input must be a string');
+    }
+    const results = new Set();
+    function backtrack(start, path) {
+        results.add(path);
+        for (let i = start; i < str.length; i++) {
+            backtrack(i + 1, path + str[i]);
+        }
+    }
+    backtrack(0, '');
+    return Array.from(results);
+}

package/dist/transformations/stringPermutations.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Generates all unique permutations of a given string.
+ *
+ * Handles repeated characters by ensuring only unique permutations
+ * are included in the result. The order of permutations is not guaranteed.
+ *
+ * Performance optimized version using iterative approach and efficient
+ * character frequency tracking to avoid duplicate permutations.
+ *
+ * @param {string} str - The input string to generate permutations for.
+ * @param {number} [limit] - Optional limit on number of permutations to generate.
+ * @returns {string[]} An array of unique permutations of the input string.
+ * @throws {TypeError} If the input is not a string.
+ * @throws {RangeError} If limit is negative.
+ *
+ * @example
+ * stringPermutations("ab");
+ * // ["ab", "ba"]
+ *
+ * @example
+ * stringPermutations("abc");
+ * // ["abc", "acb", "bac", "bca", "cab", "cba"]
+ *
+ * @example
+ * stringPermutations("aab");
+ * // ["aab", "aba", "baa"]
+ *
+ * @example
+ * stringPermutations("abcdef", 10);
+ * // Returns first 10 permutations
+ *
+ * @example
+ * stringPermutations("");
+ * // [""]
+ *
+ * @example
+ * stringPermutations("a");
+ * // ["a"]
+ */
+export declare function stringPermutations(str: string, limit?: number): string[];
+/**
+ * Generator function for permutations - yields permutations one at a time.
+ * This is the most memory-efficient approach for very large strings.
+ *
+ * @param {string} str - The input string to generate permutations for.
+ * @yields {string} Each unique permutation.
+ *
+ * @example
+ * for (const perm of stringPermutationsGenerator("abc")) {
+ *   console.log(perm);
+ * }
+ */
+export declare function stringPermutationsGenerator(str: string): Generator<string, void, unknown>;

package/dist/transformations/stringPermutations.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringPermutations = stringPermutations;
+exports.stringPermutationsGenerator = stringPermutationsGenerator;
+/**
+ * Generates all unique permutations of a given string.
+ *
+ * Handles repeated characters by ensuring only unique permutations
+ * are included in the result. The order of permutations is not guaranteed.
+ *
+ * Performance optimized version using iterative approach and efficient
+ * character frequency tracking to avoid duplicate permutations.
+ *
+ * @param {string} str - The input string to generate permutations for.
+ * @param {number} [limit] - Optional limit on number of permutations to generate.
+ * @returns {string[]} An array of unique permutations of the input string.
+ * @throws {TypeError} If the input is not a string.
+ * @throws {RangeError} If limit is negative.
+ *
+ * @example
+ * stringPermutations("ab");
+ * // ["ab", "ba"]
+ *
+ * @example
+ * stringPermutations("abc");
+ * // ["abc", "acb", "bac", "bca", "cab", "cba"]
+ *
+ * @example
+ * stringPermutations("aab");
+ * // ["aab", "aba", "baa"]
+ *
+ * @example
+ * stringPermutations("abcdef", 10);
+ * // Returns first 10 permutations
+ *
+ * @example
+ * stringPermutations("");
+ * // [""]
+ *
+ * @example
+ * stringPermutations("a");
+ * // ["a"]
+ */
+function stringPermutations(str, limit) {
+    if (typeof str !== 'string') {
+        throw new TypeError('Input must be a string');
+    }
+    if (limit !== undefined && limit < 0) {
+        throw new RangeError('Limit must be non-negative');
+    }
+    if (str.length === 0)
+        return [''];
+    // For small strings, use the original approach for simplicity
+    if (str.length <= 6) {
+        return generatePermutationsSmall(str, limit);
+    }
+    // For larger strings, use optimized approach
+    return generatePermutationsOptimized(str, limit);
+}
+/**
+ * Generates permutations for small strings (≤6 characters) using recursive approach.
+ * This is more memory efficient for small inputs.
+ */
+function generatePermutationsSmall(str, limit) {
+    const results = new Set();
+    let count = 0;
+    const permute = (prefix, remaining) => {
+        if (limit !== undefined && count >= limit)
+            return;
+        if (remaining.length === 0) {
+            results.add(prefix);
+            count++;
+        }
+        else {
+            for (let i = 0; i < remaining.length; i++) {
+                if (limit !== undefined && count >= limit)
+                    break;
+                permute(prefix + remaining[i], remaining.slice(0, i) + remaining.slice(i + 1));
+            }
+        }
+    };
+    permute('', str);
+    return Array.from(results);
+}
+/**
+ * Generates permutations for larger strings using optimized iterative approach.
+ * Uses character frequency tracking to avoid duplicate permutations efficiently.
+ */
+function generatePermutationsOptimized(str, limit) {
+    // Count character frequencies
+    const charCount = new Map();
+    for (const char of str) {
+        charCount.set(char, (charCount.get(char) || 0) + 1);
+    }
+    const results = [];
+    const chars = Array.from(charCount.keys());
+    const counts = chars.map(char => charCount.get(char));
+    // Use iterative approach with stack to avoid recursion
+    const stack = [{
+            permutation: '',
+            remainingCounts: [...counts],
+            depth: 0
+        }];
+    while (stack.length > 0) {
+        if (limit !== undefined && results.length >= limit)
+            break;
+        const current = stack.pop();
+        if (current.depth === str.length) {
+            results.push(current.permutation);
+            continue;
+        }
+        // Generate next level permutations
+        for (let i = 0; i < chars.length; i++) {
+            if (current.remainingCounts[i] > 0) {
+                const newCounts = [...current.remainingCounts];
+                newCounts[i]--;
+                stack.push({
+                    permutation: current.permutation + chars[i],
+                    remainingCounts: newCounts,
+                    depth: current.depth + 1
+                });
+            }
+        }
+    }
+    return results;
+}
+/**
+ * Generator function for permutations - yields permutations one at a time.
+ * This is the most memory-efficient approach for very large strings.
+ *
+ * @param {string} str - The input string to generate permutations for.
+ * @yields {string} Each unique permutation.
+ *
+ * @example
+ * for (const perm of stringPermutationsGenerator("abc")) {
+ *   console.log(perm);
+ * }
+ */
+function* stringPermutationsGenerator(str) {
+    if (typeof str !== 'string') {
+        throw new TypeError('Input must be a string');
+    }
+    if (str.length === 0) {
+        yield '';
+        return;
+    }
+    // Count character frequencies
+    const charCount = new Map();
+    for (const char of str) {
+        charCount.set(char, (charCount.get(char) || 0) + 1);
+    }
+    const chars = Array.from(charCount.keys());
+    const counts = chars.map(char => charCount.get(char));
+    // Use iterative approach with stack
+    const stack = [{
+            permutation: '',
+            remainingCounts: [...counts],
+            depth: 0
+        }];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (current.depth === str.length) {
+            yield current.permutation;
+            continue;
+        }
+        // Generate next level permutations
+        for (let i = 0; i < chars.length; i++) {
+            if (current.remainingCounts[i] > 0) {
+                const newCounts = [...current.remainingCounts];
+                newCounts[i]--;
+                stack.push({
+                    permutation: current.permutation + chars[i],
+                    remainingCounts: newCounts,
+                    depth: current.depth + 1
+                });
+            }
+        }
+    }
+}

package/dist/validations/index.d.ts

@@ -5,8 +5,16 @@ export { isEmpty } from './isEmpty';
 export { isSlug } from './isSlug';
 export { isURL } from './isURL';
 export { isIPv4 } from './isIPv4';
+export { isIPv6 } from './isIPv6';
 export { isHexColor } from './isHexColor';
 export { isPalindrome } from './isPalindrome';
+export { isLowerCase } from './isLowerCase';
+export { isUpperCase } from './isUpperCase';
+export { isAlphabetic } from './isAlphabetic';
+export { isAlphaNumeric } from './isAlphaNumeric';
+export { isAnagram } from './isAnagram';
+export { isPanagram } from './isPanagram';
+export { isMacAddress } from './isMacAddress';
 import { isCoordinates } from './isCoordinates';
 import { isDate } from './isDate';
 import { isEmail } from './isEmail';
@@ -14,8 +22,16 @@ import { isEmpty } from './isEmpty';
 import { isSlug } from './isSlug';
 import { isURL } from './isURL';
 import { isIPv4 } from './isIPv4';
+import { isIPv6 } from './isIPv6';
 import { isHexColor } from './isHexColor';
 import { isPalindrome } from './isPalindrome';
+import { isLowerCase } from './isLowerCase';
+import { isUpperCase } from './isUpperCase';
+import { isAlphabetic } from './isAlphabetic';
+import { isAlphaNumeric } from './isAlphaNumeric';
+import { isAnagram } from './isAnagram';
+import { isPanagram } from './isPanagram';
+import { isMacAddress } from './isMacAddress';
 export declare const validations: {
     isCoordinates: typeof isCoordinates;
     isDate: typeof isDate;
@@ -24,6 +40,14 @@ export declare const validations: {
     isSlug: typeof isSlug;
     isURL: typeof isURL;
     isIPv4: typeof isIPv4;
+    isIPv6: typeof isIPv6;
     isHexColor: typeof isHexColor;
     isPalindrome: typeof isPalindrome;
+    isLowerCase: typeof isLowerCase;
+    isUpperCase: typeof isUpperCase;
+    isAlphabetic: typeof isAlphabetic;
+    isAlphaNumeric: typeof isAlphaNumeric;
+    isAnagram: typeof isAnagram;
+    isPanagram: typeof isPanagram;
+    isMacAddress: typeof isMacAddress;
 };

package/dist/validations/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validations = exports.isPalindrome = exports.isHexColor = exports.isIPv4 = exports.isURL = exports.isSlug = exports.isEmpty = exports.isEmail = exports.isDate = exports.isCoordinates = void 0;
+exports.validations = exports.isMacAddress = exports.isPanagram = exports.isAnagram = exports.isAlphaNumeric = exports.isAlphabetic = exports.isUpperCase = exports.isLowerCase = exports.isPalindrome = exports.isHexColor = exports.isIPv6 = exports.isIPv4 = exports.isURL = exports.isSlug = exports.isEmpty = exports.isEmail = exports.isDate = exports.isCoordinates = void 0;
 var isCoordinates_1 = require("./isCoordinates");
 Object.defineProperty(exports, "isCoordinates", { enumerable: true, get: function () { return isCoordinates_1.isCoordinates; } });
 var isDate_1 = require("./isDate");
@@ -15,10 +15,26 @@ var isURL_1 = require("./isURL");
 Object.defineProperty(exports, "isURL", { enumerable: true, get: function () { return isURL_1.isURL; } });
 var isIPv4_1 = require("./isIPv4");
 Object.defineProperty(exports, "isIPv4", { enumerable: true, get: function () { return isIPv4_1.isIPv4; } });
+var isIPv6_1 = require("./isIPv6");
+Object.defineProperty(exports, "isIPv6", { enumerable: true, get: function () { return isIPv6_1.isIPv6; } });
 var isHexColor_1 = require("./isHexColor");
 Object.defineProperty(exports, "isHexColor", { enumerable: true, get: function () { return isHexColor_1.isHexColor; } });
 var isPalindrome_1 = require("./isPalindrome");
 Object.defineProperty(exports, "isPalindrome", { enumerable: true, get: function () { return isPalindrome_1.isPalindrome; } });
+var isLowerCase_1 = require("./isLowerCase");
+Object.defineProperty(exports, "isLowerCase", { enumerable: true, get: function () { return isLowerCase_1.isLowerCase; } });
+var isUpperCase_1 = require("./isUpperCase");
+Object.defineProperty(exports, "isUpperCase", { enumerable: true, get: function () { return isUpperCase_1.isUpperCase; } });
+var isAlphabetic_1 = require("./isAlphabetic");
+Object.defineProperty(exports, "isAlphabetic", { enumerable: true, get: function () { return isAlphabetic_1.isAlphabetic; } });
+var isAlphaNumeric_1 = require("./isAlphaNumeric");
+Object.defineProperty(exports, "isAlphaNumeric", { enumerable: true, get: function () { return isAlphaNumeric_1.isAlphaNumeric; } });
+var isAnagram_1 = require("./isAnagram");
+Object.defineProperty(exports, "isAnagram", { enumerable: true, get: function () { return isAnagram_1.isAnagram; } });
+var isPanagram_1 = require("./isPanagram");
+Object.defineProperty(exports, "isPanagram", { enumerable: true, get: function () { return isPanagram_1.isPanagram; } });
+var isMacAddress_1 = require("./isMacAddress");
+Object.defineProperty(exports, "isMacAddress", { enumerable: true, get: function () { return isMacAddress_1.isMacAddress; } });
 const isCoordinates_2 = require("./isCoordinates");
 const isDate_2 = require("./isDate");
 const isEmail_2 = require("./isEmail");
@@ -26,8 +42,16 @@ const isEmpty_2 = require("./isEmpty");
 const isSlug_2 = require("./isSlug");
 const isURL_2 = require("./isURL");
 const isIPv4_2 = require("./isIPv4");
+const isIPv6_2 = require("./isIPv6");
 const isHexColor_2 = require("./isHexColor");
 const isPalindrome_2 = require("./isPalindrome");
+const isLowerCase_2 = require("./isLowerCase");
+const isUpperCase_2 = require("./isUpperCase");
+const isAlphabetic_2 = require("./isAlphabetic");
+const isAlphaNumeric_2 = require("./isAlphaNumeric");
+const isAnagram_2 = require("./isAnagram");
+const isPanagram_2 = require("./isPanagram");
+const isMacAddress_2 = require("./isMacAddress");
 exports.validations = {
     isCoordinates: isCoordinates_2.isCoordinates,
     isDate: isDate_2.isDate,
@@ -36,6 +60,14 @@ exports.validations = {
     isSlug: isSlug_2.isSlug,
     isURL: isURL_2.isURL,
     isIPv4: isIPv4_2.isIPv4,
+    isIPv6: isIPv6_2.isIPv6,
     isHexColor: isHexColor_2.isHexColor,
-    isPalindrome: isPalindrome_2.isPalindrome
+    isPalindrome: isPalindrome_2.isPalindrome,
+    isLowerCase: isLowerCase_2.isLowerCase,
+    isUpperCase: isUpperCase_2.isUpperCase,
+    isAlphabetic: isAlphabetic_2.isAlphabetic,
+    isAlphaNumeric: isAlphaNumeric_2.isAlphaNumeric,
+    isAnagram: isAnagram_2.isAnagram,
+    isPanagram: isPanagram_2.isPanagram,
+    isMacAddress: isMacAddress_2.isMacAddress
 };

package/dist/validations/isAlphaNumeric.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Checks whether the given string is alphanumeric.
+ *
+ * The check ensures that the string contains only
+ * letters (a-z, A-Z) and digits (0-9).
+ *
+ * @param {string} str - The input string to check.
+ * @returns {boolean} True if the input is alphanumeric, false otherwise.
+ * @throws {TypeError} If the input is not a string.
+ */
+export declare function isAlphaNumeric(str: string): boolean;

package/dist/validations/isAlphaNumeric.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAlphaNumeric = isAlphaNumeric;
+/**
+ * Checks whether the given string is alphanumeric.
+ *
+ * The check ensures that the string contains only
+ * letters (a-z, A-Z) and digits (0-9).
+ *
+ * @param {string} str - The input string to check.
+ * @returns {boolean} True if the input is alphanumeric, false otherwise.
+ * @throws {TypeError} If the input is not a string.
+ */
+function isAlphaNumeric(str) {
+    if (typeof str !== 'string') {
+        throw new TypeError('Input must be a string');
+    }
+    if (str.length === 0) {
+        return false;
+    }
+    return /^[a-z0-9]+$/i.test(str);
+}

package/dist/validations/isAlphabetic.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Checks whether a given string contains only alphabetic characters (A-Z, a-z).
+ *
+ *
+ * @param {string} str - The input string to check.
+ * @returns {boolean} True if the input contains only alphabetic characters, otherwise false.
+ * @throws {TypeError} If the input is not a string.
+ */
+export declare function isAlphabetic(str: string): boolean;

package/dist/validations/isAlphabetic.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAlphabetic = isAlphabetic;
+/**
+ * Checks whether a given string contains only alphabetic characters (A-Z, a-z).
+ *
+ *
+ * @param {string} str - The input string to check.
+ * @returns {boolean} True if the input contains only alphabetic characters, otherwise false.
+ * @throws {TypeError} If the input is not a string.
+ */
+function isAlphabetic(str) {
+    if (typeof str !== 'string') {
+        throw new TypeError('Input must be a string');
+    }
+    // empty string is not considered alphabetic
+    if (str === '')
+        return false;
+    // Regular expression to match only alphabetic characters
+    return /^[A-Za-z]+$/.test(str);
+}

package/dist/validations/isAnagram.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Checks whether two strings are anagrams of each other.
+ *
+ * Rules:
+ * - Comparison is case-insensitive.
+ * - Spaces and punctuation are ignored.
+ *
+ * @param {string} str1 - The first input string.
+ * @param {string} str2 - The second input string.
+ * @returns {boolean} True if the inputs are anagrams, otherwise false.
+ * @throws {TypeError} If either input is not a string.
+ */
+export declare function isAnagram(str1: string, str2: string): boolean;

package/dist/validations/isAnagram.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAnagram = isAnagram;
+/**
+ * Checks whether two strings are anagrams of each other.
+ *
+ * Rules:
+ * - Comparison is case-insensitive.
+ * - Spaces and punctuation are ignored.
+ *
+ * @param {string} str1 - The first input string.
+ * @param {string} str2 - The second input string.
+ * @returns {boolean} True if the inputs are anagrams, otherwise false.
+ * @throws {TypeError} If either input is not a string.
+ */
+function isAnagram(str1, str2) {
+    if (typeof str1 !== 'string' || typeof str2 !== 'string') {
+        throw new TypeError('Both inputs must be strings');
+    }
+    // Normalize: lowercase, remove spaces & punctuation
+    const normalize = (str) => str.toLowerCase().replace(/[^a-z0-9]/g, '').split('').sort().join('');
+    return normalize(str1) === normalize(str2);
+}