stringzy 4.0.0 → 4.1.0

package/README.md

@@ -1,7 +1,6 @@
 <div align="center">
 
-
-  ![Stringzy banner](./assets/stringzy-banner2.jpg)
+![Stringzy banner](./assets/stringzy-banner2.jpg)
 
 ![NPM Version](https://img.shields.io/npm/v/stringzy)
 ![Typescript](https://img.shields.io/badge/TypeScript-3178C6?style=flat&logo=typescript&logoColor=white)
@@ -80,6 +79,9 @@ const count = stringzy.analyze.wordCount('Hello world'); // 2
 - [deburr](#deburr) – Removes accents and diacritical marks from a string
 - [splitChunks](#splitchunks) - Breaks a string down into chunks of specified length.
 - [numberToText](#numbertotext) - Converts a number to its text representation in specified language
+- [reverseWordsInString](#reversewordsinstring) - Reverses the order of words in a given string
+- [stringPermutations](#stringpermutations) -  Generates all unique permutations of a given string.
+- [stringCombinations](#stringcombinations) -  Generates all unique combinations of a given string.
 
 ### Validations
 
@@ -93,19 +95,29 @@ const count = stringzy.analyze.wordCount('Hello world'); // 2
 - [isHexColor](#ishexcolor) - Checks if the input string is a valid hex color
 - [isPalindrome](#ispalindrome) - Checks if the input string is a palindrome (ignores case, spaces, and punctuation)
 - [isCoordinates](#iscoordinates) - Checks if given latitude and longitude are valid coordinates
+- [isLowerCase](#islowercase) - Checks if given string only has lower case characters.
+- [isUpperCase](#isuppercase) - Checks if given string only has upper case characters.
+- [isAlphabetic](#isalphabetic) - Checks if input string contains only Alphabets (case insensitive)
+- [isAlphaNumeric](#isalphanumeric) - Checks if input string contains only Alphabets and Digits (case insensitive)
+- [isAnagram](#isanagram)- Checks if both strings are anagrams of each other. (ignores case and punctuations)
+- [isMacAddress](#ismacaddress)- Checks if a given string is a valid MAC address.
+- [isPanagram](#ispanagram)- Checks if a given string is a pangram (contains every letter of the English alphabet at least once).
 
 ### Analysis
 
 - [wordCount](#wordcount) - Counts the number of words in a string
+- [contentWordCount](#contentwordcount)- Counts the number of content words (nouns, verbs, adjectives, adverbs, etc.) in a string.
+- [functionWordCount](#functionwordcount)- Counts the number of function words (prepositions, pronouns, conjunctions, articles, etc.) in a string.
 - [readingDuration](#readingduration) - Calculates the reading duration of a given string
 - [characterCount](#charactercount) - Counts the number of characters in a string
 - [characterFrequency](#characterfrequency) - Analyzes character frequency in a string
 - [stringSimilarity](#stringsimilarity) - Calculates the percentage similarity between two strings
 - [complexity](#complexity) - Analyzes string complexity including score, uniqueness, and length
 - [patternCount](#patterncount) - calculates the number of times a specific pattern occurs in a given text
-- [vowelConsonantCount](#vowelconsonantcount) - Counts the number of vowels and consonants in a given string 
-
-
+- [vowelConsonantCount](#vowelconsonantcount) - Counts the number of vowels and consonants in a given string
+- [checkMultiplePatterns](#checkmultiplepatterns) - Finds occurrences of multiple patterns within a given text using Rabin–Karp algorithm (case sensitive)
+- [checkSubsequence](#checksubsequence) - Checks whether the second string is a subsequence of the first string (case sensitive)
+- [stringRotation](#stringrotation) -  Checks if one string is a rotation of another (case sensitive).
 ### Formatting
 
 - [capitalize](#capitalize) - Capitalizes the first letter of each word
@@ -413,7 +425,7 @@ maskSegment('token');
 | maskEnd   | number | `text.length` | The end index (exclusive) of the segment to mask         |
 | maskChar  | string | `'*'`         | The character to use for masking (must be one character) |
 
-#### <a id="deburr"></a>deburr(text)
+#### <a id="deburr"></a>`deburr(text)`
 
 Removes accents and diacritics from letters in a string (e.g. déjà vu → deja vu).
 
@@ -459,7 +471,9 @@ splitChunks('helloworld');
 | chunkSize | number | `1`      | The size of each chunk in which the string is to be split |
 
 ---
+
 #### <a id="numbertotext"></a>`numberToText(num, lang)`
+
 Converts a number to its text representation in the specified language.
 
 ```javascript
@@ -469,13 +483,93 @@ numberToText(12345, 'en'); // Returns: 'twelve thousand three hundred forty-five
 numberToText(12345, 'pl'); // Returns: 'dwanaście tysięcy trzysta czterdzieści pięć'
 ```
 
-| Parameter | Type   | Default | Description |
-|-----------|--------|---------|-------------|
-| num       | number | required | The number to convert to text |
-| lang      | string | 'en'    | The language code for the text representation (e.g., 'en' for English, 'pl' for Polish) |
+| Parameter | Type   | Default  | Description                                                                             |
+| --------- | ------ | -------- | --------------------------------------------------------------------------------------- |
+| num       | number | required | The number to convert to text                                                           |
+| lang      | string | 'en'     | The language code for the text representation (e.g., 'en' for English, 'pl' for Polish) |
 
 Available languages: en (English), pl (Polish).
 
+#### <a id="reversewordsinstring"></a>`reverseWordsInString(str)`
+Reverses the order of words in a string and reverses the position of surrounding whitespace (leading becomes trailing and vice-versa). 
+Reverses the order of words in a string while preserving the exact original spacing between each word.
+```javascript
+import { reverseWordsInString } from 'stringzy';
+
+reverseWordsInString('Hello   world from stringzy');
+// Returns: 'stringzy from world   Hello'
+
+// Note how the double and triple spaces are preserved:
+reverseWordsInString('  leading  spaces   and trailing  ');
+// Returns: '  trailing  and   spaces leading  '
+
+reverseWordsInString('single-word');
+// Returns: 'single-word'
+```
+| Parameter | Type   | Default  | Description                 |
+| --------- | ------ | -------- | --------------------------- |
+| str       | string | required | The input string to reverse |
+
+#### <a id="stringpermutations"></a>`stringPermutations(str)`
+
+Generates all unique permutations of a given string.
+Repeated characters are handled by ensuring only unique permutations are included in the output array.
+The order of permutations is not guaranteed.
+
+```javascript
+stringPermutations('ab');
+// ['ab', 'ba']
+
+stringPermutations('abc');
+// ['abc', 'acb', 'bac', 'bca', 'cab', 'cba']
+
+stringPermutations('aab');
+// ['aab', 'aba', 'baa']
+
+stringPermutations('');
+// ['']
+
+stringPermutations('a');
+// ['a']
+
+stringPermutations('a1!');
+// ['a1!', 'a!1', '1a!', '1!a', '!a1', '!1a']
+```
+
+| Parameter | Type   | Default  | Description                                           |
+| --------- | ------ | -------- | ----------------------------------------------------- |
+| str       | string | required | The input string to generate all unique permutations. |
+
+#### <a id="stringcombinations"></a>`stringCombinations(str)`
+
+Generates all unique combinations (subsequences) of a given string, including the empty string.  
+Duplicate characters are handled by ensuring only unique combinations are returned.  
+The order of combinations in the output array is not guaranteed.
+
+```javascript
+stringCombinations('ab');
+// ["", "a", "b", "ab"]
+
+stringCombinations('abc');
+// ["", "a", "b", "c", "ab", "ac", "bc", "abc"]
+
+stringCombinations('aab');
+// ["", "a", "b", "aa", "ab", "aab"]
+
+stringCombinations('');
+// [""]
+
+stringCombinations('A');
+// ["", "A"]
+
+stringCombinations('!@');
+// ["", "!", "@", "!@"]
+```
+
+| Parameter | Type   | Default  | Description                                            |
+| --------- | ------ | -------- | ------------------------------------------------------ |
+| str       | string | required | The input string to generate unique combinations from. |
+
 
 ### ✅ Validations
 
@@ -563,19 +657,18 @@ isSlug('hello_world'); // false (underscore not allowed)
 Checks if a file or URL has a valid extension for a given type
 
 ```javascript
-isType("photo.PNG", "image");                    // true
-isType("https://example.com/logo.svg", "image"); // true
-isType({ name: "track.mp3" }, "audio");          // true
-isType("filewithoutextension", "image");         // false
-isType("document.zip", "document");              // false
-isType("video.mp4", "document");                 // false
+isType('photo.PNG', 'image'); // true
+isType('https://example.com/logo.svg', 'image'); // true
+isType({ name: 'track.mp3' }, 'audio'); // true
+isType('filewithoutextension', 'image'); // false
+isType('document.zip', 'document'); // false
+isType('video.mp4', 'document'); // false
 ```
 
-| Parameter | Type | Default | Description |
-|-----------|------|---------|-------------|
-| input | string | required | The file name, URL string, or object with .name |
-| input | string | required | The file type category to validate (image, video, audio, document, archive) |
-
+| Parameter | Type   | Default  | Description                                                                 |
+| --------- | ------ | -------- | --------------------------------------------------------------------------- |
+| input     | string | required | The file name, URL string, or object with .name                             |
+| input     | string | required | The file type category to validate (image, video, audio, document, archive) |
 
 #### <a id="isipv4"></a>`isIPv4(text)`
 
@@ -623,11 +716,11 @@ The check is case-insensitive and ignores spaces and punctuation.
 ```javascript
 import { isPalindrome } from 'stringzy';
 
-isPalindrome('racecar');                            // true
-isPalindrome('A man, a plan, a canal: Panama');     // true
-isPalindrome('No lemon, no melon');                 // true
-isPalindrome('hello');                              // false
-isPalindrome('Was it a car or a cat I saw?');       // true
+isPalindrome('racecar'); // true
+isPalindrome('A man, a plan, a canal: Panama'); // true
+isPalindrome('No lemon, no melon'); // true
+isPalindrome('hello'); // false
+isPalindrome('Was it a car or a cat I saw?'); // true
 ```
 
 | Parameter | Type   | Default  | Description                              |
@@ -646,12 +739,158 @@ isCoordinates(40.748817, -73.985428); // true
 isCoordinates(9999, -9999); // false
 ```
 
-| Parameter | Type        | Default  | Description                               |
-| --------- | ----------- | -------- | ----------------------------------------- |
-| latitude  | number      | required | Latitude to validate                      |
-| longitude | number      | required | Longitude to validate                     |
+| Parameter | Type   | Default  | Description           |
+| --------- | ------ | -------- | --------------------- |
+| latitude  | number | required | Latitude to validate  |
+| longitude | number | required | Longitude to validate |
+
+#### <a id="islowercase"></a>`isLowerCase(str)`
+
+Checks whether the given string contains only lowercase alphabetic characters.
+Ignores digits, special characters, white spaces.
+
+```javascript
+import { isLowerCase } from 'stringzy';
+
+isLowerCase('hello');      // true
+isLowerCase('hello123!');  // true
+isLowerCase('Hello');      // false
+isLowerCase('12345');      // false
+```
+
+| Parameter | Type   | Default  | Description                                                                  |
+| --------- | ------ | -------- | ---------------------------------------------------------------------------- |
+| str       | string | required | The input string to validate as containing lowercase alphabetic letters |
+
+#### <a id="isuppercase"></a>`isUpperCase(str)`
+
+Checks whether the given string contains only uppercase alphabetic characters.
+Ignores digits, special characters, white spaces.
+
+```javascript
+import { isUpperCase } from 'stringzy';
+
+isUpperCase('HELLO');      // true
+isUpperCase('HELLO123!');  // true
+isUpperCase('Hello');      // false
+isUpperCase('12345');      // false
+```
+
+| Parameter | Type   | Default  | Description                                                                  |
+| --------- | ------ | -------- | ---------------------------------------------------------------------------- |
+| str       | string | required | The input string to validate as containing uppercase alphabetic letters |
+
+#### <a id="isalphabetic"></a>`isAlphabetic(text)`
+
+Checks if a string contains only alphabetic characters (a-z, A-Z).
+Throws an error if the input is not a string.
+
+```javascript
+import { isAlphabetic } from 'stringzy';
+
+isAlphabetic('hello'); // true
+isAlphabetic('World'); // true
+isAlphabetic('helloWORLD'); // true
+isAlphabetic('abc123'); // false
+isAlphabetic('hello!'); // false
+isAlphabetic(''); // false
+```
+
+| Parameter | Type   | Default  | Description                                   |
+| --------- | ------ | -------- | --------------------------------------------- |
+| text      | string | required | The input string to check for alphabetic only |
+
+#### <a id="isalphanumeric"></a>`isAlphaNumeric(text)`
+
+Checks if a string contains only alphanumeric characters (letters and digits).
+Throws an error if the input is not a string.
+
+```javascript
+import { isAlphaNumeric } from 'stringzy';
+
+isAlphaNumeric('abc123'); // true
+isAlphaNumeric('A1B2C3'); // true
+isAlphaNumeric('123'); // true
+isAlphaNumeric('hello'); // true
+isAlphaNumeric('hello!'); // false
+isAlphaNumeric('123 456'); // false
+isAlphaNumeric(''); // false
+```
+
+| Parameter | Type   | Default  | Description                                     |
+| --------- | ------ | -------- | ----------------------------------------------- |
+| text      | string | required | The input string to check for alphanumeric only |
+
+#### <a id="isanagram"></a>`isAnagram(str1, str2)`
+
+Checks whether two strings are anagrams of each other (contain the same characters in the same frequency, regardless of order).  
+- Comparison is case-insensitive.  
+- Spaces and punctuation are ignored.  
+- Throws an error if either input is not a string.  
+
+```javascript
+import { isAnagram } from 'stringzy';
+
+isAnagram('listen', 'silent');       // true
+isAnagram('Debit Card', 'Bad Credit'); // true
+isAnagram('Astronomer', 'Moon starer'); // true
+isAnagram('hello', 'world');         // false
+isAnagram('a', 'b');                 // false
+isAnagram('', '');                   // true
+```
+
+| Parameter | Type   | Default  | Description                              |
+| --------- | ------ | -------- | ---------------------------------------- |
+| str1      | string | required | The first string to check as an anagram  |
+| str2      | string | required | The second string to check as an anagram |
+
+#### <a id="ismacaddress"></a>`isMacAddress(str)`
+
+Checks whether a given string is a valid **MAC address**.
+- A valid MAC address consists of six pairs of hexadecimal digits (`0–9`, `A–F`, case-insensitive).
+- Returns `true` if the string is a valid MAC address, otherwise `false`.
+- Throws an error if input is not a string.
+
+```javascript
+import { isMacAddress } from 'stringzy';
+
+isMacAddress("00:1A:2B:3C:4D:5E");   // true
+isMacAddress("00-1A-2B-3C-4D-5E");   // true
+isMacAddress("aa:bb:cc:dd:ee:ff");   // true
+isMacAddress("FF-FF-FF-FF-FF-FF");   // true
+
+isMacAddress("00:1G:2B:3C:4D:5E");   // false (invalid hex digit)
+isMacAddress("00:1A-2B:3C-4D:5E");   // false (mixed separators)
+isMacAddress("001A:2B:3C:4D:5E");    // false (wrong group length)
+isMacAddress("hello-world-mac");     // false (invalid format)
+isMacAddress("");                    // false (empty string)
+```
+
+| Parameter | Type   | Default  | Description                             |
+| --------- | ------ | -------- | --------------------------------------- |
+| str       | string | required | The string to validate as a MAC address |
+
+#### <a id="ispanagram"></a>`isPangram(str)`
+
+- Checks if a given string is a **pangram** (i.e., contains every letter of the English alphabet at least once).
+- The check is **case-insensitive**, and non-alphabetic characters (numbers, punctuation, spaces) are ignored. An empty string is not considered a pangram.
+- Throws an error if the input is not a string.
 
+```javascript
+import { isPangram } from 'stringzy';
+
+isPangram("The quick brown fox jumps over the lazy dog."); // true
+isPangram("This is not a pangram."); // false
+isPangram("Abcdefghijklmnopqrstuvwxyz"); // true
+isPangram("AbCdEfGhIjKlMnOpQrStUvWxYz"); // true
+isPangram("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
+isPangram(""); // false
+isPangram("Hello world"); // false
+```
 
+| Parameter | Type   | Default  | Description                                           |
+| --------- | ------ | -------- | ----------------------------------------------------- |
+| str       | string | required | The input string to check for pangram characteristics |
 ---
 
 ### 📊 Analysis
@@ -741,8 +980,6 @@ stringSimilarity('flaw', 'lawn', 'Damerau-Levenshtein'); // Returns: 50
 | textB     | string | required      | The second text to compare.                                   |
 | algorithm | string | 'Levenshtein' | The algorithm to use: 'Levenshtein' or 'Damerau-Levenshtein'. |
 
-
-
 #### <a id="complexity"></a>`complexity(text)`
 
 Analyzes the complexity of a string, returning an object with detailed metrics.
@@ -770,7 +1007,60 @@ complexity('');
 - `uniqueness` (number): Measure of character uniqueness
 - `length` (number): Length of the input string
 
+feature/content-words
+
+#### <a id="contentwordcount"></a>`contentWordCount(text)`
+
+Counts the number of content words (nouns, verbs, adjectives, adverbs, etc.) in a string.
+
+```javascript
+
+import { contentWordCount } from 'stringzy';
+
+contentWordCount("Learning JavaScript improves coding skills!");
+// Returns: { count: 5 }
+
+contentWordCount("The cat sleeps on the warm windowsill.");
+// Returns: { count: 5 }
 
+contentWordCount("Wow! Such a beautiful day.");
+// Returns: { count: 4 }
+```
+
+| Parameter | Type   | Default  | Description                            |
+| --------- | ------ | -------- | -------------------------------------- |
+| text      | string | required | The input string to analyze content words |
+
+**Returns:** An object containing:
+
+- `count` (number): Total number of content words in the string
+
+
+#### <a id="functionwordcount"></a>`functionWordCount(text)`
+
+Counts the number of function words (prepositions, pronouns, conjunctions, articles, etc.) in a string.
+
+```javascript
+
+import { functionWordCount } from 'stringzy';
+
+functionWordCount("She and I are going to the park.");
+// Returns: { count: 7 }
+
+functionWordCount("It is an example of proper grammar usage.");
+// Returns: { count: 8 }
+
+functionWordCount("Can you see the stars tonight?");
+// Returns: { count: 5 }
+```
+
+| Parameter | Type   | Default  | Description                            |
+| --------- | ------ | -------- | -------------------------------------- |
+| text      | string | required | The input string to analyze function words |
+
+**Returns:** An object containing:
+
+- `count` (number): Total number of function words in the string
 
 #### <a id="patterncount"></a>`patternCount(text, pattern)`
 
@@ -795,7 +1085,7 @@ Counts the number of vowels and consonants in a given string.
 This function is case-insensitive and ignores non-alphabetic characters.
 
 ```javascript
-vowelConsonantCount('hello'); 
+vowelConsonantCount('hello');
 // { vowels: 2, consonants: 3 }
 
 vowelConsonantCount('stringzy');
@@ -809,6 +1099,95 @@ vowelConsonantCount('');
 | --------- | ------ | -------- | -------------------------------------------------- |
 | str       | string | required | The input string to count vowels and consonants in |
 
+feature/content-words
+
+#### <a id="checkmultiplepatterns"></a>`checkMultiplePatterns(text, patterns)`
+
+Finds occurrences of multiple patterns within a given text using the Rabin–Karp algorithm. <br>
+Accepts an array of patterns.<br>
+Returns all matches of each pattern along with starting indices.<br>
+Handles hash collisions by verifying actual substrings.<br>
+Pattern matching is case sensitive.
+
+```javascript
+checkMultiplePatterns('abracadabra', ['abra', 'cad']);
+// { abra: [0, 7], cad: [4] }
+
+checkMultiplePatterns('aaaa', ['aa', 'aaa']);
+// { aa: [0, 1, 2], aaa: [0, 1] }
+
+checkMultiplePatterns('hello world', ['xyz', '123']);
+// { xyz: [], 123: [] }
+```
+| Parameter | Type      | Default  | Description                                                 |
+| --------- | --------- | -------- | ----------------------------------------------------------- |
+| text      | string    | required | The text to search within.                                  |
+| patterns  | string\[ ] | required | An array of patterns to search for (each must be a string). |
+
+#### <a id="checksubsequence"></a>`checkSubsequence(str, sub)`
+
+Checks whether a given string sub is a subsequence of another string str.
+A subsequence maintains the relative order of characters, but they do not need to be consecutive.
+Case-sensitive comparison is performed.
+Spaces and all characters are treated literally.
+
+```javascript
+isSubsequence('abcde', 'ace');
+// true  → 'a', 'c', 'e' appear in order
+
+isSubsequence('abracadabra', 'aaa');
+// true  → multiple 'a's in correct order
+
+isSubsequence('abcde', 'aec');
+// false → order is broken (e comes before c)
+
+isSubsequence('anything', '');
+// true  → empty subsequence is always valid
+
+isSubsequence('AbC', 'AC');
+// true  → exact case matches
+
+isSubsequence('a b c', 'abc');
+// false → spaces count as characters
+```
+| Parameter | Type   | Default  | Description                                     |
+| --------- | ------ | -------- | ----------------------------------------------- |
+| str       | string | required | The main string to check within.                |
+| sub       | string | required | The subsequence string to verify against `str`. |
+
+#### <a id="stringrotation"></a>`checkStringRotations(str1, str2)`
+Checks whether a given string `str2` is a rotation of another string `str1`.
+Case-sensitive comparison is performed. Both strings must be of equal length to be considered rotations.
+Spaces and all characters are treated literally.
+
+```javascript
+isRotation('waterbottle', 'erbottlewat');
+// true  → rotation at position 3
+
+isRotation('abcde', 'cdeab');
+// true  → rotation at position 2
+
+isRotation('abc', 'abc');
+// true  → no rotation, identical strings
+
+isRotation('abc', 'cab');
+// true  → rotation at position 2
+
+isRotation('abc', 'bac');
+// false → not a valid rotation
+
+isRotation('ArB', 'Bar');
+// false → case-sensitive mismatch
+
+isRotation('abcd', 'abc');
+// false → lengths differ
+```
+
+| Parameter | Type   | Default  | Description                                         |
+| --------- | ------ | -------- | --------------------------------------------------- |
+| str1      | string | required | The original string.                                |
+| str2      | string | required | The string to verify if it is a rotation of `str1`. |
+
 ---
 
 ### 🎨 Formatting
@@ -1158,13 +1537,45 @@ Contributions are welcome! Please read our [contribution guidelines](CONTRIBUTIN
         <td align="center">
                 <a href="https://github.com/milendrakumarbaghel">
                     <img src="https://avatars.githubusercontent.com/milendrakumarbaghel" width="100px;"
-                        alt="Mariam Hasan" />
+                        alt="Milendra Kumar Baghel" />
                     <br />
                     <sub>
                         <b>Milendra Kumar Baghel</b>
                     </sub>
                 </a>
             </td>
+        <td align="center">
+                <a href="https://github.com/Farkhanda-Dalal">
+                    <img src="https://avatars.githubusercontent.com/Farkhanda-Dalal" width="100px;"
+                        alt="Farkhanda Dalal" />
+                    <br />
+                    <sub>
+                        <b>Farkhanda Dalal</b>
+                    </sub>
+                </a>
+            </td>
+        <td align="center">
+                <a href="https://github.com/S">
+                    <img src="https://avatars.githubusercontent.com/satyasrisundarapalli" width="100px;"
+                        alt="Sundarapalli Lakshmi Satya Sri" />
+                    <br />
+                    <sub>
+                        <b>Sundarapalli Lakshmi Satya Sri</b>
+                    </sub>
+                </a>
+            </td>
+      </tr>
+      <tr>
+         <td align="center">
+                <a href="https://github.com/S">
+                    <img src="https://avatars.githubusercontent.com/itspavant" width="100px;"
+                        alt="T Pavan Teja" />
+                    <br />
+                    <sub>
+                        <b>T Pavan Teja</b>
+                    </sub>
+                </a>
+            </td>
       </tr>
     </tbody>
 </table>

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;
+}