data-structure-typed 1.42.7 → 1.42.9

package/dist/mjs/src/data-structures/queue/queue.js

@@ -76,6 +76,13 @@ class Queue {
         return new Queue(elements);
     }
     /**
+     * Time Complexity: O(1) - constant time as it adds an element to the end of the array.
+     * Space Complexity: O(1) - no additional space is used.
+     */
+    /**
+     * Time Complexity: O(1) - constant time as it adds an element to the end of the array.
+     * Space Complexity: O(1) - no additional space is used.
+     *
      * The push function adds an element to the end of the queue and returns the updated queue.Adds an element at the back of the queue.
      * @param {E} element - The `element` parameter represents the element that you want to add to the queue.
      * @returns The `add` method is returning a `Queue<E>` object.
@@ -85,6 +92,13 @@ class Queue {
         return this;
     }
     /**
+     * Time Complexity: O(n) - where n is the number of elements in the queue. In the worst case, it may need to shift all elements to update the offset.
+     * Space Complexity: O(1) - no additional space is used.
+     */
+    /**
+     * Time Complexity: O(n) - where n is the number of elements in the queue. In the worst case, it may need to shift all elements to update the offset.
+     * Space Complexity: O(1) - no additional space is used.
+     *
      * The `shift` function removes and returns the first element in the queue, and adjusts the internal data structure if
      * necessary to optimize performance.
      * @returns The function `shift()` returns either the first element in the queue or `null` if the queue is empty.
@@ -103,6 +117,13 @@ class Queue {
         return first;
     }
     /**
+     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
+     * Space Complexity: O(1) - no additional space is used.
+     */
+    /**
+     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
+     * Space Complexity: O(1) - no additional space is used.
+     *
      * The `getFirst` function returns the first element of the array `_nodes` if it exists, otherwise it returns `null`.
      * @returns The `getFirst()` method returns the first element of the data structure, represented by the `_nodes` array at
      * the `_offset` index. If the data structure is empty (size is 0), it returns `null`.
@@ -111,6 +132,13 @@ class Queue {
         return this.size > 0 ? this.nodes[this.offset] : undefined;
     }
     /**
+     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
+     * Space Complexity: O(1) - no additional space is used.
+     */
+    /**
+     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
+     * Space Complexity: O(1) - no additional space is used.
+     *
      * The `peek` function returns the first element of the array `_nodes` if it exists, otherwise it returns `null`.
      * @returns The `peek()` method returns the first element of the data structure, represented by the `_nodes` array at
      * the `_offset` index. If the data structure is empty (size is 0), it returns `null`.
@@ -119,6 +147,13 @@ class Queue {
         return this.getFirst();
     }
     /**
+     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
+     * Space Complexity: O(1) - no additional space is used.
+     */
+    /**
+     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
+     * Space Complexity: O(1) - no additional space is used.
+     *
      * The `getLast` function returns the last element in an array-like data structure, or null if the structure is empty.
      * @returns The method `getLast()` returns the last element of the `_nodes` array if the array is not empty. If the
      * array is empty, it returns `null`.
@@ -127,6 +162,13 @@ class Queue {
         return this.size > 0 ? this.nodes[this.nodes.length - 1] : undefined;
     }
     /**
+     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
+     * Space Complexity: O(1) - no additional space is used.
+     */
+    /**
+     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
+     * Space Complexity: O(1) - no additional space is used.
+     *
      * The `peekLast` function returns the last element in an array-like data structure, or null if the structure is empty.
      * @returns The method `peekLast()` returns the last element of the `_nodes` array if the array is not empty. If the
      * array is empty, it returns `null`.
@@ -135,6 +177,13 @@ class Queue {
         return this.getLast();
     }
     /**
+     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
+     * Space Complexity: O(1) - no additional space is used.
+     */
+    /**
+     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
+     * Space Complexity: O(1) - no additional space is used.
+     *
      * The enqueue function adds a value to the end of a queue.
      * @param {E} value - The value parameter represents the value that you want to add to the queue.
      */
