stringzy 4.0.0 → 4.1.0

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/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

@@ -6,6 +6,11 @@ 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';
@@ -14,6 +19,9 @@ 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;
@@ -23,4 +31,7 @@ export declare const analyzing: {
     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.vowelConsonantCount = exports.patternCount = 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");
@@ -17,6 +17,16 @@ 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");
@@ -25,6 +35,9 @@ 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,
@@ -33,5 +46,8 @@ exports.analyzing = {
     wordCount: wordCount_2.wordCount,
     stringSimilarity: stringSimilarity_2.stringSimilarity,
     patternCount: patternCount_2.patternCount,
-    vowelConsonantCount: vowelConsonantCount_2.vowelConsonantCount
+    vowelConsonantCount: vowelConsonantCount_2.vowelConsonantCount,
+    checkMultiplePatterns: checkMultiplePatterns_2.checkMultiplePatterns,
+    checkSubsequence: checkSubsequence_2.checkSubsequence,
+    checkStringRotations: stringRotation_2.checkStringRotations
 };

package/dist/analyzing/patternCount.d.ts

@@ -1,10 +1,11 @@
 /**
- * Calculates the number of times a specific pattern occurs in a given text, including overlapping occurrences
+ * Counts the number of times a specific pattern occurs in a given text,
+ * including overlapping occurrences.
  *
- * The algorithm used here is based on the Knuth-Morris-Pratt (KMP) pattern matching algorithm for better performance
+ * Uses the Knuth-Morris-Pratt (KMP) pattern matching algorithm for efficient searching.
  *
- * @param {string} text - The text for which we want to count the occurrences of a specific pattern.
- * @param {string} pattern - The pattern to search for within the text.
- * @returns {number} - The number of times the pattern occurs in the text (overlapping).
+ * @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

@@ -2,50 +2,52 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.patternCount = patternCount;
 /**
- * Calculates the number of times a specific pattern occurs in a given text, including overlapping occurrences
+ * Counts the number of times a specific pattern occurs in a given text,
+ * including overlapping occurrences.
  *
- * The algorithm used here is based on the Knuth-Morris-Pratt (KMP) pattern matching algorithm for better performance
+ * Uses the Knuth-Morris-Pratt (KMP) pattern matching algorithm for efficient searching.
  *
- * @param {string} text - The text for which we want to count the occurrences of a specific pattern.
- * @param {string} pattern - The pattern to search for within the text.
- * @returns {number} - The number of times the pattern occurs in the text (overlapping).
+ * @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.length === 0) {
-        return 0; // No pattern to search for
-    }
+    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];
+            j = prefixFunction[j - 1]; // fallback in pattern
         }
-        if (text[i] === pattern[j]) {
+        if (text[i] === pattern[j])
             j++;
-        }
         if (j === pattern.length) {
             count++;
-            j = prefixFunction[j - 1]; // Allow for overlapping matches
+            j = prefixFunction[j - 1]; // allow overlapping matches
         }
     }
     return count;
 }
 /**
  * Computes the prefix function (partial match table) for KMP algorithm.
- * @param {string} pattern - The pattern string.
- * @returns {number[]} - The prefix function array.
+ *
+ * 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];
+            j = prefixFunction[j - 1]; // fallback
         }
-        if (pattern[i] === pattern[j]) {
+        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);
+}

package/dist/index.d.ts

@@ -12,6 +12,9 @@ declare const _default: {
         stringSimilarity: typeof import("./analyzing").stringSimilarity;
         patternCount: typeof import("./analyzing").patternCount;
         vowelConsonantCount: typeof import("./analyzing").vowelConsonantCount;
+        checkMultiplePatterns: typeof import("./analyzing").checkMultiplePatterns;
+        checkSubsequence: typeof import("./analyzing").checkSubsequence;
+        checkStringRotations: typeof import("./analyzing").checkStringRotations;
     };
     formatting: {
         capitalize: typeof import("./formatting").capitalize;
@@ -36,6 +39,9 @@ declare const _default: {
         maskSegment: typeof import("./transformations").maskSegment;
         deburr: typeof import("./transformations/deburr").deburr;
         numberToText: typeof import("./transformations").numberToText;
+        reverseWordsInString: typeof import("./transformations").reverseWordsInString;
+        stringPermutations: typeof import("./transformations").stringPermutations;
+        stringCombinations: typeof import("./transformations").stringCombinations;
     };
     validations: {
         isCoordinates: typeof import("./validations").isCoordinates;
@@ -47,6 +53,13 @@ declare const _default: {
         isIPv4: typeof import("./validations").isIPv4;
         isHexColor: typeof import("./validations").isHexColor;
         isPalindrome: typeof import("./validations").isPalindrome;
+        isLowerCase: typeof import("./validations").isLowerCase;
+        isUpperCase: typeof import("./validations").isUpperCase;
+        isAlphabetic: typeof import("./validations").isAlphabetic;
+        isAlphaNumeric: typeof import("./validations").isAlphaNumeric;
+        isAnagram: typeof import("./validations").isAnagram;
+        isPanagram: typeof import("./validations").isPanagram;
+        isMacAddress: typeof import("./validations").isMacAddress;
     };
 };
 export default _default;

package/dist/tests/analyzing/checkMultiplePatterns.test.d.ts

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

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

@@ -0,0 +1,81 @@
+"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 checkMultiplePatterns_1 = require("../../analyzing/checkMultiplePatterns");
+(0, node_test_1.describe)('checkMultiplePatterns', () => {
+    (0, node_test_1.it)('finds multiple valid matches', () => {
+        const text = 'abracadabra';
+        const patterns = ['abra', 'cad'];
+        const result = (0, checkMultiplePatterns_1.checkMultiplePatterns)(text, patterns);
+        // "abra" occurs at index 0: "abra...cadabra"
+        // and again at index 7: "abracad...abra"
+        node_assert_1.default.deepStrictEqual(result['abra'], [0, 7]);
+        // "cad" occurs once starting at index 4: "abraCADabra"
+        node_assert_1.default.deepStrictEqual(result['cad'], [4]);
+    });
+    (0, node_test_1.it)('handles overlapping patterns', () => {
+        const text = 'aaaa';
+        const patterns = ['aa', 'aaa'];
+        const result = (0, checkMultiplePatterns_1.checkMultiplePatterns)(text, patterns);
+        // "aa" occurs at indices 0 ("aa.."), 1 (".aa."), 2 ("..aa")
+        node_assert_1.default.deepStrictEqual(result['aa'], [0, 1, 2]);
+        // "aaa" occurs at indices 0 ("aaa.") and 1 (".aaa")
+        node_assert_1.default.deepStrictEqual(result['aaa'], [0, 1]);
+    });
+    (0, node_test_1.it)('returns empty arrays when no matches found', () => {
+        const text = 'hello world';
+        const patterns = ['xyz', '123'];
+        const result = (0, checkMultiplePatterns_1.checkMultiplePatterns)(text, patterns);
+        // Neither "xyz" nor "123" exist in "hello world"
+        node_assert_1.default.deepStrictEqual(result['xyz'], []);
+        node_assert_1.default.deepStrictEqual(result['123'], []);
+    });
+    (0, node_test_1.it)('returns empty object when text is empty', () => {
+        // No text to search → nothing to return
+        const result = (0, checkMultiplePatterns_1.checkMultiplePatterns)('', ['a', 'b']);
+        node_assert_1.default.deepStrictEqual(result, {});
+    });
+    (0, node_test_1.it)('returns empty object when patterns array is empty', () => {
+        // No patterns given → nothing to search for
+        const result = (0, checkMultiplePatterns_1.checkMultiplePatterns)('hello', []);
+        node_assert_1.default.deepStrictEqual(result, {});
+    });
+    (0, node_test_1.it)('skips patterns longer than the text', () => {
+        const result = (0, checkMultiplePatterns_1.checkMultiplePatterns)('hi', ['longpattern']);
+        // pattern is longer than text → no match possible
+        node_assert_1.default.deepStrictEqual(result['longpattern'], []);
+    });
+    (0, node_test_1.it)('is case-sensitive by default', () => {
+        const text = 'Hello hello';
+        const patterns = ['Hello', 'hello'];
+        const result = (0, checkMultiplePatterns_1.checkMultiplePatterns)(text, patterns);
+        node_assert_1.default.deepStrictEqual(result['Hello'], [0]);
+        node_assert_1.default.deepStrictEqual(result['hello'], [6]);
+    });
+    (0, node_test_1.it)('handles spaces and special characters as part of patterns', () => {
+        const text = 'hi there!';
+        const patterns = [' ', '!'];
+        const result = (0, checkMultiplePatterns_1.checkMultiplePatterns)(text, patterns);
+        // space occurs at index 2, "!" occurs at the end
+        node_assert_1.default.deepStrictEqual(result[' '], [2]);
+        node_assert_1.default.deepStrictEqual(result['!'], [8]);
+    });
+    (0, node_test_1.it)('does not match mixed case unless exact', () => {
+        const text = 'RabinKarp';
+        const patterns = ['rabinkarp'];
+        const result = (0, checkMultiplePatterns_1.checkMultiplePatterns)(text, patterns);
+        // "rabinkarp" does not match "RabinKarp" because of case
+        node_assert_1.default.deepStrictEqual(result['rabinkarp'], []);
+    });
+    (0, node_test_1.it)('throws if text is not a string', () => {
+        node_assert_1.default.throws(() => (0, checkMultiplePatterns_1.checkMultiplePatterns)(123, ['a']), /Text must be a string/);
+    });
+    (0, node_test_1.it)('throws if patterns is not an array of strings', () => {
+        node_assert_1.default.throws(() => (0, checkMultiplePatterns_1.checkMultiplePatterns)('abc', 'a'), /Patterns must be an array of strings/);
+        node_assert_1.default.throws(() => (0, checkMultiplePatterns_1.checkMultiplePatterns)('abc', [123]), /Patterns must be an array of strings/);
+    });
+});

package/dist/tests/analyzing/checkSubsequence.test.d.ts

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

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

@@ -0,0 +1,34 @@
+"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 checkSubsequence_1 = require("../../analyzing/checkSubsequence");
+(0, node_test_1.describe)('checkSubsequence', () => {
+    (0, node_test_1.it)('returns true for valid subsequences', () => {
+        node_assert_1.default.strictEqual((0, checkSubsequence_1.checkSubsequence)('abcde', 'ace'), true);
+        node_assert_1.default.strictEqual((0, checkSubsequence_1.checkSubsequence)('abracadabra', 'aaa'), true);
+        node_assert_1.default.strictEqual((0, checkSubsequence_1.checkSubsequence)('hello world', 'hlo'), true);
+    });
+    (0, node_test_1.it)('returns false when order is broken', () => {
+        node_assert_1.default.strictEqual((0, checkSubsequence_1.checkSubsequence)('abcde', 'aec'), false);
+        node_assert_1.default.strictEqual((0, checkSubsequence_1.checkSubsequence)('abcdef', 'z'), false);
+    });
+    (0, node_test_1.it)('handles empty subsequence', () => {
+        node_assert_1.default.strictEqual((0, checkSubsequence_1.checkSubsequence)('anything', ''), true);
+    });
+    (0, node_test_1.it)('is case-sensitive', () => {
+        node_assert_1.default.strictEqual((0, checkSubsequence_1.checkSubsequence)('abc', 'A'), false);
+        node_assert_1.default.strictEqual((0, checkSubsequence_1.checkSubsequence)('AbC', 'AC'), true);
+    });
+    (0, node_test_1.it)('handles spaces as normal characters', () => {
+        node_assert_1.default.strictEqual((0, checkSubsequence_1.checkSubsequence)('a b c', 'abc'), true);
+        node_assert_1.default.strictEqual((0, checkSubsequence_1.checkSubsequence)('a b c', 'a c'), true);
+    });
+    (0, node_test_1.it)('throws if inputs are not strings', () => {
+        node_assert_1.default.throws(() => (0, checkSubsequence_1.checkSubsequence)(123, 'abc'), /Both inputs must be strings/);
+        node_assert_1.default.throws(() => (0, checkSubsequence_1.checkSubsequence)('abc', null), /Both inputs must be strings/);
+    });
+});

package/dist/tests/analyzing/contentWordCount.test.d.ts

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

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

@@ -0,0 +1,20 @@
+"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 = __importDefault(require("node:test"));
+const strict_1 = __importDefault(require("node:assert/strict"));
+const contentWordCount_js_1 = require("../../analyzing/contentWordCount.js");
+(0, node_test_1.default)("counts content words in a normal sentence", () => {
+    strict_1.default.equal((0, contentWordCount_js_1.contentWordCount)("This is a test of the system"), 2);
+});
+(0, node_test_1.default)("returns 0 when there are no content words", () => {
+    strict_1.default.equal((0, contentWordCount_js_1.contentWordCount)("is the at of"), 0);
+});
+(0, node_test_1.default)("ignores case and punctuation", () => {
+    strict_1.default.equal((0, contentWordCount_js_1.contentWordCount)("Elephants, ELEPHANTS, elephants!"), 3);
+});
+(0, node_test_1.default)("returns 0 for empty string", () => {
+    strict_1.default.equal((0, contentWordCount_js_1.contentWordCount)(""), 0);
+});

package/dist/tests/analyzing/functionWordCount.test.d.ts

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

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

@@ -0,0 +1,20 @@
+"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 = __importDefault(require("node:test"));
+const strict_1 = __importDefault(require("node:assert/strict"));
+const functionWordCount_js_1 = require("../../analyzing/functionWordCount.js");
+(0, node_test_1.default)("counts function words in a normal sentence", () => {
+    strict_1.default.equal((0, functionWordCount_js_1.functionWordCount)("This is a test of the system"), 5);
+});
+(0, node_test_1.default)("returns 0 when there are no function words", () => {
+    strict_1.default.equal((0, functionWordCount_js_1.functionWordCount)("Elephants run fast"), 0);
+});
+(0, node_test_1.default)("ignores case and punctuation", () => {
+    strict_1.default.equal((0, functionWordCount_js_1.functionWordCount)("The, THE, the!"), 3);
+});
+(0, node_test_1.default)("returns 0 for empty string", () => {
+    strict_1.default.equal((0, functionWordCount_js_1.functionWordCount)(""), 0);
+});

package/dist/tests/analyzing/stringRotation.test.d.ts

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

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

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const node_assert_1 = __importDefault(require("node:assert"));
+const stringRotation_1 = require("../../analyzing/stringRotation");
+(0, node_test_1.describe)('checkStringRotations', () => {
+    (0, node_test_1.it)('returns true for valid rotations', () => {
+        node_assert_1.default.strictEqual((0, stringRotation_1.checkStringRotations)('abcd', 'cdab'), true);
+        node_assert_1.default.strictEqual((0, stringRotation_1.checkStringRotations)('hello', 'ohell'), true);
+        node_assert_1.default.strictEqual((0, stringRotation_1.checkStringRotations)('12345', '45123'), true);
+        node_assert_1.default.strictEqual((0, stringRotation_1.checkStringRotations)('!@#$', '#$!@'), true);
+    });
+    (0, node_test_1.it)('returns false for invalid rotations', () => {
+        node_assert_1.default.strictEqual((0, stringRotation_1.checkStringRotations)('abc', 'acb'), false);
+        node_assert_1.default.strictEqual((0, stringRotation_1.checkStringRotations)('hello', 'helol'), false);
+        node_assert_1.default.strictEqual((0, stringRotation_1.checkStringRotations)('12345', '54321'), false);
+    });
+    (0, node_test_1.it)('is case-sensitive', () => {
+        node_assert_1.default.strictEqual((0, stringRotation_1.checkStringRotations)('ArB', 'Bar'), false);
+        node_assert_1.default.strictEqual((0, stringRotation_1.checkStringRotations)('Case', 'case'), false);
+        node_assert_1.default.strictEqual((0, stringRotation_1.checkStringRotations)('XYZ', 'yzx'), false);
+    });
+    (0, node_test_1.it)('returns true for empty strings', () => {
+        node_assert_1.default.strictEqual((0, stringRotation_1.checkStringRotations)('', ''), true);
+    });
+    (0, node_test_1.it)('returns false for strings of different lengths', () => {
+        node_assert_1.default.strictEqual((0, stringRotation_1.checkStringRotations)('abc', 'ab'), false);
+        node_assert_1.default.strictEqual((0, stringRotation_1.checkStringRotations)('abcd', ''), false);
+    });
+    (0, node_test_1.it)('handles special characters correctly', () => {
+        node_assert_1.default.strictEqual((0, stringRotation_1.checkStringRotations)('a@b$c', 'b$ca@'), true);
+        node_assert_1.default.strictEqual((0, stringRotation_1.checkStringRotations)('a@b$c', 'c$a@b'), false);
+    });
+    (0, node_test_1.it)('throws an error if inputs are not strings', () => {
+        node_assert_1.default.throws(() => (0, stringRotation_1.checkStringRotations)(123, '123'), /Both inputs must be strings/);
+        node_assert_1.default.throws(() => (0, stringRotation_1.checkStringRotations)('abc', null), /Both inputs must be strings/);
+        node_assert_1.default.throws(() => (0, stringRotation_1.checkStringRotations)(undefined, 'abc'), /Both inputs must be strings/);
+    });
+});

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

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