min-heap-typed 1.49.6 → 1.49.7

package/src/data-structures/queue/deque.ts

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { ElementCallback, IterableWithSizeOrLength } from '../../types';
+import type { DequeOptions, ElementCallback, IterableWithSizeOrLength } from '../../types';
 import { IterableElementBase } from '../base';
 import { calcMinUnitsRequired, rangeCheck } from '../../utils';
 
@@ -22,19 +22,16 @@ export class Deque<E> extends IterableElementBase<E> {
   protected _bucketLast = 0;
   protected _lastInBucket = 0;
   protected _bucketCount = 0;
-  protected readonly _bucketSize: number;
+  protected readonly _bucketSize: number = 1 << 12;
 
-  /**
-   * The constructor initializes a data structure with a specified bucket size and populates it with
-   * elements from an iterable.
-   * @param elements - The `elements` parameter is an iterable object (such as an array or a Set) that
-   * contains the initial elements to be stored in the data structure. It can also be an object with a
-   * `length` property or a `size` property, which represents the number of elements in the iterable.
-   * @param bucketSize - The `bucketSize` parameter is the maximum number of elements that can be
-   * stored in each bucket. It determines the size of each bucket in the data structure.
-   */
-  constructor(elements: IterableWithSizeOrLength<E> = [], bucketSize = 1 << 12) {
+  constructor(elements: IterableWithSizeOrLength<E> = [], options?: DequeOptions) {
     super();
+
+    if (options) {
+      const { bucketSize } = options;
+      if (typeof bucketSize === 'number') this._bucketSize = bucketSize;
+    }
+
     let _size: number;
     if ('length' in elements) {
       if (elements.length instanceof Function) _size = elements.length();
@@ -44,7 +41,6 @@ export class Deque<E> extends IterableElementBase<E> {
       else _size = elements.size;
     }
 
-    this._bucketSize = bucketSize;
     this._bucketCount = calcMinUnitsRequired(_size, this._bucketSize) || 1;
     for (let i = 0; i < this._bucketCount; ++i) {
       this._buckets.push(new Array(this._bucketSize));
@@ -637,7 +633,7 @@ export class Deque<E> extends IterableElementBase<E> {
    * satisfy the given predicate function.
    */
   filter(predicate: ElementCallback<E, boolean>, thisArg?: any): Deque<E> {
-    const newDeque = new Deque<E>([], this._bucketSize);
+    const newDeque = new Deque<E>([], { bucketSize: this._bucketSize });
     let index = 0;
     for (const el of this) {
       if (predicate.call(thisArg, el, index, this)) {
@@ -666,7 +662,7 @@ export class Deque<E> extends IterableElementBase<E> {
    * @returns a new Deque object with the mapped values.
    */
   map<T>(callback: ElementCallback<E, T>, thisArg?: any): Deque<T> {
-    const newDeque = new Deque<T>([], this._bucketSize);
+    const newDeque = new Deque<T>([], { bucketSize: this._bucketSize });
     let index = 0;
     for (const el of this) {
       newDeque.push(callback.call(thisArg, el, index, this));

package/src/data-structures/queue/queue.ts

@@ -13,29 +13,30 @@ import { SinglyLinkedList } from '../linked-list';
  * 3. Uses: Queues are commonly used to manage a series of tasks or elements that need to be processed in order. For example, managing task queues in a multi-threaded environment, or in algorithms for data structures like trees and graphs for breadth-first search.
  * 4. Task Scheduling: Managing the order of task execution in operating systems or applications.
  * 5. Data Buffering: Acting as a buffer for data packets in network communication.
- * 6. Breadth-First Search (BFS): In traversal algorithms for graphs and trees, queues store nodes that are to be visited.
+ * 6. Breadth-First Search (BFS): In traversal algorithms for graphs and trees, queues store elements that are to be visited.
  * 7. Real-time Queuing: Like queuing systems in banks or supermarkets.
  */
 export class Queue<E = any> extends IterableElementBase<E> {
   /**
    * The constructor initializes an instance of a class with an optional array of elements and sets the offset to 0.
    * @param {E[]} [elements] - The `elements` parameter is an optional array of elements of type `E`. If provided, it
-   * will be used to initialize the `_nodes` property of the class. If not provided, the `_nodes` property will be
+   * will be used to initialize the `_elements` property of the class. If not provided, the `_elements` property will be
    * initialized as an empty array.
    */
-  constructor(elements?: E[]) {
+  constructor(elements: Iterable<E> = []) {
     super();
-    this._nodes = elements || [];
-    this._offset = 0;
+    if (elements) {
+      for (const el of elements) this.push(el);
+    }
   }
 
-  protected _nodes: E[];
+  protected _elements: E[] = [];
 
-  get nodes(): E[] {
-    return this._nodes;
+  get elements(): E[] {
+    return this._elements;
   }
 
-  protected _offset: number;
+  protected _offset: number = 0;
 
   get offset(): number {
     return this._offset;
@@ -46,19 +47,19 @@ export class Queue<E = any> extends IterableElementBase<E> {
    * @returns {number} The size of the array, which is the difference between the length of the array and the offset.
    */
   get size(): number {
-    return this.nodes.length - this.offset;
+    return this.elements.length - this.offset;
   }
 
   /**
    * 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 `first` function returns the first element of the array `_nodes` if it exists, otherwise it returns `undefined`.
-   * @returns The `get first()` method returns the first element of the data structure, represented by the `_nodes` array at
+   * The `first` function returns the first element of the array `_elements` if it exists, otherwise it returns `undefined`.
+   * @returns The `get first()` method returns the first element of the data structure, represented by the `_elements` array at
    * the `_offset` index. If the data structure is empty (size is 0), it returns `undefined`.
    */
   get first(): E | undefined {
-    return this.size > 0 ? this.nodes[this.offset] : undefined;
+    return this.size > 0 ? this.elements[this.offset] : undefined;
   }
 
   /**
@@ -71,11 +72,11 @@ export class Queue<E = any> extends IterableElementBase<E> {
    * Space Complexity: O(1) - no additional space is used.
    *
    * The `last` function returns the last element in an array-like data structure, or undefined if the structure is empty.
-   * @returns The method `get last()` returns the last element of the `_nodes` array if the array is not empty. If the
+   * @returns The method `get last()` returns the last element of the `_elements` array if the array is not empty. If the
    * array is empty, it returns `undefined`.
    */
   get last(): E | undefined {
-    return this.size > 0 ? this.nodes[this.nodes.length - 1] : undefined;
+    return this.size > 0 ? this.elements[this.elements.length - 1] : undefined;
   }
 
   /**
@@ -109,7 +110,7 @@ export class Queue<E = any> extends IterableElementBase<E> {
    * @returns The `add` method is returning a `Queue<E>` object.
    */
   push(element: E): boolean {
-    this.nodes.push(element);
+    this.elements.push(element);
     return true;
   }
 
@@ -132,11 +133,11 @@ export class Queue<E = any> extends IterableElementBase<E> {
     const first = this.first;
     this._offset += 1;
 
-    if (this.offset * 2 < this.nodes.length) return first;
+    if (this.offset * 2 < this.elements.length) return first;
 
     // only delete dequeued elements when reaching half size
     // to decrease latency of shifting elements.
-    this._nodes = this.nodes.slice(this.offset);
+    this._elements = this.elements.slice(this.offset);
     this._offset = 0;
     return first;
   }
@@ -150,8 +151,8 @@ export class Queue<E = any> extends IterableElementBase<E> {
    * 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 `undefined`.
-   * @returns The `peek()` method returns the first element of the data structure, represented by the `_nodes` array at
+   * The `peek` function returns the first element of the array `_elements` if it exists, otherwise it returns `undefined`.
+   * @returns The `peek()` method returns the first element of the data structure, represented by the `_elements` array at
    * the `_offset` index. If the data structure is empty (size is 0), it returns `undefined`.
    */
   peek(): E | undefined {
@@ -168,7 +169,7 @@ export class Queue<E = any> extends IterableElementBase<E> {
    * Space Complexity: O(1) - no additional space is used.
    *
    * The `peekLast` function returns the last element in an array-like data structure, or undefined 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
+   * @returns The method `peekLast()` returns the last element of the `_elements` array if the array is not empty. If the
    * array is empty, it returns `undefined`.
    */
   peekLast(): E | undefined {
@@ -219,7 +220,7 @@ export class Queue<E = any> extends IterableElementBase<E> {
    * @param index
    */
   getAt(index: number): E | undefined {
-    return this.nodes[index];
+    return this.elements[index];
   }
 
   /**
@@ -247,18 +248,18 @@ export class Queue<E = any> extends IterableElementBase<E> {
    * 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.
+   * The toArray() function returns an array of elements from the current offset to the end of the _elements array.
    * @returns An array of type E is being returned.
    */
   toArray(): E[] {
-    return this.nodes.slice(this.offset);
+    return this.elements.slice(this.offset);
   }
 
   /**
-   * The clear function resets the nodes array and offset to their initial values.
+   * The clear function resets the elements array and offset to their initial values.
    */
   clear(): void {
-    this._nodes = [];
+    this._elements = [];
     this._offset = 0;
   }
 
@@ -275,7 +276,7 @@ export class Queue<E = any> extends IterableElementBase<E> {
    * @returns The `clone()` method is returning a new instance of the `Queue` class.
    */
   clone(): Queue<E> {
-    return new Queue(this.nodes.slice(this.offset));
+    return new Queue(this.elements.slice(this.offset));
   }
 
   /**
@@ -345,7 +346,7 @@ export class Queue<E = any> extends IterableElementBase<E> {
    */
 
   protected* _getIterator(): IterableIterator<E> {
-    for (const item of this.nodes) {
+    for (const item of this.elements) {
       yield item;
     }
   }

package/src/data-structures/stack/stack.ts

@@ -23,17 +23,14 @@ export class Stack<E = any> extends IterableElementBase<E> {
    * of elements of type `E`. It is used to initialize the `_elements` property of the class. If the `elements` parameter
    * is provided and is an array, it is assigned to the `_elements
    */
-  constructor(elements?: Iterable<E>) {
+  constructor(elements: Iterable<E> = []) {
     super();
-    this._elements = [];
     if (elements) {
-      for (const el of elements) {
-        this.push(el);
-      }
+      for (const el of elements) this.push(el);
     }
   }
 
-  protected _elements: E[];
+  protected _elements: E[] = [];
 
   get elements(): E[] {
     return this._elements;

package/src/data-structures/trie/trie.ts

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { ElementCallback } from '../../types';
+import type { ElementCallback, TrieOptions } from '../../types';
 import { IterableElementBase } from '../base';
 
 /**
@@ -38,31 +38,30 @@ export class TrieNode {
  * 11. Text Word Frequency Count: Counting and storing the frequency of words in a large amount of text data."
  */
 export class Trie extends IterableElementBase<string> {
-  constructor(words?: string[], caseSensitive = true) {
+  constructor(words: Iterable<string> = [], options?: TrieOptions) {
     super();
-    this._root = new TrieNode('');
-    this._caseSensitive = caseSensitive;
-    this._size = 0;
+    if (options) {
+      const { caseSensitive } = options;
+      if (caseSensitive !== undefined) this._caseSensitive = caseSensitive;
+    }
     if (words) {
-      for (const word of words) {
-        this.add(word);
-      }
+      for (const word of words) this.add(word);
     }
   }
 
-  protected _size: number;
+  protected _size: number = 0;
 
   get size(): number {
     return this._size;
   }
 
-  protected _caseSensitive: boolean;
+  protected _caseSensitive: boolean = true;
 
   get caseSensitive(): boolean {
     return this._caseSensitive;
   }
 
-  protected _root: TrieNode;
+  protected _root: TrieNode = new TrieNode('');
 
   get root() {
     return this._root;

package/src/types/data-structures/binary-tree/binary-tree.ts

@@ -6,6 +6,6 @@ export type BinaryTreeNodeNested<K, V> = BinaryTreeNode<K, V, BinaryTreeNode<K,
 export type BinaryTreeNested<K, V, N extends BinaryTreeNode<K, V, N>> = BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
 export type BinaryTreeOptions<K> = {
-  iterationType: IterationType,
-  extractor: (key: K) => number
+  iterationType?: IterationType,
+  extractor?: (key: K) => number
 }

package/src/types/data-structures/binary-tree/bst.ts

@@ -7,5 +7,5 @@ export type BSTNodeNested<K, V> = BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTN
 export type BSTNested<K, V, N extends BSTNode<K, V, N>> = BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
 export type BSTOptions<K> = BinaryTreeOptions<K> & {
-  variant: BSTVariant
+  variant?: BSTVariant
 }

package/src/types/data-structures/binary-tree/tree-multimap.ts

@@ -5,4 +5,4 @@ export type TreeMultimapNodeNested<K, V> = TreeMultimapNode<K, V, TreeMultimapNo
 
 export type TreeMultimapNested<K, V, N extends TreeMultimapNode<K, V, N>> = TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
-export type TreeMultimapOptions<K> = Omit<AVLTreeOptions<K>, 'isMergeDuplicatedNodeByKey'> & {}
+export type TreeMultimapOptions<K> = AVLTreeOptions<K> & {}

package/src/types/data-structures/hash/hash-map.ts

@@ -5,9 +5,13 @@ export type HashMapLinkedNode<K, V> = {
   prev: HashMapLinkedNode<K, V>;
 };
 
+export type LinkedHashMapOptions<K> = {
+  hashFn?: (key: K) => string;
+  objHashFn?: (key: K) => object;
+};
+
 export type HashMapOptions<K> = {
-  hashFn: (key: K) => string;
-  objHashFn: (key: K) => object;
+  hashFn?: (key: K) => string;
 };
 
 export type HashMapStoreItem<K, V> = { key: K; value: V };

package/src/types/data-structures/hash/index.ts

@@ -1,4 +1,3 @@
 export * from './hash-map';
-export * from './hash-table';
 
 export type HashFunction<K> = (key: K) => number;

package/src/types/data-structures/heap/heap.ts

@@ -1,3 +1,3 @@
 import { Comparator } from '../../common';
 
-export type HeapOptions<T> = { comparator: Comparator<T> };
+export type HeapOptions<T> = { comparator?: Comparator<T> };

package/src/types/data-structures/linked-list/index.ts

@@ -1,2 +1,3 @@
 export * from './singly-linked-list';
 export * from './doubly-linked-list';
+export * from './skip-linked-list';

package/src/types/data-structures/linked-list/skip-linked-list.ts

@@ -1 +1 @@
-export {};
+export type SkipLinkedListOptions = { maxLevel?: number; probability?: number };

package/src/types/data-structures/matrix/index.ts

@@ -1 +1,2 @@
 export * from './navigator';
+export * from './matrix';

package/src/types/data-structures/matrix/matrix.ts

@@ -1 +1,7 @@
-export {};
+export type MatrixOptions = {
+  rows?: number;
+  cols?: number;
+  addFn?: (a: number, b: number) => any;
+  subtractFn?: (a: number, b: number) => any;
+  multiplyFn?: (a: number, b: number) => any;
+};

package/src/types/data-structures/queue/deque.ts

@@ -1 +1 @@
-export {};
+export type DequeOptions = { bucketSize?: number };

package/src/types/data-structures/trie/trie.ts

@@ -1 +1 @@
-export {};
+export type TrieOptions = { caseSensitive?: boolean };

package/dist/data-structures/hash/hash-table.d.ts

@@ -1,108 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-import type { HashFunction } from '../../types';
-export declare class HashTableNode<K = any, V = any> {
-    key: K;
-    value: V;
-    next: HashTableNode<K, V> | undefined;
-    constructor(key: K, value: V);
-}
-export declare class HashTable<K = any, V = any> {
-    protected static readonly DEFAULT_CAPACITY = 16;
-    protected static readonly LOAD_FACTOR = 0.75;
-    constructor(capacity?: number, hashFn?: HashFunction<K>);
-    protected _capacity: number;
-    get capacity(): number;
-    protected _size: number;
-    get size(): number;
-    protected _buckets: Array<HashTableNode<K, V> | undefined>;
-    get buckets(): Array<HashTableNode<K, V> | undefined>;
-    protected _hashFn: HashFunction<K>;
-    get hashFn(): HashFunction<K>;
-    /**
-     * The set function adds a key-value pair to the hash table, handling collisions and resizing if necessary.
-     * @param {K} key - The key parameter represents the key of the key-value pair that you want to insert into the hash
-     * table. It is of type K, which is a generic type representing the key's data type.
-     * @param {V} value - The parameter `value` represents the value that you want to associate with the given key in the hash
-     * table.
-     * @returns Nothing is being returned. The return type of the `put` method is `void`, which means it does not return any
-     * value.
-     */
-    set(key: K, value: V): void;
-    /**
-     * The `get` function retrieves the value associated with a given key from a hash table.
-     * @param {K} key - The `key` parameter represents the key of the element that we want to retrieve from the data
-     * structure.
-     * @returns The method is returning the value associated with the given key if it exists in the hash table. If the key is
-     * not found, it returns `undefined`.
-     */
-    get(key: K): V | undefined;
-    /**
-     * The delete function removes a key-value pair from a hash table.
-     * @param {K} key - The `key` parameter represents the key of the key-value pair that needs to be removed from the hash
-     * table.
-     * @returns Nothing is being returned. The `delete` method has a return type of `void`, which means it does not return
-     * any value.
-     */
-    delete(key: K): void;
-    [Symbol.iterator](): Generator<[K, V], void, undefined>;
-    forEach(callback: (entry: [K, V], index: number, table: HashTable<K, V>) => void): void;
-    filter(predicate: (entry: [K, V], index: number, table: HashTable<K, V>) => boolean): HashTable<K, V>;
-    map<T>(callback: (entry: [K, V], index: number, table: HashTable<K, V>) => T): HashTable<K, T>;
-    reduce<T>(callback: (accumulator: T, entry: [K, V], index: number, table: HashTable<K, V>) => T, initialValue: T): T;
-    /**
-     * The function `_defaultHashFn` calculates the hash value of a given key and returns the remainder when divided by the
-     * capacity of the data structure.
-     * @param {K} key - The `key` parameter is the input value that needs to be hashed. It can be of any type, but in this
-     * code snippet, it is checked whether the key is a string or an object. If it is a string, the `_murmurStringHashFn`
-     * function is used to
-     * @returns the hash value of the key modulo the capacity of the data structure.
-     */
-    protected _defaultHashFn(key: K): number;
-    /**
-     * The `_multiplicativeStringHashFn` function calculates a hash value for a given string key using the multiplicative
-     * string hash function.
-     * @param {K} key - The `key` parameter is the input value for which we want to calculate the hash. It can be of any
-     * type, as it is generic (`K`). The function converts the `key` to a string using the `String()` function.
-     * @returns a number, which is the result of the multiplicative string hash function applied to the input key.
-     */
-    protected _multiplicativeStringHashFn<K>(key: K): number;
-    /**
-     * The function `_murmurStringHashFn` calculates a hash value for a given string key using the MurmurHash algorithm.
-     * @param {K} key - The `key` parameter is the input value for which you want to calculate the hash. It can be of any
-     * type, but it will be converted to a string using the `String()` function before calculating the hash.
-     * @returns a number, which is the hash value calculated for the given key.
-     */
-    protected _murmurStringHashFn<K>(key: K): number;
-    /**
-     * The _hash function takes a key and returns a number.
-     * @param {K} key - The parameter "key" is of type K, which represents the type of the key that will be hashed.
-     * @returns The hash function is returning a number.
-     */
-    protected _hash(key: K): number;
-    /**
-     * The function calculates a hash value for a given string using the djb2 algorithm.
-     * @param {string} key - The `key` parameter in the `stringHash` function is a string value that represents the input for
-     * which we want to calculate the hash value.
-     * @returns a number, which is the hash value of the input string.
-     */
-    protected _stringHash(key: string): number;
-    /**
-     * The function `_objectHash` takes a key and returns a hash value, using a custom hash function for objects.
-     * @param {K} key - The parameter "key" is of type "K", which means it can be any type. It could be a string, number,
-     * boolean, object, or any other type of value. The purpose of the objectHash function is to generate a hash value for
-     * the key, which can be used for
-     * @returns a number, which is the hash value of the key.
-     */
-    protected _objectHash(key: K): number;
-    /**
-     * The `expand` function increases the capacity of a hash table by creating a new array of buckets with double the
-     * capacity and rehashing all the existing key-value pairs into the new buckets.
-     */
-    protected _expand(): void;
-}