stringzy 3.0.0 → 4.1.0

package/dist/analyzing/characterCount.d.ts

@@ -1 +1,20 @@
+/**
+ * Returns the number of characters in a given string.
+ *
+ * This function counts all characters in the string, including whitespace,
+ * punctuation, and special characters. It throws a `TypeError` if the input is not a string.
+ *
+ * @param {string} str - The string whose characters will be counted.
+ * @returns {number} The number of characters in the input string.
+ * @throws {TypeError} If the input is not of type string.
+ *
+ * @example
+ * characterCount("Hello, world!"); // 13
+ *
+ * @example
+ * characterCount("  ");            // 2
+ *
+ * @example
+ * characterCount("");              // 0
+ */
 export declare function characterCount(str: string): number;

package/dist/analyzing/characterCount.js

@@ -1,9 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.characterCount = characterCount;
+/**
+ * Returns the number of characters in a given string.
+ *
+ * This function counts all characters in the string, including whitespace,
+ * punctuation, and special characters. It throws a `TypeError` if the input is not a string.
+ *
+ * @param {string} str - The string whose characters will be counted.
+ * @returns {number} The number of characters in the input string.
+ * @throws {TypeError} If the input is not of type string.
+ *
+ * @example
+ * characterCount("Hello, world!"); // 13
+ *
+ * @example
+ * characterCount("  ");            // 2
+ *
+ * @example
+ * characterCount("");              // 0
+ */
 function characterCount(str) {
-    if (typeof str !== "string") {
-        throw new TypeError("Input must be a string");
+    if (typeof str !== 'string') {
+        throw new TypeError('Input must be a string');
     }
     return str.length;
 }

package/dist/analyzing/characterFrequency.d.ts

@@ -1 +1,20 @@
+/**
+ * Calculates the frequency of each non-space character in a string.
+ *
+ * This function returns an object mapping each lowercase character (excluding spaces)
+ * to the number of times it appears in the input string. The input is case-insensitive,
+ * meaning 'A' and 'a' are treated the same. It throws a `TypeError` if the input is not a string.
+ *
+ * @param {string} str - The string to analyze.
+ * @returns {Record<string, number>} An object where keys are characters and values are their counts.
+ * @throws {TypeError} If the input is not a string.
+ *
+ * @example
+ * characterFrequency("Hello World");
+ * // Returns: { h: 1, e: 1, l: 3, o: 2, w: 1, r: 1, d: 1 }
+ *
+ * @example
+ * characterFrequency("AaBb");
+ * // Returns: { a: 2, b: 2 }
+ */
 export declare function characterFrequency(str: string): Record<string, number>;

package/dist/analyzing/characterFrequency.js

@@ -1,13 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.characterFrequency = characterFrequency;
+/**
+ * Calculates the frequency of each non-space character in a string.
+ *
+ * This function returns an object mapping each lowercase character (excluding spaces)
+ * to the number of times it appears in the input string. The input is case-insensitive,
+ * meaning 'A' and 'a' are treated the same. It throws a `TypeError` if the input is not a string.
+ *
+ * @param {string} str - The string to analyze.
+ * @returns {Record<string, number>} An object where keys are characters and values are their counts.
+ * @throws {TypeError} If the input is not a string.
+ *
+ * @example
+ * characterFrequency("Hello World");
+ * // Returns: { h: 1, e: 1, l: 3, o: 2, w: 1, r: 1, d: 1 }
+ *
+ * @example
+ * characterFrequency("AaBb");
+ * // Returns: { a: 2, b: 2 }
+ */
 function characterFrequency(str) {
-    if (typeof str !== "string") {
-        throw new TypeError("Input must be a string");
+    if (typeof str !== 'string') {
+        throw new TypeError('Input must be a string');
     }
     const frequency = {};
     for (const char of str.toLowerCase()) {
-        if (char !== " ") {
+        if (char !== ' ') {
             // Exclude spaces for cleaner analysis
             frequency[char] = (frequency[char] || 0) + 1;
         }

package/dist/analyzing/checkMultiplePatterns.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Finds occurrences of multiple patterns within a given text using Rabin–Karp algorithm.
+ *
+ * - Accepts an array of patterns.
+ * - Returns all matches of each pattern along with starting indices.
+ * - Handles hash collisions by verifying actual substrings.
+ * - Is case sensitive
+ *
+ * @param {string} text - The text to search within.
+ * @param {string[]} patterns - The array of patterns to search for.
+ * @returns {Record<string, number[]>} An object mapping each pattern to an array of match indices.
+ * @throws {TypeError} If input types are invalid.
+ */
+export declare function checkMultiplePatterns(text: string, patterns: string[]): Record<string, number[]>;

package/dist/analyzing/checkMultiplePatterns.js

@@ -0,0 +1,63 @@
+"use strict";
+/**
+ * Finds occurrences of multiple patterns within a given text using Rabin–Karp algorithm.
+ *
+ * - Accepts an array of patterns.
+ * - Returns all matches of each pattern along with starting indices.
+ * - Handles hash collisions by verifying actual substrings.
+ * - Is case sensitive
+ *
+ * @param {string} text - The text to search within.
+ * @param {string[]} patterns - The array of patterns to search for.
+ * @returns {Record<string, number[]>} An object mapping each pattern to an array of match indices.
+ * @throws {TypeError} If input types are invalid.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkMultiplePatterns = checkMultiplePatterns;
+function checkMultiplePatterns(text, patterns) {
+    if (typeof text !== 'string') {
+        throw new TypeError('Text must be a string');
+    }
+    if (!Array.isArray(patterns) || !patterns.every(p => typeof p === 'string')) {
+        throw new TypeError('Patterns must be an array of strings');
+    }
+    const result = {};
+    if (text.length === 0 || patterns.length === 0) {
+        return result;
+    }
+    const prime = 101; // A prime base for hashing
+    const getHash = (str, m) => {
+        let h = 0;
+        for (let i = 0; i < m; i++) {
+            h = (h * 256 + str.charCodeAt(i)) % prime;
+        }
+        return h;
+    };
+    const recomputeHash = (oldHash, dropped, added, m) => {
+        let h = (oldHash - dropped.charCodeAt(0) * Math.pow(256, m - 1)) % prime;
+        h = (h * 256 + added.charCodeAt(0)) % prime;
+        if (h < 0)
+            h += prime;
+        return h;
+    };
+    for (const pattern of patterns) {
+        const m = pattern.length;
+        result[pattern] = [];
+        if (m === 0 || m > text.length)
+            continue;
+        const patternHash = getHash(pattern, m);
+        let windowHash = getHash(text, m);
+        for (let i = 0; i <= text.length - m; i++) {
+            if (patternHash === windowHash) {
+                // Verify to avoid collision false positives
+                if (text.slice(i, i + m) === pattern) {
+                    result[pattern].push(i);
+                }
+            }
+            if (i < text.length - m) {
+                windowHash = recomputeHash(windowHash, text[i], text[i + m], m);
+            }
+        }
+    }
+    return result;
+}

package/dist/analyzing/checkSubsequence.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Checks whether the second string is a subsequence of the first string.
+ *
+ * A subsequence means all characters of the second string appear in the first string
+ * in the same relative order, but not necessarily consecutively.
+ *
+ * Is case sensitive
+ *
+ * @param {string} str1 - The string to check against.
+ * @param {string} str2 - The candidate subsequence.
+ * @returns {boolean} True if str2 is a subsequence of str1, otherwise false.
+ * @throws {TypeError} If either input is not a string.
+ */
+export declare function checkSubsequence(str1: string, str2: string): boolean;

package/dist/analyzing/checkSubsequence.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkSubsequence = checkSubsequence;
+/**
+ * Checks whether the second string is a subsequence of the first string.
+ *
+ * A subsequence means all characters of the second string appear in the first string
+ * in the same relative order, but not necessarily consecutively.
+ *
+ * Is case sensitive
+ *
+ * @param {string} str1 - The string to check against.
+ * @param {string} str2 - The candidate subsequence.
+ * @returns {boolean} True if str2 is a subsequence of str1, otherwise false.
+ * @throws {TypeError} If either input is not a string.
+ */
+function checkSubsequence(str1, str2) {
+    if (typeof str1 !== "string" || typeof str2 !== "string") {
+        throw new TypeError("Both inputs must be strings");
+    }
+    // empty subsequence is always valid
+    if (str2 === "")
+        return true;
+    let i = 0; // pointer for str2 (the subsequence)
+    let j = 0; // pointer for str1 (the main string)
+    while (i < str2.length && j < str1.length) {
+        if (str2[i] === str1[j]) {
+            i++;
+        }
+        j++;
+    }
+    return i === str2.length;
+}

package/dist/analyzing/complexity.d.ts

@@ -3,4 +3,37 @@ export type ComplexityResult = {
     uniqueness: number;
     length: number;
 };
+/**
+ * Evaluates the complexity of a given string based on length, character uniqueness,
+ * and character type diversity (lowercase, uppercase, numbers, symbols).
+ *
+ * The returned score ranges from 0 to 1, where a higher score indicates greater complexity.
+ * It also returns the raw length of the string and its uniqueness ratio (unique chars / total length).
+ *
+ * - `uniqueness`: Measures how varied the characters are.
+ * - `score`: Combines uniqueness, type diversity, and length into a weighted value.
+ * - `length`: The total number of characters in the input.
+ *
+ * Throws a `TypeError` if the input is not a string.
+ *
+ * @param {string} str - The input string to evaluate.
+ * @returns {ComplexityResult} An object containing `score`, `uniqueness`, and `length`.
+ * @throws {TypeError} If the input is not a string.
+ *
+ * @example
+ * complexity("abcABC123!");
+ * // {
+ * //   score: 0.93,
+ * //   uniqueness: 1.00,
+ * //   length: 10
+ * // }
+ *
+ * @example
+ * complexity("aaaa");
+ * // {
+ * //   score: 0.25,
+ * //   uniqueness: 0.25,
+ * //   length: 4
+ * // }
+ */
 export declare function complexity(str: string): ComplexityResult;

package/dist/analyzing/complexity.js

@@ -1,11 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.complexity = complexity;
+/**
+ * Evaluates the complexity of a given string based on length, character uniqueness,
+ * and character type diversity (lowercase, uppercase, numbers, symbols).
+ *
+ * The returned score ranges from 0 to 1, where a higher score indicates greater complexity.
+ * It also returns the raw length of the string and its uniqueness ratio (unique chars / total length).
+ *
+ * - `uniqueness`: Measures how varied the characters are.
+ * - `score`: Combines uniqueness, type diversity, and length into a weighted value.
+ * - `length`: The total number of characters in the input.
+ *
+ * Throws a `TypeError` if the input is not a string.
+ *
+ * @param {string} str - The input string to evaluate.
+ * @returns {ComplexityResult} An object containing `score`, `uniqueness`, and `length`.
+ * @throws {TypeError} If the input is not a string.
+ *
+ * @example
+ * complexity("abcABC123!");
+ * // {
+ * //   score: 0.93,
+ * //   uniqueness: 1.00,
+ * //   length: 10
+ * // }
+ *
+ * @example
+ * complexity("aaaa");
+ * // {
+ * //   score: 0.25,
+ * //   uniqueness: 0.25,
+ * //   length: 4
+ * // }
+ */
 function complexity(str) {
     if (!str)
         return { score: 0, uniqueness: 0, length: 0 };
-    if (typeof str !== "string") {
-        throw new TypeError("Input must be a string");
+    if (typeof str !== 'string') {
+        throw new TypeError('Input must be a string');
     }
     const length = str.length;
     const unique = new Set(str).size;

package/dist/analyzing/contentWordCount.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Counts the number of content words in a given text.
+ *
+ * Content words are words that carry lexical meaning (nouns, verbs, adjectives, adverbs),
+ * excluding function words such as prepositions, pronouns, and articles.
+ *
+ * @param {string} text - The text to analyze.
+ * @returns {number} The count of content words in the text.
+ * @throws {TypeError} If the input is not a string.
+ */
+export declare function contentWordCount(text: string): number;

package/dist/analyzing/contentWordCount.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contentWordCount = contentWordCount;
+const functionWordCount_1 = require("./functionWordCount");
+const wordCount_1 = require("./wordCount");
+/**
+ * Counts the number of content words in a given text.
+ *
+ * Content words are words that carry lexical meaning (nouns, verbs, adjectives, adverbs),
+ * excluding function words such as prepositions, pronouns, and articles.
+ *
+ * @param {string} text - The text to analyze.
+ * @returns {number} The count of content words in the text.
+ * @throws {TypeError} If the input is not a string.
+ */
+function contentWordCount(text) {
+    if (typeof text !== 'string') {
+        throw new TypeError('Input must be a string');
+    }
+    const totalWords = (0, wordCount_1.wordCount)(text);
+    const functionWords = (0, functionWordCount_1.functionWordCount)(text);
+    return totalWords - functionWords;
+}

package/dist/analyzing/functionWordCount.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Counts the number of function words in a given text.
+ *
+ * Function words are common words (e.g., prepositions, pronouns, conjunctions, articles, etc.)
+ * that carry grammatical meaning rather than lexical meaning.
+ *
+ * @param {string} text - The text to analyze.
+ * @returns {number} The count of function words in the text.
+ * @throws {TypeError} If the input is not a string.
+ */
+export declare function functionWordCount(text: string): number;

package/dist/analyzing/functionWordCount.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.functionWordCount = functionWordCount;
+/**
+ * Counts the number of function words in a given text.
+ *
+ * Function words are common words (e.g., prepositions, pronouns, conjunctions, articles, etc.)
+ * that carry grammatical meaning rather than lexical meaning.
+ *
+ * @param {string} text - The text to analyze.
+ * @returns {number} The count of function words in the text.
+ * @throws {TypeError} If the input is not a string.
+ */
+function functionWordCount(text) {
+    if (typeof text !== 'string') {
+        throw new TypeError('Input must be a string');
+    }
+    const functionWords = new Set([
+        'a', 'an', 'the', 'and', 'but', 'or', 'nor', 'so', 'yet',
+        'for', 'of', 'in', 'on', 'at', 'by', 'to', 'from', 'with', 'about',
+        'as', 'into', 'like', 'through', 'after', 'over', 'between', 'out',
+        'against', 'during', 'without', 'before', 'under', 'around', 'among',
+        'is', 'am', 'are', 'was', 'were', 'be', 'been', 'being',
+        'he', 'she', 'it', 'they', 'we', 'you', 'i', 'me', 'him', 'her',
+        'them', 'us', 'my', 'your', 'his', 'their', 'our',
+        'this', 'that', 'these', 'those',
+        'who', 'whom', 'which', 'what', 'when', 'where', 'why', 'how'
+    ]);
+    // ✅ Normalize text: lowercase + remove punctuation
+    const cleanedText = text.toLowerCase().replace(/[^\w\s]/g, '');
+    const words = cleanedText.trim().split(/\s+/);
+    return words.filter(word => functionWords.has(word)).length;
+}

package/dist/analyzing/index.d.ts

@@ -1,15 +1,27 @@
-export { characterCount } from "./characterCount";
-export { characterFrequency } from "./characterFrequency";
-export { complexity } from "./complexity";
-export { readingDuration } from "./readingDuration";
-export { wordCount } from "./wordCount";
-export { stringSimilarity } from "./stringSimilarity";
-import { characterCount } from "./characterCount";
-import { characterFrequency } from "./characterFrequency";
-import { complexity } from "./complexity";
-import { readingDuration } from "./readingDuration";
-import { wordCount } from "./wordCount";
-import { stringSimilarity } from "./stringSimilarity";
+export { characterCount } from './characterCount';
+export { characterFrequency } from './characterFrequency';
+export { complexity } from './complexity';
+export { readingDuration } from './readingDuration';
+export { wordCount } from './wordCount';
+export { stringSimilarity } from './stringSimilarity';
+export { patternCount } from './patternCount';
+export { vowelConsonantCount } from './vowelConsonantCount';
+export { checkMultiplePatterns } from './checkMultiplePatterns';
+export { checkSubsequence } from './checkSubsequence';
+export { functionWordCount } from './functionWordCount';
+export { contentWordCount } from './contentWordCount';
+export { checkStringRotations } from './stringRotation';
+import { characterCount } from './characterCount';
+import { characterFrequency } from './characterFrequency';
+import { complexity } from './complexity';
+import { readingDuration } from './readingDuration';
+import { wordCount } from './wordCount';
+import { stringSimilarity } from './stringSimilarity';
+import { patternCount } from './patternCount';
+import { vowelConsonantCount } from './vowelConsonantCount';
+import { checkMultiplePatterns } from './checkMultiplePatterns';
+import { checkSubsequence } from './checkSubsequence';
+import { checkStringRotations } from './stringRotation';
 export declare const analyzing: {
     characterCount: typeof characterCount;
     characterFrequency: typeof characterFrequency;
@@ -17,4 +29,9 @@ export declare const analyzing: {
     readingDuration: typeof readingDuration;
     wordCount: typeof wordCount;
     stringSimilarity: typeof stringSimilarity;
+    patternCount: typeof patternCount;
+    vowelConsonantCount: typeof vowelConsonantCount;
+    checkMultiplePatterns: typeof checkMultiplePatterns;
+    checkSubsequence: typeof checkSubsequence;
+    checkStringRotations: typeof checkStringRotations;
 };

package/dist/analyzing/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.analyzing = exports.stringSimilarity = exports.wordCount = exports.readingDuration = exports.complexity = exports.characterFrequency = exports.characterCount = void 0;
+exports.analyzing = exports.checkStringRotations = exports.contentWordCount = exports.functionWordCount = exports.checkSubsequence = exports.checkMultiplePatterns = exports.vowelConsonantCount = exports.patternCount = exports.stringSimilarity = exports.wordCount = exports.readingDuration = exports.complexity = exports.characterFrequency = exports.characterCount = void 0;
 var characterCount_1 = require("./characterCount");
 Object.defineProperty(exports, "characterCount", { enumerable: true, get: function () { return characterCount_1.characterCount; } });
 var characterFrequency_1 = require("./characterFrequency");
@@ -13,17 +13,41 @@ var wordCount_1 = require("./wordCount");
 Object.defineProperty(exports, "wordCount", { enumerable: true, get: function () { return wordCount_1.wordCount; } });
 var stringSimilarity_1 = require("./stringSimilarity");
 Object.defineProperty(exports, "stringSimilarity", { enumerable: true, get: function () { return stringSimilarity_1.stringSimilarity; } });
+var patternCount_1 = require("./patternCount");
+Object.defineProperty(exports, "patternCount", { enumerable: true, get: function () { return patternCount_1.patternCount; } });
+var vowelConsonantCount_1 = require("./vowelConsonantCount");
+Object.defineProperty(exports, "vowelConsonantCount", { enumerable: true, get: function () { return vowelConsonantCount_1.vowelConsonantCount; } });
+var checkMultiplePatterns_1 = require("./checkMultiplePatterns");
+Object.defineProperty(exports, "checkMultiplePatterns", { enumerable: true, get: function () { return checkMultiplePatterns_1.checkMultiplePatterns; } });
+var checkSubsequence_1 = require("./checkSubsequence");
+Object.defineProperty(exports, "checkSubsequence", { enumerable: true, get: function () { return checkSubsequence_1.checkSubsequence; } });
+var functionWordCount_1 = require("./functionWordCount");
+Object.defineProperty(exports, "functionWordCount", { enumerable: true, get: function () { return functionWordCount_1.functionWordCount; } });
+var contentWordCount_1 = require("./contentWordCount");
+Object.defineProperty(exports, "contentWordCount", { enumerable: true, get: function () { return contentWordCount_1.contentWordCount; } });
+var stringRotation_1 = require("./stringRotation");
+Object.defineProperty(exports, "checkStringRotations", { enumerable: true, get: function () { return stringRotation_1.checkStringRotations; } });
 const characterCount_2 = require("./characterCount");
 const characterFrequency_2 = require("./characterFrequency");
 const complexity_2 = require("./complexity");
 const readingDuration_2 = require("./readingDuration");
 const wordCount_2 = require("./wordCount");
 const stringSimilarity_2 = require("./stringSimilarity");
+const patternCount_2 = require("./patternCount");
+const vowelConsonantCount_2 = require("./vowelConsonantCount");
+const checkMultiplePatterns_2 = require("./checkMultiplePatterns");
+const checkSubsequence_2 = require("./checkSubsequence");
+const stringRotation_2 = require("./stringRotation");
 exports.analyzing = {
     characterCount: characterCount_2.characterCount,
     characterFrequency: characterFrequency_2.characterFrequency,
     complexity: complexity_2.complexity,
     readingDuration: readingDuration_2.readingDuration,
     wordCount: wordCount_2.wordCount,
-    stringSimilarity: stringSimilarity_2.stringSimilarity
+    stringSimilarity: stringSimilarity_2.stringSimilarity,
+    patternCount: patternCount_2.patternCount,
+    vowelConsonantCount: vowelConsonantCount_2.vowelConsonantCount,
+    checkMultiplePatterns: checkMultiplePatterns_2.checkMultiplePatterns,
+    checkSubsequence: checkSubsequence_2.checkSubsequence,
+    checkStringRotations: stringRotation_2.checkStringRotations
 };

package/dist/analyzing/patternCount.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Counts the number of times a specific pattern occurs in a given text,
+ * including overlapping occurrences.
+ *
+ * Uses the Knuth-Morris-Pratt (KMP) pattern matching algorithm for efficient searching.
+ *
+ * @param text - The text to search within
+ * @param pattern - The pattern to count
+ * @returns The number of times the pattern occurs (including overlapping)
+ */
+export declare function patternCount(text: string, pattern: string): number;

package/dist/analyzing/patternCount.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patternCount = patternCount;
+/**
+ * Counts the number of times a specific pattern occurs in a given text,
+ * including overlapping occurrences.
+ *
+ * Uses the Knuth-Morris-Pratt (KMP) pattern matching algorithm for efficient searching.
+ *
+ * @param text - The text to search within
+ * @param pattern - The pattern to count
+ * @returns The number of times the pattern occurs (including overlapping)
+ */
+function patternCount(text, pattern) {
+    if (!pattern)
+        return 0; // Return 0 for empty pattern
+    const prefixFunction = computePrefixFunction(pattern);
+    let count = 0;
+    let j = 0; // Index for pattern
+    for (let i = 0; i < text.length; i++) {
+        while (j > 0 && text[i] !== pattern[j]) {
+            j = prefixFunction[j - 1]; // fallback in pattern
+        }
+        if (text[i] === pattern[j])
+            j++;
+        if (j === pattern.length) {
+            count++;
+            j = prefixFunction[j - 1]; // allow overlapping matches
+        }
+    }
+    return count;
+}
+/**
+ * Computes the prefix function (partial match table) for KMP algorithm.
+ *
+ * The prefix function stores the length of the longest proper prefix
+ * which is also a suffix for each prefix of the pattern.
+ *
+ * @param pattern - Pattern string
+ * @returns Array of prefix lengths
+ */
+function computePrefixFunction(pattern) {
+    const prefixFunction = new Array(pattern.length).fill(0);
+    let j = 0;
+    for (let i = 1; i < pattern.length; i++) {
+        while (j > 0 && pattern[i] !== pattern[j]) {
+            j = prefixFunction[j - 1]; // fallback
+        }
+        if (pattern[i] === pattern[j])
+            j++;
+        prefixFunction[i] = j;
+    }
+    return prefixFunction;
+}

package/dist/analyzing/stringRotation.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Checks if one string is a rotation of another.
+ *
+ * A string `str2` is a rotation of `str1` if it can be obtained by shifting
+ * the characters of `str1` in a circular fashion.
+ *
+ * The check is case-sensitive and supports special characters and numbers.
+ *
+ * @param {string} str1 - The original string.
+ * @param {string} str2 - The string to check if it is a rotation of str1.
+ * @returns {boolean} True if str2 is a rotation of str1, otherwise false.
+ * @throws {TypeError} If either input is not a string.
+ *
+ * @example
+ * checkStringRotations("abcd", "cdab"); // true
+ *
+ * @example
+ * checkStringRotations("abc", "acb"); // false
+ *
+ * @example
+ * checkStringRotations("hello", "ohell"); // true
+ *
+ * @example
+ * checkStringRotations("", ""); // true
+ *
+ * @example
+ * checkStringRotations("abc", "ab"); // false
+ */
+export declare function checkStringRotations(str1: string, str2: string): boolean;

package/dist/analyzing/stringRotation.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkStringRotations = checkStringRotations;
+/**
+ * Checks if one string is a rotation of another.
+ *
+ * A string `str2` is a rotation of `str1` if it can be obtained by shifting
+ * the characters of `str1` in a circular fashion.
+ *
+ * The check is case-sensitive and supports special characters and numbers.
+ *
+ * @param {string} str1 - The original string.
+ * @param {string} str2 - The string to check if it is a rotation of str1.
+ * @returns {boolean} True if str2 is a rotation of str1, otherwise false.
+ * @throws {TypeError} If either input is not a string.
+ *
+ * @example
+ * checkStringRotations("abcd", "cdab"); // true
+ *
+ * @example
+ * checkStringRotations("abc", "acb"); // false
+ *
+ * @example
+ * checkStringRotations("hello", "ohell"); // true
+ *
+ * @example
+ * checkStringRotations("", ""); // true
+ *
+ * @example
+ * checkStringRotations("abc", "ab"); // false
+ */
+function checkStringRotations(str1, str2) {
+    if (typeof str1 !== 'string' || typeof str2 !== 'string') {
+        throw new TypeError('Both inputs must be strings');
+    }
+    // Edge case: both empty strings
+    if (str1 === '' && str2 === '')
+        return true;
+    // If lengths differ, they cannot be rotations
+    if (str1.length !== str2.length)
+        return false;
+    // Concatenate str1 with itself and check if str2 is a substring
+    return (str1 + str1).includes(str2);
+}