@@ -142,16 +191,40 @@ class Queue {
         this.push(value);
     }
     /**
+     * Time Complexity: O(n) - same as shift().
+     * Space Complexity: O(1) - same as shift().
+     */
+    /**
+     * Time Complexity: O(n) - same as shift().
+     * Space Complexity: O(1) - same as shift().
+     *
      * The `dequeue` function removes and returns the first element from a queue, or returns null if the queue is empty.
      * @returns The method is returning a value of type E or null.
      */
     dequeue() {
         return this.shift();
     }
+    /**
+     * Time Complexity: O(1) - constant time as it retrieves the value at the specified index.
+     * Space Complexity: O(1) - no additional space is used.
+     */
+    /**
+     * Time Complexity: O(1) - constant time as it retrieves the value at the specified index.
+     * Space Complexity: O(1) - no additional space is used.
+     *
+     * @param index
+     */
     getAt(index) {
         return this.nodes[index];
     }
     /**
+     * Time Complexity: O(1) - constant time as it retrieves the value at the specified index.
+     * Space Complexity: O(1) - no additional space is used.
+     */
+    /**
+     * Time Complexity: O(1) - constant time as it retrieves the value at the specified index.
+     * Space Complexity: O(1) - no additional space is used.
+     *
      * The function checks if a data structure is empty by comparing its size to zero.
      * @returns {boolean} A boolean value indicating whether the size of the object is 0 or not.
      */
@@ -159,6 +232,13 @@ class Queue {
         return this.size === 0;
     }
     /**
+     * Time Complexity: O(1) - constant time as it returns a shallow copy of the internal array.
+     * Space Complexity: O(n) - where n is the number of elements in the queue.
+     */
+    /**
+     * Time Complexity: O(1) - constant time as it returns a shallow copy of the internal array.
+     * Space Complexity: O(n) - where n is the number of elements in the queue.
+     *
      * The toArray() function returns an array of elements from the current offset to the end of the _nodes array.
      * @returns An array of type E is being returned.
      */
@@ -173,6 +253,13 @@ class Queue {
         this._offset = 0;
     }
     /**
+     * Time Complexity: O(n) - where n is the number of elements in the queue. It creates a shallow copy of the internal array.
+     * Space Complexity: O(n) - the space required is proportional to the number of elements in the queue.
+     */
+    /**
+     * Time Complexity: O(n) - where n is the number of elements in the queue. It creates a shallow copy of the internal array.
+     * Space Complexity: O(n) - the space required is proportional to the number of elements in the queue.
+     *
      * The `clone()` function returns a new Queue object with the same elements as the original Queue.
      * @returns The `clone()` method is returning a new instance of the `Queue` class.
      */

package/dist/mjs/src/data-structures/stack/stack.d.ts

@@ -14,6 +14,13 @@ export declare class Stack<E = any> {
     protected _elements: E[];
     get elements(): E[];
     /**
+     * Time Complexity: O(n), where n is the number of elements in the input array. Similar to the constructor, it requires iterating through each element.
+     * Space Complexity: O(n), as it creates a new stack with the elements from the input array.
+     */
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the input array. Similar to the constructor, it requires iterating through each element.
+     * Space Complexity: O(n), as it creates a new stack with the elements from the input array.
+     *
      * The function "fromArray" creates a new Stack object from an array of elements.
      * @param {E[]} elements - The `elements` parameter is an array of elements of type `E`.
      * @returns {Stack} The method is returning a new instance of the Stack class, initialized with the elements from the input
@@ -31,23 +38,51 @@ export declare class Stack<E = any> {
      */
     size(): number;
     /**
+     * Time Complexity: O(1), as it only involves accessing the last element of the array.
+     * Space Complexity: O(1), as it does not use any additional space.
+     */
+    /**
+     * Time Complexity: O(1), as it only involves accessing the last element of the array.
+     * Space Complexity: O(1), as it does not use any additional space.
+     *
      * The `peek` function returns the last element of an array, or null if the array is empty.
      * @returns The `peek()` function returns the last element of the `_elements` array, or `null` if the array is empty.
      */
     peek(): E | null;
     /**
+     * Time Complexity: O(1), as it only involves accessing the last element of the array.
+     * Space Complexity: O(1), as it does not use any additional space.
+     */
+    /**
+     * Time Complexity: O(1), as it only involves accessing the last element of the array.
+     * Space Complexity: O(1), as it does not use any additional space.
+     *
      * The push function adds an element to the stack and returns the updated stack.
      * @param {E} element - The parameter "element" is of type E, which means it can be any data type.
      * @returns The `push` method is returning the updated `Stack<E>` object.
      */
     push(element: E): Stack<E>;
     /**
+     * Time Complexity: O(1), as it only involves accessing the last element of the array.
+     * Space Complexity: O(1), as it does not use any additional space.
+     */
+    /**
+     * Time Complexity: O(1), as it only involves accessing the last element of the array.
+     * Space Complexity: O(1), as it does not use any additional space.
+     *
      * The `pop` function removes and returns the last element from an array, or returns null if the array is empty.
      * @returns The `pop()` method is returning the last element of the array `_elements` if the array is not empty. If the
      * array is empty, it returns `null`.
      */
     pop(): E | null;
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
      * The toArray function returns a copy of the elements in an array.
      * @returns An array of type E.
      */
@@ -57,6 +92,13 @@ export declare class Stack<E = any> {
      */
     clear(): void;
     /**
+     * Time Complexity: O(n), where n is the number of elements in the stack, as it creates a new stack and copies all elements into it.
+     * Space Complexity: O(n), as it creates a new stack.
+     */
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the stack, as it creates a new stack and copies all elements into it.
+     * Space Complexity: O(n), as it creates a new stack.
+     *
      * The `clone()` function returns a new `Stack` object with the same elements as the original stack.
      * @returns The `clone()` method is returning a new `Stack` object with a copy of the `_elements` array.
      */

package/dist/mjs/src/data-structures/stack/stack.js

@@ -21,6 +21,13 @@ class Stack {
         return this._elements;
     }
     /**
+     * Time Complexity: O(n), where n is the number of elements in the input array. Similar to the constructor, it requires iterating through each element.
+     * Space Complexity: O(n), as it creates a new stack with the elements from the input array.
+     */
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the input array. Similar to the constructor, it requires iterating through each element.
+     * Space Complexity: O(n), as it creates a new stack with the elements from the input array.
+     *
      * The function "fromArray" creates a new Stack object from an array of elements.
      * @param {E[]} elements - The `elements` parameter is an array of elements of type `E`.
      * @returns {Stack} The method is returning a new instance of the Stack class, initialized with the elements from the input
@@ -44,6 +51,13 @@ class Stack {
         return this.elements.length;
     }
     /**
+     * Time Complexity: O(1), as it only involves accessing the last element of the array.
+     * Space Complexity: O(1), as it does not use any additional space.
+     */
+    /**
+     * Time Complexity: O(1), as it only involves accessing the last element of the array.
+     * Space Complexity: O(1), as it does not use any additional space.
+     *
      * The `peek` function returns the last element of an array, or null if the array is empty.
      * @returns The `peek()` function returns the last element of the `_elements` array, or `null` if the array is empty.
      */
@@ -53,6 +67,13 @@ class Stack {
         return this.elements[this.elements.length - 1];
     }
     /**
+     * Time Complexity: O(1), as it only involves accessing the last element of the array.
+     * Space Complexity: O(1), as it does not use any additional space.
+     */
+    /**
+     * Time Complexity: O(1), as it only involves accessing the last element of the array.
+     * Space Complexity: O(1), as it does not use any additional space.
+     *
      * The push function adds an element to the stack and returns the updated stack.
      * @param {E} element - The parameter "element" is of type E, which means it can be any data type.
      * @returns The `push` method is returning the updated `Stack<E>` object.
@@ -62,6 +83,13 @@ class Stack {
         return this;
     }
     /**
+     * Time Complexity: O(1), as it only involves accessing the last element of the array.
+     * Space Complexity: O(1), as it does not use any additional space.
+     */
+    /**
+     * Time Complexity: O(1), as it only involves accessing the last element of the array.
+     * Space Complexity: O(1), as it does not use any additional space.
+     *
      * The `pop` function removes and returns the last element from an array, or returns null if the array is empty.
      * @returns The `pop()` method is returning the last element of the array `_elements` if the array is not empty. If the
      * array is empty, it returns `null`.
@@ -72,6 +100,13 @@ class Stack {
         return this.elements.pop() || null;
     }
     /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
      * The toArray function returns a copy of the elements in an array.
      * @returns An array of type E.
      */
@@ -85,6 +120,13 @@ class Stack {
         this._elements = [];
     }
     /**
+     * Time Complexity: O(n), where n is the number of elements in the stack, as it creates a new stack and copies all elements into it.
+     * Space Complexity: O(n), as it creates a new stack.
+     */
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the stack, as it creates a new stack and copies all elements into it.
+     * Space Complexity: O(n), as it creates a new stack.
+     *
      * The `clone()` function returns a new `Stack` object with the same elements as the original stack.
      * @returns The `clone()` method is returning a new `Stack` object with a copy of the `_elements` array.
      */

package/dist/mjs/src/data-structures/trie/trie.d.ts

@@ -25,48 +25,113 @@ export declare class Trie {
     protected _root: TrieNode;
     get root(): TrieNode;
     /**
+     * Time Complexity: O(M), where M is the length of the word being added.
+     * Space Complexity: O(M) - Each character in the word adds a TrieNode.
+     */
+    /**
+     * Time Complexity: O(M), where M is the length of the word being added.
+     * Space Complexity: O(M) - Each character in the word adds a TrieNode.
+     *
      * Add a word to the Trie structure.
      * @param {string} word - The word to add.
      * @returns {boolean} True if the word was successfully added.
      */
     add(word: string): boolean;
     /**
+     * Time Complexity: O(M), where M is the length of the input word.
+     * Space Complexity: O(1) - Constant space.
+     */
+    /**
+     * Time Complexity: O(M), where M is the length of the input word.
+     * Space Complexity: O(1) - Constant space.
+     *
      * Check if the Trie contains a given word.
      * @param {string} word - The word to check for.
      * @returns {boolean} True if the word is present in the Trie.
      */
     has(word: string): boolean;
     /**
+     * Time Complexity: O(M), where M is the length of the word being deleted.
+     * Space Complexity: O(M) - Due to the recursive DFS approach.
+     */
+    /**
+     * Time Complexity: O(M), where M is the length of the word being deleted.
+     * Space Complexity: O(M) - Due to the recursive DFS approach.
+     *
      * Remove a word from the Trie structure.
      * @param{string} word - The word to delete.
      * @returns {boolean} True if the word was successfully removed.
      */
     delete(word: string): boolean;
+    /**
+     * Time Complexity: O(N), where N is the total number of nodes in the trie.
+     * Space Complexity: O(1) - Constant space.
+     */
+    /**
+     * Time Complexity: O(N), where N is the total number of nodes in the trie.
+     * Space Complexity: O(1) - Constant space.
+     *
+     */
     getHeight(): number;
     /**
+     * Time Complexity: O(M), where M is the length of the input prefix.
+     * Space Complexity: O(1) - Constant space.
+     */
+    /**
+     * Time Complexity: O(M), where M is the length of the input prefix.
+     * Space Complexity: O(1) - Constant space.
+     *
      * Check if a given input string has an absolute prefix in the Trie, meaning it's not a complete word.
      * @param {string} input - The input string to check.
      * @returns {boolean} True if it's an absolute prefix in the Trie.
      */
     hasPurePrefix(input: string): boolean;
     /**
+     * Time Complexity: O(M), where M is the length of the input prefix.
+     * Space Complexity: O(1) - Constant space.
+     */
+    /**
+     * Time Complexity: O(M), where M is the length of the input prefix.
+     * Space Complexity: O(1) - Constant space.
+     *
      * Check if a given input string is a prefix of any existing word in the Trie, whether as an absolute prefix or a complete word.
      * @param {string} input - The input string representing the prefix to check.
      * @returns {boolean} True if it's a prefix in the Trie.
      */
     hasPrefix(input: string): boolean;
     /**
+     * Time Complexity: O(N), where N is the total number of nodes in the trie.
+     * Space Complexity: O(M), where M is the length of the input prefix.
+     */
+    /**
+     * Time Complexity: O(N), where N is the total number of nodes in the trie.
+     * Space Complexity: O(M), where M is the length of the input prefix.
+     *
      * Check if the input string is a common prefix in the Trie, meaning it's a prefix shared by all words in the Trie.
      * @param {string} input - The input string representing the common prefix to check for.
      * @returns {boolean} True if it's a common prefix in the Trie.
      */
     hasCommonPrefix(input: string): boolean;
     /**
+     * Time Complexity: O(N), where N is the total number of nodes in the trie.
+     * Space Complexity: O(M), where M is the length of the longest common prefix.
+     */
+    /**
+     * Time Complexity: O(N), where N is the total number of nodes in the trie.
+     * Space Complexity: O(M), where M is the length of the longest common prefix.
+     *
      * Get the longest common prefix among all the words stored in the Trie.
      * @returns {string} The longest common prefix found in the Trie.
      */
     getLongestCommonPrefix(): string;
     /**
+     * Time Complexity: O(K * L), where K is the number of words retrieved, and L is the average length of the words.
+     * Space Complexity: O(K * L) - The space required for the output array.
+     */
+    /**
+     * Time Complexity: O(K * L), where K is the number of words retrieved, and L is the average length of the words.
+     * Space Complexity: O(K * L) - The space required for the output array.
+     *
      * The `getAll` function returns an array of all words in a Trie data structure that start with a given prefix.
      * @param {string} prefix - The `prefix` parameter is a string that represents the prefix that we want to search for in the
      * trie. It is an optional parameter, so if no prefix is provided, it will default to an empty string.
@@ -75,5 +140,16 @@ export declare class Trie {
      * @returns {string[]} an array of strings.
      */
     getWords(prefix?: string, max?: number, isAllWhenEmptyPrefix?: boolean): string[];
+    /**
+     * Time Complexity: O(M), where M is the length of the input string.
+     * Space Complexity: O(1) - Constant space.
+     */
+    /**
+     * Time Complexity: O(M), where M is the length of the input string.
+     * Space Complexity: O(1) - Constant space.
+     *
+     * @param str
+     * @protected
+     */
     protected _caseProcess(str: string): string;
 }

package/dist/mjs/src/data-structures/trie/trie.js

@@ -45,6 +45,13 @@ class Trie {
         return this._root;
     }
     /**
+     * Time Complexity: O(M), where M is the length of the word being added.
+     * Space Complexity: O(M) - Each character in the word adds a TrieNode.
+     */
+    /**
+     * Time Complexity: O(M), where M is the length of the word being added.
+     * Space Complexity: O(M) - Each character in the word adds a TrieNode.
+     *
      * Add a word to the Trie structure.
      * @param {string} word - The word to add.
      * @returns {boolean} True if the word was successfully added.
@@ -64,6 +71,13 @@ class Trie {
         return true;
     }
     /**
+     * Time Complexity: O(M), where M is the length of the input word.
+     * Space Complexity: O(1) - Constant space.
+     */
+    /**
+     * Time Complexity: O(M), where M is the length of the input word.
+     * Space Complexity: O(1) - Constant space.
+     *
      * Check if the Trie contains a given word.
      * @param {string} word - The word to check for.
      * @returns {boolean} True if the word is present in the Trie.
@@ -80,6 +94,13 @@ class Trie {
         return cur.isEnd;
     }
     /**
+     * Time Complexity: O(M), where M is the length of the word being deleted.
+     * Space Complexity: O(M) - Due to the recursive DFS approach.
+     */
+    /**
+     * Time Complexity: O(M), where M is the length of the word being deleted.
+     * Space Complexity: O(M) - Due to the recursive DFS approach.
+     *
      * Remove a word from the Trie structure.
      * @param{string} word - The word to delete.
      * @returns {boolean} True if the word was successfully removed.
@@ -116,6 +137,15 @@ class Trie {
         dfs(this.root, 0);
         return isDeleted;
     }
+    /**
+     * Time Complexity: O(N), where N is the total number of nodes in the trie.
+     * Space Complexity: O(1) - Constant space.
+     */
+    /**
+     * Time Complexity: O(N), where N is the total number of nodes in the trie.
+     * Space Complexity: O(1) - Constant space.
+     *
+     */
     getHeight() {
         const beginRoot = this.root;
         let maxDepth = 0;
@@ -135,8 +165,14 @@ class Trie {
         }
         return maxDepth;
     }
-    // --- start additional methods ---
     /**
+     * Time Complexity: O(M), where M is the length of the input prefix.
+     * Space Complexity: O(1) - Constant space.
+     */
+    /**
+     * Time Complexity: O(M), where M is the length of the input prefix.
+     * Space Complexity: O(1) - Constant space.
+     *
      * Check if a given input string has an absolute prefix in the Trie, meaning it's not a complete word.
      * @param {string} input - The input string to check.
      * @returns {boolean} True if it's an absolute prefix in the Trie.
@@ -153,6 +189,13 @@ class Trie {
         return !cur.isEnd;
     }
     /**
+     * Time Complexity: O(M), where M is the length of the input prefix.
+     * Space Complexity: O(1) - Constant space.
+     */
+    /**
+     * Time Complexity: O(M), where M is the length of the input prefix.
+     * Space Complexity: O(1) - Constant space.
+     *
      * Check if a given input string is a prefix of any existing word in the Trie, whether as an absolute prefix or a complete word.
      * @param {string} input - The input string representing the prefix to check.
      * @returns {boolean} True if it's a prefix in the Trie.
@@ -169,6 +212,13 @@ class Trie {
         return true;
     }
     /**
+     * Time Complexity: O(N), where N is the total number of nodes in the trie.
+     * Space Complexity: O(M), where M is the length of the input prefix.
+     */
+    /**
+     * Time Complexity: O(N), where N is the total number of nodes in the trie.
+     * Space Complexity: O(M), where M is the length of the input prefix.
+     *
      * Check if the input string is a common prefix in the Trie, meaning it's a prefix shared by all words in the Trie.
      * @param {string} input - The input string representing the common prefix to check for.
      * @returns {boolean} True if it's a common prefix in the Trie.
@@ -191,6 +241,13 @@ class Trie {
         return commonPre === input;
     }
     /**
+     * Time Complexity: O(N), where N is the total number of nodes in the trie.
+     * Space Complexity: O(M), where M is the length of the longest common prefix.
+     */
+    /**
+     * Time Complexity: O(N), where N is the total number of nodes in the trie.
+     * Space Complexity: O(M), where M is the length of the longest common prefix.
+     *
      * Get the longest common prefix among all the words stored in the Trie.
      * @returns {string} The longest common prefix found in the Trie.
      */
@@ -209,6 +266,13 @@ class Trie {
         return commonPre;
     }
     /**
+     * Time Complexity: O(K * L), where K is the number of words retrieved, and L is the average length of the words.
+     * Space Complexity: O(K * L) - The space required for the output array.
+     */
+    /**
+     * Time Complexity: O(K * L), where K is the number of words retrieved, and L is the average length of the words.
+     * Space Complexity: O(K * L) - The space required for the output array.
+     *
      * The `getAll` function returns an array of all words in a Trie data structure that start with a given prefix.
      * @param {string} prefix - The `prefix` parameter is a string that represents the prefix that we want to search for in the
      * trie. It is an optional parameter, so if no prefix is provided, it will default to an empty string.
@@ -246,6 +310,17 @@ class Trie {
             dfs(startNode, prefix);
         return words;
     }
+    /**
+     * Time Complexity: O(M), where M is the length of the input string.
+     * Space Complexity: O(1) - Constant space.
+     */
+    /**
+     * Time Complexity: O(M), where M is the length of the input string.
+     * Space Complexity: O(1) - Constant space.
+     *
+     * @param str
+     * @protected
+     */
     _caseProcess(str) {
         if (!this._caseSensitive) {
             str = str.toLowerCase(); // Convert str to lowercase if case-insensitive